21.13. Redis with Docker
Table of Contents
Why Use Redis with Docker?
Running Redis with Docker is one of the easiest ways to get a consistent, isolated Redis instance for development and even for production. Docker gives you:
- A predictable Redis version and configuration
- Easy cleanup and recreation
- Simple networking with your app containers
In this chapter you will see practical examples of how to run Redis in Docker and connect it to a backend application.
Running Redis in a Single Container
The simplest way to run Redis in Docker is with a single container.
Pulling the Redis Image
First, get the official Redis image from Docker Hub:
docker pull redis:7
You can also use redis:latest, but using a specific version is more predictable.
Important rule
Always use explicit versions in production, for example redis:7.2, not just latest. This avoids unexpected upgrades when images are rebuilt.
Starting a Redis Container
Run Redis in the foreground:
docker run --name my-redis redis:7This starts Redis, but you cannot access it from your host by default because no ports are published.
Expose Redis on the default port 6379:
docker run \
--name my-redis \
-p 6379:6379 \
redis:7Explanation of key flags:
| Flag | Meaning |
|---|---|
--name my-redis | Set a readable container name |
-p 6379:6379 | Map host port 6379 to container port 6379 |
redis:7 | Use image redis with tag 7 |
Now you can connect from your host:
redis-cli -h 127.0.0.1 -p 6379 ping
# PONG
If redis-cli is not installed on your host, you can use the one inside the container:
docker exec -it my-redis redis-cli ping
# PONGRunning Redis in the Background
To avoid blocking your terminal, run the container in detached mode:
docker run -d \
--name my-redis \
-p 6379:6379 \
redis:7Check if it is running:
docker psStop and remove when you are done:
docker stop my-redis
docker rm my-redisPersisting Redis Data with Volumes
By default, Redis data is stored inside the container filesystem. If the container is removed, the data is lost.
For development this might be fine, but for anything more serious you need persistence.
Using an Anonymous Volume
Quick way to keep data even when recreating the container:
docker run -d \
--name my-redis \
-p 6379:6379 \
-v /data \
redis:7
Docker will create an anonymous volume attached to /data in the container. Redis uses /data for persistence by default.
However, anonymous volumes are not easy to manage explicitly. A better approach is to use named or bind volumes.
Using a Named Volume
Create a named volume:
docker volume create redis-dataRun Redis with the named volume:
docker run -d \
--name my-redis \
-p 6379:6379 \
-v redis-data:/data \
redis:7Now:
- Data is stored in the
redis-datavolume. - You can remove and recreate the container and keep the data.
Remove the container and recreate:
docker stop my-redis
docker rm my-redis
docker run -d \
--name my-redis \
-p 6379:6379 \
-v redis-data:/data \
redis:7Your data is still there.
Using a Bind Mount
If you want to see files on your host, use a bind mount:
mkdir -p ./redis-data
docker run -d \
--name my-redis \
-p 6379:6379 \
-v $(pwd)/redis-data:/data \
redis:7
Now all Redis data is visible in the ./redis-data folder.
Important rule
Never put your production Redis data on a local, temporary, or non-backed-up directory. For production use a persistent, reliable storage location and proper backup strategy.
Configuring Redis in a Container
The default Redis configuration is fine for local experiments. For real applications you often need to customize it.
You can configure Redis with:
- Command line arguments
- A custom
redis.conffile
Using Command Line Arguments
Example, disable protected mode so Redis is reachable from other machines (only for controlled environments):
docker run -d \
--name my-redis \
-p 6379:6379 \
redis:7 \
redis-server --appendonly yes --protected-mode noHere:
redis:7is the imageredis-server ...overrides the default command
Using a redis.conf File
- Create a config file, for example
redis.conf:
bind 0.0.0.0
port 6379
appendonly yes
maxmemory 256mb
maxmemory-policy allkeys-lru- Run Redis using this config:
docker run -d \
--name my-redis \
-p 6379:6379 \
-v $(pwd)/redis.conf:/usr/local/etc/redis/redis.conf \
redis:7 \
redis-server /usr/local/etc/redis/redis.confNow Redis uses your custom settings.
Security rule
Never expose a Redis instance on the public internet without:
- A firewall or private network
- Proper authentication and access controls
An open Redis on the internet is a very common and very serious security problem.
Connecting a Backend Application to Redis in Docker
There are two common situations:
- Backend on host, Redis in Docker
- Backend in Docker, Redis in Docker (same Docker network)
1. Backend on Host, Redis in Docker
You already saw how to expose Redis on port 6379:
docker run -d \
--name my-redis \
-p 6379:6379 \
redis:7Your backend configuration would look like:
| Setting | Value |
|---|---|
| Host | 127.0.0.1 or localhost |
| Port | 6379 |
| Password | none by default |
Example in Python (using redis-py):
import redis
redis_client = redis.Redis(host="localhost", port=6379, db=0)
redis_client.set("greeting", "hello")
print(redis_client.get("greeting"))2. Backend in Docker, Redis in Docker
It is better to use a Docker network so containers can resolve each other by name.
Create a network:
docker network create backend-netRun Redis on that network:
docker run -d \
--name redis-server \
--network backend-net \
redis:7Run your backend container on the same network:
docker build -t my-backend .
docker run -d \
--name backend-app \
--network backend-net \
-p 8000:8000 \
-e REDIS_HOST=redis-server \
my-backend
In your backend code, use redis-server as the host:
import os
import redis
redis_host = os.getenv("REDIS_HOST", "localhost")
redis_client = redis.Redis(host=redis_host, port=6379, db=0)
Because both containers share backend-net, the backend can find Redis by container name.
Connection rule
When both app and Redis are in the same Docker network, do not use localhost as the Redis host in the app. Use the container name or service name on the network.
Using Redis and FastAPI with Docker Compose
In real projects you often use Docker Compose to manage multi-container setups.
Basic docker-compose.yml Example
Create a file docker-compose.yml:
version: "3.9"
services:
redis:
image: redis:7
container_name: redis
ports:
- "6379:6379"
volumes:
- redis-data:/data
backend:
build: .
container_name: backend
ports:
- "8000:8000"
environment:
REDIS_HOST: redis
REDIS_PORT: 6379
depends_on:
- redis
volumes:
redis-data:Key points:
- Both services share a default network created by Compose.
- The backend can use host
redisand port6379. depends_onensures Redis container starts before the backend.
Minimal FastAPI + Redis Example
Assume your Dockerfile builds a FastAPI app that uses Redis:
# app/main.py
import os
from fastapi import FastAPI
import redis
app = FastAPI()
redis_host = os.getenv("REDIS_HOST", "redis")
redis_port = int(os.getenv("REDIS_PORT", "6379"))
r = redis.Redis(host=redis_host, port=redis_port, db=0)
@app.get("/set/{key}/{value}")
def set_value(key: str, value: str):
r.set(key, value)
return {"status": "ok"}
@app.get("/get/{key}")
def get_value(key: str):
value = r.get(key)
if value is None:
return {"key": key, "value": None}
return {"key": key, "value": value.decode()}Start everything:
docker compose upThen test:
curl "http://localhost:8000/set/name/Alice"
curl "http://localhost:8000/get/name"Using Redis Authentication in Docker
For more secure setups, you can set a Redis password.
Setting a Password via redis.conf
redis.conf:
requirepass my-strong-password
appendonly yesRun Redis:
docker run -d \
--name my-secure-redis \
-p 6379:6379 \
-v $(pwd)/redis.conf:/usr/local/etc/redis/redis.conf \
redis:7 \
redis-server /usr/local/etc/redis/redis.conf
Connect with redis-cli:
redis-cli -h 127.0.0.1 -p 6379
> AUTH my-strong-password
OK
> PING
PONGConnect from Python:
import redis
r = redis.Redis(
host="localhost",
port=6379,
password="my-strong-password",
db=0,
)Using AUTH with Docker Compose
Example docker-compose.yml:
version: "3.9"
services:
redis:
image: redis:7
command: ["redis-server", "--requirepass", "my-strong-password"]
ports:
- "6379:6379"
backend:
build: .
environment:
REDIS_HOST: redis
REDIS_PORT: 6379
REDIS_PASSWORD: my-strong-password
depends_on:
- redisIn your backend:
import os
import redis
redis_client = redis.Redis(
host=os.getenv("REDIS_HOST", "redis"),
port=int(os.getenv("REDIS_PORT", "6379")),
password=os.getenv("REDIS_PASSWORD"),
db=0,
)
Security rule
Never hardcode real production passwords in docker-compose.yml or images. Use environment variables, Docker secrets, or a dedicated secrets manager.
Common Troubleshooting Tips
Here are typical problems and how to fix them.
Problem: Cannot Connect from Host
Symptoms:
redis-cli -h 127.0.0.1 -p 6379 ping
# could not connect to RedisChecklist:
| Check | Command / Fix |
|---|---|
| Container is running | docker ps |
| Port is published | Started with -p 6379:6379 |
| Port not already in use | Change -p 6380:6379 if 6379 is busy |
| Firewall rules | Ensure firewall allows connections to that port |
Problem: App in Container Cannot Reach Redis
Typical error: "Connection refused" when using localhost from inside the app.
Fix:
- Use
redis(the service name) as host when using Docker Compose. - Or use the container name when using manual networks.
Example wrong configuration:
redis.Redis(host="localhost", port=6379)Correct for Docker Compose:
redis.Redis(host="redis", port=6379)Problem: Data Is Lost After Container Recreated
You did not use a volume, or you used an anonymous volume that you later removed.
Fix:
- Use a named volume:
-v redis-data:/data - Or a bind mount to a known directory
Summary
In this chapter you learned how to:
- Run Redis in Docker with
docker run - Persist data with named volumes and bind mounts
- Configure Redis with command line arguments or
redis.conf - Connect backend applications to Redis in Docker, both from host and from other containers
- Use Redis and a backend together with Docker Compose
- Add authentication to your Redis container
- Diagnose common connection and persistence problems
These patterns are the foundation for using Redis in real backend projects, from local development to more advanced 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!