21.15. Production Docker Best Practices
Table of Contents
Why Production Docker Is Different
Running Docker in production is not the same as running containers on your laptop. In production, you care about:
- Security
- Reliability
- Performance
- Repeatability
- Observability
You must assume that containers will crash, nodes will reboot, and traffic will spike. Good production Docker practices reduce the impact of these events and make your system easier to operate.
Rule: Never treat a production Docker setup as "just like my local environment." Always harden, monitor, and test it under realistic conditions.
Build Images for Production
Use a small base image
Smaller images:
- Build faster
- Pull faster
- Have fewer packages to attack
- Are easier to cache
Common choices:
| Use case | Base image example |
|---|---|
| Python app | python:3.12-slim |
| Minimal Linux base | debian:bookworm-slim |
| Extremely small | alpine:3.20 (with care) |
Example (Python, production image):
FROM python:3.12-slim
WORKDIR /app
# Install system dependencies only if needed
RUN apt-get update && \
apt-get install -y --no-install-recommends build-essential && \
rm -rf /var/lib/apt/lists/*
# Copy dependency files first to leverage layer caching
COPY pyproject.toml poetry.lock ./
RUN pip install --no-cache-dir poetry && \
poetry config virtualenvs.create false && \
poetry install --only main --no-root --no-interaction --no-ansi
# Now copy the application code
COPY . .
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]Use multi-stage builds
In production you should not ship build tools or test dependencies. Multi-stage builds let you build in one stage and run in a smaller, cleaner stage.
Example:
# Build stage
FROM python:3.12-slim AS builder
WORKDIR /build
COPY pyproject.toml poetry.lock ./
RUN pip install --no-cache-dir poetry && \
poetry config virtualenvs.create false && \
poetry install --only main --no-root --no-interaction --no-ansi
COPY . .
RUN poetry build -f wheel
# Runtime stage
FROM python:3.12-slim AS runtime
WORKDIR /app
COPY --from=builder /build/dist/*.whl /tmp/app.whl
RUN pip install --no-cache-dir /tmp/app.whl && rm /tmp/app.whl
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]Benefits:
- No build tools in the final image
- Smaller image size
- Clear separation of build and runtime
Pin dependency versions
Unpinned versions can change when you rebuild, even from the same Dockerfile, which makes debugging production issues harder.
Good:
fastapi==0.115.0
uvicorn[standard]==0.30.0
SQLAlchemy==2.0.34Bad:
fastapi
uvicorn[standard]
SQLAlchemy>=2.0Rule: Always pin both system packages and application dependencies in production images to get repeatable builds.
Keep Containers Stateless
A stateless container does not keep important data in its own filesystem. If you delete it and start another one, the application still works.
What should not live inside a container
- User uploads
- Database data
- Cache data that must survive restarts
- Logs that you need for debugging (these should be streamed, not stored)
Instead:
- Use volumes for database data
- Use object storage (S3 and compatible) for user uploads
- Stream logs to stdout and stderr, not to files
Example docker-compose.yml snippet for a database:
services:
db:
image: postgres:16
volumes:
- db-data:/var/lib/postgresql/data
volumes:
db-data:Stateless containers can be:
- Scaled horizontally
- Replaced when you deploy new versions
- Restarted without losing state
Use Environment Variables for Configuration
In production, configuration must be:
- Separate from code
- Easy to change without rebuilding images
- Different per environment (dev, staging, prod)
Use environment variables, not hard-coded values in the image.
Docker example:
services:
api:
image: myorg/task-api:1.2.3
environment:
- APP_ENV=production
- DATABASE_URL=postgresql+psycopg://user:pass@db:5432/app
- REDIS_URL=redis://redis:6379/0
- SECRET_KEY_FILE=/run/secrets/secret_keyYour app reads from environment variables at startup.
Rule: Never bake secrets or environment-specific values directly into Docker images. Always inject them through environment variables or secret files.
Manage Secrets Safely
Do not store secrets in:
- Dockerfiles
- Image layers
- Git repositories
docker-compose.ymlin a public repo
Better options
- Docker secrets (Swarm) or orchestrator secrets (Kubernetes)
- External secret managers (Vault, AWS Secrets Manager, etc.)
- Mounted files with restricted permissions
Example using file-based secret:
services:
api:
image: myorg/task-api:1.2.3
environment:
- DB_PASSWORD_FILE=/run/secrets/db_password
volumes:
- ./secrets/db_password:/run/secrets/db_password:ro
Your app reads the content of /run/secrets/db_password at startup.
Run Containers with Least Privilege
Production containers should assume they could be compromised, so you must limit the damage they can do.
Avoid root inside the container
Create an unprivileged user in the Dockerfile:
FROM python:3.12-slim
RUN useradd -u 1001 -m appuser
WORKDIR /app
COPY . .
RUN chown -R appuser:appuser /app
USER appuser
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]Also:
- Avoid
--privileged - Grant only needed capabilities
- Use read-only root filesystem when possible
Example in docker-compose.yml:
services:
api:
image: myorg/task-api:1.2.3
read_only: true
tmpfs:
- /tmpRule: Do not run application containers as root in production unless you have a very specific, justified reason.
Handle Logs Correctly
Write logs to stdout and stderr
In containers you usually do not want to write application logs to files.
Good:
import logging
import sys
logging.basicConfig(
level=logging.INFO,
stream=sys.stdout,
format="%(asctime)s %(levelname)s %(name)s %(message)s",
)Then you can:
- Use
docker logsin simple setups - Use a logging driver or sidecar to send logs to a central system
Use structured logging
Structured logs are easier to search and analyze.
Example JSON log line:
{"ts":"2026-08-28T14:32:15Z","level":"INFO","msg":"user_logged_in","user_id":123}Health Checks and Graceful Shutdown
Health checks
You should expose:
- A liveness endpoint: is the process up?
- A readiness endpoint: is the app ready to receive traffic?
Examples in a FastAPI app:
from fastapi import FastAPI
app = FastAPI()
@app.get("/health/live")
def live():
return {"status": "ok"}
@app.get("/health/ready")
def ready():
# Optionally check database, cache, etc.
return {"status": "ok"}Container configuration:
services:
api:
image: myorg/task-api:1.2.3
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:8000/health/live"]
interval: 30s
timeout: 5s
retries: 3Graceful shutdown
Your app must handle termination signals such as SIGTERM and stop cleanly:
- Stop accepting new requests
- Finish in-flight requests
- Close database connections
Most application servers like Uvicorn or Gunicorn already handle this. You only need to ensure that long-running tasks are not abruptly killed without retry or cleanup, for example, delegate them to background workers.
Use Tags and Versioning Properly
Avoid using `latest` in production
latest means "whatever was pushed last," not a specific version.
Bad:
image: myorg/task-api:latestGood:
image: myorg/task-api:1.2.3Benefits:
- Predictable deployments
- Easier rollbacks
- Clear mapping between code and running containers
You can also use multi-part tags:
1.2.3exact version1.2latest in that minor series1latest in that major series
Rule: Always deploy explicit image tags that map to specific application versions.
Optimize for Performance and Resource Usage
Use resource limits
Without limits a single container can use all CPU or memory on a host.
Example:
services:
api:
image: myorg/task-api:1.2.3
deploy:
resources:
limits:
cpus: "1.0"
memory: 512M
reservations:
cpus: "0.25"
memory: 256MIn plain Docker:
docker run --cpus=1.0 --memory=512m myorg/task-api:1.2.3Use appropriate process model
For CPU bound apps:
- You may run multiple worker processes inside one container
- Or multiple containers with 1 process each
For typical Python web apps, many teams use:
- Several Uvicorn or Gunicorn workers per container
- Multiple containers behind a load balancer
Example Gunicorn command:
gunicorn "app.main:app" -w 4 -k uvicorn.workers.UvicornWorkerNumber of workers can follow a rough rule like:
$$\text{workers} = 2 \cdot \text{cores} + 1$$
Rule: Always test your container under realistic load before production. Default settings are rarely optimal.
Image Maintenance and Security
Regularly rebuild and update images
Security fixes often come from base images and system packages.
- Rebuild images regularly
- Apply security updates promptly
- Keep a changelog of image updates
Scan images for vulnerabilities
Use scanners such as:
- Trivy
- Grype
- Docker Scout
Automate scanning in your CI pipeline.
Remove unnecessary tools
Remove:
- Shells if not needed
- Compilers and build tools from runtime images
- Debug tools
They all increase attack surface.
Networking and Exposed Ports
Expose only what is necessary
Inside the Dockerfile, you can indicate the port:
EXPOSE 8000In production:
- Bind internal ports to internal networks
- Use a reverse proxy such as Nginx or Traefik to expose only HTTP or HTTPS to the internet
Example docker-compose.yml with an API behind Traefik:
services:
api:
image: myorg/task-api:1.2.3
networks:
- internal
traefik:
image: traefik:v3.1
ports:
- "80:80"
- "443:443"
networks:
- internal
- public
networks:
internal:
public:The database and cache should be on internal networks only, not directly exposed to the internet.
Observability in Production
Your containers in production must be:
- Loggable
- Measurable
- Inspectable
Metrics
Expose metrics for:
- Request rate
- Latencies
- Error rate
- Resource usage
You can:
- Run a metrics sidecar with Prometheus exporters
- Export application metrics directly
Traces
In more advanced setups, use tracing for:
- Following requests through multiple services
- Debugging slow operations
Tracing is usually integrated via libraries and environment variables, not directly through Docker, but your Docker configuration must ensure the tracer can reach its backend.
Rollouts and Rollbacks
In production you must think about how to:
- Roll out a new version
- Roll back to a previous version
Good practices:
- Use image tags that map to releases
- Keep configuration for both current and previous versions
- Test new images in staging environments that match production
In simple setups with plain Docker or Docker Compose:
- Pull the new image
- Start containers with the new tag
- If something goes wrong, switch back to the previous tag
In more advanced environments, use:
- Blue/green deployments
- Canary releases
These are orchestrator-level topics, but Docker images and tagging must support them.
Example: Production Docker Compose for a Simple Backend
Here is a small but realistic example for a backend API, PostgreSQL, and Redis:
version: "3.9"
services:
api:
image: myorg/task-api:1.2.3
env_file:
- ./env/production.env
environment:
- APP_ENV=production
- DB_PASSWORD_FILE=/run/secrets/db_password
secrets:
- db_password
depends_on:
- db
- redis
ports:
- "8000:8000"
restart: unless-stopped
read_only: true
tmpfs:
- /tmp
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:8000/health/live"]
interval: 30s
timeout: 5s
retries: 3
db:
image: postgres:16
environment:
- POSTGRES_DB=taskdb
- POSTGRES_USER=taskuser
- POSTGRES_PASSWORD_FILE=/run/secrets/db_password
secrets:
- db_password
volumes:
- db-data:/var/lib/postgresql/data
restart: unless-stopped
redis:
image: redis:7-alpine
command: ["redis-server", "--appendonly", "yes"]
volumes:
- redis-data:/data
restart: unless-stopped
secrets:
db_password:
file: ./secrets/db_password
volumes:
db-data:
redis-data:This example illustrates several best practices:
- Explicit image tags
- Secrets not in plain environment variables
- Restart policies
- Health checks
- Persistent volumes only for stateful services
- Read-only filesystem for the stateless API
Summary Checklist
You can use this as a quick review before deploying Docker to production:
| Area | Question | Done? |
|---|---|---|
| Image | Is the image small, multi-stage, and without build tools at runtime? | |
| Dependencies | Are system and app dependencies pinned to exact versions? | |
| Statelessness | Does the container avoid storing important data inside its filesystem? | |
| Configuration | Is all config provided via environment or secret files, not hard-coded? | |
| Secrets | Are secrets outside image layers and not in Git or docker-compose.yml? | |
| User | Does the container run as a non-root user? | |
| Logging | Do logs go to stdout and stderr in a structured format? | |
| Health checks | Are health endpoints and Docker healthcheck configured? | |
| Resources | Are CPU and memory limits defined and tested? | |
| Security | Are images scanned and unnecessary tools removed? | |
| Networking | Are only required ports exposed, behind a reverse proxy if needed? | |
| Versioning | Are explicit image tags used, with a clear rollback plan? |
If you can answer "yes" to these questions, your Docker setup is much closer to being production ready.
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!