21.14. Multi-Container Applications
Table of Contents
Why Multi-Container Matters
Most real backend systems are not a single container. A typical production setup might include:
- An application container (FastAPI)
- A database container (PostgreSQL)
- A cache container (Redis)
- A message broker container (Redis or RabbitMQ)
- A reverse proxy container (Nginx or Traefik)
Running each part in its own container gives you:
- Clear separation of responsibilities
- Independent scaling of each service
- Easier updates and rollbacks
- Consistent local and production environments
In this chapter you will learn how to make multiple containers work together as one application.
Important rule: In Docker, a multi-container application is a group of containers that:
- Share a network so they can talk to each other by name.
- Use volumes or other storage to keep important data.
- Are started and managed together, usually with Docker Compose.
Single Container vs Multi-Container
The single-container approach
When you start, you might try to put everything in one container:
- Application code
- Database server
- Task queue workers
- Reverse proxy
- Cron jobs
For example, a big Dockerfile that installs PostgreSQL, Redis, Nginx and your app, then runs a shell script that starts them all. This works for a demo, but it has serious problems:
- If PostgreSQL crashes, the whole container may fail.
- You cannot scale the app without also scaling the database.
- Logs from all processes are mixed together.
- Updating one part forces you to rebuild and redeploy everything.
The multi-container approach
Instead, you run each piece as its own container. For example:
| Service | Image | Role |
|---|---|---|
web | myorg/myapp:latest | FastAPI application |
db | postgres:16 | PostgreSQL database |
redis | redis:7 | Cache and background jobs |
worker | myorg/myapp:latest | Celery or RQ background worker |
nginx | nginx:stable | Reverse proxy and static files |
Each container:
- Runs one main process.
- Can have its own resource limits.
- Can be restarted or replaced independently.
Important rule: A container should run one main process. If you need many different services, use many containers.
Docker Networks in Multi-Container Setups
To let containers communicate, they must share a Docker network.
Default bridge network vs custom network
When you start containers with docker run and do not specify a network, Docker uses the bridge network. Containers on that network can talk to each other, but DNS names can be tricky to manage manually.
For multi-container applications you usually create a user-defined bridge network:
docker network create myapp-networkThen run containers on that network:
docker run -d --name db --network myapp-network postgres:16
docker run -d --name web --network myapp-network myorg/myapp:latest
Inside the web container, you can now connect to PostgreSQL with:
host = "db"
port = 5432because Docker gives each container a hostname equal to its container name.
Networks and Docker Compose
With Docker Compose, you usually do not create networks manually. Compose creates a network automatically and attaches all services to it.
For a project named myapp, the default network might be named myapp_default. Each service is reachable by its service name:
- Service
dbis reachable asdb - Service
redisis reachable asredis
Example environment values inside the app container:
DATABASE_URL=postgresql://postgres:postgres@db:5432/mydb
REDIS_URL=redis://redis:6379/0
You never need to use localhost inside a container to reach another container. localhost always means "this same container".
Important rule: To connect from one container to another, use the service or container name on the shared Docker network, not localhost.
Introducing Docker Compose
Managing many docker run commands is painful. Docker Compose solves this problem.
A simple docker-compose.yml:
version: "3.9"
services:
db:
image: postgres:16
environment:
POSTGRES_USER: myuser
POSTGRES_PASSWORD: mypassword
POSTGRES_DB: mydb
volumes:
- myapp-db:/var/lib/postgresql/data
web:
build: .
environment:
DATABASE_URL: postgresql://myuser:mypassword@db:5432/mydb
ports:
- "8000:8000"
depends_on:
- db
volumes:
myapp-db:One command to start everything:
docker compose upand to stop everything:
docker compose downYou will use Docker Compose for almost all local multi-container development.
A Typical 3-Container Setup
Let us build a very common setup:
- FastAPI app
- PostgreSQL database
- Redis cache
Directory layout example
myapp/
app/
main.py
...
Dockerfile
requirements.txt
docker-compose.ymlExample `Dockerfile` for FastAPI
FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app ./app
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]Example `docker-compose.yml`
version: "3.9"
services:
db:
image: postgres:16
environment:
POSTGRES_USER: myuser
POSTGRES_PASSWORD: mypassword
POSTGRES_DB: mydb
volumes:
- db-data:/var/lib/postgresql/data
redis:
image: redis:7
volumes:
- redis-data:/data
web:
build: .
environment:
DATABASE_URL: postgresql://myuser:mypassword@db:5432/mydb
REDIS_URL: redis://redis:6379/0
ports:
- "8000:8000"
depends_on:
- db
- redis
volumes:
db-data:
redis-data:Now:
webconnects to PostgreSQL atdb:5432.webconnects to Redis atredis:6379.- Data for PostgreSQL and Redis is stored in named volumes.
Run:
docker compose up --build
Then open http://localhost:8000 in your browser.
`depends_on` and Startup Order
depends_on defines start order, but it does not wait for the service to be "ready". It only guarantees that the container is started.
For example:
web:
depends_on:
- db
This means Docker will start db before web, but PostgreSQL might still be initializing when the app tries to connect.
To handle this, you can:
- Use retry loops in your application startup.
- Use a "wait for" script that tries the connection until it succeeds.
- Use healthchecks and conditional start in more advanced setups.
Example simple retry in Python (pseudo-code):
import time
import psycopg2
for attempt in range(10):
try:
conn = psycopg2.connect("postgresql://...")
break
except Exception:
print("Database not ready, waiting...")
time.sleep(2)
else:
raise RuntimeError("Database not available")
Important rule: depends_on does not guarantee that a service is ready, only that the container has been started.
Sharing Data with Volumes
In multi-container applications, you usually need:
- Persistent storage for databases and other stateful services.
- Shared access to files between services, for example logs, uploads, or code in development.
Named volumes for persistent data
Named volumes are managed by Docker. They work well for database storage:
services:
db:
image: postgres:16
volumes:
- my-db-data:/var/lib/postgresql/data
volumes:
my-db-data:If the container is removed, the volume still exists and you do not lose your data.
Bind mounts for local development
During development, you often want to edit code on your machine and see changes instantly without rebuilding the image every time. Use a bind mount:
services:
web:
build: .
volumes:
- ./app:/app/app
Now, any changes you make in the local ./app directory are visible inside the container at /app/app.
Example: App + Worker + Broker
A common multi-container pattern:
webserves HTTP requests.workerprocesses background jobs.redisor another message broker passes jobs from web to worker.
Example docker-compose setup
version: "3.9"
services:
redis:
image: redis:7
web:
build: .
environment:
REDIS_URL: redis://redis:6379/0
ports:
- "8000:8000"
depends_on:
- redis
worker:
build: .
environment:
REDIS_URL: redis://redis:6379/0
command: ["python", "-m", "app.worker"]
depends_on:
- redis- Both
webandworkeruse the same image. webuses the defaultCMDfrom the Dockerfile to run Uvicorn.workeroverridesCMDand runs a separate worker process.- Both connect to Redis using the service name
redis.
Inside your code, you can have:
# app/main.py
import redis
r = redis.from_url("redis://redis:6379/0")# app/worker.py
import redis
r = redis.from_url("redis://redis:6379/0")Environment Configuration in Multi-Container Apps
Each service can have its own environment variables. You can:
- Define them inline in
docker-compose.yml. - Load them from an external
.envfile.
Inline environment example
web:
environment:
DATABASE_URL: postgresql://myuser:mypassword@db:5432/mydb
REDIS_URL: redis://redis:6379/0
APP_ENV: developmentUsing a `.env` file with Compose
Create a .env file:
POSTGRES_USER=myuser
POSTGRES_PASSWORD=mypassword
POSTGRES_DB=mydb
APP_ENV=development
Then in docker-compose.yml:
services:
db:
image: postgres:16
environment:
POSTGRES_USER: ${POSTGRES_USER}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
POSTGRES_DB: ${POSTGRES_DB}
web:
build: .
environment:
DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@db:5432/${POSTGRES_DB}
APP_ENV: ${APP_ENV}
Compose will read variables from the .env file when you run docker compose up.
Important rule: Do not hardcode secrets directly in images. Use environment variables or secret management tools for sensitive data.
Scaling Services
One of the biggest advantages of multi-container setups is that you can scale different parts independently.
For example, you might want:
- 1 PostgreSQL container
- 1 Redis container
- 3 FastAPI containers
- 2 worker containers
With Docker Compose, you can scale a service:
docker compose up --scale web=3 --scale worker=2or define replicas in the file (supported in some Compose versions and in Swarm/Kubernetes).
When you scale web, Docker:
- Starts multiple containers from the same image.
- Connects them all to the same network.
- Assigns them different internal IPs.
If you have a reverse proxy like Nginx or Traefik, it can route traffic across all web containers.
You will see containers with names like:
myapp-web-1myapp-web-2myapp-web-3
Inside the network, they are all reachable by the common service name web through load balancing that your proxy handles.
Adding a Reverse Proxy Container
A common 4-container setup:
webFastAPIdbPostgreSQLrediscachenginxreverse proxy
Example:
version: "3.9"
services:
db:
image: postgres:16
environment:
POSTGRES_USER: myuser
POSTGRES_PASSWORD: mypassword
POSTGRES_DB: mydb
volumes:
- db-data:/var/lib/postgresql/data
redis:
image: redis:7
web:
build: .
environment:
DATABASE_URL: postgresql://myuser:mypassword@db:5432/mydb
REDIS_URL: redis://redis:6379/0
expose:
- "8000"
depends_on:
- db
- redis
nginx:
image: nginx:stable
ports:
- "80:80"
volumes:
- ./nginx.conf:/etc/nginx/nginx.conf:ro
depends_on:
- web
volumes:
db-data:
In nginx.conf you can point to web:8000 as the upstream. The user only accesses Nginx on port 80, and Nginx forwards requests to the FastAPI service.
Debugging Multi-Container Issues
Common problems and how to diagnose them:
1. Container cannot reach another container
Symptoms:
- Connection errors like
Connection refusedorName or service not known.
Checklist:
- Are both containers on the same Docker network?
Usedocker compose psanddocker network inspectfor Compose setups. - Are you using the service name as the host, not
localhost? - Is the target service actually running?
Usedocker compose logs dbordocker ps.
2. Database or Redis loses data after restart
Likely cause: missing or misconfigured volume.
Checklist:
- Does the service have a
volumessection? - Is the volume declared in the top-level
volumessection? - Did you run
docker compose down -vwhich removes volumes?
3. Environment variables not loaded
Checklist:
- Are you using the right syntax
${VAR_NAME}indocker-compose.yml? - Does the
.envfile exist in the same directory where you rundocker compose? - Did you restart the containers after changing environment variables?
4. Service restarts in a loop
Run:
docker compose logs <service-name>Look for Python errors, connection issues, or misconfigurations. Fix the underlying problem, then restart.
Summary
In this chapter you learned the core ideas of multi-container applications with Docker:
- Split your application into separate containers for each service.
- Use Docker networks so containers can communicate by service name.
- Use Docker Compose to define and run your entire stack with one command.
- Use volumes to keep database and other important data persistent.
- Use environment variables to configure each service.
- Scale services independently when you need more capacity.
- Add extra containers like workers and reverse proxies when your app grows.
These patterns are the foundation for more advanced orchestration tools, such as Kubernetes, that you may use later in production.
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!