12.14. Alembic
Table of Contents
Why Alembic Matters
When you build a real application, your database schema will change many times. You will:
- Add new tables.
- Add or remove columns.
- Change column types.
- Add or drop indexes and constraints.
If you do this manually with raw ALTER TABLE statements, you quickly get:
- Out of sync environments, for example dev vs production.
- Confusing database state, for example, "Did we already add this column?"
- Hard, error prone deployments.
Alembic solves this by giving you versioned database migrations for SQLAlchemy based projects.
With Alembic you:
- Describe changes to the schema in Python migration files.
- Apply them step by step to any database.
- Roll them back if you need to.
Alembic is the standard migration tool for SQLAlchemy. If you use SQLAlchemy in production, you should use Alembic or some other migration tool, never manual SQL only.
This chapter focuses on how to use Alembic, not on designing schemas or writing SQL. Those topics are covered in other chapters.
Core Concepts
Alembic is a migration engine. Its main concepts are:
| Concept | Description |
|---|---|
| Migration | A small step that changes the schema, for example, add a column. |
| Revision | A migration file, identified by a unique revision ID. |
| Upgrade | Apply a migration, move schema to a newer version. |
| Downgrade | Reverse a migration, move schema to an older version. |
| Revision history | A chain of revisions, similar to git commits. |
| Head | The latest revision in your migration history. |
| Alembic environment | The configuration and script folder that defines how migrations run. |
Each Alembic revision file contains two functions:
def upgrade():
# code that applies the migration
def downgrade():
# code that reverses the migration
Alembic also maintains a special table in your database called something like alembic_version. It stores the current revision of the schema for that database.
Setting Up Alembic in a Project
Installing Alembic
Alembic is a Python package. Install it in your project environment:
pip install alembicYou should run all Alembic commands from your project root, inside your virtual environment.
Initializing Alembic
To create Alembic configuration and migrations directory:
alembic init alembicThis creates:
alembic.ini(top level file)alembic/folder, containing:env.pyscript.py.makoversions/(empty folder for migration scripts)
Typical project tree after initializing:
my_app/
app/
__init__.py
models.py
db.py
alembic/
env.py
script.py.mako
versions/
alembic.ini
requirements.txtConfiguring Alembic
Alembic needs to know:
- How to connect to your database.
- How to import your SQLAlchemy
Baseand models, for autogeneration.
Database URL in `alembic.ini`
Open alembic.ini. You will see something like:
[alembic]
script_location = alembic
sqlalchemy.url = driver://user:pass@localhost/dbnameThere are two main patterns.
Pattern 1: Put URL directly here
For simple projects or local testing:
sqlalchemy.url = postgresql+psycopg2://user:password@localhost:5432/mydbPattern 2: Read URL from environment or your code
More common in real applications. You leave sqlalchemy.url blank or dummy, and configure inside env.py.
Example alembic.ini:
sqlalchemy.url = driver_not_used://
Then in alembic/env.py you load environment variables or import from your app.
Configuring `env.py` to use your models
Open alembic/env.py. Find something like:
from alembic import context
from sqlalchemy import engine_from_config, pool
# this is the Alembic Config object, which provides
# access to the values within the .ini file
config = context.config
target_metadata = None
You must set target_metadata to the MetaData of your SQLAlchemy models.
Assume you have something like this in app/db.py:
from sqlalchemy.orm import declarative_base
Base = declarative_base()
And your models in app/models.py inherit from Base.
Then modify env.py:
import os
import sys
from logging.config import fileConfig
from alembic import context
from sqlalchemy import engine_from_config, pool
# Add project root to sys.path so imports work
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
from app.db import Base # import your Base
config = context.config
fileConfig(config.config_file_name)
# Here, tell Alembic about your models
target_metadata = Base.metadataNow Alembic can see your tables and generate migrations from them.
Reading the database URL from your app
If your app defines a DATABASE_URL or similar, you can reuse it.
Example app/db.py:
import os
from sqlalchemy import create_engine
from sqlalchemy.orm import declarative_base, sessionmaker
DATABASE_URL = os.getenv("DATABASE_URL")
engine = create_engine(DATABASE_URL, future=True)
SessionLocal = sessionmaker(bind=engine, autoflush=False, autocommit=False)
Base = declarative_base()
In alembic/env.py, instead of using the sqlalchemy.url from the ini, you can set it:
from app.db import DATABASE_URL
config.set_main_option("sqlalchemy.url", DATABASE_URL)
A minimal env.py section might look like:
from alembic import context
from sqlalchemy import engine_from_config, pool
from app.db import Base, DATABASE_URL
config = context.config
config.set_main_option("sqlalchemy.url", DATABASE_URL)
target_metadata = Base.metadata
def run_migrations_offline():
url = config.get_main_option("sqlalchemy.url")
context.configure(
url=url,
target_metadata=target_metadata,
literal_binds=True,
dialect_opts={"paramstyle": "named"},
)
with context.begin_transaction():
context.run_migrations()
def run_migrations_online():
connectable = engine_from_config(
config.get_section(config.config_ini_section),
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
with connectable.connect() as connection:
context.configure(connection=connection, target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online()You do not need to fully understand offline vs online mode now. For most use cases you will run migrations in online mode with a live database.
Creating Migrations
There are two main ways to create migrations:
- Autogenerate from your SQLAlchemy models.
- Manual migrations that you write yourself.
You often combine both.
Making your first autogeneration
Assume:
- You have models defined and imported via
Base.metadatainenv.py. - The database is empty.
Run:
alembic revision --autogenerate -m "create initial tables"Alembic will:
- Compare your
Base.metadata(what models say should exist) with the actual database. - Generate a migration script in
alembic/versions/with a random looking revision ID in the filename.
Example filename:
alembic/versions/1975ea83b712_create_initial_tables.pyOpen the created file. You will see something like:
"""create initial tables"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic
revision = '1975ea83b712'
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
op.create_table(
'users',
sa.Column('id', sa.Integer(), primary_key=True),
sa.Column('email', sa.String(), nullable=False, unique=True),
sa.Column('hashed_password', sa.String(), nullable=False),
)
def downgrade():
op.drop_table('users')
op is Alembic’s helper object. You use it to declare schema changes.
Always open and review autogenerated migrations. Never trust autogeneration blindly. Fix issues by editing the migration file before running it.
Common operations with `op`
Here are typical examples of Alembic operations that you will use.
Create a new table
def upgrade():
op.create_table(
'posts',
sa.Column('id', sa.Integer, primary_key=True),
sa.Column('title', sa.String(200), nullable=False),
sa.Column('content', sa.Text, nullable=False),
sa.Column('user_id', sa.Integer, sa.ForeignKey('users.id'), nullable=False),
)
def downgrade():
op.drop_table('posts')Add a new column
def upgrade():
op.add_column('users', sa.Column('full_name', sa.String(200), nullable=True))
def downgrade():
op.drop_column('users', 'full_name')Rename a column
SQLAlchemy does not have a direct cross database rename. Alembic has op.alter_column with new_column_name, but not all databases support it. Example for PostgreSQL:
def upgrade():
op.alter_column('users', 'full_name', new_column_name='name')
def downgrade():
op.alter_column('users', 'name', new_column_name='full_name')Add an index
def upgrade():
op.create_index('ix_users_email', 'users', ['email'], unique=True)
def downgrade():
op.drop_index('ix_users_email', table_name='users')Add a foreign key constraint
def upgrade():
op.create_foreign_key(
'fk_posts_user_id_users',
source_table='posts',
referent_table='users',
local_cols=['user_id'],
remote_cols=['id'],
ondelete='CASCADE',
)
def downgrade():
op.drop_constraint('fk_posts_user_id_users', 'posts', type_='foreignkey')Execute raw SQL
Only when necessary, for example complex operations:
def upgrade():
op.execute("UPDATE users SET full_name = '' WHERE full_name IS NULL")
def downgrade():
# sometimes hard or impossible to fully reverse
passRunning Migrations
Once you have migration files, you apply them to the database.
Apply all pending migrations
alembic upgrade headThis will:
- Look at the current database revision.
- Run all
upgrade()functions up to the latest revision.
Upgrade to a specific revision
You can upgrade only to a particular revision ID:
alembic upgrade 1975ea83b712Alembic understands also relative steps:
# Go one revision forward
alembic upgrade +1
# Go three revisions forward
alembic upgrade +3Downgrade (rollback) migrations
To undo the last migration:
alembic downgrade -1To go all the way back to the base (no migrations):
alembic downgrade baseBe very careful when downgrading in production, because:
- You can lose data if a migration drops columns or tables.
- Downgrades are safe only if the downgrade code correctly reverses everything.
Check current revision
alembic currentThis prints the current revision of the connected database.
See history of revisions
alembic historyYou will see something like:
1975ea83b712 -> 3b1ae6349c66, add posts table
<base> -> 1975ea83b712, create initial tablesTypical Workflow with Alembic
Here is a practical step by step workflow for schema changes.
Scenario 1: Create initial schema
- Define your models using SQLAlchemy:
# app/models.py
from sqlalchemy import Column, Integer, String
from .db import Base
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True, index=True)
email = Column(String, unique=True, nullable=False, index=True)
hashed_password = Column(String, nullable=False)- Initialize and configure Alembic, as described earlier.
- Autogenerate initial migration:
alembic revision --autogenerate -m "create users table"- Review the migration file, adjust if necessary.
- Apply the migration:
alembic upgrade head
Now the database has the users table.
Scenario 2: Add a new column
You decide to add is_active to User.
- Change the model:
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True, index=True)
email = Column(String, unique=True, nullable=False, index=True)
hashed_password = Column(String, nullable=False)
is_active = Column(Boolean, nullable=False, server_default="true")- Autogenerate:
alembic revision --autogenerate -m "add is_active to users"- Open the new migration:
def upgrade():
op.add_column(
'users',
sa.Column('is_active', sa.Boolean(), server_default='true', nullable=False)
)
def downgrade():
op.drop_column('users', 'is_active')- Apply it:
alembic upgrade headNow all environments that run this migration will have the new column.
Scenario 3: Data migration with schema change
You need to split a full_name column into first_name and last_name.
- Update your models to use
first_nameandlast_name, and maybe keepfull_nametemporarily. - Manually write a migration that:
- Adds the new columns.
- Copies and splits data.
- (Optionally) drops the old column.
Example migration:
from alembic import op
import sqlalchemy as sa
revision = '6677b0f8e2c0'
down_revision = '3b1ae6349c66'
branch_labels = None
depends_on = None
def upgrade():
op.add_column('users', sa.Column('first_name', sa.String(100), nullable=True))
op.add_column('users', sa.Column('last_name', sa.String(100), nullable=True))
# Example simple split: assume full_name is "First Last"
connection = op.get_bind()
users = connection.execute(sa.text("SELECT id, full_name FROM users")).fetchall()
for user in users:
full_name = user.full_name or ""
parts = full_name.split(" ", 1)
first = parts[0] if len(parts) >= 1 else ""
last = parts[1] if len(parts) == 2 else ""
connection.execute(
sa.text(
"UPDATE users SET first_name = :first, last_name = :last WHERE id = :id"
),
{"first": first, "last": last, "id": user.id},
)
# Optionally drop old column
op.drop_column('users', 'full_name')
def downgrade():
op.add_column('users', sa.Column('full_name', sa.String(200), nullable=True))
connection = op.get_bind()
users = connection.execute(
sa.text("SELECT id, first_name, last_name FROM users")
).fetchall()
for user in users:
full = (user.first_name or "") + " " + (user.last_name or "")
full = full.strip()
connection.execute(
sa.text(
"UPDATE users SET full_name = :full WHERE id = :id"
),
{"full": full, "id": user.id},
)
op.drop_column('users', 'first_name')
op.drop_column('users', 'last_name')This example shows that migrations are full Python scripts. You can read and write data directly when needed, not only alter schema.
Good Practices for Using Alembic
Keep migrations small and focused
Each revision should do one logical change, for example:
- Add a table.
- Add or change a few related columns.
- Add an index.
This makes upgrades and debugging easier.
Do not edit old migrations that already ran in shared environments
Once a migration has been:
- Committed to version control.
- Applied to any shared environment (staging, production).
Do not change its contents. Instead, create a new migration that fixes or adjusts the schema.
Changing old migrations after they ran can:
- Break new deployments that started from an older base.
- Confuse Alembic when revision code does not match the actual schema.
Always review autogenerated scripts
Autogeneration is helpful but not perfect. It can:
- Miss complex constraints.
- Generate wrong or unnecessary changes.
For example, if you only reorder columns in your model class, Alembic might try to recreate columns. That is not what you want. You must inspect and fix the resulting operations.
Use meaningful migration messages
When creating revisions:
alembic revision --autogenerate -m "add index on user email"
This message goes into the migration file and appears in alembic history. It is your documentation for the schema history.
Run migrations as part of deployment
A common production deployment flow:
- Build the new app image or package.
- Deploy it (but maybe keep it not serving traffic yet).
- Run
alembic upgrade headto update the database schema. - Start serving traffic with the new version.
This keeps app and database schema in sync.
Example: Integrating Alembic with a FastAPI + SQLAlchemy Project
Suppose you have:
app/
db.py
models.py
main.py
alembic/
env.py
versions/
alembic.ini
app/db.py:
import os
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, declarative_base
DATABASE_URL = os.getenv("DATABASE_URL", "postgresql+psycopg2://user:pass@localhost/db")
engine = create_engine(DATABASE_URL, future=True)
SessionLocal = sessionmaker(bind=engine, autoflush=False, autocommit=False)
Base = declarative_base()
app/models.py:
from sqlalchemy import Column, Integer, String, Boolean
from .db import Base
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True, index=True)
email = Column(String, unique=True, index=True, nullable=False)
hashed_password = Column(String, nullable=False)
is_active = Column(Boolean, nullable=False, server_default="true")
Configure alembic/env.py:
import os
import sys
from logging.config import fileConfig
from alembic import context
from sqlalchemy import engine_from_config, pool
# Add project root to sys.path
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
from app.db import Base, DATABASE_URL
config = context.config
fileConfig(config.config_file_name)
# Use DATABASE_URL from app
config.set_main_option("sqlalchemy.url", DATABASE_URL)
target_metadata = Base.metadata
def run_migrations_offline():
url = config.get_main_option("sqlalchemy.url")
context.configure(
url=url, target_metadata=target_metadata, literal_binds=True,
dialect_opts={"paramstyle": "named"},
)
with context.begin_transaction():
context.run_migrations()
def run_migrations_online():
connectable = engine_from_config(
config.get_section(config.config_ini_section),
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
with connectable.connect() as connection:
context.configure(connection=connection, target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online()Workflow:
- Set
DATABASE_URLin your environment. - Generate initial migration:
alembic revision --autogenerate -m "create users table"- Review and run:
alembic upgrade head- Any time you change models, repeat:
alembic revision --autogenerate -m "describe your change"
alembic upgrade headSummary
- Alembic provides versioned migrations for SQLAlchemy based applications.
- You configure it via
alembic.iniandalembic/env.py, pointingtarget_metadatato yourBase.metadata. - Use
alembic revision --autogenerateto create migrations from model changes, then review and edit them. - Apply migrations with
alembic upgrade head, roll back withalembic downgrade. - Keep migrations small, do not modify old applied migrations, and make migrations part of your deployment process.
With a solid grasp of Alembic, you can evolve your database schema safely as your backend application grows.
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!