24.8. Building Docker Images
Table of Contents
Why CI/CD Needs Docker Images
In CI/CD, almost everything ends up as a Docker image. Your pipeline usually:
- Runs tests.
- Builds a Docker image that contains your app and its dependencies.
- Pushes that image to a registry.
- Deploys that exact image to staging or production.
So, learning to build good images is critical for:
- Reproducible deployments.
- Fast pipelines.
- Smaller attack surface and fewer bugs in production.
This chapter focuses on how to build images that are predictable, small, and CI/CD friendly, not on Docker basics in general.
From Application Code to Docker Image
In a typical backend repository, you will have:
- Application code, for example
app/orsrc/. - A dependency file, for example
requirements.txtorpyproject.toml. - A
Dockerfilein the project root.
The CI pipeline will use the Dockerfile:
docker build -t my-backend:1.0.0 .
The build context is the current directory .. Docker sends all files in this directory (except what is ignored) to the Docker daemon. The instructions in the Dockerfile tell Docker:
- Which base image to use.
- How to install dependencies.
- How to copy code.
- How to start the application.
Important rule: The Dockerfile is the source of truth for how your CI/CD builds the runtime environment for your backend.
Writing a Basic Dockerfile for a Backend
Here is a minimal Dockerfile for a Python FastAPI app in app/main.py:
FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]Line by line:
FROM python:3.11-slim
Uses an official base image with Python 3.11, slimmed down to reduce size.WORKDIR /app
All following relative paths will be inside/app.COPY requirements.txt .
Copies only the dependency file, not the whole project yet.RUN pip install --no-cache-dir -r requirements.txt
Installs dependencies inside the image.COPY . .
Copies all project files into/app.EXPOSE 8000
Documents that the container listens on port 8000.CMD [...]
Defines the default command to start the app.
This simple pattern already works fine for CI/CD and small projects.
Choosing a Base Image
The FROM line is extremely important. Common options for Python backends:
| Base image | Size | Includes | Typical use case |
|---|---|---|---|
python:3.11 | Large | Tools, build chain | Development, debugging |
python:3.11-slim | Medium | Minimal userland | Standard production usage |
python:3.11-alpine | Small | BusyBox, musl libc | Only if you know Alpine issues and build needs |
debian:bookworm | Medium | No Python | Custom Python builds or polyglot apps |
For CI/CD and most production workloads, python:3.11-slim is usually a good compromise.
Rule of thumb: Use a slim official runtime image for production, not the full OS with everything installed. This reduces size and attack surface.
Layer Caching and Build Performance
Docker images are built in layers. Each instruction in the Dockerfile (like RUN, COPY, ADD) creates a new layer.
Docker caches each layer. If nothing changed in that layer's inputs, the cached version is reused. This is very important for CI/CD speed.
Example:
FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]- If only your application code changes, and
requirements.txtstays the same, then: COPY requirements.txt .uses cache.RUN pip install ...uses cache, so dependencies are not reinstalled.COPY . .is rebuilt, but this is cheap.- Result: build in CI is much faster.
If you invert the order like this:
COPY . .
RUN pip install --no-cache-dir -r requirements.txt
Then any code change invalidates the layer before RUN, so pip install must run again. This makes CI builds slow.
Key rule: Put rarely changing steps (OS packages, Python dependencies) before frequently changing steps (application code) in the Dockerfile to fully use layer caching.
Reducing Image Size
Smaller images are faster to:
- Build.
- Push and pull in CI/CD.
- Deploy to servers.
Common strategies:
Use slim base images
Prefer something like:
FROM python:3.11-sliminstead of:
FROM python:3.11Avoid unnecessary build tools in final image
If you need build tools for compiling dependencies, remove them after install, or use multi-stage builds (see next section).
Example without multi-stage:
FROM python:3.11-slim
RUN apt-get update \
&& apt-get install -y --no-install-recommends build-essential \
&& pip install --no-cache-dir some-package-that-needs-compilation \
&& apt-get remove -y build-essential \
&& rm -rf /var/lib/apt/lists/*This keeps only what is needed at runtime.
Clean caches
Use --no-cache-dir with pip, and remove package lists after apt-get:
RUN pip install --no-cache-dir -r requirements.txtRUN apt-get update \
&& apt-get install -y curl \
&& rm -rf /var/lib/apt/lists/*Multi-Stage Builds
Multi-stage builds allow you to have one image for building, and a smaller, clean image for running.
This is very useful in CI/CD, especially for:
- Compiled languages.
- Heavy build tools.
- Minimizing attack surface.
Example for a Python backend that needs build tools:
# Stage 1: builder
FROM python:3.11-slim AS builder
WORKDIR /app
COPY requirements.txt .
RUN apt-get update \
&& apt-get install -y --no-install-recommends build-essential \
&& pip install --no-cache-dir -r requirements.txt \
&& rm -rf /var/lib/apt/lists/*
COPY . .
# Stage 2: runtime
FROM python:3.11-slim
WORKDIR /app
# Copy installed site-packages from builder
COPY --from=builder /usr/local/lib/python3.11 /usr/local/lib/python3.11
# Copy app code
COPY --from=builder /app /app
EXPOSE 8000
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]- The builder stage uses compilers and builds dependencies.
- The runtime stage is clean, only copies installed libraries and app code.
- The final image does not include build tools.
If your app is written in another language or has a frontend, you can use one stage to build assets (for example npm run build) and another to serve them.
Using .dockerignore to Speed Up Builds
When you run docker build ., Docker sends the entire directory as build context. Large or unnecessary files slow down builds, and may end up in the image.
Use a .dockerignore file to exclude what you do not need:
Example .dockerignore:
.git
.gitignore
__pycache__
*.pyc
*.pyo
*.pyd
env
venv
.idea
.vscode
.dist
build
node_modules
.coverage
htmlcov
tests
docs
Dockerfile*
docker-compose*.yml
*.logBenefits in CI/CD:
- Smaller context, so builds are faster.
- Sensitive files from
.gitor local configs do not leak into images.
Rule: Always create a .dockerignore file. Treat it like .gitignore for Docker builds.
Tagging Images in CI/CD
Tags identify versions of your image. In CI/CD, you want tags that:
- Are unique per build.
- Are easy to trace back to a commit or branch.
- Work well with deployment tools.
Common strategies:
| Tag pattern | Example | Use case |
|---|---|---|
| Semantic version | my-api:1.4.2 | Manual releases |
| Git SHA | my-api:abc1234 | Exact build trace |
| Branch name | my-api:feature-login | Preview environments |
| Latest per branch | my-api:latest, my-api:staging | Environments without versioning |
Typical CI behavior:
- Build and push image with:
my-api:<git-sha>my-api:mainormy-api:latestif on main branch.
Example Docker build and push commands in CI:
IMAGE_NAME="registry.example.com/my-api"
GIT_SHA="${CI_COMMIT_SHA}"
docker build -t "$IMAGE_NAME:$GIT_SHA" -t "$IMAGE_NAME:latest" .
docker push "$IMAGE_NAME:$GIT_SHA"
docker push "$IMAGE_NAME:latest"
Your deployment then uses $GIT_SHA so you can roll back to a known image.
Build Arguments and Environment Variables
You can parametrize your Docker build using build arguments. They are available at build time only.
Example:
FROM python:3.11-slim
ARG APP_ENV=production
RUN echo "Building for environment: ${APP_ENV}"
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]Build with:
docker build --build-arg APP_ENV=staging -t my-api:staging .Use environment variables for runtime configuration, not build args:
ENV PYTHONUNBUFFERED=1
ENV PYTHONDONTWRITEBYTECODE=1The CI/CD pipeline usually sets runtime environment variables at container run time, not bake secrets into images.
Security rule: Do not bake secrets into images using ARG or ENV. Pass secrets through runtime environment variables or secret managers in deployment, not at build time.
Example: Production-Ready Dockerfile for a FastAPI App
Here is a more realistic example with some best practices:
FROM python:3.11-slim AS base
ENV PYTHONUNBUFFERED=1 \
PYTHONDONTWRITEBYTECODE=1 \
PIP_NO_CACHE_DIR=1 \
PIP_DISABLE_PIP_VERSION_CHECK=1
WORKDIR /app
# System dependencies (if needed)
RUN apt-get update \
&& apt-get install -y --no-install-recommends \
build-essential \
&& rm -rf /var/lib/apt/lists/*
# Install dependencies separately for caching
COPY requirements.txt .
RUN pip install -r requirements.txt
# Now copy the source code
COPY . .
# Create a non-root user
RUN useradd -m appuser
USER appuser
EXPOSE 8000
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]This image:
- Uses slim base.
- Sets Python environment variables to improve behavior in containers.
- Uses caching for dependencies.
- Removes apt lists to reduce size.
- Runs the app as a non-root user.
In CI/CD, you would build and push this image, then use it in staging and production.
Integrating Docker Builds into CI Pipelines
While the next chapters discuss CI systems in detail, here is a generic sketch.
Example: GitHub Actions style
A job might:
- Check out code.
- Log in to container registry.
- Build and push image.
Pseudo YAML:
jobs:
build-and-push:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Log in to registry
run: echo "$REGISTRY_PASSWORD" | docker login \
-u "$REGISTRY_USERNAME" --password-stdin registry.example.com
- name: Build image
run: |
IMAGE="registry.example.com/my-api"
TAG="${GITHUB_SHA}"
docker build -t "$IMAGE:$TAG" -t "$IMAGE:latest" .
- name: Push image
run: |
IMAGE="registry.example.com/my-api"
TAG="${GITHUB_SHA}"
docker push "$IMAGE:$TAG"
docker push "$IMAGE:latest"
Your deployment jobs pick up registry.example.com/my-api:<sha> and roll out that exact image.
Common Pitfalls and How to Avoid Them
| Pitfall | Problem in CI/CD | Better approach |
|---|---|---|
| Copying everything before installing deps | Cache misses, slow builds | Copy only dependency files first |
No .dockerignore | Huge build context, slow and heavy images | Add .dockerignore similar to .gitignore |
| Using full OS images with many packages | Large images, more attack surface | Use slim base images |
| Installing build tools in runtime image | Larger images, security risk | Use multi-stage builds or remove tools after install |
| Running as root | Higher security risk | Create non-root user and switch with USER |
Baking secrets into image via ENV or ARG | Secret exposure, hard to rotate | Use runtime secrets from deployment environment |
| Not tagging images with commit SHA | Hard to know which code is in which deployment | Use tags based on Git SHA or version |
Summary
In CI/CD, Docker images are the artifact you test, push, and deploy. To build good images:
- Write a clear
Dockerfilewith a slim base image. - Order instructions to maximize layer caching.
- Use
.dockerignoreto keep builds fast and images clean. - Use multi-stage builds when you need heavy build tools.
- Tag images with meaningful versions, often including Git SHA.
- Keep secrets out of images and run containers with least privilege.
These practices make your pipelines faster, your deployments safer, and your backend easier to operate 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!