8.6. Dependency Injection
Table of Contents
Why Dependency Injection Matters in FastAPI
In FastAPI, dependency injection is the core mechanism that connects your route functions with everything they need, such as database sessions, configuration, authentication, and more. You already know how to write basic routes. This chapter explains how FastAPI’s dependency system lets you keep those routes clean, testable, and reusable.
Dependency injection, or DI, lets you declare what your function needs, and FastAPI takes care of how to provide it.
FastAPI uses the Depends class to implement DI. You will see it everywhere in real-world FastAPI projects.
The Basic Idea: `Depends`
In plain terms:
- A dependency is a function that returns something useful, for example a database session or the current user.
- You declare the dependency in your path operation or other dependency function using
Depends. - FastAPI calls the dependency function for you and injects its return value into your function.
A minimal example:
from fastapi import FastAPI, Depends
app = FastAPI()
def get_message():
return "Hello from dependency"
@app.get("/hello")
def read_hello(message: str = Depends(get_message)):
return {"message": message}Here:
get_messageis a dependency function.message: str = Depends(get_message)tells FastAPI: “Before callingread_hello, callget_messageand put its result intomessage.”- The client just calls
/hello. It never knows about the dependency chain.
You can think of Depends as a declarative way to say “I need this”.
Function Dependencies
Any normal Python function can be a dependency. It can:
- Take parameters (which can themselves be dependencies).
- Return any value or object.
- Have side effects (although you should keep them predictable).
Example: a dependency that reads a setting from environment variables.
import os
from fastapi import FastAPI, Depends
app = FastAPI()
def get_settings():
db_url = os.getenv("DB_URL", "sqlite:///./test.db")
debug = os.getenv("DEBUG", "false").lower() == "true"
return {"db_url": db_url, "debug": debug}
@app.get("/settings")
def read_settings(settings: dict = Depends(get_settings)):
return settingsFastAPI:
- Calls
get_settings. - Takes its return value.
- Passes it to the
settingsargument inread_settings.
You do not call get_settings yourself.
Combining Dependencies
Dependencies can depend on other dependencies. This builds a dependency tree.
from fastapi import FastAPI, Depends
app = FastAPI()
def get_app_name():
return "MyApp"
def get_greeting(app_name: str = Depends(get_app_name)):
return f"Welcome to {app_name}"
@app.get("/greet")
def greet(message: str = Depends(get_greeting)):
return {"greeting": message}
Execution order for /greet:
- FastAPI sees
message: str = Depends(get_greeting). - To call
get_greeting, it must provideapp_name: str = Depends(get_app_name). - It calls
get_app_name, gets"MyApp". - Calls
get_greeting("MyApp"), gets the greeting string. - Calls
greet(message=that_string).
You never manually wire them together. You only declare the dependencies and FastAPI resolves the graph.
Typical Use Cases in Backends
Dependency injection is especially useful for:
- Database sessions.
- Authentication and authorization.
- Configuration.
- Reusable logic like pagination or rate limiting.
You will see examples of each pattern in other chapters, but here we focus on the DI technique itself.
Request-Scoped Dependencies and `yield`
Many backend resources must be created at the start of a request and cleaned up at the end, such as:
- Database connections.
- External service clients.
- File handles.
FastAPI supports this using a dependency function that uses yield instead of return.
Pattern:
from fastapi import Depends
def get_resource():
# setup
resource = create_resource()
try:
yield resource
finally:
# cleanup
resource.close()FastAPI:
- Runs the code before
yieldwhen the dependency is first used. - Gives the yielded value to the dependent function.
- After the request is finished, runs the
finallyblock to clean up.
A typical database session dependency (simplified):
from fastapi import Depends
from sqlalchemy.orm import Session
def get_db() -> Session:
db = SessionLocal() # create session
try:
yield db # use it in routes
finally:
db.close() # always closeUsage in a route:
@app.get("/items")
def list_items(db: Session = Depends(get_db)):
return db.query(Item).all()
The route does not know how the session is created or closed. It only receives a usable db object.
Important rule
Use yield in dependencies when you must guarantee cleanup after the request.
Do not manually close or dispose such resources in your route handlers.
Reusing Dependencies Across Routes
One of the main benefits of DI is reusability. You can attach the same dependency to many routes.
Example: a simple authentication check dependency.
from fastapi import Depends, HTTPException, status
def get_token_header(x_token: str | None = None):
if x_token != "secret-token":
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="Invalid X-Token header",
)
@app.get("/secure-data", dependencies=[Depends(get_token_header)])
def secure_data():
return {"data": "Top secret"}
Here, get_token_header:
- Does not return anything.
- Raises an exception if the condition fails.
- Is applied to the route through
dependencies=[Depends(get_token_header)].
You can attach Depends(get_token_header) to as many routes as you want.
Two main ways to use a dependency:
| Pattern | When to use |
|---|---|
param: Type = Depends(func) | You need the return value of the dependency in the function. |
dependencies=[Depends(func)] | You only need side effects or validation, not the value. |
Class-Based Dependencies
Dependencies do not have to be plain functions. They can also be classes that define an __call__ method, or classes that are used to hold parameters and logic.
Simple class dependency
Example of a dependency that uses a class instance:
from fastapi import FastAPI, Depends
app = FastAPI()
class Calculator:
def __init__(self, base: int):
self.base = base
def double(self) -> int:
return self.base * 2
def get_calculator() -> Calculator:
return Calculator(base=10)
@app.get("/calc")
def calc_value(calc: Calculator = Depends(get_calculator)):
return {"double": calc.double()}Here:
get_calculatoris the dependency function.- The route receives a
Calculatorinstance.
Using class as the dependency itself
You can also use a class directly as a dependency. FastAPI will instantiate it, injecting other dependencies into its parameters.
from fastapi import Depends
class CommonQueryParams:
def __init__(
self,
q: str | None = None,
page: int = 1,
limit: int = 10,
):
self.q = q
self.page = page
self.limit = limit
@app.get("/items")
def list_items(params: CommonQueryParams = Depends()):
return {
"query": params.q,
"page": params.page,
"limit": params.limit,
}Explanation:
Depends()without arguments means: “use the type itself as the dependency,” hereCommonQueryParams.- FastAPI will inspect
__init__, readq,page,limitand map them to query parameters.
You can reuse CommonQueryParams in many routes.
Another variant with __call__:
class Multiplier:
def __init__(self, factor: int = 2):
self.factor = factor
def __call__(self, value: int) -> int:
return value * self.factor
@app.get("/multiply/{value}")
def multiply(
result: int = Depends(Multiplier) # Multiplier is used as dependency
):
return {"result": result}FastAPI:
- Creates
Multiplier(factor=2). - Sees
result: int = Depends(Multiplier). - Calls the created instance as a function with parameters from the request, here
value. - Injects the output into
result.
Dependency Injection in Path Operations
The most common place to use dependencies is in your path operations.
from fastapi import FastAPI, Depends
app = FastAPI()
def get_current_user():
# Here you would normally read a token, load from DB, etc.
return {"username": "alice"}
@app.get("/me")
def read_me(current_user: dict = Depends(get_current_user)):
return current_userTypical patterns:
- Inject a current user object from a token.
- Inject a database session.
- Inject pagination parameters.
- Inject configuration.
Multiple dependencies in one route:
from sqlalchemy.orm import Session
def get_db() -> Session:
db = SessionLocal()
try:
yield db
finally:
db.close()
def get_current_user():
return {"username": "alice"}
@app.get("/posts")
def list_posts(
db: Session = Depends(get_db),
current_user: dict = Depends(get_current_user),
):
posts = db.query(Post).filter(Post.owner == current_user["username"]).all()
return posts
FastAPI will resolve all dependencies before calling list_posts:
- Create and yield
db. - Get
current_user. - Call the route handler.
Global and Router-Level Dependencies
Sometimes you want a dependency to run for many routes at once, like a global authentication check or a logging hook.
You can attach dependencies to:
- The whole app.
- A router.
- A single route.
App-level dependencies
from fastapi import FastAPI, Depends, Request
app = FastAPI()
def log_request(request: Request):
print("Incoming:", request.method, request.url)
app = FastAPI(dependencies=[Depends(log_request)])
@app.get("/one")
def route_one():
return {"route": "one"}
@app.get("/two")
def route_two():
return {"route": "two"}
Here log_request runs for every request, but its result is not injected as a parameter anywhere.
Router-level dependencies
from fastapi import APIRouter
router = APIRouter(
prefix="/admin",
dependencies=[Depends(get_token_header)], # will apply to all routes here
)
@router.get("/users")
def list_admin_users():
return [{"username": "admin1"}]
@router.get("/stats")
def admin_stats():
return {"users": 42}
app.include_router(router)get_token_headerruns for all routes inside/admin.- Routes do not receive any parameter from it, because it is used for validation only.
Dependency Injection and Testing
Dependency injection makes testing much easier because you can override dependencies with test versions.
FastAPI exposes app.dependency_overrides to do this.
Suppose you have:
def get_db() -> Session:
db = SessionLocal()
try:
yield db
finally:
db.close()
@app.get("/items")
def list_items(db: Session = Depends(get_db)):
return db.query(Item).all()
In tests you can override get_db:
from fastapi.testclient import TestClient
from sqlalchemy.orm import Session
client = TestClient(app)
def override_get_db() -> Session:
# use a test database or a fake object
db = TestSessionLocal()
try:
yield db
finally:
db.close()
app.dependency_overrides[get_db] = override_get_db
def test_list_items():
response = client.get("/items")
assert response.status_code == 200During tests:
- Whenever FastAPI needs
get_db, it callsoverride_get_dbinstead. - Your application code does not change.
You can override any dependency in this way, for example get_current_user to simulate authenticated users.
Optional Dependencies
Sometimes a dependency is not mandatory. You can allow it to fail without raising an error by using Depends with use_cache and default or by catching exceptions inside the dependency.
A common pattern is to make a dependency return None if authentication is missing:
from fastapi import Depends, Header, HTTPException
def get_optional_token(x_token: str | None = Header(default=None)):
if x_token is None:
return None
if x_token != "secret-token":
raise HTTPException(status_code=403, detail="Invalid token")
return x_token
@app.get("/maybe-secure")
def maybe_secure(x_token: str | None = Depends(get_optional_token)):
if x_token is None:
return {"message": "Public access"}
return {"message": "Private access", "token": x_token}
The route can then behave differently depending on whether the dependency returned something or None.
Caching Dependency Results per Request
By default, FastAPI calls each dependency once per request for each unique combination of parameters. If multiple parameters or dependencies refer to the same dependency with the same arguments, FastAPI reuses the result.
Example:
def get_config():
print("Config dependency called")
return {"debug": True}
@app.get("/a")
def route_a(cfg: dict = Depends(get_config)):
return cfg
@app.get("/b")
def route_b(
cfg1: dict = Depends(get_config),
cfg2: dict = Depends(get_config),
):
return {"same_object": cfg1 is cfg2}
For /b in a single request:
get_configis called once.cfg1andcfg2receive the same object.
You can disable this behavior in rare cases by setting use_cache=False:
@app.get("/c")
def route_c(
cfg1: dict = Depends(get_config, use_cache=False),
cfg2: dict = Depends(get_config, use_cache=False),
):
return {"same_object": cfg1 is cfg2} # will be FalseIn most backend use cases, keep the default caching because it saves work and keeps consistency inside a single request.
Important rule
Within a single request, a dependency is called at most once for a given parameter combination, unless you set use_cache=False.
This makes dependencies predictable and efficient.
Common Patterns and Examples
To make the concepts concrete, here are a few patterns that you will frequently use.
Database session per request
from fastapi import Depends
from sqlalchemy.orm import Session
def get_db() -> Session:
db = SessionLocal()
try:
yield db
finally:
db.close()
@app.post("/users")
def create_user(user_in: UserCreate, db: Session = Depends(get_db)):
user = User(**user_in.model_dump())
db.add(user)
db.commit()
db.refresh(user)
return userCurrent user from token
from fastapi import Depends, HTTPException, status, Header
def get_current_user(authorization: str | None = Header(default=None)):
if authorization is None:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Missing Authorization header",
)
scheme, _, token = authorization.partition(" ")
if scheme.lower() != "bearer" or token != "valid-token":
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Invalid token",
)
return {"username": "alice"}
@app.get("/profile")
def read_profile(current_user: dict = Depends(get_current_user)):
return current_userCommon pagination parameters
from fastapi import Query, Depends
class Pagination:
def __init__(
self,
page: int = Query(1, ge=1),
size: int = Query(10, ge=1, le=100),
):
self.page = page
self.size = size
@app.get("/products")
def list_products(p: Pagination = Depends()):
skip = (p.page - 1) * p.size
limit = p.size
return {"page": p.page, "size": p.size, "skip": skip, "limit": limit}Summary
Dependency injection in FastAPI:
- Uses
Dependsto describe what your functions need. - Lets FastAPI create, resolve, and clean up those needs automatically.
- Encourages separation of concerns, making code cleaner and more testable.
- Supports functions, classes, and
yieldfor setup and teardown. - Can be attached at route, router, or app level, and easily overridden in tests.
You will rely on this system heavily when adding authentication, database access, configuration, and more to your FastAPI backends.
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!