FastAPI Fundamentals and Asynchronous Processing

If you work with AI applications, web scraping, or data science, Python is undoubtedly your primary language. However, in the past, if you wanted to build a backend API server with Python, you typically had only two options:

  1. Django: Too bulky, packed with systems you don’t need.
  2. Flask: Lightweight, but lacks built-in data validation and has poor support for asynchronous (Async) operations.

Enter FastAPI.

FastAPI is currently the fastest-growing web framework in Python. As the name suggests, its hallmark is "speed." Not only does it run fast (built on Starlette and Pydantic, with performance close to Node.js and Go), but it also enables "rapid development" by automatically generating Swagger API documentation.

In this lesson, we’ll build your first FastAPI microservice!

1. Environment Setup and Installation

First, we need a clean Python virtual environment. Open your terminal:

# Create a virtual environment (Mac/Linux)
python3 -m venv venv
source venv/bin/activate

# Create a virtual environment (Windows)
python -m venv venv
venv\Scripts\activate

Next, install FastAPI and its dedicated server engine, uvicorn:

pip install fastapi "uvicorn[standard]"

[!TIP] What is Uvicorn? Uvicorn is a lightning-fast ASGI (Asynchronous Server Gateway Interface) server. FastAPI handles the logic, while Uvicorn listens to the port and asynchronously routes HTTP requests to FastAPI.

2. Build Your First Hello World API

Create a file named main.py in your project directory:

from fastapi import FastAPI

# Create a FastAPI instance
app = FastAPI(
    title="Vibe Tutor AI Microservice API",
    description="This is my first backend server built with FastAPI!",
    version="1.0.0"
)

# Define a GET route
@app.get("/")
async def root():
    return {"message": "Hello World! Welcome to the world of FastAPI."}

# Define a route with a path parameter
@app.get("/users/{user_id}")
async def read_user(user_id: int):
    return {"user_id": user_id, "status": "active"}

It’s that simple! No complex configuration files—just use Python’s @app.get decorator to define routes.

3. Start the Server with Hot Reload

Run the following command in your terminal to start the server:

uvicorn main:app --reload
  • main: Refers to the main.py file.
  • app: Refers to the app = FastAPI() instance we created in the code.
  • --reload: A developer’s best friend! The server will instantly restart whenever you modify and save the code—no manual interruption needed.

When you see Uvicorn running on http://127.0.0.1:8000, you’re good to go!

4. Automated OpenAPI Documentation (Swagger UI)

This is FastAPI’s killer feature that engineers adore.
Now, open your browser and navigate to:
👉 http://127.0.0.1:8000/docs

You’ll see an exquisitely designed Swagger UI interface!
FastAPI automatically parses your code and generates this interactive API documentation, which you can test directly on the page.

No need to write a single line of Postman configuration—frontend engineers (or your Next.js app) can directly refer to this documentation for API integration. If you visit http://127.0.0.1:8000/redoc, you’ll find an alternative documentation style.

5. Why Use async def? (Asynchronous Processing)

You’ll notice we used async def instead of the traditional def when declaring functions.

This is FastAPI’s core secret to outperforming Flask: Asynchronous Processing.

In the past, if your API was executing a slow task (e.g., calling the OpenAI API to generate an article, which takes 10 seconds), the entire server would "block," forcing other users’ requests to wait in line.

With async / await, while the server waits for OpenAI’s response during those 10 seconds, it can yield control to handle other users’ requests. This allows FastAPI to handle extremely high concurrency with minimal hardware resources.

import asyncio
from fastapi import FastAPI

app = FastAPI()

@app.get("/generate-ai-text")
async def generate_text():
    # Simulate a 5-second AI generation task
    print("Starting generation...")
    await asyncio.sleep(5)  # Note: Must use await
    print("Generation complete!")
    
    return {"result": "This is an awesome AI-generated article."}

[!WARNING] Never use blocking functions!
If you use traditional time.sleep(5) or synchronous requests.get() inside an async def, the entire server will still freeze! You must use asynchronous alternatives (e.g., asyncio.sleep or the httpx library). If you absolutely need synchronous functions, declare them as traditional def, and FastAPI will automatically run them in a ThreadPool.

In the next chapter, we’ll explore another core weapon of FastAPI: Pydantic Data Validation. See how it eliminates the need for painful code like if request.get("name") is None!

Project Structure

A well-organized FastAPI project follows a predictable structure.

Recommended Layout

my-fastapi-api/
├── app/
│   ├── __init__.py
│   ├── main.py              # FastAPI app instance, routers
│   ├── config.py            # Settings, environment variables
│   ├── models/              # SQLAlchemy models
│   │   ├── __init__.py
│   │   └── user.py
│   ├── schemas/             # Pydantic schemas
│   │   ├── __init__.py
│   │   └── user.py
│   ├── routers/             # Route handlers
│   │   ├── __init__.py
│   │   └── users.py
│   └── dependencies.py     # Shared dependencies
├── tests/
│   ├── __init__.py
│   └── test_users.py
├── requirements.txt
├── Dockerfile
└── .env

Why This Structure?

| Reason | Benefit | |--------|---------| | Separation of concerns | Routes, models, schemas are independent | | Testability | Each module testable in isolation | | Scalability | Easy to add new features without touching existing code | | Reusability | Schemas and models are importable anywhere |

Routing and Modularity

Router Example

# app/routers/users.py
from fastapi import APIRouter, Depends, HTTPException
from typing import list

router = APIRouter(prefix="/users", tags=["users"])

# In-memory database for demo
fake_db = {}

@router.get("/")
async def get_users():
    return list(fake_db.values())

@router.get("/{user_id}")
async def get_user(user_id: int):
    if user_id not in fake_db:
        raise HTTPException(status_code=404, detail="User not found")
    return fake_db[user_id]

@router.post("/", status_code=201)
async def create_user(user: dict):
    user_id = len(fake_db) + 1
    fake_db[user_id] = {**user, "id": user_id}
    return fake_db[user_id]

Main App Assembly

# app/main.py
from fastapi import FastAPI
from app.routers import users, items, health

app = FastAPI(
    title="My FastAPI Microservice",
    description="Production-ready API built with FastAPI",
    version="1.0.0",
    docs_url="/docs",
    redoc_url="/redoc"
)

# Include routers
app.include_router(health.router)
app.include_router(users.router)
app.include_router(items.router)

@app.get("/")
async def root():
    return {
        "service": "My FastAPI API",
        "version": "1.0.0",
        "docs": "/docs",
        "status": "running"
    }

Configuration Management

# app/config.py
from pydantic_settings import BaseSettings

class Settings(BaseSettings):
    app_name: str = "My FastAPI API"
    database_url: str = "sqlite:///./test.db"
    jwt_secret: str = "change-me-in-production"
    jwt_algorithm: str = "HS256"
    jwt_expire_minutes: int = 30
    cors_origins: list[str] = ["*"]
    environment: str = "development"
    debug: bool = True

    class Config:
        env_file = ".env"

settings = Settings()

Async vs Sync Routes

| Declaration | Best For | Behavior | |-------------|----------|----------| | async def | I/O bound (DB, API, file) | Runs on event loop | | def | CPU bound, sync libraries | Runs in ThreadPool |

# Async — non-blocking I/O
@app.get("/async-example")
async def read_async():
    data = await fetch_from_database()
    return data

# Sync — blocking I/O, auto-handled
@app.get("/sync-example")
def read_sync():
    data = some_blocking_function()
    return data

Summary

FastAPI setup involves installing the framework, structuring your project, defining routers, managing configuration, and understanding async vs sync routes. Its automatic OpenAPI docs and type-based validation make it a leading choice for Python APIs.

Key takeaways:

  • Install: pip install fastapi uvicorn |
  • Run: uvicorn app.main:app --reload |
  • Project structure: app/main.py, routers/, schemas/, models/ |
  • APIRouter organizes routes with prefix and tags |
  • Pydantic-settings loads config from .env files |
  • async def for I/O, def for CPU/sync code |
  • Auto-generated docs at /docs and /redoc |
  • Interactive Swagger UI for testing endpoints |

What's Next: Pydantic Validation

The next chapter covers Pydantic models for request/response validation.

Member Exclusive Free Tutorial

This chapter is free exclusive content for registered members! Please login or register to unlock immediately.

Login / Register Now