21.7. Running Containers
Table of Contents
Basic Idea Of Running Containers
Running a container means starting an isolated process from an image.
You can think of it as:
- Image: a template or class.
- Container: a running instance of that template, like an object.
You always:
- Choose an image.
- Run
docker runwith some options. - Docker creates a container, starts it, and attaches or detaches your terminal.
In this chapter we focus on how to run containers in different ways and what the most common options mean.
Key rule:
You build or pull an image once, then you can run many containers from that image.
The `docker run` Command
The main command:
docker run [OPTIONS] IMAGE [COMMAND] [ARG...]Typical structure:
| Part | Example | Meaning |
|---|---|---|
docker run | docker run | Start a new container |
OPTIONS | -it -p 8080:80 | Configure networking, environment, etc. |
IMAGE | nginx | Base image to use |
COMMAND | bash | Override default command (optional) |
ARG... | -l | Arguments passed to the command |
Example:
docker run ubuntu echo "Hello from container"- Image:
ubuntu - Command:
echo "Hello from container" - The container runs the command and then exits.
Running Simple Commands
You can use containers just to run a short command.
docker run ubuntu lsThis:
- Starts a container from the
ubuntuimage. - Runs
lsinside it. - Shows the result in your terminal.
- Stops the container.
Some common examples:
# Print OS version inside Ubuntu
docker run ubuntu cat /etc/os-release
# Use Alpine as a small Linux to run 'echo'
docker run alpine echo "Hi from Alpine"
# Use Python image to run a small one-line script
docker run python:3.12-alpine python -c "print('Hello, Python in Docker')"Every time you run these, Docker creates a new container instance.
Interactive Containers (`-it`)
To get a shell inside a container you use:
-ikeep STDIN open.-tallocate a pseudo-TTY so it looks like a normal terminal.
Often combined as -it:
docker run -it ubuntu bashThis gives you an interactive shell:
root@<some-id>:/# ls
bin boot dev etc home ...
root@<some-id>:/# pwd
/
When you type exit (or press Ctrl+D), the shell exits and the container stops.
More examples:
# Alpine image uses 'sh' by default
docker run -it alpine sh
# Python REPL inside a container
docker run -it python:3.12-alpine python
Important:
If the main process (like bash, sh, or python) exits, the container stops.
A container lives as long as its main process runs.
Detached Mode (`-d`)
If you do not want to keep the container attached to your current terminal, run it in detached mode:
docker run -d nginx-dmeans "run in the background".- Docker prints a container ID and returns you to your prompt.
You can then:
docker ps # list running containers
docker logs <id> # view output
docker stop <id> # stop containerExample with a specific name:
docker run -d --name my-nginx nginx
docker ps
docker logs my-nginx
docker stop my-nginxNaming Containers (`--name`)
If you do not specify a name, Docker generates one like elegant_panda.
To work with containers more easily, name them:
docker run --name backend -d python:3.12-alpine sleep 3600
Now you can use backend instead of the long ID:
docker logs backend
docker stop backend
docker rm backendCommon pattern for backend work:
# Example: run PostgreSQL with a fixed name
docker run -d \
--name my-postgres \
-e POSTGRES_PASSWORD=secret \
postgres:16Publishing Ports (`-p`)
By default, container ports are not reachable from your host.
To make a container port accessible, you publish it:
docker run -d -p HOST_PORT:CONTAINER_PORT IMAGEExample with Nginx:
docker run -d -p 8080:80 nginx- Port
80in the container is Nginx’s HTTP port. - Port
8080on your host maps to container port80. - You can open:
http://localhost:8080.
Another example, typical for a backend:
# Suppose your app listens on port 8000 inside the container
docker run -d -p 8000:8000 my-backend-imageTable of examples:
| Command | Meaning |
|---|---|
-p 8080:80 | Host 8080 → Container 80 |
-p 5000:5000 | Host 5000 → Container 5000 |
-p 127.0.0.1:5432:5432 | Only on localhost, 5432 → Container 5432 |
If you specify IP like 127.0.0.1:8080:80, the port is only bound to localhost, not all network interfaces.
Environment Variables in Containers (`-e`)
Backends often configure:
- Database URLs
- Secrets
- Debug flags
through environment variables.
You can set them when running a container:
docker run -d \
-e APP_ENV=production \
-e DEBUG=false \
my-backend-imageTo check environment variables inside a container:
docker run --rm -e FOO=bar alpine sh -c 'echo $FOO'Examples for common services:
# PostgreSQL with password
docker run -d \
--name db \
-e POSTGRES_PASSWORD=secret \
postgres:16
# Redis with a custom password (example)
docker run -d \
-e REDIS_PASSWORD=somepass \
redis:7-alpineYou can also load environment variables from a file:
docker run -d --env-file .env my-backend-image
.env format:
APP_ENV=development
DATABASE_URL=postgresql://user:pass@db:5432/appVolumes and Mounts (`-v` / `--mount`)
Containers have their own filesystem.
When a container is removed, its filesystem is usually removed too.
To keep data or share files with the host, you use volumes or bind mounts.
Anonymous volume
Simple example:
docker run -d -v /var/lib/postgresql/data postgres:16
Docker creates a volume and mounts it at /var/lib/postgresql/data inside the container.
Named volume
Better for databases and important data:
docker volume create pgdata
docker run -d \
--name db \
-e POSTGRES_PASSWORD=secret \
-v pgdata:/var/lib/postgresql/data \
postgres:16Now database data persists even if you remove the container.
Bind mount (share host directory)
Very useful during development to share your code with the container:
docker run -it \
-v $(pwd):/app \
-w /app \
python:3.12-alpine \
python main.pyExplanation:
-v $(pwd):/app
Mount current host directory into/appin the container.-w /app
Set working directory inside the container.python main.py
Run your app using container’s Python interpreter.
Table of mount patterns:
| Type | Example | Use case |
|---|---|---|
| Named volume | -v pgdata:/var/lib/postgresql/data | Persistent DB data |
| Bind mount | -v $(pwd):/app | Share source code in development |
| Read-only | -v $(pwd):/app:ro | Share code without write access |
Working With Container Lifecycle
Listing containers
docker ps # running only
docker ps -a # all, including stoppedImportant columns:
CONTAINER IDNAMESSTATUSPORTSIMAGE
Example:
CONTAINER ID IMAGE COMMAND STATUS PORTS NAMES
abc123def456 nginx "/docker-entrypoin..." Up 2 minutes 0.0.0.0:8080->80/tcp my-nginxStopping and starting
docker stop my-nginx # send SIGTERM then SIGKILL after timeout
docker start my-nginx # start a stopped container
stop and start keep the container’s filesystem and configuration.
Restarting
docker restart my-nginx
This is like stop then start.
Removing containers
When you no longer need a container:
docker rm my-nginxIf it is running, you can force:
docker rm -f my-nginx
Important:
docker rm removes the container, not the image.
If you did not use volumes, data inside the container filesystem is lost.
You can also automatically remove a container after it exits:
docker run --rm alpine echo "one-time task"Inspecting Containers
To inspect what is happening inside or about a container:
Logs
docker logs my-nginx
docker logs -f my-nginx # follow logs like 'tail -f'Executing commands in a running container
docker exec -it my-nginx bashor for Alpine:
docker exec -it my-app sh
This gives you a shell in an already running container.
You can also run a single command:
docker exec my-nginx ls /etc/nginxInspect metadata
docker inspect my-nginxThis prints detailed JSON about:
- Environment variables
- Mounted volumes
- Configured ports
- Networks
- Image used
- And more
Restart Policies
For backend services in production, you often want containers to restart automatically if they crash or when the host reboots.
Use --restart:
docker run -d \
--name my-backend \
--restart unless-stopped \
my-backend-imageCommon restart policies:
| Policy | Behavior |
|---|---|
no | Never restart (default) |
on-failure | Restart only if exit code is non-zero |
always | Always restart, even after docker daemon restart |
unless-stopped | Restart unless you manually stop the container |
Example for a database:
docker run -d \
--name db \
--restart unless-stopped \
-e POSTGRES_PASSWORD=secret \
-v pgdata:/var/lib/postgresql/data \
postgres:16Practical Backend Examples
Here are some realistic commands you might use as a backend developer.
Run a local PostgreSQL database
docker volume create pgdata
docker run -d \
--name postgres \
-e POSTGRES_USER=app \
-e POSTGRES_PASSWORD=secret \
-e POSTGRES_DB=app_db \
-v pgdata:/var/lib/postgresql/data \
-p 5432:5432 \
postgres:16
Then in your backend app you can connect to localhost:5432.
Run Redis for caching or sessions
docker run -d \
--name redis \
-p 6379:6379 \
redis:7-alpine
Connect from your app to localhost:6379.
Run a FastAPI app image
Assume you built my-fastapi-app:latest which listens on port 8000.
docker run -d \
--name fastapi \
-p 8000:8000 \
-e APP_ENV=development \
my-fastapi-app:latest
You can now open http://localhost:8000/docs.
Summary
In this chapter you learned how to:
- Use
docker runwith images and commands. - Start containers interactively with
-it. - Run long‑lived services in the background with
-d. - Name containers with
--nameand manage them withps,stop,start,rm. - Expose container ports using
-p. - Pass configuration using environment variables
-eand--env-file. - Persist and share data using volumes and bind mounts.
- Inspect, log, and exec into running containers.
- Use restart policies for resilient backend services.
These are the day-to-day Docker commands you will use when developing and running backend applications.
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!