5.9.6. S3-Compatible Storage
Table of Contents
Why S3-Compatible Storage Matters
Most beginner projects store files on the local disk of the server. This is fine for experiments, but it quickly breaks in real applications:
- You cannot easily scale to multiple servers.
- You lose files when the server is destroyed or redeployed.
- Backups and durability become hard to manage.
Object storage solves these problems by giving you a separate, durable place to store files. The most famous example is Amazon S3. Many other services implement the same API, which is why we talk about S3-compatible storage.
In this chapter you will learn what S3-compatible storage is, how it is different from normal file storage, and how to use it in a backend application.
What “S3-Compatible” Means
The S3 API
S3 exposes a simple HTTP-based API with operations such as:
- Create a bucket
- Upload an object
- Download an object
- List objects
- Delete objects
When a provider is S3-compatible, it means:
- It supports the same HTTP endpoints and operations as S3, or almost the same.
- It understands S3-style authorization headers, like AWS Signature v4.
- Libraries written for S3 (like
boto3in Python) can usually connect with only configuration changes.
Examples of S3-compatible providers:
| Provider | Typical Use |
|---|---|
| Amazon S3 | Original S3, part of AWS |
| MinIO | Self-hosted S3-compatible server |
| DigitalOcean Spaces | Managed S3-compatible object storage |
| Backblaze B2 | Cheap long-term storage |
| Wasabi | Low-cost S3-compatible storage |
You can usually switch providers with no application code changes, only environment variables like endpoint URLs or credentials.
Important:
S3-compatible means “same API style”, not “identical behavior”.
Always check:
- Region names and endpoints,
- How public URLs are formed,
- Limits, pricing, and performance.
Buckets and Objects
Core Concepts
Object storage does not use folders in the same way as a normal filesystem. It uses two main concepts:
- Bucket: A top-level container for files.
- Object: A file stored inside a bucket, identified by a unique key.
You can think of a bucket as a drive, and the object key as the path on that drive.
Example:
- Bucket:
my-app-uploads - Object key:
avatars/user_123.png
There are no real nested directories. The key is just a string. Providers may simulate folders by treating / characters in keys as path separators.
Example keys in one bucket:
| Key | What it looks like |
|---|---|
avatars/user_1.png | Avatar of user 1 |
avatars/user_2.png | Avatar of user 2 |
documents/invoices/2024-01.pdf | Invoice of January 2024 |
logs/2024/08/28/log.txt | Log file for specific date |
To your application, each of these is just an object identified by its key string.
How S3-Compatible Storage Differs from Local Files
File System vs Object Storage
Typical differences:
| Feature | Local File System | S3-Compatible Storage |
|---|---|---|
| Structure | Directories and files | Buckets and object keys |
| Operations | open, read, write, os.* | HTTP API (PUT, GET, DELETE, etc.) |
| Latency | Very low | Higher (network request) |
| Shared across servers | Hard without network filesystems | Easy, all servers talk to same endpoint |
| Durability & backups | Up to you | Handled by the provider |
| Scaling | You manage disks | Provider scales capacity & throughput |
In object storage you cannot:
- Append to a file.
- Modify bytes in the middle of a file.
Instead, you upload the entire object again. For logs and similar use cases you usually create new objects instead of appending.
Basic Operations with S3-Compatible Storage
You will usually use a client library instead of crafting HTTP requests by hand. In Python, the standard choice for S3 APIs is boto3.
Below we show general patterns. The exact code examples use AWS-style syntax, but you can connect to any S3-compatible endpoint by changing configuration.
Connecting to an S3-Compatible Endpoint
You usually need:
endpoint_url(domain of the service),- Access key ID,
- Secret access key,
- Region (sometimes optional for non-AWS providers),
- Bucket name.
Example configuration using environment variables:
export S3_ENDPOINT_URL="https://nyc3.digitaloceanspaces.com"
export S3_ACCESS_KEY_ID="your-access-key"
export S3_SECRET_ACCESS_KEY="your-secret-key"
export S3_REGION="nyc3"
export S3_BUCKET="my-app-uploads"Python client setup:
import os
import boto3
session = boto3.session.Session()
s3 = session.client(
service_name="s3",
endpoint_url=os.environ["S3_ENDPOINT_URL"],
aws_access_key_id=os.environ["S3_ACCESS_KEY_ID"],
aws_secret_access_key=os.environ["S3_SECRET_ACCESS_KEY"],
region_name=os.environ.get("S3_REGION"),
)
BUCKET_NAME = os.environ["S3_BUCKET"]Uploading an Object
Example: upload a user avatar.
def upload_avatar(user_id: int, file_bytes: bytes, content_type: str) -> str:
key = f"avatars/user_{user_id}.png"
s3.put_object(
Bucket=BUCKET_NAME,
Key=key,
Body=file_bytes,
ContentType=content_type,
)
return key
Here key is what you store in your database to remember where the avatar lives.
Example DB record:
| user_id | avatar_key |
|---|---|
| 1 | avatars/user_1.png |
| 2 | avatars/user_2.png |
Downloading an Object
To read the bytes back:
def download_avatar(key: str) -> bytes:
response = s3.get_object(Bucket=BUCKET_NAME, Key=key)
data = response["Body"].read()
return dataDeleting an Object
def delete_avatar(key: str) -> None:
s3.delete_object(Bucket=BUCKET_NAME, Key=key)Listing Objects
You can list all objects with a given prefix, which behaves like listing a folder.
def list_user_avatars() -> list[str]:
response = s3.list_objects_v2(
Bucket=BUCKET_NAME,
Prefix="avatars/",
)
contents = response.get("Contents", [])
return [obj["Key"] for obj in contents]If your bucket has:
avatars/user_1.pngavatars/user_2.pngdocuments/invoices/2024-01.pdf
The function will return only the two avatar keys.
Public URLs and Permissions
Controlling Who Can Access Objects
There are two main access patterns:
- Public objects
Anyone with the URL can download the file. You usually use this for public assets, for example product images. - Private objects
Only authenticated requests or presigned URLs can access the file. You use this for user-specific or sensitive data.
Security for S3-compatible storage has two layers:
- Bucket policies / ACLs decide defaults (public or private, who can read/write).
- Application logic decides which keys you create and who gets their URLs.
Public Objects
Some providers allow you to make an entire bucket or specific prefixes public. Then, each object can be accessed by a predictable URL.
Common patterns:
- Path-style:
https://<endpoint>/<bucket>/<key> - Virtual-hosted-style:
https://<bucket>.<endpoint>/<key>
Example:
- Endpoint:
https://files.example-cdn.com - Bucket:
my-app-uploads - Key:
avatars/user_1.png
Public URL might look like:
https://my-app-uploads.files.example-cdn.com/avatars/user_1.png
orhttps://files.example-cdn.com/my-app-uploads/avatars/user_1.png
Presigned URLs
Presigned URLs allow temporary access to a private object without sharing credentials. This is very useful in backend development.
Two common use cases:
- Your backend gives the client a presigned download URL for a file.
- Your backend gives the client a presigned upload URL to upload directly to storage.
Presigned Download URL Example
def create_presigned_download_url(key: str, expires_in: int = 3600) -> str:
url = s3.generate_presigned_url(
"get_object",
Params={"Bucket": BUCKET_NAME, "Key": key},
ExpiresIn=expires_in,
)
return url
The client can use the returned url with a normal HTTP GET to download the file for the next 1 hour.
Presigned Upload URL Example
def create_presigned_upload_url(
key: str, content_type: str, expires_in: int = 3600
) -> dict:
url = s3.generate_presigned_url(
"put_object",
Params={
"Bucket": BUCKET_NAME,
"Key": key,
"ContentType": content_type,
},
ExpiresIn=expires_in,
)
return {"url": url, "key": key}
The client can then perform an HTTP PUT to that URL with the file body, and the object will be stored under key in your bucket.
Security rule:
Never trust the path or file names chosen by the client.
Your backend should generate the object key and control which prefixes the client can use.
Integrating S3-Compatible Storage with a Backend API
Typical Flow for File Uploads
A common pattern for modern backends:
- Client asks your API for a presigned upload URL.
- API:
- Generates a safe key,
- Creates a presigned upload URL,
- Returns URL and key to client.
- Client uploads the file directly to S3-compatible storage using the URL.
- Client notifies your API that upload is finished and sends the key.
- API stores the key in the database.
This pattern avoids sending large files through your application server, which:
- Reduces CPU and bandwidth usage,
- Makes scaling easier,
- Limits how long your endpoints stay busy.
Example JSON API Contract
| Step | Request from client | Response from backend |
|---|---|---|
| 1 | POST /files/avatar/upload-url (no file body) | { "upload_url": "...", "key": "avatars/user_123/abc123.png" } |
| 2 | PUT upload_url with file bytes | S3-compatible service returns 200 OK |
| 3 | POST /users/me/avatar with { "key": "avatars/user_123/abc123.png" } | Backend stores key for the user and returns updated user |
Serving Files
To serve files to users you have options:
- Direct S3 URLs:
You show either public object URLs or presigned URLs. - Proxy through backend (simple but less scalable):
Your backend downloads the file and streams it to the client.
Suitable for small projects or when you need strong access control but do not want presigned URLs yet.
Naming and Organizing Object Keys
Good Key Design
Key design affects:
- How easily you can find related files.
- How you clean up data when a user or resource is deleted.
- How you handle name conflicts.
Useful patterns:
- Prefix by resource type
avatars/user_123.pngproducts/53/images/main.jpgorders/2024/08/28/order_987.pdf- Include IDs and random parts
To avoid collisions and make guessing harder:
avatars/user_123/6f1a2b5c.pnguploads/2024/08/28/uuid-4c1e.../file.pdf
- Avoid user-controlled paths
Do not let clients send ../../secret or entire folder names.
Generate keys on the server.
Example Key Strategy
For a user uploads feature:
- Avatars:
avatars/{user_id}/{uuid4()}.png - Other files:
user-files/{user_id}/{date}/{uuid4()}_{original_filename}
Example resulting keys:
| Purpose | Key example |
|---|---|
| Avatar | avatars/42/3e7ad2ed-09cc-4e3e-8c38-d36f40c8cbd9.png |
| Document | user-files/42/2024-08-28/1a2b3c4d_invoice_march.pdf |
Local Development with MinIO
Why MinIO
Using real cloud storage during development can be:
- Slow.
- Costly.
- Hard to use offline.
MinIO is an S3-compatible storage server you can run locally, for example with Docker. Your application connects in the same way as with real S3, but to localhost.
Mini example docker-compose.yml:
version: "3.8"
services:
minio:
image: minio/minio
command: server /data
environment:
MINIO_ROOT_USER: minioadmin
MINIO_ROOT_PASSWORD: minioadmin123
ports:
- "9000:9000" # API endpoint
- "9001:9001" # Web console
volumes:
- ./minio-data:/dataThen set environment variables for your backend:
export S3_ENDPOINT_URL="http://localhost:9000"
export S3_ACCESS_KEY_ID="minioadmin"
export S3_SECRET_ACCESS_KEY="minioadmin123"
export S3_REGION="us-east-1"
export S3_BUCKET="my-app-uploads"You create the bucket once using MinIO’s web console or a script, and your code stays mostly the same as with real S3.
Common Pitfalls and Best Practices
Common Pitfalls
| Pitfall | Problem | Better approach |
|---|---|---|
| Hardcoding bucket and endpoint in code | Hard to change per environment | Use environment variables and config files |
| Using user-provided filenames as keys | Name collisions, path tricks, information disclosure | Generate safe keys, store original name separately if needed |
| Returning internal object keys directly | Leaks bucket structure and provider info | Use public / CDN URLs or presigned URLs |
| Uploading via backend server for all files | High load, slow responses | Use presigned upload URLs for large files |
| Mixing public and private data in same path | Hard to write security policies | Use separate prefixes or even separate buckets |
Best Practices
Key best practices:
- Use environment variables for all S3-compatible configuration.
- Treat object keys as sensitive references, not as public identifiers.
- Prefer presigned URLs for protected downloads and direct client uploads.
- Design predictable key structures that are easy to clean up per user or resource.
Additional recommendations:
- Validate file type and size before generating upload URLs, or after upload completion.
- Consider a CDN in front of S3-compatible storage for faster global delivery.
- Regularly clean unused files, for example orphaned uploads that are never attached to a database record.
- Log storage operations for debugging and audit, especially deletions.
Summary
You have learned:
- What S3-compatible storage is and why it is useful for backends.
- How buckets and object keys work.
- How to upload, download, delete, and list objects with a client library.
- How to use public URLs and presigned URLs in a secure way.
- How to design good key naming schemes and integrate object storage into an API.
- How to use MinIO for local development with the same S3-style API.
With these concepts, you can now replace simple local file storage with scalable and robust S3-compatible storage in your 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!