32.7. Redis Integration
Table of Contents
Why Use Redis in the Final Project?
By the time you reach this chapter, your final project should already have:
- A PostgreSQL database
- A REST API
- Authentication and authorization
- Background workers
- File storage
Redis adds two important capabilities:
- Fast, in-memory key-value storage for things like:
- Caching expensive database queries
- Session or token blacklists
- Rate limiting and throttling
- Storing transient data for background jobs
- Lightweight coordination between services, for example:
- Sharing state between your API and workers
- Distributed locks to avoid race conditions
In this chapter, you will integrate Redis into your final project in a way that is structured, testable, and production-ready.
Designing Redis Usage in Your Architecture
Before writing code, decide clearly what Redis is responsible for in your project.
Typical uses for a production-style backend:
| Use case | Example key pattern | Typical TTL (time to live) |
|---|---|---|
| Caching DB queries | product:{id}, user:{id} | 5–30 minutes |
| API rate limiting | rate:{user_id}:{endpoint} | 1 minute |
| Session / token revoke | blacklist:{jti} or session:{id} | Until token/session expiration |
| Background job metadata | job:{id} | Until job completion + 1 day |
| Feature flags (optional) | feature:{name} | No expiration or long TTL |
Rule: Redis must never be your only source of truth for critical data.
All important, persistent data must still be stored in PostgreSQL or another durable store.
Decide and document:
- Which features will use Redis
- What key patterns you will use
- What TTLs make sense
- How Redis failures should affect your app (fail-open vs fail-closed)
Create a small design document in your project repo, for example:
docs/redis-usage.md.
Configuring Redis in the Project
Environment Variables
Add Redis configuration to your environment variables.
Example .env entries:
REDIS_HOST=redis
REDIS_PORT=6379
REDIS_DB=0
REDIS_PASSWORD=
REDIS_USE_TLS=falseIn production you might have:
REDIS_URL=redis://default:strong-password@my-redis-host:6379/0Decide whether you will:
- Use separate variables (
REDIS_HOST,REDIS_PORT, etc.), or - Use a single
REDIS_URLconnection string
Then be consistent across your codebase.
Configuration Module
Create or extend a central config (for example with Pydantic settings):
from pydantic import BaseSettings, AnyUrl
class Settings(BaseSettings):
redis_url: AnyUrl | None = None
redis_host: str = "localhost"
redis_port: int = 6379
redis_db: int = 0
redis_password: str | None = None
class Config:
env_file = ".env"
settings = Settings()
A helper to build the URL if REDIS_URL is not given:
from urllib.parse import quote_plus
def get_redis_url_from_settings(settings: Settings) -> str:
if settings.redis_url:
return str(settings.redis_url)
pwd_segment = ""
if settings.redis_password:
pwd_segment = f":{quote_plus(settings.redis_password)}@"
return (
f"redis://{pwd_segment}"
f"{settings.redis_host}:{settings.redis_port}/{settings.redis_db}"
)Choosing a Redis Client Library
For a modern FastAPI-based backend, a common choice is redis-py with async support.
Install:
pip install redis[hiredis]This gives you:
- Synchronous client:
redis.Redis - Asynchronous client:
redis.asyncio.Redis
For an async-first backend, it is better to use redis.asyncio.Redis.
Creating a Redis Client and Dependency
Central Redis Client Creation
Create app/core/redis.py (or similar):
from redis.asyncio import Redis
from typing import AsyncGenerator
from app.core.config import settings, get_redis_url_from_settings
_redis_client: Redis | None = None
async def get_redis_client() -> Redis:
global _redis_client
if _redis_client is None:
url = get_redis_url_from_settings(settings)
_redis_client = Redis.from_url(
url,
encoding="utf-8",
decode_responses=True, # return strings instead of bytes
)
return _redis_client
async def redis_lifespan(app) -> AsyncGenerator[None, None]:
client = await get_redis_client()
try:
# Verify connection at startup
await client.ping()
yield
finally:
await client.close()
You can hook redis_lifespan into FastAPI’s lifespan handler in your app initialization chapter, so here focus only on the Redis-specific part.
FastAPI Dependency
Create a dependency that can be injected into routes or services:
from fastapi import Depends
from redis.asyncio import Redis
from app.core.redis import get_redis_client
async def get_redis(
client: Redis = Depends(get_redis_client),
) -> Redis:
return client
Use this dependency only in the top layers (like routes) and in infrastructure services. Do not pass Redis directly into your domain logic.
Implementing a Caching Layer
Designing a Reusable Cache Service
Create app/services/cache.py:
from typing import Any, Callable, Awaitable
import json
import functools
from redis.asyncio import Redis
class CacheService:
def __init__(self, redis: Redis, default_ttl_seconds: int = 300):
self._redis = redis
self._default_ttl = default_ttl_seconds
async def get(self, key: str) -> Any | None:
raw = await self._redis.get(key)
if raw is None:
return None
return json.loads(raw)
async def set(
self,
key: str,
value: Any,
ttl_seconds: int | None = None,
) -> None:
ttl = ttl_seconds or self._default_ttl
await self._redis.set(key, json.dumps(value), ex=ttl)
async def delete(self, key: str) -> None:
await self._redis.delete(key)
async def exists(self, key: str) -> bool:
return bool(await self._redis.exists(key))Then a small factory dependency:
from fastapi import Depends
from redis.asyncio import Redis
from app.core.redis import get_redis_client
from app.services.cache import CacheService
def get_cache_service(
redis: Redis = Depends(get_redis_client),
) -> CacheService:
return CacheService(redis)Caching a Database Query
Imagine you have a product service:
class ProductService:
def __init__(self, repo, cache: CacheService | None = None):
self._repo = repo
self._cache = cache
async def get_product_by_id(self, product_id: int):
cache_key = f"product:{product_id}"
# 1. Try from cache
if self._cache:
cached = await self._cache.get(cache_key)
if cached is not None:
return cached
# 2. Fallback to DB
product = await self._repo.get_by_id(product_id)
if product is None:
return None
# 3. Save into cache
if self._cache:
await self._cache.set(cache_key, product, ttl_seconds=600)
return productExample route:
from fastapi import APIRouter, Depends, HTTPException, status
from app.services.cache import CacheService, get_cache_service
from app.services.products import ProductService, get_product_repo
router = APIRouter()
def get_product_service(
repo = Depends(get_product_repo),
cache: CacheService = Depends(get_cache_service),
) -> ProductService:
return ProductService(repo=repo, cache=cache)
@router.get("/products/{product_id}")
async def read_product(
product_id: int,
service: ProductService = Depends(get_product_service),
):
product = await service.get_product_by_id(product_id)
if product is None:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
return product
Note how the route does not know any Redis details. It just uses a ProductService.
Cache Invalidation
Caching only works correctly if you invalidate or update cached data when the underlying data changes.
For products, whenever you update or delete a product, you should clear the cache for that product.
Example in ProductService:
async def update_product(self, product_id: int, data) -> dict | None:
updated = await self._repo.update(product_id, data)
if updated and self._cache:
cache_key = f"product:{product_id}"
await self._cache.delete(cache_key)
return updated
async def delete_product(self, product_id: int) -> bool:
deleted = await self._repo.delete(product_id)
if deleted and self._cache:
cache_key = f"product:{product_id}"
await self._cache.delete(cache_key)
return deleted
Rule: Every write that affects cached data must either update or invalidate the relevant cache keys.
If you forget this, your API may return stale or inconsistent data.
For list endpoints, for example GET /products?category_id=123, a simple pattern is:
- Do not cache every possible query combination at first, or
- Cache only specific, highly used queries with clear keys like
products:category:{id}.
Rate Limiting with Redis
Rate limiting prevents a single client from sending too many requests in a short time.
A simple per-user, per-endpoint limit:
- Key:
rate:{user_id}:{endpoint_path} - Value: count of requests in the current window
- TTL: window length, for example 60 seconds
Simple Sliding Window Implementation
Create app/services/rate_limiter.py:
from redis.asyncio import Redis
from fastapi import HTTPException, status
class RateLimiter:
def __init__(self, redis: Redis, limit: int, window_seconds: int):
self.redis = redis
self.limit = limit
self.window = window_seconds
async def check(self, key: str) -> None:
# INCR returns the new value after increment
current = await self.redis.incr(key)
if current == 1:
# First hit, set expiration
await self.redis.expire(key, self.window)
if current > self.limit:
raise HTTPException(
status_code=status.HTTP_429_TOO_MANY_REQUESTS,
detail="Too many requests, please try again later.",
)Now a FastAPI dependency that uses it:
from fastapi import Depends, Request
from redis.asyncio import Redis
from app.core.redis import get_redis_client
from app.services.rate_limiter import RateLimiter
def rate_limiter_dependency(
limit: int,
window_seconds: int,
):
async def dependency(
request: Request,
redis: Redis = Depends(get_redis_client),
):
user_id = request.state.user_id if hasattr(request.state, "user_id") else "anonymous"
endpoint = request.url.path
key = f"rate:{user_id}:{endpoint}"
limiter = RateLimiter(redis, limit, window_seconds)
await limiter.check(key)
return dependencyUse it on a route:
from fastapi import Depends
from app.services.rate_limiter_dependency import rate_limiter_dependency
@router.get("/orders")
async def list_orders(
_=Depends(rate_limiter_dependency(limit=60, window_seconds=60)),
):
...
This limits each user to 60 requests per minute to /orders.
Token Blacklisting or Session Storage
If you implement JWT access and refresh tokens, you may want to:
- Store active sessions in Redis, or
- Maintain a blacklist of revoked tokens until they expire
Storing Sessions
A simple session model:
- Key:
session:{session_id} - Value: JSON with
user_id,created_at, etc. - TTL: equal to session lifetime
Example repository:
import json
from datetime import timedelta
from redis.asyncio import Redis
class SessionStore:
def __init__(self, redis: Redis):
self._redis = redis
async def create_session(
self,
session_id: str,
data: dict,
ttl: timedelta,
) -> None:
key = f"session:{session_id}"
await self._redis.set(
key,
json.dumps(data),
ex=int(ttl.total_seconds()),
)
async def get_session(self, session_id: str) -> dict | None:
key = f"session:{session_id}"
raw = await self._redis.get(key)
if raw is None:
return None
return json.loads(raw)
async def delete_session(self, session_id: str) -> None:
key = f"session:{session_id}"
await self._redis.delete(key)Your authentication layer can then:
- Create a session when the user logs in
- Validate the session ID from cookies or headers
- Delete the session when the user logs out
Blacklisting JWTs
JWTs are stateless, so to support logout you can:
- Include a
jti(JWT ID) in each token - Store
blacklist:{jti}in Redis with TTL equal to token lifetime
Example:
class TokenBlacklist:
def __init__(self, redis: Redis):
self._redis = redis
async def add(self, jti: str, ttl_seconds: int) -> None:
key = f"blacklist:{jti}"
await self._redis.set(key, "1", ex=ttl_seconds)
async def is_blacklisted(self, jti: str) -> bool:
key = f"blacklist:{jti}"
return bool(await self._redis.exists(key))Your auth dependency can then:
- Extract
jtifrom token - Check
TokenBlacklist.is_blacklisted(jti) - Reject requests if it returns
True
Using Redis from Background Workers
Your background worker processes (for example Celery or a custom worker) can also use Redis.
Typical roles:
- Broker/message queue (covered in the background processing chapter)
- Central cache access
- Storing job state or deduplication keys
Key point: use the same configuration approach.
In your worker process:
- Import the same settings
- Build the same Redis client
Example in a worker module:
from redis.asyncio import Redis
from app.core.config import settings, get_redis_url_from_settings
def create_redis_for_worker() -> Redis:
url = get_redis_url_from_settings(settings)
return Redis.from_url(
url,
encoding="utf-8",
decode_responses=True,
)Use this function in your task handlers to get a Redis client.
Handling Redis Failures Gracefully
In production, Redis may be temporarily unavailable. You must decide how the system behaves when Redis fails.
Typical strategy:
- For caching and rate limiting: log the error and proceed with DB or no rate limit, to avoid total downtime
- For sessions or token blacklists: probably treat failure as an authentication failure, or lock down access
Example: Safe Cache Wrapper
Update your CacheService methods to catch Redis errors:
import logging
from redis.exceptions import RedisError
logger = logging.getLogger(__name__)
class CacheService:
...
async def get(self, key: str):
try:
raw = await self._redis.get(key)
except RedisError:
logger.exception("Redis GET failed")
return None
if raw is None:
return None
return json.loads(raw)
async def set(self, key: str, value: Any, ttl_seconds: int | None = None):
try:
ttl = ttl_seconds or self._default_ttl
await self._redis.set(key, json.dumps(value), ex=ttl)
except RedisError:
logger.exception("Redis SET failed, ignoring")For rate limiting:
from redis.exceptions import RedisError
class RateLimiter:
...
async def check(self, key: str) -> None:
try:
current = await self.redis.incr(key)
if current == 1:
await self.redis.expire(key, self.window)
except RedisError:
# Fail-open: if Redis is down, skip limiting
return
if current > self.limit:
...Rule: Decide per feature whether Redis failures should:
- Fail-open, allow the request (caches, most rate limits), or
- Fail-closed, deny the request (security-sensitive session checks)
Document this behavior.
Testing Redis Integration
To keep tests fast and deterministic, avoid using a real Redis instance for unit tests if possible.
Common patterns:
- Use a mock Redis client for unit tests of higher-level services
- Use a real Redis (with Docker or local) for integration tests
Mocking Redis for Unit Tests
Create a simple in-memory fake:
class FakeRedis:
def __init__(self):
self.store = {}
async def get(self, key: str):
return self.store.get(key)
async def set(self, key: str, value, ex=None):
self.store[key] = value
async def delete(self, key: str):
self.store.pop(key, None)
async def incr(self, key: str):
value = int(self.store.get(key, "0"))
value += 1
self.store[key] = str(value)
return value
async def expire(self, key: str, seconds: int):
# For unit tests, you can ignore TTL
return True
async def exists(self, key: str):
return 1 if key in self.store else 0Use this fake in tests:
import pytest
from app.services.cache import CacheService
from tests.fakes import FakeRedis
@pytest.mark.asyncio
async def test_cache_service_get_set():
redis = FakeRedis()
cache = CacheService(redis)
assert await cache.get("foo") is None
await cache.set("foo", {"a": 1})
assert await cache.get("foo") == {"a": 1}Integration Tests with a Real Redis
If you already use Docker Compose, add a Redis service, then in tests:
- Use the same Redis URL as your app
- Clear keys before each test, for example
await redis.flushdb()in a fixture
Example fixture:
import pytest
from redis.asyncio import Redis
from app.core.config import settings, get_redis_url_from_settings
@pytest.fixture
async def redis_client():
url = get_redis_url_from_settings(settings)
client = Redis.from_url(url, encoding="utf-8", decode_responses=True)
await client.flushdb()
try:
yield client
finally:
await client.close()Operational Considerations
For production, also think about:
- Key naming conventions
Use clear prefixes, for example: cache:product:{id}rate:{user_id}:{endpoint}session:{session_id}- Expiration policies
Ensure that all temporary keys have a TTL to avoid unbounded growth. - Metrics and monitoring
Track: - Hit/miss ratio for caches
- Number of rate limit rejections
- Redis latency and memory usage
- Security
- Use authentication on your Redis server
- Restrict network access to Redis (VPC, firewall rules)
- Enable TLS if traffic crosses untrusted networks
Summary
In the final project, Redis should:
- Act as a shared, in-memory service for caching, rate limiting, and session/token data
- Be configured using consistent environment variables and a central settings module
- Be accessed through small, focused services such as
CacheService,RateLimiter,SessionStore, andTokenBlacklist - Fail gracefully so that your application behaves predictably even if Redis is unavailable
- Be testable through mock clients for unit tests and a real instance for integration tests
With this integration in place, your final project closely resembles a real production backend that combines PostgreSQL for durable data and Redis for fast, transient operations.
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!