I’ve been building web applications for years, and recently, I hit a wall with monolithic architectures. Scaling became a nightmare, deployments turned risky, and adding new features felt like walking through a minefield. That’s when I dove into microservices, specifically using FastAPI, SQLAlchemy, and Docker. In this guide, I’ll walk you through creating a robust user management microservice that’s ready for production. Stick with me, and you’ll see how these tools can transform your development process.

Setting up the environment is your first step. I always start by creating a virtual environment and installing dependencies. Here’s a snippet from my requirements.txt file:

fastapi==0.104.1
uvicorn[standard]==0.24.0
sqlalchemy==2.0.23
asyncpg==0.29.0

Configuration management is crucial. I use Pydantic settings to handle environment variables securely. Have you ever forgotten to set a critical environment variable in production? I have, and it taught me to centralize configuration early.

from pydantic_settings import BaseSettings

class Settings(BaseSettings):
    database_url: str
    secret_key: str
    
    class Config:
        env_file = ".env"

settings = Settings()

Building the core FastAPI application involves more than just routes. I implement an application factory with lifespan events for clean startup and shutdown. This ensures database connections and caches are handled properly. What happens if your service crashes mid-request? Proper lifecycle management prevents data corruption.

from contextlib import asynccontextmanager
from fastapi import FastAPI

@asynccontextmanager
async def lifespan(app: FastAPI):
    await init_db()
    yield
    await close_db()

app = FastAPI(lifespan=lifespan)

For the database layer, I use SQLAlchemy 2.0 with async support. This avoids blocking operations and improves concurrency. Here’s a basic model setup:

from sqlalchemy.orm import DeclarativeBase

class Base(DeclarativeBase):
    pass

class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True)
    email = Column(String, unique=True)

Authentication is a common pain point. I implement JWT tokens with secure password hashing. Why rely on sessions when you can have stateless authentication that scales?

from passlib.context import CryptContext

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

def hash_password(password: str) -> str:
    return pwd_context.hash(password)

Error handling and logging are often overlooked. I use structured logging with tools like structlog to track requests and errors. Imagine debugging an issue without proper logs—it’s like finding a needle in a haystack.

import structlog

logger = structlog.get_logger()

async def get_user(user_id: int):
    try:
        # Database operation
    except Exception:
        logger.error("User fetch failed", user_id=user_id)
        raise

Testing is non-negotiable. I write tests for every endpoint using pytest and asyncio. How confident are you in your code without tests?

import pytest
from httpx import AsyncClient

@pytest.mark.asyncio
async def test_create_user(client: AsyncClient):
    response = await client.post("/users/", json={"email": "test@example.com"})
    assert response.status_code == 200

Containerization with Docker ensures consistency across environments. Here’s a simple Dockerfile:

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0"]

Health checks and monitoring keep your service reliable. I add endpoints for liveness and readiness probes. What good is a service if it can’t tell you it’s healthy?

Deployment strategies vary, but I prefer using Docker Compose for development and orchestration tools like Kubernetes for production. Performance optimization comes from profiling and using async patterns effectively.

Throughout this process, I’ve learned that common pitfalls include ignoring database connection pooling or skipping migration tests. Always validate your assumptions with real-world scenarios.

I hope this guide helps you build something amazing. If you found it useful, please like, share, and comment with your experiences. Let’s learn together and make our systems more resilient.