21.12. PostgreSQL with Docker
Table of Contents
Why Run PostgreSQL in Docker?
Running PostgreSQL inside Docker gives you a reproducible, disposable database environment. You can:
- Spin up PostgreSQL in seconds.
- Keep your local machine clean.
- Use different PostgreSQL versions per project.
- Share a standard setup with your team.
In this chapter you will learn practical ways to run PostgreSQL with Docker for local development and testing. Production details will be handled in the deployment chapters, so we keep the focus here on local use.
Getting a PostgreSQL Image
The official PostgreSQL image is on Docker Hub with the name postgres.
You can see it with:
docker pull postgres:16
postgres:16 means:
- Repository:
postgres - Tag (version):
16
You can omit the tag:
docker pull postgres
This pulls the latest stable version, but for projects it is usually better to pin a specific version, for example postgres:15 or postgres:16.
Always pin a PostgreSQL version in your Dockerfile or docker-compose.yml, for example postgres:16.
Do not rely on latest for real projects.
Running PostgreSQL with `docker run`
The simplest PostgreSQL container only needs a password:
docker run --name my-postgres \
-e POSTGRES_PASSWORD=mysecretpassword \
-p 5432:5432 \
-d postgres:16What each flag does:
| Flag / option | Meaning |
|---|---|
--name my-postgres | Gives the container a readable name |
-e POSTGRES_PASSWORD=… | Sets the postgres superuser password inside the container |
-p 5432:5432 | Maps host port 5432 to container port 5432 |
-d | Detached mode, container runs in the background |
postgres:16 | Image name and tag, here PostgreSQL version 16 |
Now you can connect from your host using any PostgreSQL client.
Example using psql on your machine:
psql -h localhost -p 5432 -U postgres
It will ask for the password mysecretpassword.
If you want to override the default database and user that are created, the image supports:
POSTGRES_DBPOSTGRES_USERPOSTGRES_PASSWORD
Example:
docker run --name my-postgres \
-e POSTGRES_DB=myapp_db \
-e POSTGRES_USER=myapp_user \
-e POSTGRES_PASSWORD=myapp_password \
-p 5432:5432 \
-d postgres:16This creates:
- Database:
myapp_db - User:
myapp_user - Password:
myapp_password
You can then connect with:
psql "postgresql://myapp_user:myapp_password@localhost:5432/myapp_db"Persisting PostgreSQL Data with Volumes
By default, if the container is removed, your data is lost. For development this is sometimes fine, but usually you want persistent data.
The PostgreSQL image stores its data in /var/lib/postgresql/data inside the container. You can map this path to a Docker volume or a host directory.
Using a named volume
docker volume create pgdataThen run:
docker run --name my-postgres \
-e POSTGRES_PASSWORD=mysecretpassword \
-p 5432:5432 \
-v pgdata:/var/lib/postgresql/data \
-d postgres:16Now even if you remove the container:
docker rm -f my-postgres
Your data remains in the pgdata volume. You can reuse it:
docker run --name my-postgres \
-e POSTGRES_PASSWORD=mysecretpassword \
-p 5432:5432 \
-v pgdata:/var/lib/postgresql/data \
-d postgres:16Using a host directory
You can also store data in a folder on your machine:
mkdir -p ~/docker-data/postgres
docker run --name my-postgres \
-e POSTGRES_PASSWORD=mysecretpassword \
-p 5432:5432 \
-v ~/docker-data/postgres:/var/lib/postgresql/data \
-d postgres:16
Now your database files live in ~/docker-data/postgres.
Never store PostgreSQL data on a folder that is inside a Git repository or in a sync folder like Dropbox or Google Drive.
Use a dedicated data directory or named volume instead.
Connecting an Application Container to PostgreSQL
The typical setup is:
- One container for your app (for example FastAPI).
- One container for PostgreSQL.
- Both containers on the same Docker network.
You can create a network:
docker network create myapp-networkRun PostgreSQL on that network:
docker run --name my-postgres \
--network myapp-network \
-e POSTGRES_DB=myapp_db \
-e POSTGRES_USER=myapp_user \
-e POSTGRES_PASSWORD=myapp_password \
-v pgdata:/var/lib/postgresql/data \
-d postgres:16Then run your app container on the same network:
docker run --name myapp \
--network myapp-network \
-e DATABASE_URL=postgresql://myapp_user:myapp_password@my-postgres:5432/myapp_db \
-p 8000:8000 \
myapp-image
Notice that in DATABASE_URL the host is my-postgres. Inside the network, containers can reach each other using their container names.
Example connection string
For a Python backend with SQLAlchemy:
DATABASE_URL = "postgresql+psycopg2://myapp_user:myapp_password@my-postgres:5432/myapp_db"The database connection URL structure is:
$$
\text{postgresql://user:password@host:port/database}
$$
For SQLAlchemy with psycopg2 driver:
$$
\text{postgresql+psycopg2://user:password@host:port/database}
$$
Inside Docker networks use the container name as the host, for example my-postgres.
From your host machine use localhost (with port mapping).
Using Docker Compose for PostgreSQL
docker-compose (or docker compose in newer Docker versions) lets you define multi-container setups in one YAML file.
Create a docker-compose.yml:
version: "3.9"
services:
db:
image: postgres:16
container_name: myapp-postgres
environment:
POSTGRES_DB: myapp_db
POSTGRES_USER: myapp_user
POSTGRES_PASSWORD: myapp_password
ports:
- "5432:5432"
volumes:
- pgdata:/var/lib/postgresql/data
app:
build: .
container_name: myapp-api
environment:
DATABASE_URL: postgresql://myapp_user:myapp_password@db:5432/myapp_db
ports:
- "8000:8000"
depends_on:
- db
volumes:
pgdata:Key points:
- The database service is called
db. - The app connects to host
dbon port5432. - The
pgdatanamed volume keeps data persistent. depends_onensures PostgreSQL container is started beforeappis started.
Start everything:
docker compose up -dStop containers but keep data:
docker compose downStop and remove data too:
docker compose down -v
Use docker compose down -v carefully.
The -v flag removes named volumes, so it deletes all data in your PostgreSQL database.
Seeding and Initializing the Database
The PostgreSQL image supports running initialization scripts on first startup.
Any .sql or .sh files placed in /docker-entrypoint-initdb.d/ are executed the first time the database is created.
Example directory structure:
.
├── docker-compose.yml
└── db-init
└── 01_create_tables.sql
01_create_tables.sql:
CREATE TABLE IF NOT EXISTS users (
id SERIAL PRIMARY KEY,
email TEXT NOT NULL UNIQUE,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
Update docker-compose.yml:
services:
db:
image: postgres:16
environment:
POSTGRES_DB: myapp_db
POSTGRES_USER: myapp_user
POSTGRES_PASSWORD: myapp_password
ports:
- "5432:5432"
volumes:
- pgdata:/var/lib/postgresql/data
- ./db-init:/docker-entrypoint-initdb.dOn the first run of this database volume, PostgreSQL will:
- Create the database and user.
- Run all scripts in
/docker-entrypoint-initdb.din alphabetical order.
If you want to re-run the initialization, you must remove the volume:
docker compose down -v
docker compose up -dYou can also use shell scripts:
# db-init/02_extra.sh
#!/bin/bash
set -e
psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" <<-SQL
INSERT INTO users (email) VALUES ('admin@example.com')
ON CONFLICT DO NOTHING;
SQLRemember to make it executable:
chmod +x db-init/02_extra.shRunning `psql` inside the Container
You do not always need psql on your host. You can use the psql client that is already inside the PostgreSQL container.
Connect to the container:
docker exec -it my-postgres bashThen:
psql -U myapp_user -d myapp_dbOr in one command from outside:
docker exec -it my-postgres \
psql -U myapp_user -d myapp_db
Some useful psql commands for quick checks:
| Command | Description |
|---|---|
\l | List databases |
\c myapp_db | Connect to database |
\dt | List tables |
\d table_name | Describe a table |
\q | Quit psql |
Environment Variables and Secrets
In examples above we put passwords directly in the compose file. For real projects, you want to keep secrets out of the repository.
Common patterns:
Using `.env` file with docker compose
Create a .env file:
POSTGRES_DB=myapp_db
POSTGRES_USER=myapp_user
POSTGRES_PASSWORD=my_strong_password
In docker-compose.yml:
services:
db:
image: postgres:16
environment:
POSTGRES_DB: ${POSTGRES_DB}
POSTGRES_USER: ${POSTGRES_USER}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
Docker compose automatically loads .env in the same directory.
Your app service can also read from .env and build a DATABASE_URL.
Using environment variables directly
You can also export variables in your shell before running compose:
export POSTGRES_PASSWORD=my_strong_password
docker compose up -d
Never commit real database passwords or connection strings to Git.
Use .env files ignored by Git or environment variables in your shell or CI.
Common Problems and Debugging
Container cannot connect to PostgreSQL
If your app shows errors like:
could not connect to server: Connection refused
Check:
- Is the database running?
docker ps- Logs of the database:
docker logs my-postgres- Correct host name in the connection string:
- From host:
localhost - From another container on same network: container name, for example
my-postgresor service namedb. - Correct port:
- Default PostgreSQL port is
5432. - If you mapped port
5433:5432, then from the host you must use5433.
Port already in use
Error on docker run:
Bind for 0.0.0.0:5432 failed: port is already allocated
Someone is already using port 5432 on your host, maybe a local PostgreSQL installation.
Solutions:
- Stop the local PostgreSQL service.
- Or run PostgreSQL on a different host port:
docker run --name my-postgres \
-e POSTGRES_PASSWORD=mysecretpassword \
-p 5433:5432 \
-d postgres:16
Then connect with localhost:5433.
Resetting everything in development
If your local development database is broken or you want a fresh start:
- Stop containers:
docker compose down- Remove database volume:
docker volume rm <project_name>_pgdataOr simply:
docker compose down -v- Start again:
docker compose up -dThis will recreate the database from scratch and rerun your initialization scripts.
Putting It All Together: Example FastAPI + PostgreSQL Setup
Here is a minimal structure for a FastAPI backend with PostgreSQL, all in Docker.
.
├── app
│ ├── main.py
│ └── requirements.txt
└── docker-compose.yml
app/requirements.txt:
fastapi
uvicorn[standard]
sqlalchemy
psycopg2-binary
app/main.py (very simplified):
from fastapi import FastAPI
from sqlalchemy import create_engine, text
DATABASE_URL = "postgresql+psycopg2://myapp_user:myapp_password@db:5432/myapp_db"
engine = create_engine(DATABASE_URL, echo=True, future=True)
app = FastAPI()
@app.get("/ping-db")
def ping_db():
with engine.connect() as conn:
result = conn.execute(text("SELECT 1")).scalar_one()
return {"db": result}
docker-compose.yml:
version: "3.9"
services:
db:
image: postgres:16
environment:
POSTGRES_DB: myapp_db
POSTGRES_USER: myapp_user
POSTGRES_PASSWORD: myapp_password
ports:
- "5432:5432"
volumes:
- pgdata:/var/lib/postgresql/data
app:
build:
context: ./app
dockerfile: Dockerfile
environment:
# Could also be read from env or .env
DATABASE_URL: postgresql+psycopg2://myapp_user:myapp_password@db:5432/myapp_db
ports:
- "8000:8000"
depends_on:
- db
volumes:
pgdata:
app/Dockerfile:
FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]Start everything:
docker compose up -dTest from your browser or curl:
curl http://localhost:8000/ping-dbYou should get:
{"db": 1}Your FastAPI app is now talking to PostgreSQL, both running in Docker containers.
You now have all the practical tools you need to:
- Run PostgreSQL with
docker runand with Docker Compose. - Persist data using volumes.
- Connect containerized backends to PostgreSQL.
- Seed and initialize databases with scripts.
- Handle common connection and port issues.
More advanced PostgreSQL performance and tuning topics are covered in the dedicated PostgreSQL and deployment chapters.
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!