22.10. Load Balancing
Table of Contents
Why Load Balancing Matters
When your backend grows, a single server often becomes a bottleneck. It might run out of CPU, memory, or network bandwidth, or need maintenance without downtime. Load balancing solves these problems by distributing incoming traffic across multiple backend instances.
Typical goals of load balancing:
- Increase availability: if one server dies, others can still handle requests.
- Improve performance: more servers can handle more concurrent users.
- Enable scaling: add or remove servers based on load.
- Simplify maintenance: take servers out of rotation without stopping the service.
Imagine you have three identical FastAPI application servers behind Nginx. Users only see one domain, for example api.example.com. Nginx accepts all incoming requests and forwards each one to one of the three backend servers according to a load balancing strategy.
Key idea: A load balancer sits between clients and your backend instances and decides which backend should handle each incoming request.
You can think of it as a traffic cop at a junction, directing cars to different roads to avoid congestion.
Basic Load Balancing Architecture
A common production architecture looks like this:
Client → Internet → Reverse Proxy / Load Balancer → Application Servers → Database / Cache / Other services
You may have:
- One or more public load balancers (for example Nginx, HAProxy, AWS ELB).
- Several application servers (for example FastAPI with Uvicorn behind Gunicorn).
- A database cluster and Redis cluster behind them.
The client never talks directly to an application server. It sends all requests to the load balancer, which:
- Receives the HTTP or HTTPS request.
- Chooses a backend server.
- Forwards the request.
- Receives the response from the backend.
- Sends the response back to the client.
If one backend server goes down, the load balancer detects this through health checks and stops sending requests to that server.
Load Balancing Strategies
Load balancers use different algorithms to decide which backend should handle a request. Knowing the basic strategies helps you choose the right one for your backend.
Below is a quick overview:
| Strategy | Idea | Good for |
|---|---|---|
| Round robin | Next server in turn | Simple, similar servers |
| Weighted round robin | Prefer stronger servers | Mixed capacity servers |
| Least connections | Server with fewest active connections | Long-lived or uneven requests |
| IP hash | Same client IP goes to same server | Basic session stickiness |
| URL / header based | Route based on path or header | Microservices, A/B testing, canary releases |
| Random | Random server | Very simple, sometimes good enough |
Round Robin
Round robin cycles through the list of backends:
- Request 1 → Server A
- Request 2 → Server B
- Request 3 → Server C
- Request 4 → Server A
- and so on.
This works well when:
- All backend servers are similar in CPU, memory, and performance.
- Requests are short and similar in cost.
Example Nginx configuration using round robin:
upstream api_backend {
server 10.0.0.10:8000;
server 10.0.0.11:8000;
server 10.0.0.12:8000;
}
server {
listen 80;
server_name api.example.com;
location / {
proxy_pass http://api_backend;
}
}
Nginx default behavior for upstream without extra parameters is round robin.
Weighted Round Robin
Weighted round robin assigns more requests to stronger servers.
For example:
- Server A: 2 CPU cores.
- Server B: 4 CPU cores.
- Server C: 8 CPU cores.
You might give weights 1, 2, 4 respectively. Over time:
- A gets 1/7 of traffic.
- B gets 2/7 of traffic.
- C gets 4/7 of traffic.
Example Nginx configuration:
upstream api_backend {
server 10.0.0.10:8000 weight=1;
server 10.0.0.11:8000 weight=2;
server 10.0.0.12:8000 weight=4;
}This is useful when:
- You have mixed hardware.
- You are slowly migrating from an old small server to a new big one.
Least Connections
Least connections sends the next request to the backend with the fewest active connections.
This is better than round robin when:
- Some requests are long running.
- Traffic is uneven and some users are heavier than others.
Example with Nginx:
upstream api_backend {
least_conn;
server 10.0.0.10:8000;
server 10.0.0.11:8000;
server 10.0.0.12:8000;
}If:
- Server A has 20 active connections.
- Server B has 5.
- Server C has 3.
Then new requests go to Server C until its connection count grows.
IP Hash (Session Affinity)
Many backend applications use in-memory sessions or cache on each server. If a user hits a different server on each request, their session may disappear. IP hash keeps clients on the same server.
Idea:
- Hash the client IP.
- Always send that IP to the same server, as long as the pool does not change.
Example in Nginx:
upstream api_backend {
ip_hash;
server 10.0.0.10:8000;
server 10.0.0.11:8000;
}
All requests from 203.0.113.5 will always go to the same backend server.
This is a form of session stickiness. It is less precise when clients are behind a NAT or proxy, because many users share a single IP.
Other Strategies and Layer 7 Routing
Load balancers at HTTP level can inspect:
- URL path, for example
/api/orders. - HTTP method, for example
GET,POST. - Headers, for example
X-Version: beta. - Cookies.
- Query parameters.
You can then route requests to different backends.
Some examples:
/api/usersgoes to a user service./api/ordersgoes to an order service.- Requests with
X-Canary: 1go to a new version of the service.
Example Nginx configuration:
upstream users_service {
server 10.0.0.10:8000;
}
upstream orders_service {
server 10.0.0.20:8000;
}
server {
listen 80;
server_name api.example.com;
location /api/users/ {
proxy_pass http://users_service;
}
location /api/orders/ {
proxy_pass http://orders_service;
}
}This is useful in microservice architectures or when doing canary releases.
Health Checks and Failover
A load balancer must know which backends are healthy. If it sends traffic to a dead server, users will see errors or timeouts.
There are two basic types of health checks:
- Passive: detect failures by observing connection errors or timeouts.
- Active: periodically send a private health check request, often to
/healthor/status, and check the response.
Typical health check behavior:
- Every few seconds the load balancer sends a request to each backend:
- For example
GET /health. - If the backend returns an unhealthy status (for example 500) or no response:
- Mark the backend as down.
- Stop sending new user requests to it.
- After a few successful health checks:
- Mark it as up again.
- Slowly start sending traffic again.
Example of a very simple health endpoint in FastAPI:
from fastapi import FastAPI
app = FastAPI()
@app.get("/health")
def health():
return {"status": "ok"}In Nginx you usually combine built-in checks and, if needed, modules or an upstream such as a cloud LB that does health checks.
Important rule: A backend that fails health checks should not receive production traffic until it is healthy again.
Failover simply means:
- If Server A fails, the load balancer automatically sends all traffic to Servers B and C.
- When Server A is healthy again, it re-enters the pool.
This is a core part of high availability.
Session Stickiness and Stateful Backends
Many beginner backends use stateful techniques:
- In-memory user sessions.
- In-memory cache with important values that are not shared.
- Local file-based sessions.
If the load balancer sends a user to a different backend on each request, the user may:
- Get logged out.
- Lose their shopping cart.
- See inconsistent data.
There are three common solutions.
1. Client-independent Session Store
Best practice is to make your application stateless by storing sessions and cache in shared services, for example:
- Redis.
- Database.
Then any backend server can serve any request, because all use the same shared state.
High level flow:
- User logs in.
- Backend creates a session in Redis.
- Backend sets a session cookie on the client.
- On each request, any server can read the session from Redis.
This removes the need for session stickiness and makes load balancing easier.
2. Sticky Sessions at the Load Balancer
If you cannot change your application, you can use sticky sessions.
Options include:
- IP hash (as shown earlier), which groups users by IP.
- Cookie-based stickiness, where the load balancer sets a cookie and uses it to route users to the same backend.
Example idea:
- First request: user hits load balancer.
- Load balancer chooses backend B, sets a cookie, for example
LB_NODE=B. - Future requests with
LB_NODE=Bgo to backend B.
Some cloud load balancers support application cookies and implement this for you.
3. Keep Sessions on the Client
Another stateless approach is to store session data on the client, for example JWT access tokens for authentication. The backend only needs to verify and interpret the token, no server memory needed.
However, JWT and token-based auth have their own security and design considerations covered in other chapters.
Layer 4 vs Layer 7 Load Balancing
Load balancers can work at different layers of the network stack.
| Type | OSI Layer | What it sees | Typical tools |
|---|---|---|---|
| Layer 4 (L4) | Transport | IP addresses, TCP/UDP ports | HAProxy (L4 mode), AWS NLB |
| Layer 7 (L7) | Application | HTTP headers, URLs, cookies | Nginx, Traefik, AWS ALB |
Layer 4 Load Balancing
L4 load balancers do not understand HTTP. They only see TCP connections from clients to the load balancer and forward them to backend servers.
Characteristics:
- Very fast and efficient.
- Limited routing flexibility.
- Good for any TCP or UDP protocol, not only HTTP.
Example use cases:
- Balancing database connections across replicas.
- Balancing gRPC traffic if you do not need advanced routing.
Layer 7 Load Balancing
L7 load balancers understand the protocol, for example HTTP or HTTP/2.
They can:
- Inspect URLs, headers, methods, body size.
- Do smart routing, for example path based, host based, or header based.
- Add or remove headers.
- Terminate TLS and re-encrypt to backends.
- Compress or cache responses.
For most web APIs and backends, you will use L7 load balancing, for example Nginx as a reverse proxy.
Example: Load Balancing a FastAPI Application with Nginx
Let us put everything together with a complete example.
Step 1: Run Multiple Application Servers
Assume you have a FastAPI application in app.main:app. You run three Gunicorn + Uvicorn workers on different servers or ports.
For example, on three different machines:
10.0.0.10:800010.0.0.11:800010.0.0.12:8000
Or on one machine with different ports for demo purposes.
Start Gunicorn + Uvicorn workers on each:
gunicorn -k uvicorn.workers.UvicornWorker app.main:app -b 0.0.0.0:8000Step 2: Configure Nginx as a Load Balancer
Nginx config:
http {
upstream fastapi_app {
least_conn; # or use round robin by removing this line
server 10.0.0.10:8000;
server 10.0.0.11:8000;
server 10.0.0.12:8000;
}
server {
listen 80;
server_name api.example.com;
# Optional: limit max connections per backend connection
proxy_http_version 1.1;
proxy_set_header Connection "";
location / {
proxy_pass http://fastapi_app;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}
}
Now any request to http://api.example.com is forwarded to one of the three FastAPI backends.
You can test which backend you hit by adding an endpoint that returns the hostname or environment variable unique to that instance.
Example FastAPI endpoint:
import socket
from fastapi import FastAPI
app = FastAPI()
@app.get("/whoami")
def whoami():
return {"hostname": socket.gethostname()}
Call /whoami several times and you should see different hostnames if the load balancer is distributing traffic.
Scaling and Auto Scaling
Load balancing allows horizontal scaling by adding or removing servers.
Manual Scaling
When you see your CPU or response time increase, you can:
- Start a new backend server.
- Add it to the load balancer configuration.
- Reload the load balancer.
For Nginx, you typically reload without downtime:
sudo nginx -s reloadIf health checks are configured, the new server will start to receive traffic as soon as it is healthy.
Auto Scaling
Cloud platforms often offer auto scaling groups:
- You define a minimum and maximum number of instances.
- You define metrics (for example CPU > 70 percent for 5 minutes).
- The platform creates or terminates instances automatically.
- The load balancer becomes aware of new or removed backends.
Example metrics to watch:
- Average response time.
- CPU usage.
- Request count per second.
- Error rate.
Auto scaling is out of scope to configure in detail here, but you should know that load balancing is a prerequisite for scaling horizontally.
Load Balancing and Sticky Problems
Load balancing introduces some common pitfalls.
Problem 1: Caching on One Node
Imagine you cache frequently used data in memory on each server. One server may have the data in cache, another may not. So users see different performance depending on which server they hit.
Solutions:
- Use a shared cache such as Redis.
- Or accept some inconsistency and use longer-term persistent storage.
Problem 2: Non-Idempotent Requests Retried
If the load balancer or a proxy retries a request, and the request is not idempotent, operations may be repeated. For example POST /orders may create two orders instead of one.
You will learn about idempotency more in advanced API chapters, but with load balancing you must:
- Be careful with automatic retries.
- Use idempotency keys for sensitive operations.
Problem 3: Source IP Lost
Some reverse proxies hide the original client IP from backends. Your application may always see the load balancer IP, which breaks rate limiting or logging.
Solution: use X-Forwarded-For or a similar header and configure your application or framework to trust it.
Nginx example:
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;Your backend framework usually has settings to use these headers as the real client IP.
Practical Tips for Beginners
To effectively use load balancing in your backend projects:
- Design your application to be as stateless as possible.
- Use a shared session store or token-based auth, not in-memory sessions tied to one server.
- Offload static files to object storage or a CDN to reduce load on your app servers.
- Start with round robin for simple setups, and use least connections if you have long-lived connections or WebSockets.
- Always implement health endpoints for your services.
- Monitor metrics like:
- Requests per second.
- Error rate.
- Latency percentiles (p50, p95, p99).
- CPU and memory usage on each backend node.
Rule of thumb: A load balancer does not fix a slow application. It only spreads the load. Always profile and optimize your backend first, then scale and load balance.
With these concepts and examples, you should be able to understand how load balancing fits into your backend architecture and how to configure simple load balancing with tools like Nginx.
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!