22.6. Traefik
Table of Contents
Why Traefik?
Traefik is a modern HTTP reverse proxy and load balancer, designed specifically with containers and dynamic infrastructure in mind. While Nginx and similar servers work very well, they were originally built for static configuration files. Traefik focuses on:
- Automatic service discovery (for example, from Docker, Kubernetes, Consul)
- Dynamic configuration that updates when containers start or stop
- Built‑in support for HTTPS, including automatic Let's Encrypt certificates
- Simple routing rules that integrate nicely with labels or annotations
For a backend developer who uses Docker or container orchestration, Traefik often requires much less manual configuration than traditional proxies.
Traefik’s Core Concepts
To understand Traefik, you need a set of basic concepts. They are similar to what you saw in the Reverse Proxies and Nginx chapters, but Traefik has its own terminology.
EntryPoints
An EntryPoint defines where Traefik listens for incoming traffic. For example:
- HTTP on port 80
- HTTPS on port 443
- Custom internal admin port
A minimal Traefik configuration might define two EntryPoints: web and websecure.
Example static configuration (YAML style):
entryPoints:
web:
address: ":80"
websecure:
address: ":443"You can think of an EntryPoint as: “Which port does Traefik open and what protocol does it use?”
Routers
A Router connects an EntryPoint to a specific backend service, based on rules that match each incoming request.
Routers can match on:
- Host name, for example
Host("api.example.com") - Path prefix, for example
PathPrefix("/api") - Methods, headers, and more
Router responsibilities:
- Decide if a request applies to them (using rules)
- Attach middlewares (for example authentication, redirects)
- Choose which service to route to
- Optionally enforce HTTPS, TLS, etc.
Example:
http:
routers:
api-router:
rule: "Host(`api.example.com`) && PathPrefix(`/`)"
entryPoints:
- websecure
service: api-service
tls: {}
Here, any HTTPS request on websecure whose Host is api.example.com is sent to api-service.
Services
A Service in Traefik represents one or more backend servers, for example your FastAPI app running in a Docker container or multiple replicas behind load balancing.
A simple service might be defined as:
http:
services:
api-service:
loadBalancer:
servers:
- url: "http://app1:8000"
- url: "http://app2:8000"
Traefik will load balance requests between app1 and app2.
Middlewares
Middlewares are filters or modifiers applied between the client and the service. Typical uses:
- Redirect HTTP to HTTPS
- Add or remove headers
- Strip or add a path prefix
- Rate limiting
- Basic auth
Example middleware that redirects HTTP to HTTPS:
http:
middlewares:
redirect-to-https:
redirectScheme:
scheme: https
permanent: trueThen you attach it to a router:
http:
routers:
http-router:
rule: "Host(`api.example.com`)"
entryPoints:
- web
middlewares:
- redirect-to-https
service: api-serviceProviders
Providers are where Traefik discovers configuration from. Common providers include:
dockerfor Docker labelskubernetesfor Kubernetes Ingress or CRDsfilefor static or dynamic YAML/TOML filesconsulCatalog,etcd, etc.
When you use Docker, Traefik reads labels on your containers and automatically creates routers, services, and middlewares.
Static vs Dynamic Configuration
Traefik splits configuration into:
- Static configuration: defined at startup. It includes:
- EntryPoints
- Providers
- API/dashboard configuration
- Logging options
- Dynamic configuration: can change while Traefik is running. It includes:
- Routers
- Services
- Middlewares
- TLS options and certificates
Static configuration is often set through a traefik.yml or command line flags, and dynamic configuration is often provided by Docker labels or additional config files that Traefik watches.
Important rule: Static configuration requires a restart of Traefik to change, dynamic configuration does not. Use dynamic configuration for things that depend on running applications, like routes and backends.
Running Traefik with Docker
For backend projects, Traefik shines when combined with Docker and Docker Compose. Instead of editing configuration files for every new service, you add a set of labels to containers.
Basic `docker-compose.yml` with Traefik
Here is a minimal example that exposes a FastAPI container behind Traefik, without HTTPS yet:
version: "3.8"
services:
traefik:
image: traefik:v3.0
command:
- "--api.dashboard=true"
- "--api.insecure=true"
- "--entrypoints.web.address=:80"
- "--providers.docker=true"
- "--providers.docker.exposedbydefault=false"
ports:
- "80:80"
- "8080:8080" # Dashboard
volumes:
- /var/run/docker.sock:/var/run/docker.sock:ro
api:
image: my-fastapi-image
container_name: api
labels:
- "traefik.enable=true"
- "traefik.http.routers.api.rule=Host(`api.localhost`)"
- "traefik.http.routers.api.entrypoints=web"
- "traefik.http.services.api.loadbalancer.server.port=8000"Explanation of the important parts:
--providers.docker=true: tells Traefik to read Docker labels.--providers.docker.exposedbydefault=false: containers are not exposed unlesstraefik.enable=trueis set.- The
apiservice: traefik.http.routers.api.rule: the routing rule. It matchesHost("api.localhost").traefik.http.routers.api.entrypoints=web: routes from thewebEntryPoint.traefik.http.services.api.loadbalancer.server.port=8000: tells Traefik the internal port of the container.
With this setup:
- When you open
http://api.localhostin your browser (and map the host name to127.0.0.1in/etc/hostson Linux/macOS or Hosts file on Windows), Traefik forwards the request to theapicontainer. - You can open
http://localhost:8080to see the Traefik dashboard.
Mapping Hostnames for Local Development
In local development, you typically do not own a domain. You can still use host-based routing by editing your hosts file.
For example, add:
127.0.0.1 api.localhost
127.0.0.1 web.localhostThen you can create different routers for different services:
labels:
- "traefik.enable=true"
- "traefik.http.routers.api.rule=Host(`api.localhost`)"
- "traefik.http.routers.web.rule=Host(`web.localhost`)"This lets you simulate multiple subdomains on your laptop.
Using Traefik for HTTPS and Let's Encrypt
One of Traefik’s most popular features is automatic certificate management with Let's Encrypt.
Basic HTTPS Configuration with ACME
Here is an example static configuration snippet for Traefik using Let's Encrypt:
entryPoints:
web:
address: ":80"
websecure:
address: ":443"
certificatesResolvers:
letsencrypt:
acme:
email: "you@example.com"
storage: "/letsencrypt/acme.json"
httpChallenge:
entryPoint: webThis instructs Traefik to:
- Listen on
web(80) andwebsecure(443). - Use Let's Encrypt to obtain certificates.
- Use the HTTP challenge on port 80.
- Store certificates in
/letsencrypt/acme.json.
In Docker Compose:
services:
traefik:
image: traefik:v3.0
command:
- "--entrypoints.web.address=:80"
- "--entrypoints.websecure.address=:443"
- "--providers.docker=true"
- "--providers.docker.exposedbydefault=false"
- "--certificatesresolvers.letsencrypt.acme.email=you@example.com"
- "--certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json"
- "--certificatesresolvers.letsencrypt.acme.httpchallenge=true"
- "--certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web"
ports:
- "80:80"
- "443:443"
volumes:
- /var/run/docker.sock:/var/run/docker.sock:ro
- ./letsencrypt:/letsencrypt
Now your services can reference the letsencrypt resolver to get HTTPS certificates.
Creating an HTTPS Router for Your API
Your Dockerized FastAPI service might look like this:
services:
api:
image: my-fastapi-image
labels:
- "traefik.enable=true"
- "traefik.http.routers.api.rule=Host(`api.example.com`)"
- "traefik.http.routers.api.entrypoints=websecure"
- "traefik.http.routers.api.tls.certresolver=letsencrypt"
- "traefik.http.services.api.loadbalancer.server.port=8000"Traefik will:
- Terminate TLS on
websecurewith a certificate obtained forapi.example.com. - Forward decrypted HTTP traffic to the
apicontainer on port 8000.
Redirecting HTTP to HTTPS
You usually want all HTTP traffic on port 80 redirected to HTTPS.
You can apply a middleware through labels:
services:
traefik:
# same as above
api:
image: my-fastapi-image
labels:
- "traefik.enable=true"
# HTTPS router
- "traefik.http.routers.api-https.rule=Host(`api.example.com`)"
- "traefik.http.routers.api-https.entrypoints=websecure"
- "traefik.http.routers.api-https.tls.certresolver=letsencrypt"
- "traefik.http.routers.api-https.service=api"
# HTTP -> HTTPS router
- "traefik.http.routers.api-http.rule=Host(`api.example.com`)"
- "traefik.http.routers.api-http.entrypoints=web"
- "traefik.http.routers.api-http.middlewares=redirect-to-https"
- "traefik.http.middlewares.redirect-to-https.redirectscheme.scheme=https"
- "traefik.http.services.api.loadbalancer.server.port=8000"api-httplistens onweb(port 80).- It applies the
redirect-to-httpsmiddleware. - The middleware sends a redirect to the HTTPS version of the URL.
Common Middleware Examples
Middlewares in Traefik can solve many everyday problems in backend APIs.
1. Stripping a Path Prefix
Imagine your application expects / but you want to expose it at /api. Instead of changing your app, you can use stripPrefix.
Example:
labels:
- "traefik.enable=true"
- "traefik.http.routers.api.rule=Host(`api.example.com`) && PathPrefix(`/api`)"
- "traefik.http.routers.api.entrypoints=websecure"
- "traefik.http.routers.api.tls.certresolver=letsencrypt"
- "traefik.http.routers.api.middlewares=api-strip"
- "traefik.http.middlewares.api-strip.stripprefix.prefixes=/api"
- "traefik.http.services.api.loadbalancer.server.port=8000"Client requests:
https://api.example.com/api/users
Traefik forwards:
http://api:8000/users
2. Adding Security Headers
You can add common security headers without changing your application code.
labels:
- "traefik.http.middlewares.sec-headers.headers.stsSeconds=31536000"
- "traefik.http.middlewares.sec-headers.headers.stsIncludeSubdomains=true"
- "traefik.http.middlewares.sec-headers.headers.contentTypeNosniff=true"
- "traefik.http.middlewares.sec-headers.headers.browserXssFilter=true"
- "traefik.http.routers.api.middlewares=sec-headers"
These labels configure a sec-headers middleware which is attached to the api router.
Important security tip: Do not rely only on Traefik for security. Add secure headers, rate limiting, and authentication at the proxy level, but also validate inputs and protect your application itself.
3. Basic Authentication for Internal Tools
You might want a simple password prompt for an internal dashboard.
labels:
- "traefik.http.middlewares.simple-auth.basicauth.users=user:$$apr1$$0AD..../$F5X..."
- "traefik.http.routers.dashboard.rule=Host(`traefik.example.com`)"
- "traefik.http.routers.dashboard.middlewares=simple-auth"
- "traefik.http.routers.dashboard.service=api@internal"
Here, api@internal is Traefik’s own dashboard service. The password is a hashed value generated by tools like htpasswd.
Load Balancing with Traefik
Traefik supports multiple load balancing algorithms, such as:
wrr(weighted round robin)drr(dynamic round robin) in newer versions
Typical use case, multiple replicas of an API:
services:
api1:
image: my-fastapi-image
labels:
- "traefik.enable=true"
- "traefik.http.routers.api.rule=Host(`api.example.com`)"
- "traefik.http.routers.api.entrypoints=websecure"
- "traefik.http.routers.api.tls.certresolver=letsencrypt"
- "traefik.http.services.api.loadbalancer.server.port=8000"
api2:
image: my-fastapi-image
labels:
- "traefik.enable=true"
# Share the same service name "api"
- "traefik.http.services.api.loadbalancer.server.port=8000"
Traefik groups containers with the same service configuration and balances traffic between them.
You can also set weights:
labels:
- "traefik.http.services.api.loadbalancer.server.port=8000"
- "traefik.http.services.api.loadbalancer.sticky.cookie=true"
- "traefik.http.services.api.loadbalancer.serversTransport=mytransport"Or in file-based configuration, you can specify weights per server.
Monitoring and Debugging Traefik
Traefik provides:
- A dashboard
- Access logs
- Metrics for Prometheus and others
Enabling the Dashboard
You can enable the (insecure) dashboard in development via command options:
command:
- "--api.dashboard=true"
- "--api.insecure=true"
Then open http://localhost:8080 to see:
- EntryPoints
- Routers
- Services
- Middlewares
This is extremely useful when learning or debugging, but you must avoid --api.insecure=true in production.
Access Logs
Access logs help you see what requests Traefik handles:
command:
- "--accesslog=true"
- "--accesslog.format=json"You can pipe these logs to a central logging system or inspect them directly.
When to Choose Traefik vs Nginx
Both Traefik and Nginx can act as reverse proxies for your backend.
A short comparison:
| Feature | Traefik | Nginx |
|---|---|---|
| Dynamic discovery | Native (Docker, Kubernetes, etc.) | Manual or using extra tooling |
| Configuration style | Labels, TOML/YAML | Static config files |
| Automatic HTTPS (Let's Encrypt) | Built-in ACME support | Via additional tools or custom config |
| Dashboard | Built-in, very visual | Third-party or manual |
| Best suited for | Container-based, dynamic environments | Static or traditional server setups |
As an absolute beginner:
- If you use Docker for almost everything, Traefik can simplify your setup.
- If you deploy on a single VPS with only a few fixed services, Nginx is also a great choice.
You do not have to commit to one forever. You can start with whichever seems easier, then learn the other later.
Example: FastAPI Behind Traefik in Production
To tie everything together, here is a simplified production-style Compose configuration for a FastAPI backend with PostgreSQL, using Traefik for HTTPS.
version: "3.8"
services:
traefik:
image: traefik:v3.0
command:
- "--entrypoints.web.address=:80"
- "--entrypoints.websecure.address=:443"
- "--providers.docker=true"
- "--providers.docker.exposedbydefault=false"
- "--certificatesresolvers.letsencrypt.acme.email=you@example.com"
- "--certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json"
- "--certificatesresolvers.letsencrypt.acme.httpchallenge=true"
- "--certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web"
- "--accesslog=true"
- "--api.dashboard=true"
ports:
- "80:80"
- "443:443"
- "8080:8080" # remove or protect in real production
volumes:
- /var/run/docker.sock:/var/run/docker.sock:ro
- ./letsencrypt:/letsencrypt
api:
image: my-fastapi-image
environment:
- DATABASE_URL=postgresql://user:pass@db:5432/app
labels:
- "traefik.enable=true"
- "traefik.http.routers.api.rule=Host(`api.example.com`)"
- "traefik.http.routers.api.entrypoints=websecure"
- "traefik.http.routers.api.tls.certresolver=letsencrypt"
- "traefik.http.routers.api.middlewares=sec-headers@docker"
- "traefik.http.services.api.loadbalancer.server.port=8000"
- "traefik.http.middlewares.sec-headers.headers.contentTypeNosniff=true"
- "traefik.http.middlewares.sec-headers.headers.stsSeconds=31536000"
- "traefik.http.middlewares.sec-headers.headers.stsIncludeSubdomains=true"
db:
image: postgres:16
environment:
- POSTGRES_PASSWORD=secret
- POSTGRES_DB=app
volumes:
- db-data:/var/lib/postgresql/data
volumes:
db-data:In this example:
- Traefik terminates HTTPS and routes
https://api.example.comtraffic to your FastAPI app. - Traefik automatically obtains and renews Let's Encrypt certificates.
- Security headers are added by a middleware.
- PostgreSQL is not exposed directly to the internet, only to the internal Docker network.
This pattern is common in real-world backend systems. Traefik becomes the single entry point for all HTTP(S) traffic, and your backend services remain simple, focused, and unaware of TLS, host-based routing, or redirects.
By understanding these Traefik basics, you can design and deploy container-based backend systems that are easier to manage, more secure, and highly flexible as you add more services over time.
Views: 0
Where to Move
Move chapter:
- ☰ 1. Introduction to Backend Development
- ☰ 1.1. What Is Backend Development?
- ☰ 1.2. Frontend vs Backend
- ☰ 1.3. How Web Applications Work
- ☰ 1.4. Client-Server Architecture
- ☰ 1.5. Request-Response Cycle
- ☰ 1.6. Static vs Dynamic Websites
- ☰ 1.7. Backend Developer Responsibilities
- ☰ 1.8. Backend Development Roadmap
-
- ☰ 2. How the Web Works
- ☰ 2.1. The Internet and the Web
- ☰ 2.2. IP Addresses
- ☰ 2.3. Domain Names
- ☰ 2.4. DNS
- ☰ 2.5. Ports
- ☰ 2.6. TCP/IP Basics
- ☰ 2.7. HTTP and HTTPS
- ☰ 2.8. HTTP Requests
- ☰ 2.9. HTTP Responses
- ☰ 2.10. HTTP Methods
- ☰ 2.11. HTTP Status Codes
- ☰ 2.12. HTTP Headers
- ☰ 2.13. Cookies
- ☰ 2.14. Sessions
- ☰ 2.15. What Happens When You Enter a URL?
-
- ☰ 3. Development Environment
- ☰ 3.1. Choosing an Operating System
- ☰ 3.2. Linux Basics for Backend Developers
- ☰ 3.3. Command Line Basics
- ☰ 3.4. Environment Variables
- ☰ 3.5. Installing Development Tools
- ☰ 3.6. Code Editors and IDEs
- ☰ 3.7. Git
- ☰ 3.8. GitHub and GitLab
- ☰ 3.9. Creating Your First Repository
- ☰ 3.10. Branches and Commits
- ☰ 3.11. Basic Git Workflow
-
- ☰ 4. Programming Fundamentals
- ☰ 4.1. Variables and Data Types
- ☰ 4.2. Operators
- ☰ 4.3. Conditions
- ☰ 4.4. Loops
- ☰ 4.5. Functions
- ☰ 4.6. Data Structures
- ☰ 4.7. Error Handling
- ☰ 4.8. Modules and Packages
- ☰ 4.9. File Handling
- ☰ 4.10. Object-Oriented Programming
- ☰ 4.11. Classes and Objects
- ☰ 4.12. Inheritance and Composition
- ☰ 4.13. Clean Code Principles
-
- ☰ 5. Python for Backend Development
- ☰ 5.1. Introduction to Python
- ☰ 5.2. Installing Python
- ☰ 5.3. Virtual Environments
- ☰ 5.4. pip and Package Management
- ☰ 5.5. Python Project Structure
- ☰ 5.6. Functions and Type Hints
- ☰ 5.7. Classes and Dataclasses
- ☰ 5.8. Exceptions
- ☰ 5.9. Working with Files
- ☰ 5.9.1. File Downloads
- ☰ 5.9.2. File Validation
- ☰ 5.9.3. Image Uploads
- ☰ 5.9.4. Local File Storage
- ☰ 5.9.5. Object Storage
- ☰ 5.9.6. S3-Compatible Storage
- ☰ 5.9.7. Presigned URLs
- ☰ 5.9.8. Secure File Handling
-
- ☰ 5.10. JSON
- ☰ 5.11. Date and Time
- ☰ 5.12. Logging
- ☰ 5.13. Configuration
- ☰ 5.14. Environment Variables
- ☰ 5.15. Async Programming
- ☰ 5.16. Python Backend Best Practices
-
- ☰ 6. Introduction to Web Backends
- ☰ 6.1. Building a Simple Web Server
- ☰ 6.2. Routing
- ☰ 6.3. URL Parameters
- ☰ 6.4. Query Parameters
- ☰ 6.5. Request Bodies
- ☰ 6.6. Form Data
- ☰ 6.7. JSON Requests
- ☰ 6.8. Returning Responses
- ☰ 6.9. Templates
- ☰ 6.10. Static Files
- ☰ 6.11. Middleware
- ☰ 6.12. Application Configuration
-
- ☰ 7. REST APIs
- ☰ 7.1. What Is an API?
- ☰ 7.2. What Is REST?
- ☰ 7.3. Resources and Endpoints
- ☰ 7.4. RESTful URL Design
- ☰ 7.5. HTTP Methods in REST
- ☰ 7.6. GET Requests
- ☰ 7.7. POST Requests
- ☰ 7.8. PUT Requests
- ☰ 7.9. PATCH Requests
- ☰ 7.10. DELETE Requests
- ☰ 7.11. Request Validation
- ☰ 7.12. Response Models
- ☰ 7.13. HTTP Status Codes
- ☰ 7.14. Error Responses
- ☰ 7.15. Pagination
- ☰ 7.16. Filtering
- ☰ 7.17. Sorting
- ☰ 7.18. Searching
- ☰ 7.19. API Versioning
- ☰ 7.20. API Documentation
- ☰ 7.21. OpenAPI and Swagger
-
- ☰ 8. FastAPI
- ☰ 8.1. Introduction to FastAPI
- ☰ 8.2. Routes and Path Operations
- ☰ 8.3. Path Parameters
- ☰ 8.4. Pydantic Models
- ☰ 8.5. Data Validation
- ☰ 8.6. Dependency Injection
- ☰ 8.7. Exception Handling
- ☰ 8.8. Background Tasks
- ☰ 8.9. File Uploads
- ☰ 8.10. Async Endpoints
- ☰ 8.11. FastAPI Project Structure
- ☰ 8.12. Building a Complete REST API
-
- ☰ 9. Databases
- ☰ 9.1. Introduction to Databases
- ☰ 9.2. Relational vs NoSQL Databases
- ☰ 9.3. Tables, Rows, and Columns
- ☰ 9.4. Primary Keys
- ☰ 9.5. Foreign Keys
- ☰ 9.6. Relationships
- ☰ 9.7. One-to-One Relationships
- ☰ 9.8. One-to-Many Relationships
- ☰ 9.9. Many-to-Many Relationships
- ☰ 9.10. Database Schema Design
- ☰ 9.11. Normalization
- ☰ 9.12. Indexes
- ☰ 9.13. Transactions
- ☰ 9.14. ACID Properties
-
- ☰ 10. SQL
- ☰ 10.1. Introduction to SQL
- ☰ 10.2. CREATE
- ☰ 10.3. INSERT
- ☰ 10.4. SELECT
- ☰ 10.5. UPDATE
- ☰ 10.6. DELETE
- ☰ 10.7. WHERE
- ☰ 10.8. ORDER BY
- ☰ 10.9. GROUP BY
- ☰ 10.10. Aggregate Functions
- ☰ 10.11. JOINs
- ☰ 10.12. Subqueries
- ☰ 10.13. Constraints
- ☰ 10.14. Indexes
- ☰ 10.15. Transactions
- ☰ 10.16. Common Table Expressions
- ☰ 10.17. SQL Performance Basics
-
- ☰ 11. PostgreSQL
- ☰ 11.1. Introduction to PostgreSQL
- ☰ 11.2. Installing PostgreSQL
- ☰ 11.3. Creating Databases
- ☰ 11.4. Users and Roles
- ☰ 11.5. Permissions
- ☰ 11.6. PostgreSQL Data Types
- ☰ 11.7. Constraints
- ☰ 11.8. Indexes
- ☰ 11.9. Transactions
- ☰ 11.10. JSON Data
- ☰ 11.11. Backup and Restore
- ☰ 11.12. PostgreSQL Performance Basics
-
- ☰ 12. ORM and Database Integration
- ☰ 12.1. What Is an ORM?
- ☰ 12.2. SQLAlchemy
- ☰ 12.3. Models
- ☰ 12.4. Database Sessions
- ☰ 12.5. Creating Records
- ☰ 12.6. Reading Records
- ☰ 12.7. Updating Records
- ☰ 12.8. Deleting Records
- ☰ 12.9. Relationships
- ☰ 12.10. Queries
- ☰ 12.11. Transactions
- ☰ 12.12. Connection Pooling
- ☰ 12.13. Database Migrations
- ☰ 12.14. Alembic
- ☰ 12.15. Repository Pattern
-
- ☰ 13. Authentication
- ☰ 13.1. Authentication vs Authorization
- ☰ 13.2. Password Storage
- ☰ 13.3. Password Hashing
- ☰ 13.4. Registration
- ☰ 13.5. Login
- ☰ 13.6. Tokens
- ☰ 13.7. JSON Web Tokens
- ☰ 13.8. Access Tokens
- ☰ 13.9. Refresh Tokens
- ☰ 13.10. OAuth 2.0
- ☰ 13.11. OpenID Connect
- ☰ 13.12. Social Login
- ☰ 13.13. Logout
- ☰ 13.14. Password Reset
- ☰ 13.15. Email Verification
- ☰ 13.16. Multi-Factor Authentication
-
- ☰ 14. Authorization
- ☰ 14.1. Users and Permissions
- ☰ 14.2. Role-Based Access Control
- ☰ 14.3. Permission-Based Access Control
- ☰ 14.4. Protecting API Endpoints
- ☰ 14.5. Admin Permissions
- ☰ 14.6. Resource Ownership
- ☰ 14.7. Authorization Best Practices
-
- ☰ 15. Backend Security
- ☰ 15.1. Introduction to Web Security
- ☰ 15.2. HTTPS and TLS
- ☰ 15.3. SQL Injection
- ☰ 15.4. Cross-Site Scripting
- ☰ 15.5. Cross-Site Request Forgery
- ☰ 15.6. CORS
- ☰ 15.7. Authentication Attacks
- ☰ 15.8. Brute-Force Protection
- ☰ 15.9. Rate Limiting
- ☰ 15.10. Input Validation
- ☰ 15.11. Secure Password Storage
- ☰ 15.12. Secrets Management
- ☰ 15.13. Secure Cookies
- ☰ 15.14. Security Headers
- ☰ 15.15. File Upload Security
- ☰ 15.16. Dependency Vulnerabilities
- ☰ 15.17. OWASP Top 10
-
- ☰ 16. Caching
- ☰ 16.1. Why Caching Matters
- ☰ 16.2. Application Caching
- ☰ 16.3. Redis
- ☰ 16.3.1. Introduction to Redis
- ☰ 16.3.2. Installing Redis
- ☰ 16.3.3. Keys and Values
- ☰ 16.3.4. Expiration
- ☰ 16.3.5. Distributed Locks
-
- ☰ 16.4. Cache Keys
- ☰ 16.5. Cache Invalidation
- ☰ 16.6. Caching Database Queries
- ☰ 16.7. Distributed Caching
-
- ☰ 17. Background Processing
- ☰ 17.1. Synchronous vs Asynchronous Tasks
- ☰ 17.2. Background Jobs
- ☰ 17.3. Message Queues
- ☰ 17.4. Celery
- ☰ 17.5. Redis as a Message Broker
- ☰ 17.6. Scheduled Tasks
- ☰ 17.7. Retry Strategies
- ☰ 17.8. Handling Failed Jobs
- ☰ 17.9. Email Jobs
- ☰ 17.10. Long-Running Tasks
-
- ☰ 18. Email
- ☰ 18.1. How Email Works
- ☰ 18.2. SMTP
- ☰ 18.3. Sending Emails
- ☰ 18.4. HTML Emails
- ☰ 18.5. Transactional Emails
- ☰ 18.6. Password Reset Emails
- ☰ 18.7. Background Email Delivery
- ☰ 18.8. Email Delivery Best Practices
-
- ☰ 19. Testing
- ☰ 19.1. Why Backend Testing Matters
- ☰ 19.2. Unit Testing
- ☰ 19.3. Integration Testing
- ☰ 19.4. API Testing
- ☰ 19.5. pytest
- ☰ 19.6. Fixtures
- ☰ 19.7. Mocking
- ☰ 19.8. Testing Databases
- ☰ 19.9. Testing Authentication
- ☰ 19.10. Testing FastAPI
- ☰ 19.11. Test Coverage
- ☰ 19.12. Automated Testing
-
- ☰ 20. Logging and Monitoring
- ☰ 20.1. Application Logging
- ☰ 20.2. Log Levels
- ☰ 20.3. Structured Logging
- ☰ 20.4. Request Logging
- ☰ 20.5. Error Logging
- ☰ 20.6. Metrics
- ☰ 20.7. Health Checks
- ☰ 20.8. Monitoring
- ☰ 20.9. Prometheus
- ☰ 20.10. Grafana
- ☰ 20.11. Alerting
- ☰ 20.12. Error Tracking
- ☰ 20.13. Observability Basics
-
- ☰ 21. Docker
- ☰ 21.1. Introduction to Containers
- ☰ 21.2. Docker Architecture
- ☰ 21.3. Images
- ☰ 21.4. Containers
- ☰ 21.5. Dockerfiles
- ☰ 21.6. Building Images
- ☰ 21.7. Running Containers
- ☰ 21.8. Volumes
- ☰ 21.9. Networks
- ☰ 21.10. Docker Compose
- ☰ 21.11. FastAPI with Docker
- ☰ 21.12. PostgreSQL with Docker
- ☰ 21.13. Redis with Docker
- ☰ 21.14. Multi-Container Applications
- ☰ 21.15. Production Docker Best Practices
-
- ☰ 22. Web Servers and Reverse Proxies
- ☰ 22.1. Application Servers
- ☰ 22.2. Uvicorn
- ☰ 22.3. Gunicorn
- ☰ 22.4. Reverse Proxies
- ☰ 22.5. Nginx
- ☰ 22.6. Traefik
- ☰ 22.7. HTTPS
- ☰ 22.8. TLS Certificates
- ☰ 22.9. Let's Encrypt
- ☰ 22.10. Load Balancing
-
- ☰ 23. Deployment
- ☰ 23.1. Development vs Production
- ☰ 23.2. Preparing an Application for Production
- ☰ 23.3. Linux Server Setup
- ☰ 23.4. Deploying with Docker
- ☰ 23.5. Environment Configuration
- ☰ 23.6. Managing Secrets
- ☰ 23.7. HTTPS Configuration
- ☰ 23.8. Production Logging
- ☰ 23.9. Backups
- ☰ 23.10. Zero-Downtime Deployment
- ☰ 23.11. Rollbacks
-
- ☰ 24. CI/CD
- ☰ 24.1. Introduction to CI/CD
- ☰ 24.2. Continuous Integration
- ☰ 24.3. Continuous Delivery
- ☰ 24.4. Continuous Deployment
- ☰ 24.5. CI/CD Pipelines
- ☰ 24.6. GitHub Actions
- ☰ 24.7. GitLab CI/CD
- ☰ 24.8. Building Docker Images
- ☰ 24.9. Container Registries
- ☰ 24.10. Deployment Pipelines
- ☰ 24.11. Staging Environments
- ☰ 24.12. Production Environments
- ☰ 24.13. Rollback Strategies
-
- ☰ 25. Backend Architecture
- ☰ 25.1. Monolithic Architecture
- ☰ 25.2. Modular Monoliths
- ☰ 25.3. Microservices
- ☰ 25.4. Layered Architecture
- ☰ 25.5. Service Layer
- ☰ 25.6. Separation of Concerns
- ☰ 25.7. Domain-Driven Design Basics
- ☰ 25.8. Event-Driven Architecture
- ☰ 25.9. Choosing an Architecture
-
- ☰ 26. Performance and Scalability
- ☰ 26.1. Understanding Backend Performance
- ☰ 26.2. CPU-Bound vs I/O-Bound Work
- ☰ 26.3. Asynchronous Programming
- ☰ 26.4. Database Optimization
- ☰ 26.5. Query Optimization
- ☰ 26.6. Indexing
- ☰ 26.7. Load Balancing
- ☰ 26.8. Horizontal Scaling
- ☰ 26.9. Vertical Scaling
- ☰ 26.10. Stateless Applications
- ☰ 26.11. Performance Testing
- ☰ 26.12. Load Testing
-
- ☰ 27. Advanced API Development
- ☰ 27.1. WebSockets
- ☰ 27.2. Server-Sent Events
- ☰ 27.3. GraphQL
- ☰ 27.4. Webhooks
- ☰ 27.5. Idempotency
- ☰ 27.6. API Rate Limiting
- ☰ 27.7. API Keys
- ☰ 27.8. API Gateways
- ☰ 27.9. Distributed APIs
- ☰ 27.10. Real-Time Applications
-
- ☰ 28. Production Backend Engineering
- ☰ 28.1. Configuration Management
- ☰ 28.2. Database Backups
- ☰ 28.3. Disaster Recovery
- ☰ 28.4. Graceful Shutdown
- ☰ 28.5. Fault Tolerance
- ☰ 28.6. Circuit Breakers
- ☰ 28.7. High Availability
- ☰ 28.8. Monitoring Production Systems
- ☰ 28.9. Incident Response
-
- ☰ 29. Project 1: Task Management API
- ☰ 29.1. Project Requirements
- ☰ 29.2. Project Structure
- ☰ 29.3. Database Design
- ☰ 29.4. CRUD Operations
- ☰ 29.5. Validation
-
- ☰ 30. Project 2: Authentication System
- ☰ 30.1. User Registration
- ☰ 30.2. JWT Authentication
- ☰ 30.3. Role-Based Authorization
- ☰ 30.4. Security Testing
-
- ☰ 31. Project 3: E-Commerce Backend
- ☰ 31.1. Architecture
- ☰ 31.2. User Management
- ☰ 31.3. Product Management
- ☰ 31.4. Categories
- ☰ 31.5. Shopping Cart
- ☰ 31.6. Orders
- ☰ 31.7. Inventory
- ☰ 31.8. Payments
- ☰ 31.9. Admin API
-
- ☰ 32. Final Project: Production Backend
- ☰ 32.1. Planning the Application
- ☰ 32.2. Designing the Architecture
- ☰ 32.3. Designing the Database
- ☰ 32.4. Building the REST API
- ☰ 32.5. Authentication and Authorization
- ☰ 32.6. PostgreSQL Integration
- ☰ 32.7. Redis Integration
- ☰ 32.8. Background Workers
- ☰ 32.9. File Storage
- ☰ 32.10. Dockerizing the Application
- ☰ 32.11. CI/CD Pipeline
- ☰ 32.12. Production Deployment
- ☰ 32.13. HTTPS and Domain Setup
- ☰ 32.14. Performance Optimization
- ☰ 32.15. Security Review
- ☰ 32.16. Documentation
-
- ☰ 33. Backend Developer Roadmap
- ☰ 33.1. What You Should Know Now
- ☰ 33.2. Building a Portfolio
- ☰ 33.3. Creating Backend Projects
- ☰ 33.4. Contributing to Open Source
- ☰ 33.5. Preparing for Backend Interviews
- ☰ 33.6. Backend Interview Questions
- ☰ 33.7. Database Interview Questions
- ☰ 33.8. API Interview Questions
- ☰ 33.9. Linux and Docker Interview Questions
- ☰ 33.10. Where to Go Next
-
Comments
Please login to add a comment.
Don't have an account? Register now!