FastAPI'de request lifecycle nasıl çalışır?

Question

IT Interview Practice · Accepted Answer

FastAPI **ASGI** üzerinde çalışır, bu yüzden bir request asenkron bir pipeline'dan geçer: ASGI sunucusu onu kabul eder, middleware onu sarar, router bir path eşleştirir, **dependencies çözülür**, path operation'ınız çalışır ve dönen değer response'a serialize edilir.

## Aşamalar

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── method + path eşleştir → path operation
   ▼
Dependencies (Depends)  ── sub-deps, security, yield-setup çöz
   ▼
Path operation function  ── handler'ınız çalışır
   ▼
Response model  ── validate + JSON'a serialize et
   ▼
Background tasks  ── response gönderildikten sonra çalışır
   ▼
Response ──▶ client
```

1. **ASGI sunucusu** (uvicorn/hypercorn) bağlantıyı kabul eder ve uygulamaya bir `scope` ile `receive`/`send` callable'larını iletir.
2. **Middleware** girişte dıştan-içe, çıkışta içten-dışa çalışır (`BaseHTTPMiddleware` veya saf ASGI middleware). CORS, GZip ve özel zaman ölçümü burada yer alır.
3. **Routing** HTTP method + path'i bir path operation ile eşleştirir; path/query/body parametreleri **Pydantic** tarafından çıkarılır ve validate edilir.
4. **Dependency injection** — `Depends(...)` her dependency'yi (DB session, mevcut kullanıcı, settings) çözer ve request içinde cache'ler. `yield` içeren bir dependency, handler'dan önce setup ve sonra teardown çalıştırır.
5. **Path operation** — `async def`'iniz (veya threadpool'da çalışan `def`) iş mantığını yürütür.
6. **Response** — dönen değer bildirilen `response_model`'e dönüştürülür, validate edilir ve JSON'a serialize edilir; status code ve headers uygulanır.
7. **Background tasks** `BackgroundTasks` aracılığıyla kaydedilenler, response gönderildikten *sonra* çalışır.

```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 üzerinden serialize edilir
```

İstisnalar (exceptions) **exception handler**'lar (`@app.exception_handler(...)` / `HTTPException`) tarafından yakalanır ve request'i çökertmek yerine onları response'lara dönüştürür.

## Neden önemli

Request lifecycle, FastAPI'nin öne çıkan özelliklerinin gerçekten gerçekleştiği yerdir: async I/O, Pydantic validation ve dependency injection hepsi belirli aşamalara bağlanır. Sırayı bilmek — middleware, sonra routing, sonra dependencies, sonra handler, sonra serialization — kesişen mantığı doğru yere koymanızı sağlar (auth bir dependency olarak, zaman ölçümü middleware olarak, temizlik bir `yield` dependency'de), bir validation veya auth hatasının kodunuz çalışmadan önce neden tetiklendiğini debug etmenizi ve bir async handler içinde event loop'u bloke etmekten kaçınmanızı sağlar.

Aşamalar

Neden önemli

İlgili sorular