Miten pyynnön elinkaari toimii FastAPIssa?

Question

IT Interview Practice · Accepted Answer

FastAPI toimii **ASGI**:n päällä, joten pyyntö kulkee asynkronisen pipelinen läpi: ASGI-palvelin ottaa sen vastaan, middleware kietoutuu sen ympärille, router täsmää polun, **dependencyt selvitetään**, path operation -funktiosi ajetaan, ja paluuarvo serialisoidaan responseksi.

## Vaiheet

```
uvicorn (ASGI-palvelin)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── täsmää method + path → path operation
   ▼
Dependencies (Depends)  ── selvitä sub-depit, security, yield-setup
   ▼
Path operation -funktio  ── handlerisi ajetaan
   ▼
Response-malli  ── validoi + serialisoi JSONiksi
   ▼
Background-taskit  ── ajetaan sen jälkeen kun response on lähetetty
   ▼
Response ──▶ client
```

1. **ASGI-palvelin** (uvicorn/hypercorn) ottaa yhteyden vastaan ja välittää sovellukselle `scope`n sekä `receive`/`send`-callablet.
2. **Middleware** ajetaan ulkoa-sisään sisääntulossa ja sisältä-ulos ulostulossa (`BaseHTTPMiddleware` tai puhdas ASGI-middleware). CORS, GZip ja custom-ajanotto sijaitsevat täällä.
3. **Routing** täsmää HTTP-methodin + polun path operationiin; path/query/body-parametrit poimitaan ja validoidaan **Pydanticilla**.
4. **Dependency injection** — `Depends(...)` selvittää jokaisen dependencyn (DB-session, nykyinen käyttäjä, asetukset) ja cachettaa sen pyynnön sisällä. `yield`iä käyttävä dependency ajaa setupin ennen handleria ja teardownin sen jälkeen.
5. **Path operation** — `async def`-funktiosi (tai `def`, joka ajetaan threadpoolissa) suorittaa liiketoimintalogiikan.
6. **Response** — paluuarvo muunnetaan ilmoitettuun `response_model`iin, validoidaan ja serialisoidaan JSONiksi; status code ja headerit asetetaan.
7. **Background-taskit**, jotka on rekisteröity `BackgroundTasks`in kautta, ajetaan *sen jälkeen* kun response on lähetetty.

```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. serialisoitu response_modelin kautta
```

Poikkeukset otetaan kiinni **exception handlereilla** (`@app.exception_handler(...)` / `HTTPException`), jotka muuntavat ne responseiksi sen sijaan että pyyntö kaatuisi.

## Miksi se on tärkeää

Pyynnön elinkaari on paikka, jossa FastAPIn pääominaisuudet oikeasti tapahtuvat: asynkroninen I/O, Pydantic-validointi ja dependency injection kytkeytyvät kaikki tiettyihin vaiheisiin. Kun tiedät järjestyksen — middleware, sitten routing, sitten dependencyt, sitten handler, sitten serialisointi — voit sijoittaa läpileikkaavan logiikan oikeaan paikkaan (auth dependencynä, ajanotto middlewarena, siivous `yield`-dependencyssä), debugata miksi validointi- tai auth-virhe laukeaa ennen kuin koodisi ajetaan, ja välttää event loopin blokkaamisen async-handlerin sisällä.

Vaiheet

Miksi se on tärkeää

Aiheeseen liittyvät kysymykset