На каких технологиях базируется FastAPI?

Технологии, на которых базируется FastAPI

FastAPI — это современный веб-фреймворк для Python, который построен на нескольких ключевых технологиях. Давайте разберёмся в его архитектуре.

Основные технологии

1. Starlette — ASGI веб-фреймворк

FastAPI использует Starlette в качестве основы для асинхронной обработки HTTP запросов:

from fastapi import FastAPI
from starlette.middleware import Middleware
from starlette.middleware.cors import CORSMiddleware

app = FastAPI()

# FastAPI наследует возможности Starlette
# (маршрутизация, middleware, background tasks и т.д.)

2. Pydantic — валидация данных

Pydantic отвечает за валидацию и сериализацию данных:

from pydantic import BaseModel, Field, validator
from typing import Optional

class User(BaseModel):
    id: int
    name: str = Field(..., min_length=1, max_length=100)
    email: str
    age: Optional[int] = None
    
    @validator('email')
    def email_valid(cls, v):
        if '@' not in v:
            raise ValueError('Invalid email')
        return v

@app.post("/users/")
async def create_user(user: User):  # Автоматическая валидация
    return user

3. ASGI (Asynchronous Server Gateway Interface)

FastAPI полностью построен на ASGI стандарте для асинхронных приложений:

from fastapi import FastAPI
import asyncio

app = FastAPI()

@app.get("/")
async def root():
    # Асинхронная функция
    await asyncio.sleep(1)
    return {"message": "Hello"}

# Запуск: uvicorn main:app --reload

4. Uvicorn — ASGI сервер

Увикорн — это очень быстрый ASGI сервер для запуска FastAPI приложений:

# Базовый запуск
uvicorn main:app --reload

# С параметрами
uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4

# Production режим
uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4 --loop uvloop

Стек технологий FastAPI

FastAPI
  ├─ Starlette (веб-фреймворк)
  │   ├─ ASGI (асинхронный интерфейс)
  │   ├─ маршрутизация
  │   ├─ middleware
  │   └─ background tasks
  │
  ├─ Pydantic (валидация данных)
  │   ├─ типизация данных
  │   ├─ валидация
  │   └─ сериализация JSON
  │
  └─ Uvicorn (ASGI сервер)
      ├─ асинхронная обработка
      └─ высокая производительность

Пример интеграции всех компонентов

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import asyncio

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float
    is_available: bool = True

class Database:
    items = []

@app.post("/items/")
async def create_item(item: Item):
    # Pydantic валидирует item
    Database.items.append(item)
    return {"status": "created", "item": item}

@app.get("/items/{item_id}")
async def get_item(item_id: int):
    # Асинхронная работа с БД (например)
    await asyncio.sleep(0.1)  # Имитация DB запроса
    
    if item_id >= len(Database.items):
        raise HTTPException(status_code=404, detail="Item not found")
    
    return Database.items[item_id]

@app.on_event("startup")
async def startup_event():
    print("Приложение стартовало")

@app.on_event("shutdown")
async def shutdown_event():
    print("Приложение завершилось")

Дополнительные технологии в FastAPI

OpenAPI и Swagger UI — автоматическая документация:

from fastapi import FastAPI
from fastapi.openapi.utils import get_openapi

app = FastAPI(
    title="My API",
    description="Отличное описание API",
    version="1.0.0",
)

# Swagger UI доступен автоматически на /docs
# ReDoc доступен на /redoc
# OpenAPI schema на /openapi.json

Dependency Injection — внедрение зависимостей:

from fastapi import FastAPI, Depends

app = FastAPI()

class DatabaseSession:
    def __init__(self):
        self.connected = True

def get_db_session():
    db = DatabaseSession()
    try:
        yield db
    finally:
        db.connected = False

@app.get("/items/")
async def list_items(db: DatabaseSession = Depends(get_db_session)):
    return {"db_connected": db.connected}

Сравнение с другими фреймворками

# Django — встроённый ORM, админка, но медленнее
from django.http import HttpResponse

def view(request):
    return HttpResponse("Hello")

# FastAPI — асинхронная, быстрая, документация
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "Hello"}

# Flask — минималистичная, требует доп. библиотек
from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    return {"message": "Hello"}

Почему FastAPI быстрый?

1. ASGI + Uvicorn — асинхронная обработка тысяч запросов
2. Встроенная валидация — Pydantic проверяет данные на входе
3. Быстрая маршрутизация — Starlette использует оптимизированные алгоритмы
4. Автоматическая сериализация — JSON кодируется эффективно
5. Минимальные зависимости — только необходимые компоненты

Production деплой

# С Gunicorn и Uvicorn workers
gunicorn main:app --workers 4 --worker-class uvicorn.workers.UvicornWorker

# Или просто Uvicorn
uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4

# Docker
docker run -p 8000:8000 myapp

Заключение

FastAPI построен на проверенных и надёжных технологиях:

• Starlette для веб-функционала
• Pydantic для валидации
• ASGI для асинхронности
• Uvicorn для высокой производительности

Эта комбинация делает FastAPI одним из самых быстрых Python фреймворков с отличной документацией и удобством разработки.