Как работает жизненный цикл запроса в FastAPI?

Question

IT Interview Practice · Accepted Answer

FastAPI работает поверх **ASGI**, поэтому запрос проходит через асинхронный конвейер: сервер ASGI принимает его, middleware оборачивает его, router сопоставляет path, **разрешаются зависимости (dependencies)**, выполняется ваша path operation, а возвращаемое значение сериализуется в ответ.

## Этапы

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── сопоставить метод + path → path operation
   ▼
Dependencies (Depends)  ── разрешить sub-deps, security, yield-setup
   ▼
Path operation function  ── выполняется ваш handler
   ▼
Response model  ── валидация + сериализация в JSON
   ▼
Background tasks  ── выполняются после отправки ответа
   ▼
Response ──▶ client
```

1. **Сервер ASGI** (uvicorn/hypercorn) принимает соединение и передаёт приложению `scope`, а также вызываемые объекты `receive`/`send`.
2. **Middleware** на входе работает снаружи внутрь, а на выходе — изнутри наружу (`BaseHTTPMiddleware` или чистый ASGI middleware). CORS, GZip и собственный замер времени находятся здесь.
3. **Routing** сопоставляет HTTP-метод + path с path operation; параметры path/query/body извлекаются и валидируются с помощью **Pydantic**.
4. **Внедрение зависимостей (dependency injection)** — `Depends(...)` разрешает каждую зависимость (сессия БД, текущий пользователь, настройки), кэшируя её в пределах запроса. Зависимость с `yield` выполняет setup до и teardown после handler.
5. **Path operation** — ваш `async def` (или `def`, выполняемый в threadpool) выполняет бизнес-логику.
6. **Response** — возвращаемое значение приводится к объявленному `response_model`, валидируется и сериализуется в JSON; применяются код статуса и заголовки.
7. **Background tasks**, зарегистрированные через `BackgroundTasks`, выполняются *после* отправки ответа.

```python
from fastapi import FastAPI, Depends, Request

app = FastAPI()

@app.middleware("http")
async def timing(request: Request, call_next):   # 2. middleware
    response = await call_next(request)
    response.headers["X-Time"] = "..."
    return response

async def get_db():                               # 4. dependency (yield)
    db = Session()
    try:
        yield db
    finally:
        db.close()

@app.get("/items/{id}")                           # 3. routing
async def read_item(id: int, db=Depends(get_db)): # 5. handler
    return db.get(Item, id)                        # 6. сериализация через response_model
```

Исключения перехватываются **обработчиками исключений (exception handlers)** (`@app.exception_handler(...)` / `HTTPException`), которые преобразуют их в ответы вместо аварийного завершения запроса.

## Почему это важно

Жизненный цикл запроса — это место, где на самом деле происходят ключевые возможности FastAPI: асинхронный I/O, валидация Pydantic и внедрение зависимостей — все они подключаются к конкретным этапам. Знание порядка — middleware, затем routing, затем зависимости, затем handler, затем сериализация — позволяет размещать сквозную логику в нужном месте (аутентификация как зависимость, замер времени как middleware, очистка в зависимости с `yield`), отлаживать, почему ошибка валидации или аутентификации возникает раньше вашего кода, и избегать блокировки event loop внутри асинхронного handler.

Этапы

Почему это важно

Похожие вопросы