21.6. Building Images
Table of Contents
Why Building Images Matters
When you build a Docker image, you are creating a repeatable, portable package of your backend application and everything it needs to run.
You can then:
- Run the same image on your laptop, a CI server, and in production.
- Share the image with your team or deploy it via Kubernetes or another orchestrator.
- Rebuild new versions of the image when you change your code.
This chapter focuses on the practical process of building images from a Dockerfile, verifying them, and avoiding common mistakes. You will use the concepts from the previous Docker chapters, but here the focus is specifically on image creation and good practices.
The `docker build` Command
The main command to create an image is:
docker build -t my-backend-app:1.0 .Let us break this down:
| Part | Meaning |
|---|---|
docker build | Build a Docker image from a Dockerfile. |
-t my-backend-app:1.0 | Tag the image name is my-backend-app, tag is 1.0. |
. | Build context the current directory (files sent to the Docker daemon). |
Important rule: The last argument of docker build is the build context directory, not the path to the Dockerfile. Docker sends everything in that directory (except ignored files) to the Docker daemon.
Keep your build context small to avoid slow builds and accidental leaks of secrets.
You can specify a different Dockerfile:
docker build -f Dockerfile.prod -t my-backend-app:prod .-f Dockerfile.prodtells Docker which file to use.- The final
.is still the context.
If your Dockerfile is in docker/Dockerfile, you can run:
docker build -f docker/Dockerfile -t my-backend-app:1.0 .Understanding the Build Context
Docker does not read files directly from your filesystem during build. Instead, it sends the context directory to the daemon.
If your project structure is:
my-backend/
app/
main.py
requirements.txt
docker/
Dockerfile
.git/
.env
README.mdTypical build command:
cd my-backend
docker build -f docker/Dockerfile -t my-backend-app:1.0 .Here:
- Context is
my-backend. - Docker can copy
app/main.py,app/requirements.txtinto the image. - It will also send
.git,.envunless you exclude them.
Use a .dockerignore file in the context directory:
# .dockerignore
.git
.env
__pycache__
*.pyc
node_modules
testsThis keeps the image build:
- Faster, because less data is sent.
- Safer, because secrets (like
.envor SSH keys) are not sent and cannot be copied into the image.
A Simple Backend Image Example
Assume a basic Python backend using FastAPI:
my-backend/
app/
main.py
requirements.txt
Dockerfile
app/main.py:
from fastapi import FastAPI
app = FastAPI()
@app.get("/ping")
def ping():
return {"message": "pong"}
requirements.txt:
fastapi
uvicorn[standard]
Dockerfile:
FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app ./app
EXPOSE 8000
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]Build and run:
docker build -t fastapi-backend:1.0 .
docker run -p 8000:8000 fastapi-backend:1.0Test:
curl http://localhost:8000/ping
# {"message":"pong"}Tagging Images Correctly
Image names usually look like:
repository/name:tagExamples:
| Image name | Meaning |
|---|---|
my-backend:latest | Local image named my-backend, tag latest. |
my-backend:1.0.0 | Versioned image, useful for releases. |
username/my-backend:dev | Often used for Docker Hub. |
registry.example.com/api:prod | Image in a private registry. |
You can tag several versions for the same image:
docker build -t my-backend:1.0.0 .
docker tag my-backend:1.0.0 my-backend:latest
Now docker run my-backend will use the latest tag.
Important rule: Do not rely on latest in production. Always use a specific tag, for example 1.0.0 or a commit hash, so that you know exactly which version is running.
Using Build Arguments
Sometimes you need parameters during build, without baking them into the image code.
In Dockerfile:
ARG APP_ENV=development
RUN echo "Building for environment: ${APP_ENV}"Build with a custom value:
docker build -t my-backend:staging --build-arg APP_ENV=staging .Key points:
ARGvalues are only available during build.- They are not available at runtime inside the container.
- Do not use
ARGfor secrets. They can appear in the image history.
If you want runtime values, use environment variables when running containers, not ARG.
Layer Caching and Faster Builds
Each Dockerfile instruction creates a layer. Docker caches these layers and can reuse them if nothing changed.
Simplified example:
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"]Build 1:
docker build -t my-backend:1.0 .All layers are built.
If you now only change app/main.py and build again:
FROM,WORKDIR,COPY requirements.txt,RUN pip installare cached.- Only
COPY appand layers after it are rebuilt. - The build is much faster.
If you modify requirements.txt, Docker must re-run the pip install step, which is slower.
Important rule: Put instructions that change rarely (like installing system packages, pip install) before instructions that change often (like copying source code). This maximizes cache reuse and speeds up builds.
To force a clean build without cache:
docker build --no-cache -t my-backend:clean .This is useful if you suspect caching issues or you updated system-level dependencies.
Multi-Stage Builds
Multi-stage builds let you:
- Use one image for building (with tools and compilers).
- Use a smaller image for running the final application.
This is very useful when building compiled code, but it is also useful for interpreted languages to drop build-only tools.
Example with a Python backend that uses a build step:
# Stage 1: build dependencies
FROM python:3.12-slim AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --prefix=/install --no-cache-dir -r requirements.txt
# Stage 2: runtime image
FROM python:3.12-slim
WORKDIR /app
# copy installed packages from builder image
COPY --from=builder /install /usr/local
COPY app ./app
EXPOSE 8000
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]Here:
builderstage installs dependencies.- Final image copies only the installed packages and source code.
- The final image does not contain build caches or extra tools from the builder stage.
Another example, static build for a small Go HTTP backend (even though this course uses Python, this demonstrates the idea clearly):
# Stage 1: build binary
FROM golang:1.22-alpine AS builder
WORKDIR /src
COPY . .
RUN go build -o server ./cmd/server
# Stage 2: minimal runtime
FROM alpine:3.20
WORKDIR /app
COPY --from=builder /src/server .
EXPOSE 8080
CMD ["./server"]Multi-stage builds help you keep production images:
- Smaller.
- Safer, fewer tools inside that an attacker could use.
- Faster to pull and deploy.
Inspecting, Listing, and Cleaning Images
List images:
docker imagesExample output:
| REPOSITORY | TAG | IMAGE ID | CREATED | SIZE |
|---|---|---|---|---|
| my-backend | 1.0.0 | 123abc456d | 2 minutes ago | 230MB |
| my-backend | latest | 123abc456d | 2 minutes ago | 230MB |
| python | 3.12-slim | 789ghi012j | 3 weeks ago | 150MB |
Inspect an image:
docker inspect my-backend:1.0.0This shows JSON with details:
- Environment variables.
- Entrypoint and command.
- Exposed ports.
- Layers.
Remove an image:
docker rmi my-backend:1.0.0If a container still uses this image, you must stop and remove the container first.
Remove dangling images (untagged images, often from intermediate builds):
docker image pruneClean more aggressively:
docker system pruneThis removes unused containers, networks, dangling images, and build cache. Be careful on shared machines.
Common Pitfalls When Building Images
Including Secrets in the Image
Bad example:
ENV DB_PASSWORD=supersecretpasswordor:
COPY .env .Anyone with the image can read these values.
Use runtime environment variables instead, for example:
docker run -e DB_PASSWORD=supersecretpassword my-backend:1.0
and read them inside your app using your language tools (for example os.environ in Python).
Also ensure .env goes into .dockerignore.
Copying Too Much
Bad example:
COPY . .This copies everything from the context, including:
- Tests.
- Local environment files.
.githistory.- Temporary files.
Better:
COPY app ./app
COPY requirements.txt .Be explicit about what you copy.
Using a Heavy Base Image
Compare:
FROM python:3.12versus:
FROM python:3.12-slim
The -slim variant is much smaller and usually sufficient for backend applications.
If you need system packages, such as libpq-dev for PostgreSQL, you can still install them using apt-get.
Not Pinning Dependencies
requirements.txt:
fastapi
uvicorn[standard]This may install different versions over time, leading to inconsistent builds.
Better:
fastapi==0.115.0
uvicorn[standard]==0.30.0
You can lock versions with tools like pip freeze or dependency managers.
Example: Development vs Production Build
Often you want slightly different images or configurations for development and production.
Single Dockerfile with ARG
FROM python:3.12-slim
ARG APP_ENV=production
ENV APP_ENV=${APP_ENV}
WORKDIR /app
COPY requirements.txt .
RUN if [ "$APP_ENV" = "development" ]; then \
pip install --no-cache-dir -r requirements.txt -r requirements-dev.txt; \
else \
pip install --no-cache-dir -r requirements.txt; \
fi
COPY app ./app
EXPOSE 8000
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]Build a dev image:
docker build -t my-backend:dev --build-arg APP_ENV=development .Build a prod image:
docker build -t my-backend:prod --build-arg APP_ENV=production .Both images will behave differently depending on what is installed.
Separate Dockerfiles
Another approach is to have two files, for example:
Dockerfile.devDockerfile.prod
Then:
docker build -f Dockerfile.dev -t my-backend:dev .
docker build -f Dockerfile.prod -t my-backend:prod .Choose the approach that keeps your configuration clear for your team.
Verifying and Testing a New Image
After building an image, always verify that it behaves as expected.
- Run it locally
docker run --rm -p 8000:8000 my-backend:1.0.0
--rm removes the container after it stops.
- Check logs
You should see your application startup logs.
- Test endpoints
curl http://localhost:8000/ping- Check environment expectations
If your app expects DATABASE_URL, you can run:
docker run --rm -p 8000:8000 \
-e DATABASE_URL=postgresql://user:pass@db:5432/appdb \
my-backend:1.0.0- Confirm image size
docker images my-backend
If the image is extremely large, inspect the Dockerfile to remove unnecessary files or use a smaller base image.
Summary Checklist for Building Backend Images
Use this checklist whenever you build a backend image:
- [ ] Use a suitable base image, for example
python:3.12-slim. - [ ] Keep the build context small, use
.dockerignore. - [ ] Avoid
COPY . .if possible, copy only what you need. - [ ] Place rarely changing steps before frequently changing steps to benefit from caching.
- [ ] Use multi-stage builds for smaller, cleaner production images.
- [ ] Do not store secrets in the image or
Dockerfile. - [ ] Tag images meaningfully, for example
my-backend:1.0.0. - [ ] Pin dependency versions for reproducible builds.
- [ ] Test the image by running containers and calling endpoints.
- [ ] Clean unused images and cache when needed.
With these practices, your backend Docker images will be reproducible, efficient, and ready for use in later chapters where you will integrate them with Docker Compose and deploy them to 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!