Como funciona o ciclo de vida de uma requisição no FastAPI?

Question

IT Interview Practice · Accepted Answer

O FastAPI roda sobre **ASGI**, então uma requisição percorre um pipeline assíncrono: o servidor ASGI a aceita, o middleware a envolve, o router casa uma rota, **as dependências são resolvidas**, sua operação de rota (path operation) roda e o valor de retorno é serializado na resposta.

## As etapas

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── casa método + rota → path operation
   ▼
Dependencies (Depends)  ── resolve sub-deps, security, yield-setup
   ▼
Path operation function  ── seu handler roda
   ▼
Response model  ── valida + serializa para JSON
   ▼
Background tasks  ── rodam depois que a resposta é enviada
   ▼
Response ──▶ client
```

1. **Servidor ASGI** (uvicorn/hypercorn) aceita a conexão e passa um `scope` mais os callables `receive`/`send` para a aplicação.
2. **Middleware** roda de fora para dentro na ida e de dentro para fora na volta (`BaseHTTPMiddleware` ou middleware ASGI puro). CORS, GZip e medição de tempo customizada ficam aqui.
3. **Routing** casa o método HTTP + a rota com uma path operation; os parâmetros de path/query/body são extraídos e validados pelo **Pydantic**.
4. **Injeção de dependência** — `Depends(...)` resolve cada dependência (sessão do BD, usuário atual, configurações), fazendo cache dentro da requisição. Uma dependência com `yield` roda o setup antes e o teardown depois do handler.
5. **Path operation** — sua `async def` (ou `def`, executada em um threadpool) executa a lógica de negócio.
6. **Response** — o valor de retorno é convertido para o `response_model` declarado, validado e serializado para JSON; código de status e cabeçalhos são aplicados.
7. **Background tasks** registradas via `BackgroundTasks` rodam *depois* que a resposta é enviada.

```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. serializado via response_model
```

Exceções são capturadas por **exception handlers** (`@app.exception_handler(...)` / `HTTPException`), que as convertem em respostas em vez de derrubar a requisição.

## Por que isso importa

O ciclo de vida da requisição é onde os recursos de destaque do FastAPI realmente acontecem: I/O assíncrono, validação com Pydantic e injeção de dependência se conectam a etapas específicas. Conhecer a ordem — middleware, depois routing, depois dependências, depois handler, depois serialização — permite colocar a lógica transversal no lugar certo (auth como dependência, medição de tempo como middleware, limpeza em uma dependência com `yield`), depurar por que um erro de validação ou de autenticação dispara antes do seu código rodar e evitar bloquear o event loop dentro de um handler assíncrono.

As etapas

Por que isso importa

Perguntas relacionadas