24.9. Container Registries
Table of Contents
Understanding Container Registries
A container registry is a service where you store and share container images. It plays a similar role to Git hosting platforms for source code, but for built images.
When you build Docker images in CI, the registry is usually the bridge between your CI pipeline and your deployment environment.
What Is a Container Registry?
A container registry is a centralized storage for container images, typically supporting:
- Pushing images (upload)
- Pulling images (download)
- Tagging and versioning
- Access control (who can push or pull)
- Scanning for vulnerabilities
- Replication and caching
You interact with a registry using docker or compatible tools.
Example:
# Login to registry
docker login registry.example.com
# Build image
docker build -t registry.example.com/my-app:1.0.0 .
# Push image
docker push registry.example.com/my-app:1.0.0
# Later, on a server
docker pull registry.example.com/my-app:1.0.0
docker run -d --name my-app registry.example.com/my-app:1.0.0
A container registry is not the same as Docker Hub.
Docker Hub is one implementation of a registry. You can use many different registries or even run your own.
Image Names and Tags
Every image in a registry has a name and a tag. The full image reference usually looks like this:
[registry-host]/[namespace]/[repository]:[tag]Common patterns:
| Example | Meaning |
|---|---|
python:3.12 | Docker Hub, library/python, tag 3.12 |
myuser/myapp:latest | Docker Hub, namespace myuser, repo myapp, tag latest |
ghcr.io/my-org/my-api:1.0.0 | GitHub Container Registry, org my-org, repo my-api |
registry.example.com/myteam/app:2024-08-01 | Private registry at registry.example.com |
Useful conventions:
- Use semantic versioning:
1.0.0,1.0.1,2.0.0. - Use build metadata:
1.0.0-commit-sha,1.0.0-2024-08-01. - Avoid relying only on
latestin production.
Rule: Always tag images explicitly in CI, for example using $GIT_SHA or a release version.
Never deploy untagged or implicitly tagged latest images to production.
Example CI tags:
IMAGE_TAG="$GITHUB_SHA" # full commit SHA
IMAGE_TAG="1.0.0" # release
IMAGE_TAG="1.0.0-$GITHUB_SHA" # release + SHATypes of Container Registries
There are several common types of registries you will encounter.
Public Registries
Public registries host images that are often accessible to everyone.
Examples:
| Registry | Example image | Notes |
|---|---|---|
| Docker Hub | nginx:1.27 | Most common public registry |
| GitHub Container Registry | ghcr.io/user/app:tag | Integrated with GitHub |
| GitLab Registry | registry.gitlab.com/group/app | Integrated with GitLab |
Typical use cases:
- Base images such as
python,nginx,postgres. - Open source application images.
Private Registries
Private registries are used for internal or proprietary images.
Options:
| Option | Description |
|---|---|
| Private repos on Docker Hub | Private images under your Docker account |
| GitHub Packages / GHCR | Private images tied to GitHub repos |
| GitLab Container Registry | Private images tied to GitLab projects |
| Cloud provider registries | ECR, GCR, ACR etc |
| Self-hosted registry | Your own registry instance, often via Docker |
Use a private registry when:
- Your code is proprietary.
- You need fine-grained access control.
- You want images close to your deployment region to reduce latency.
Popular Registry Providers
Many CI/CD setups use registries that are built into source hosting or cloud platforms.
Docker Hub
- Default registry for Docker CLI.
- Image names like
user/app:tag. - Public by default, can be private.
- Useful for:
- Public open source projects.
- Simple personal projects.
Example usage:
# Logged-in as 'mydockeruser'
docker build -t mydockeruser/my-api:1.0.0 .
docker push mydockeruser/my-api:1.0.0GitHub Container Registry (GHCR)
- Registry host:
ghcr.io. - Integrates with GitHub Actions and repo permissions.
- Images tied to GitHub organizations and repositories.
Example naming conventions:
| Pattern | Description |
|---|---|
ghcr.io/OWNER/IMAGE_NAME:tag | General image |
ghcr.io/OWNER/REPO/IMAGE_NAME | Sometimes used inside org repos |
Minimal GitHub Actions example:
name: Build and push image
on:
push:
branches: [ main ]
jobs:
build-and-push:
runs-on: ubuntu-latest
permissions:
contents: read
packages: write
steps:
- uses: actions/checkout@v4
- name: Log in to GHCR
uses: docker/login-action@v3
with:
registry: ghcr.io
username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
- name: Build and push
uses: docker/build-push-action@v6
with:
context: .
push: true
tags: ghcr.io/${{ github.repository }}/my-api:${{ github.sha }}GitLab Container Registry
- Integrated per GitLab project.
- Registry host typically
registry.gitlab.com. - Image path usually follows project path.
Example name:
registry.gitlab.com/my-group/my-project/backend:1.0.0Minimal GitLab CI snippet:
image: docker:24
services:
- docker:24-dind
variables:
DOCKER_DRIVER: overlay2
build_and_push:
stage: build
script:
- docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" "$CI_REGISTRY"
- docker build -t "$CI_REGISTRY_IMAGE:$CI_COMMIT_SHA" .
- docker push "$CI_REGISTRY_IMAGE:$CI_COMMIT_SHA"Cloud Provider Registries
Cloud platforms provide registries that integrate with their services:
| Provider | Registry | Example image |
|---|---|---|
| AWS | Amazon ECR | 123456789012.dkr.ecr.us-east-1.amazonaws.com/app:tag |
| GCP | Artifact Registry / GCR | us-docker.pkg.dev/project/repo/app:tag |
| Azure | Azure Container Registry (ACR) | myregistry.azurecr.io/app:tag |
Common use case:
- Build image in CI, push to cloud registry, then deploy to Kubernetes or container services within the same cloud.
Authentication and Access Control
To push to most registries, you must authenticate. To pull, you may or may not need authentication, depending on whether the image is public.
Basic Docker Login
For many registries you can login with docker login:
docker login registry.example.com
# Prompts for username and password or tokenThen build and push:
docker build -t registry.example.com/myteam/app:1.0.0 .
docker push registry.example.com/myteam/app:1.0.0CI Authentication With Secrets
In CI you should never hardcode credentials in the pipeline file. Use secret variables.
Example with GitHub Actions and Docker Hub:
- name: Log in to Docker Hub
uses: docker/login-action@v3
with:
username: ${{ secrets.DOCKERHUB_USERNAME }}
password: ${{ secrets.DOCKERHUB_TOKEN }}Example with GitHub Actions and a private registry:
- name: Docker login
uses: docker/login-action@v3
with:
registry: registry.example.com
username: ${{ secrets.REGISTRY_USER }}
password: ${{ secrets.REGISTRY_PASSWORD }}Example with environment variables in GitLab:
script:
- docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" "$CI_REGISTRY"
Rule: Store registry credentials in CI secrets, never in the repository.
Use tokens or service accounts instead of personal passwords when possible.
Using Registries in CI/CD Pipelines
In a typical CI/CD workflow, the registry connects the build and deploy stages:
- Build job in CI:
- Checkout code.
- Build Docker image.
- Tag image with version or commit SHA.
- Push image to registry.
- Deploy job in CI or CD:
- Pull specific image tag from registry.
- Update Kubernetes deployment, Docker Compose, or server to use that tag.
Example: Simple Build and Push Pipeline
GitHub Actions example:
name: Build and push image
on:
push:
branches: [ main ]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Log in to Docker Hub
uses: docker/login-action@v3
with:
username: ${{ secrets.DOCKERHUB_USERNAME }}
password: ${{ secrets.DOCKERHUB_TOKEN }}
- name: Build and push
uses: docker/build-push-action@v6
with:
context: .
push: true
tags: mydockeruser/my-api:${{ github.sha }}
A deploy job could then reference mydockeruser/my-api:${{ github.sha }}.
Example: Multiple Tags for the Same Image
You can apply several tags to the same image, for example commit SHA and branch name:
IMAGE_NAME="registry.example.com/myteam/app"
COMMIT_SHA="$GITHUB_SHA"
BRANCH_NAME="${GITHUB_REF_NAME}"
docker build -t "$IMAGE_NAME:$COMMIT_SHA" .
docker tag "$IMAGE_NAME:$COMMIT_SHA" "$IMAGE_NAME:$BRANCH_NAME"
docker tag "$IMAGE_NAME:$COMMIT_SHA" "$IMAGE_NAME:latest"
docker push "$IMAGE_NAME:$COMMIT_SHA"
docker push "$IMAGE_NAME:$BRANCH_NAME"
docker push "$IMAGE_NAME:latest"This way:
- Production may use a frozen version like
:1.2.3. - Staging might follow
:main. - Local testing can use
:latest.
Self-Hosted Registries
Sometimes you want to run your own registry, for example inside a corporate network.
Basic Docker Registry
Docker provides a reference implementation you can run as a container:
docker run -d \
-p 5000:5000 \
--name registry \
registry:2
You can then push images to localhost:5000:
docker build -t localhost:5000/my-app:1.0.0 .
docker push localhost:5000/my-app:1.0.0This is useful for:
- Local development.
- Internal use in a private network.
For production use, you typically add:
- Authentication.
- TLS via reverse proxy.
- Storage backends (S3, etc).
Using a Private Registry in CI
If your registry is at registry.internal:5000, your CI configuration might include:
- name: Docker login
run: echo "$REGISTRY_PASSWORD" | docker login registry.internal:5000 -u "$REGISTRY_USER" --password-stdin
- name: Build
run: docker build -t registry.internal:5000/my-app:${GITHUB_SHA} .
- name: Push
run: docker push registry.internal:5000/my-app:${GITHUB_SHA}
Note that the CI runners must have network access to registry.internal:5000.
Security and Best Practices
When dealing with container registries in CI/CD you must think about:
Keep Images Private When Needed
- Make private images private in the registry.
- Restrict who can push and who can pull.
- Use organization or project scoped permissions.
Avoid Leaking Credentials
- Store registry credentials in CI secrets.
- Use token-based authentication where possible.
- Rotate tokens periodically.
- Avoid printing tokens or passwords in CI logs.
Example of a bad practice:
# BAD: Hardcoded password
- run: docker login -u user -p mysecretpasswordExample of a safer practice:
- run: echo "$REGISTRY_PASSWORD" | docker login -u "$REGISTRY_USER" --password-stdinImage Scanning
Many registries support vulnerability scanning:
- GitHub Container Registry security features.
- Docker Hub scanning (for some plans).
- Cloud provider registries with built-in scanners.
In CI you can:
- Fail builds if critical vulnerabilities are found.
- Schedule regular scans on existing images.
Retention and Cleanup
Images can quickly consume storage. Good policies:
- Automatically delete old tags that are no longer deployed.
- Keep recent images per branch or per environment.
- Keep release tags indefinitely, or based on business requirements.
Example policy:
| Tag type | Example | Retention |
|---|---|---|
| Commit tags | :sha-1234abcd | Last 30 days or 100 images |
| Branch tags | :main | Keep latest only |
| Release tags | :1.0.0 | Keep all or manual cleanup |
Connecting Registries to Deployment Environments
Your deployment environment must be able to pull images from your registry.
Docker Compose
In a docker-compose.yml file:
services:
api:
image: registry.example.com/myteam/app:1.0.0
ports:
- "8000:8000"
Before docker-compose up, you might need:
docker login registry.example.comKubernetes
For Kubernetes, you define the image in the Deployment manifest:
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-api
spec:
replicas: 2
selector:
matchLabels:
app: my-api
template:
metadata:
labels:
app: my-api
spec:
containers:
- name: my-api
image: registry.example.com/myteam/app:1.0.0
ports:
- containerPort: 8000For private registries you typically configure:
- ImagePullSecrets referencing registry credentials.
- Or cloud identity mechanisms for cloud registries.
By understanding container registries and how to integrate them into CI/CD pipelines, you can:
- Consistently build, version, and distribute images.
- Separate build from deploy stages.
- Securely manage your application artifacts across environments.
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!