Web Development with FastAPI

Build Modern, Production-Ready APIs and Web Applications with Python

Introduction

Who This Book Is For

How This Book Is Structured

The Running Application

Conventions Used in This Book

What You Will Be Able to Do After This Book

Part I: Foundations — Understanding FastAPI and Its Ecosystem

Chapter 1: Your First FastAPI Application

1. Installing FastAPI and Uvicorn
2. Writing Your First API Endpoint
3. Running and Testing Your First App
4. Understanding ASGI vs WSGI
5. The Request-Response Lifecycle at a Glance
6. Automatic Interactive Documentation
7. Common Beginner Pitfalls
8. Summary

Chapter 2: Python Type Hints and Pydantic — The Foundation of FastAPI

1. Python Type Hints Refresher
2. Pydantic Models: Definition, Validation, Serialization
3. Nested Models and Complex Data Structures
4. Field Configuration with Field()
5. Custom Validators and Computed Fields
6. When to Use TypedDict or Dataclasses Instead of Pydantic
7. Summary

Part II: Core Features — Building Real APIs

Chapter 3: Routing, Parameters, and Request Bodies

1. Path Operations and HTTP Methods
2. Path Parameters: Typing, Validation, Regex Constraints
3. Query Parameters: Optional vs Required, Defaults, Multiple Values
4. Request Bodies with Pydantic Models
5. Headers, Cookies, and Dependencies on Them
6. Form Data and File Uploads
7. Mixing Different Parameter Types
8. Summary

Chapter 4: Responses, Status Codes, and Error Handling

1. Response Models and Automatic Serialization
2. HTTP Status Codes: Choosing the Right One
3. Custom Responses: JSONResponse, FileResponse, HTMLResponse, StreamingResponse
4. Headers and Cookies in Responses
5. Exception Handling with Custom Exception Classes
6. Global Error Handlers and Response Formatting
7. Summary

Chapter 5: Dependency Injection — FastAPI’s Superpower

1. What Dependency Injection Is and Why It Matters
2. Defining Dependencies with Depends()
3. Dependencies on Parameters and Other Dependencies
4. Sub-dependencies and Dependency Graphs
5. Yield-Based Dependencies for Setup and Teardown
6. Dependency Override for Testing
7. Common Patterns: Database Sessions, Current User, Config Access
8. Summary

Chapter 6: Middleware, Lifespan Events, and Background Tasks

1. What Middleware Is and How It Works in ASGI
2. Writing Custom Middleware (Logging, Timing, Request ID)
3. Built-in Middleware: CORS, TrustedHost, GZip
4. Lifespan Events: Startup and Shutdown Hooks
5. Background Tasks for Async Work After Responses
6. When to Use Background Tasks vs Message Queues
7. Summary

Chapter 7: Configuration, Logging, and OpenAPI Documentation

1. Environment-Based Configuration (Pydantic Settings)
2. Loading Config from .env Files, Environment Variables, and Secrets
3. Structured Logging with Python Logging Module
4. Log Levels, Formatters, and Handlers for Production
5. OpenAPI Specification: What It Is and How FastAPI Generates It
6. Customizing Documentation (Swagger UI, ReDoc, API Title/Version)
7. Hiding Endpoints from Docs, Custom Tags, Grouping
8. Summary

Part III: Data Layer — Databases, ORMs, and Persistence

Chapter 8: Database Integration with SQLAlchemy

1. Relational Database Concepts for API Developers
2. Installing and Configuring SQLAlchemy with PostgreSQL
3. Async Engine and Session Setup
4. Defining Models (Declarative Base, Columns, Types)
5. CRUD Operations: Create, Read, Update, Delete
6. Filtering, Ordering, Pagination in Queries
7. Summary

Chapter 9: Relationships, Transactions, and Migrations

1. One-to-Many, Many-to-One, and Many-to-Many Relationships
2. Loading Strategies: Eager vs Lazy Loading
3. Transaction Management in FastAPI
4. Database Migrations with Alembic
5. Summary

Chapter 10: Repository and Service Patterns

1. Why Separation of Concerns Matters in APIs
2. The Repository Pattern: Abstracting Data Access
3. The Service Layer: Encapsulating Business Logic
4. Wiring Repositories and Services with Dependencies
5. Handling Errors at Each Layer
6. When to Skip Patterns (Small Apps) vs When They Are Essential
7. Summary

Part IV: Security, Authentication, and Advanced Features

Chapter 11: Authentication and Authorization

1. Auth vs Authorization: Key Concepts
2. Password Hashing with Argon2
3. Session-Based Authentication (Cookies)
4. JWT Tokens: Structure, Signing, Verification
5. OAuth2 Password Flow with FastAPI Security
6. Role-Based and Permission-Based Access Control
7. Securing Individual Endpoints
8. Summary

Chapter 12: Security Best Practices and Hardening

1. HTTPS and TLS in Production
2. CORS Configuration and Common Mistakes
3. Input Validation and Sanitization
4. SQL Injection Prevention (Parameterized Queries)
5. Rate Limiting and Throttling
6. Security Headers
7. Secrets Management in Production
8. Summary

Chapter 13: Advanced Features — WebSockets, Streaming, Caching, Pagination, and External APIs

1. WebSockets: Setup, Message Handling, Connection Management
2. Server-Sent Events (SSE) as an Alternative to WebSockets
3. Streaming Responses for Large Data
4. Caching Strategies: In-Memory, Redis, HTTP Cache Headers
5. Pagination Patterns: Offset, Cursor, Keyset
6. Filtering and Searching APIs
7. External API Integration with httpx
8. Summary

Part V: Testing, Architecture, and Production Deployment

Chapter 14: Testing FastAPI Applications

1. Why Test APIs and What to Test (Unit vs Integration vs E2E)
2. Using TestClient for Request-Level Testing
3. Testing Path Operations, Validation, and Responses
4. Mocking External Services and Dependencies
5. Using Dependency Overrides in Tests
6. Database Testing Strategies (In-Memory SQLite, Fixtures, Transactions)
7. Async Test Patterns with pytest-asyncio
8. Summary

Chapter 15: Architecture, Deployment, and Production Operations

1. Project Structure for Medium to Large Applications
2. Modularization with Routers and Packages
3. Docker Containerization (Multi-Stage Builds)
4. Production ASGI Servers: Uvicorn Workers, Gunicorn
5. Reverse Proxies: Nginx Configuration
6. CI/CD Pipelines (GitHub Actions Example)
7. Monitoring, Health Checks, and Observability
8. Scaling Strategies and Performance Tuning
9. Summary

Conclusion

References