17.5. Redis as a Message Broker
Table of Contents
Why Use Redis as a Message Broker?
In background processing, a message broker is the part that sits between the web application and the workers. It receives jobs, stores them, and delivers them to workers.
Redis is a very popular choice for this role because:
- It is extremely fast, in memory, and simple.
- It has data structures that map nicely to queues.
- It is widely supported by task queues like Celery and RQ.
- It is easy to install and run in Docker.
You already saw Redis used for caching and other use cases. Here we focus on using Redis specifically as the transport layer for background jobs.
Important rule: A message broker should be reliable. Your application must never assume that "fire and forget" is enough. Always design for:
- Jobs being retried.
- Messages possibly being delivered more than once.
- Workers possibly crashing while processing.
Basic Message Queue Concepts with Redis
A queue is a list of tasks that need to be processed. The main operations are:
- Producer puts messages into the queue.
- Worker takes messages out of the queue and processes them.
With Redis you can implement queues using list commands like LPUSH, RPUSH, LPOP, and blocking operations like BLPOP.
Simple Redis Queue with Lists
Imagine a queue called email_queue that stores tasks. Each task is a JSON string.
Adding a message (producer)
Producer (web app) enqueues a new task:
LPUSH email_queue '{"to": "alice@example.com", "subject": "Hello", "body": "Hi Alice"}'Or from Python:
import json
import redis
r = redis.Redis(host="localhost", port=6379, db=0)
task = {
"to": "alice@example.com",
"subject": "Hello",
"body": "Hi Alice",
}
r.lpush("email_queue", json.dumps(task))Here the left side of the list is considered the "front" of the queue.
Consuming a message (worker)
A worker can block and wait for new jobs:
BLPOP email_queue 0
The 0 means "wait forever until something is available".
In Python:
import json
import redis
r = redis.Redis(host="localhost", port=6379, db=0)
while True:
# BLPOP returns (queue_name, data)
_, raw_task = r.blpop("email_queue", timeout=0)
task = json.loads(raw_task)
print(f"Sending email to {task['to']}")
# ... actually send email here ...This is already a working message queue with:
- Producer using
LPUSH - Consumer using
BLPOP
But it has a major limitation: if the worker crashes after BLPOP but before finishing the job, the message is lost.
Reliable Message Delivery Patterns
To be a useful message broker, Redis needs to support reliable processing:
- Jobs should not be lost if a worker crashes.
- Jobs should not be processed twice unless you design for that case.
Redis on its own does not give you a full job system, but you can build patterns on top of it or use libraries that do it for you.
Using a Work Queue and a Processing Queue
A common pattern is:
- One list:
queue:pending - Another list:
queue:processing
The idea:
- Worker moves a job from
pendingtoprocessingin one atomic step usingRPOPLPUSH. - Worker processes the job.
- If processing succeeds, worker removes the job from
processing. - If worker crashes, the job remains in
processing. A recovery process can check for old jobs inprocessingand requeue them.
Step-by-step with Redis commands
1. Producer puts job in pending queue
LPUSH queue:pending '{"id": 1, "task": "send_email", "to": "alice@example.com"}'2. Worker atomically moves job to processing
RPOPLPUSH queue:pending queue:processing
This removes the rightmost element from queue:pending and pushes it to the left of queue:processing, atomically.
In Python:
raw_job = r.rpoplpush("queue:pending", "queue:processing")
job = json.loads(raw_job)3. Worker processes the job
try:
# Do the work
print(f"Sending email to {job['to']}")
# ... send email ...
except Exception:
# If failed, you may choose to move it back or log
raise
else:
# If successful, remove from processing
r.lrem("queue:processing", 1, raw_job)4. Recovery process
A separate script can scan queue:processing and decide if items are too old and should be requeued:
processing_jobs = r.lrange("queue:processing", 0, -1)
for raw_job in processing_jobs:
job = json.loads(raw_job)
# Suppose job has a "started_at" timestamp
# If too old, move back to pendingThis pattern is the foundation of many Redis-based queues.
Rule: Never just BLPOP from a single queue if you care about reliability. Use patterns that keep a separate processing state or use a library that implements it for you.
Using Redis Pub/Sub vs Queues
Redis also has Pub/Sub, which allows clients to subscribe to channels and receive messages that are published to them.
Example:
SUBSCRIBE log_channel
PUBLISH log_channel "Server restarted"In Python:
import redis
r = redis.Redis()
pubsub = r.pubsub()
pubsub.subscribe("log_channel")
for message in pubsub.listen():
print(message)Differences from queues:
| Feature | Queues (lists) | Pub/Sub |
|---|---|---|
| Message persistence | Stored in Redis until removed | Not stored, only delivered to subscribers |
| Late subscribers | Can read older messages still in the list | Miss messages sent before subscription |
| Typical use case | Background jobs, task queues | Real-time notifications, chat updates |
| Reliability after restart | Messages can remain if Redis persists data | Messages are lost on restart |
For background processing, you usually want queues with lists, not Pub/Sub, because:
- You need messages to be stored until processed.
- Workers may be restarted or offline temporarily.
Pub/Sub is more for real-time events where it is acceptable to miss some messages.
Redis as a Broker for Celery
Instead of manually implementing your queue logic, you can use Celery, a popular task queue library in Python. Celery supports Redis as a broker and handles:
- Enqueueing tasks.
- Distributing tasks to workers.
- Retries, acknowledgements, and results.
Here is a minimal setup.
Installing Celery with Redis
pip install celery[redis]Defining a Celery app using Redis as broker
celery_app.py:
from celery import Celery
celery_app = Celery(
"tasks",
broker="redis://localhost:6379/0", # Redis as broker
backend="redis://localhost:6379/1", # Optional, store results
)Declaring a task
tasks.py:
import time
from celery_app import celery_app
@celery_app.task
def add(x, y):
time.sleep(2) # simulate long work
return x + ySending a task from your web app
from tasks import add
# Enqueue a task
result = add.delay(4, 5) # returns immediately
print(result.id) # task IDCelery will push a message into Redis that looks something like:
- Queue name:
celery - Payload: JSON with task name
tasks.add, arguments[4, 5], etc.
Running a Celery worker
In a terminal:
celery -A tasks worker --loglevel=infoThe worker connects to Redis, listens to the queue, pulls messages, executes them, and updates the result.
Getting the result later
from tasks import add
result = add.delay(4, 5)
# Wait for the result (blocking)
value = result.get(timeout=10)
print(value) # 9Internally:
- The producer is your Python code calling
add.delay. - The broker is Redis storing the job message.
- The worker is the Celery process.
You do not need to manage Redis commands directly. Celery uses Redis lists and keys to implement a reliable queue.
Redis as a Broker with FastAPI
Let us combine FastAPI, Celery, and Redis. In a real project you would split files, but here is a simple example.
Project structure
.
├─ celery_app.py
├─ tasks.py
└─ main.py
celery_app.py:
from celery import Celery
celery_app = Celery(
"background_tasks",
broker="redis://localhost:6379/0",
backend="redis://localhost:6379/1",
)
tasks.py:
import time
from celery_app import celery_app
@celery_app.task
def send_email(to: str, subject: str, body: str) -> str:
time.sleep(5) # simulate long operation
# Here you would call an email provider
print(f"Sending email to {to} with subject '{subject}'")
return "ok"
main.py:
from fastapi import FastAPI
from pydantic import BaseModel
from tasks import send_email
app = FastAPI()
class EmailRequest(BaseModel):
to: str
subject: str
body: str
@app.post("/send-email")
def enqueue_email(email: EmailRequest):
task = send_email.delay(email.to, email.subject, email.body)
return {"task_id": task.id, "status": "queued"}Running everything
- Start Redis:
redis-server- Start Celery worker:
celery -A tasks worker --loglevel=info- Start FastAPI:
uvicorn main:app --reload- Send a request:
curl -X POST http://localhost:8000/send-email \
-H "Content-Type: application/json" \
-d '{"to": "alice@example.com", "subject": "Hi", "body": "Hello"}'Response example:
{
"task_id": "a203f18f-0f34-4abd-b9b2-53d43b96a0be",
"status": "queued"
}The HTTP response is immediate, while the actual email task is processed in the background by Celery workers, with Redis acting as the message broker.
Designing Queues and Routing with Redis
In real systems, you often need multiple queues for different job types and priorities.
Multiple queues
Example queues:
emailsreportsthumbnailshigh_prioritylow_priority
Producers push to different lists:
r.lpush("queue:emails", email_job_json)
r.lpush("queue:reports", report_job_json)Workers can:
- Listen to a specific queue, for example only
queue:emails. - Or use
BLPOPon multiple queues with a priority order:
# Prefer high_priority, fall back to low_priority
queue, raw_job = r.blpop("queue:high_priority", "queue:low_priority", timeout=0)With Celery, you can define named queues and route tasks to them using configuration, but Redis is still the underlying broker that stores these per-queue lists.
Priority queues
Basic priority pattern with multiple lists:
queue:highqueue:mediumqueue:low
Worker:
while True:
item = r.blpop("queue:high", "queue:medium", "queue:low", timeout=0)
queue_name, raw_job = item
# Process jobFor simple systems, this is enough. For more complex priority rules you might use sorted sets with a score field, but that is more advanced.
Handling Retries and Failures
Background jobs fail for many reasons:
- Temporary network problems.
- External services being down.
- Bugs in your code.
You should have a strategy for retries.
Manual retry strategy with Redis
A job may have fields like:
{
"id": 123,
"task": "send_email",
"payload": {
"to": "alice@example.com"
},
"retry_count": 0,
"max_retries": 5
}Simplified worker logic:
import json
import time
import redis
r = redis.Redis()
MAX_RETRIES = 5
while True:
_, raw_job = r.blpop("queue:pending", timeout=0)
job = json.loads(raw_job)
try:
# process job
print(f"Sending email to {job['payload']['to']}")
# ...
except Exception as e:
job["retry_count"] += 1
if job["retry_count"] <= job["max_retries"]:
# Requeue with some delay (very naive)
time.sleep(2 ** job["retry_count"]) # exponential backoff
r.lpush("queue:pending", json.dumps(job))
else:
# Move to dead-letter queue
r.lpush("queue:failed", json.dumps(job))This demonstrates:
- Retry count stored in job.
- Exponential backoff using
2 ** retry_count. - Dead-letter queue for jobs that failed too many times.
Rule: Always have a way to inspect failed jobs, usually a dead-letter queue or a dedicated set or list like queue:failed. Never silently drop failures.
Visibility Timeouts and Acknowledgements
More advanced message brokers, such as AWS SQS, have a visibility timeout: after a worker takes a message, the message becomes invisible for a time. If the worker does not acknowledge it before the timeout, the message becomes visible again and can be processed by another worker.
Redis does not have this built in, but some Redis-based queues implement a similar idea:
- Job is moved to a "processing" structure with a timestamp.
- A separate component checks if the job has been in "processing" too long and moves it back.
Systems like RQ, Celery, and BullMQ (Node.js) implement acknowledgement and timeouts on top of Redis, so you do not have to.
When you choose Redis as a broker through such libraries, you automatically get:
- Acknowledge on success.
- Retry on failure.
- Visibility timeout or similar mechanism.
Scaling Workers with Redis
One of the strengths of Redis as a broker is that you can add many workers, even on multiple machines, all pointing to the same Redis instance.
Horizontal scaling
Suppose you have heavy tasks:
- Image processing.
- Sending a lot of emails.
- Report generation.
You can run multiple worker processes or containers:
celery -A tasks worker --loglevel=info --concurrency=4
celery -A tasks worker --loglevel=info --concurrency=4With 2 worker processes and concurrency of 4 each, you can run up to 8 tasks in parallel, all reading from the same queue in Redis.
Because Redis operations are atomic, only one worker gets each message.
Load balancing
Redis does not "load balance" by itself through any special feature. Instead, all workers pull from the same queue. The number of workers and their concurrency levels determine how much total work can be processed.
If you see:
- Queue length growing fast.
- Jobs waiting a long time.
You can:
- Add more workers.
- Use separate queues for heavy tasks versus light tasks.
- Use more Redis instances if one becomes a bottleneck.
Redis Broker Configuration and Tuning Basics
For real systems, you need to think about:
- Persistence.
- Memory and eviction policy.
- Security and access.
Persistence and durability
Redis is in memory, but can persist to disk using:
- RDB snapshots.
- AOF (Append Only File).
For a message broker, losing messages on a restart can be very bad.
Basic configuration options in redis.conf to enable AOF:
appendonly yes
appendfsync everysecThis makes Redis slower but safer.
Eviction policies
If Redis runs out of memory, the eviction policy decides what to remove. For a broker, you usually do not want Redis to start evicting arbitrary keys that might be queue messages.
Example safe-ish choice in redis.conf for a broker:
maxmemory-policy noevictionWith this, Redis will refuse writes if it is out of memory, instead of deleting messages. Your application then needs to handle errors.
Security basics
For production:
- Run Redis in a private network, not accessible from the public internet.
- Use authentication:
In redis.conf:
requirepass your_strong_password_hereIn Python:
r = redis.Redis(host="redis-host", port=6379, password="your_strong_password_here")- Use TLS if Redis is accessed over untrusted networks.
Summary
Redis as a message broker gives you:
- Fast, simple queues using lists and commands like
LPUSH,BLPOP, andRPOPLPUSH. - The ability to build reliable patterns with pending and processing queues.
- Support for multiple queues and priority handling.
- Integration with libraries such as Celery, RQ, and others that implement robust task processing.
For backend development, Redis is often the easiest way to get from "I have a FastAPI app" to "I have background workers that process tasks reliably."
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!