8.10. Async Endpoints
Table of Contents
Why Async Endpoints Matter in FastAPI
When you build backends that talk to databases, call other APIs, or do file operations, your code often waits for I/O. If your server waits in a blocking way, it cannot handle many requests at the same time.
FastAPI is built on top of asyncio and is designed to work very well with asynchronous endpoints. In this chapter you will learn how to write async endpoints correctly, when to use async def versus def, what you can and cannot do in async functions, and how this affects performance.
The goal here is not to teach all of async programming in Python, but to show how to use it correctly inside FastAPI.
Sync vs Async Path Operations
In FastAPI, you can define path operations using both normal functions and async functions.
from fastapi import FastAPI
app = FastAPI()
# Synchronous endpoint
@app.get("/sync")
def get_sync():
return {"type": "sync"}
# Asynchronous endpoint
@app.get("/async")
async def get_async():
return {"type": "async"}FastAPI can call both kinds of functions. The difference is how they behave when there is waiting for I/O.
What happens inside each type
| Type of function | Definition | Can use await | Behavior with I/O |
|---|---|---|---|
| Synchronous | def | No | Blocking. The worker waits during I/O. |
| Asynchronous | async def | Yes | Non-blocking if you await async I/O operations. |
In an async endpoint:
@app.get("/hello")
async def hello():
# this is allowed
await some_async_call()
return {"msg": "hello"}In a sync endpoint:
@app.get("/hello-sync")
def hello_sync():
# this is NOT allowed here
# await some_async_call() # SyntaxError
return {"msg": "hello"}FastAPI decides how to execute your function based on its signature:
async def: runs directly in the event loop.def: runs in a threadpool, so it does not block the event loop.
A First Async Endpoint
Here is a minimal full example with one async and one sync endpoint that simulate work with time.sleep and asyncio.sleep.
from fastapi import FastAPI
import time
import asyncio
app = FastAPI()
@app.get("/slow-sync")
def slow_sync():
time.sleep(3) # blocking sleep
return {"status": "done", "type": "sync"}
@app.get("/slow-async")
async def slow_async():
await asyncio.sleep(3) # non-blocking sleep
return {"status": "done", "type": "async"}If you send many requests at the same time:
/slow-syncwill block the worker duringtime.sleep, so each worker processes fewer concurrent requests./slow-asyncwill release the worker duringasyncio.sleep, so the worker can start handling other requests while it waits.
You will see the performance difference clearly if you use a load testing tool.
Using async and await in FastAPI
Inside an async endpoint, you can and should use await for any operation that supports it.
Example with asyncio.sleep and an async HTTP client:
import asyncio
import httpx
from fastapi import FastAPI
app = FastAPI()
@app.get("/external")
async def call_external():
await asyncio.sleep(0.5) # simulate some delay
async with httpx.AsyncClient() as client:
response = await client.get("https://httpbin.org/get")
data = response.json()
return {"external_origin": data["origin"]}Key points:
- Every async operation that returns an awaitable must be awaited.
- If you forget to
awaitan async call, you will either get a warning or a bug that is hard to see.
Example of a mistake:
@app.get("/bad")
async def bad():
# This creates a coroutine object but never runs it
asyncio.sleep(1) # missing 'await'
return {"ok": True}This endpoint will return immediately. The sleep never actually happens.
When to Use async def vs def
You can always use def, even in FastAPI. Using async def only helps if you use non-blocking I/O inside the function.
Use this rule:
Rule:
Use async def for endpoints that call async libraries (for example async DB drivers, async HTTP clients, async file I/O).
Use def for pure CPU work or when using only blocking libraries.
Good use cases for async endpoints
- Calling other HTTP APIs with an async client, such as
httpx.AsyncClientoraiohttp. - Using an async database driver, for example:
asyncpgfor PostgreSQL.databaseslibrary.- Async SQLAlchemy (2.x with async engine).
- Using async ORMs such as Tortoise ORM or Gino.
- Doing file I/O with async libraries (for example
aiofiles).
Example calling an async database method:
from fastapi import FastAPI
app = FastAPI()
# imagine this is your async repository:
class UserRepo:
async def get_user(self, user_id: int):
# await some db call here
...
user_repo = UserRepo()
@app.get("/users/{user_id}")
async def get_user(user_id: int):
user = await user_repo.get_user(user_id)
return userWhen async does not help
If your function:
- Only does CPU work.
- Or only calls traditional blocking libraries, like
psycopg2DB driver, standardrequestsHTTP client, or regularopen()for files.
Then using async def does not make it faster. In fact, it can make things worse if you use blocking calls inside async def.
Example of what not to do:
import time
from fastapi import FastAPI
app = FastAPI()
@app.get("/wrong")
async def wrong():
# This blocks the event loop for 5 seconds
time.sleep(5)
return {"msg": "this hurts concurrency"}
In this example, the worker cannot handle other requests during the time.sleep.
If you must run blocking code but you still want an async endpoint, move the blocking work into a separate thread or process. You will see that in the next section.
Blocking Code in Async Endpoints
Sometimes you have no choice but to use a blocking library. For example, a blocking database driver or a machine learning library that takes CPU time.
You have three main options:
- Keep the endpoint synchronous with
def. - Use a background task system (see dedicated chapter).
- Run the blocking code in a thread from the async endpoint.
Option 1: Keep the endpoint sync
If your stack is mostly sync, you can simply write:
@app.get("/report")
def generate_report():
data = generate_report_sync() # heavy sync function
return data
FastAPI will run generate_report in a threadpool automatically, so it does not block the event loop. You lose some of the benefits of async, but the code is simpler.
Option 3: Run blocking code in a thread from async
If you want to keep the endpoint async, you can offload the blocking function to a thread.
From Python 3.9 onward, a common pattern is:
import anyio
from fastapi import FastAPI
app = FastAPI()
def blocking_db_call():
# blocking work, example with time.sleep
import time
time.sleep(2)
return {"result": "done"}
@app.get("/threaded")
async def threaded():
result = await anyio.to_thread.run_sync(blocking_db_call)
return result
Older style with asyncio.get_running_loop().run_in_executor:
import asyncio
from fastapi import FastAPI
app = FastAPI()
def blocking_db_call():
import time
time.sleep(2)
return {"result": "done"}
@app.get("/threaded-old")
async def threaded_old():
loop = asyncio.get_running_loop()
result = await loop.run_in_executor(None, blocking_db_call)
return resultNow the event loop is free while your blocking code runs in another thread.
Using Async Database Libraries
A common real use case is an async database driver. For example, with SQLAlchemy 2.x async engine.
Very simplified example:
from fastapi import FastAPI, Depends
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select
from .database import get_async_session
from .models import User
app = FastAPI()
@app.get("/users/{user_id}")
async def get_user(
user_id: int,
session: AsyncSession = Depends(get_async_session),
):
result = await session.execute(
select(User).where(User.id == user_id)
)
user = result.scalar_one_or_none()
if not user:
return {"error": "User not found"}
return {"id": user.id, "email": user.email}Points to notice:
- The endpoint is
async def. get_async_sessionis usually an async dependency that yields anAsyncSession.- You
await session.execute(...)because DB calls are I/O.
This pattern allows FastAPI to handle many requests efficiently, even when each request talks to the database.
Async HTTP Clients in Endpoints
Calling external APIs is another typical task. With an async endpoint you can use an async HTTP client to avoid blocking.
Example using httpx.AsyncClient:
import httpx
from fastapi import FastAPI
app = FastAPI()
@app.get("/weather/{city}")
async def get_weather(city: str):
url = "https://api.example.com/weather"
params = {"city": city}
async with httpx.AsyncClient() as client:
response = await client.get(url, params=params)
data = response.json()
return {
"city": city,
"temperature": data["temperature"],
"description": data["description"],
}
If your request handler needs to call multiple services, you can even call them concurrently using asyncio.gather.
Running Multiple Async Operations Concurrently
A big advantage of async is that you can start multiple I/O operations and wait for all of them at once.
Example: call two microservices in parallel from a single endpoint.
import asyncio
import httpx
from fastapi import FastAPI
app = FastAPI()
async def get_user_profile(client: httpx.AsyncClient, user_id: int):
r = await client.get(f"https://api.example.com/users/{user_id}")
return r.json()
async def get_user_orders(client: httpx.AsyncClient, user_id: int):
r = await client.get(f"https://api.example.com/users/{user_id}/orders")
return r.json()
@app.get("/user-summary/{user_id}")
async def user_summary(user_id: int):
async with httpx.AsyncClient() as client:
profile_task = get_user_profile(client, user_id)
orders_task = get_user_orders(client, user_id)
profile, orders = await asyncio.gather(profile_task, orders_task)
return {
"user": profile,
"orders": orders,
}Here:
- Both HTTP calls start almost at the same time.
- The total time is about the maximum of the two call durations, not the sum.
Limitations and Gotchas with Async Endpoints
Async endpoints are powerful but there are some important rules and common mistakes.
Rule 1: Do not mix blocking calls in async code
Important:
Avoid calling blocking libraries such as time.sleep, requests.get, blocking DB drivers, or long CPU loops directly inside async def endpoints.
If you must, offload them to a thread.
Bad:
import requests
@app.get("/bad-external")
async def bad_external():
# This blocks the event loop
response = requests.get("https://httpbin.org/get")
return response.json()Better:
import requests
import anyio
def blocking_request():
return requests.get("https://httpbin.org/get").json()
@app.get("/better-external")
async def better_external():
data = await anyio.to_thread.run_sync(blocking_request)
return data
Or best: use an async HTTP client instead of requests.
Rule 2: Never forget to await async calls
Bad:
async def do_something():
async_operation() # missing await
return "done"Correct:
async def do_something():
await async_operation()
return "done"
If you see a function defined with async def, it almost always should be awaited somewhere.
Rule 3: Do not call async from sync without a runner
Inside a plain def endpoint, you cannot call an async function directly.
Bad:
def sync_endpoint():
result = some_async_function() # returns coroutine, does not run it
return result
If you must call async from sync, you need something to run it, such as asyncio.run (but you usually should not call it in FastAPI endpoints) or a proper runner. In practice, you should design your code so that:
- Async code is called from async endpoints or async dependencies.
- Sync endpoints call sync functions.
Patterns for Structuring Async Code
To keep your code clean:
- Have async services that do I/O, for example:
class UserService:
def __init__(self, session_factory):
self.session_factory = session_factory
async def get_user(self, user_id: int):
async with self.session_factory() as session:
user = await session.get(User, user_id)
return user- Inject these services into async endpoints using FastAPI dependencies.
Example:
from fastapi import Depends
def get_user_service():
return UserService(session_factory=make_session_factory())
@app.get("/users/{user_id}")
async def read_user(
user_id: int,
service: UserService = Depends(get_user_service),
):
user = await service.get_user(user_id)
if not user:
return {"error": "not found"}
return userThis keeps your endpoint thin and uses async in a clean way.
Simple Performance Experiment
You can build a tiny app to feel the difference between sync blocking and async non-blocking.
# file: app.py
from fastapi import FastAPI
import time
import asyncio
app = FastAPI()
@app.get("/sync-sleep")
def sync_sleep():
time.sleep(2)
return {"status": "ok"}
@app.get("/async-sleep")
async def async_sleep():
await asyncio.sleep(2)
return {"status": "ok"}Run the server with Uvicorn:
uvicorn app:app --workers 1Then in another terminal, run something like:
# 10 requests to /sync-sleep
ab -n 10 -c 10 http://127.0.0.1:8000/sync-sleep
# 10 requests to /async-sleep
ab -n 10 -c 10 http://127.0.0.1:8000/async-sleepOr use any other tool that can send concurrent requests.
You will see that with only 1 worker:
/sync-sleeptakes about2 seconds * number_of_requests / concurrency./async-sleeptakes about 2 seconds total, because the wait is non-blocking.
Summary
Async endpoints in FastAPI:
- Are written with
async defand can useawait. - Shine when doing I/O with async libraries, such as async DB drivers or async HTTP clients.
- Allow you to handle many concurrent requests by not blocking the event loop during waits.
- Must avoid blocking operations inside them, or offload these operations to threads.
If you keep these rules in mind, you can build FastAPI applications that are both easy to read and highly performant under load.
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!