Cén fáth a bhíonn FastAPI tapa, agus conas a choinníonn tú go tapa é?

Question

Accepted Answer

Tá FastAPI i measc na frameworks Python is tapa toisc go bhfuil sé tógtha ar **Starlette** (framework ASGI éadrom) agus tá sé **async-native**, ag láimhseáil go héifeachtach go leor iarratas I/O-bound comhthréimhseacha. Ach a choinneáil tapa a bhíonn sé gá a úsáid async i gceart — is é an earráid is coitianta ná bac a chur ar an lúp imeachta.

## Cén fáth a bhíonn sé tapa

```text
✓ ASGI + Starlette — a modern async foundation (vs older WSGI sync frameworks)
✓ Async-native — one process handles thousands of concurrent I/O-bound requests
  by overlapping wait times, instead of one-at-a-time
✓ Pydantic v2 — validation/serialization core is now in Rust (very fast)
✓ Minimal overhead per request
```

Is é an tsamhail async an eochair: agus a bhíonn iarratas amháin ag feitheamh ar iarratas bunachar sonraí nó glaoch API, láimhseálann an freastalaí a chéile — ag tabhairt aeir ard do ghníomhaireachtaí I/O-bound.

## An #1 bealach a choinneáil tapa: ná cuir bac ar an lúp imeachta

```python
# ❌ blocking call inside async def → freezes the event loop, serializing ALL requests
@app.get("/bad")
async def bad():
    return requests.get(url).json()       # SYNC/blocking → kills concurrency

# ✅ use an async client and await it
@app.get("/good")
async def good():
    async with httpx.AsyncClient() as c:
        return (await c.get(url)).json()  # non-blocking

# ✅ OR use a plain def — FastAPI runs it in a thread pool (safe for blocking code)
@app.get("/also-good")
def also_good():
    return requests.get(url).json()
```

Is é seo an riail fheidhmíochta is tábhachtaí: cuireann glaoch bacach taobh istigh de `async def` bac ar an lúp imeachta iomlán, á fhórsa iarratas a rith ar a chéile. Úsáid leabharlanna async le `await`, nó `def` simplí (rith i bpoll snáithe).

## Coinneáil go tapa — an seiceáil

```text
✓ Use async DB drivers / async libraries (httpx, asyncpg) in async endpoints
✓ Run blocking code in plain def (thread pool) or via run_in_executor
✓ Avoid heavy CPU work on the event loop → offload to workers/processes
✓ Add caching (Redis) for expensive repeated work
✓ Optimize the database (fix N+1, add indexes) — often the real bottleneck
✓ Run multiple worker processes (uvicorn/gunicorn workers) to use all CPU cores
✓ Use connection pooling; paginate large results
✓ MEASURE first (profiling, load testing) — fix the actual bottleneck
```

## Cén fáth a bhíonn sé tábhachtach

Is é luas FastAPI príomhchúis a bhíonn ag foirne é a roghnú, ach a bhaint amach sa ghréine a bhraitheann ar **async a úsáid i gceart** — agus is é an riail is tábhachtaí agus is minice a bhíonn á bhriseadh ná **ná cuir bac ar an lúp imeachta riamh**.

A thuiscint *cén fáth* a bhíonn FastAPI tapa (bonn ASGI async-native, comhthaobhú I/O éifeachtach, croí Pydantic v2 tapa) soiléiríonn go bhfuil a bhéim fheidhmíochta i bhfeidhm ar ghníomhaireachtaí I/O-bound a bhíonn á láimhseáil go comhthréimhseach.

A bhheith ar eolas conas a *choinneáil* go tapa is é an scil phraiticiúil ríthábhachtach: an earráid dhéistinach a sheachaint de ghlaoch blocach a chur i `async def` (a dhéanann gach iarratas a shéaladh taobh thiar de lúp imeachta fhriota), leabharlanna async a úsáid i pointí deiridh async (nó `def` simplí do chód blocach), obair CPU a bhogadh amach, taisce, an bunachar sonraí a bharrfheidhmiú (an fhíor bhac is minice), agus oibrithe iolracha a rith do chroí iolracha.

Is é an combination seo — async a bheith intuigthe i gceart agus a thomhas chun fíor bhacanna a aimsiú — an rud a ligint duit poitéinseal feidhmíochta FastAPI a bhaint amach, ag déanamh gur eolas tábhachtach ar leibhéal sinsear atá ann chun APIs fíor thapa, inchreidthe a thógáil seachas iad siúd atá cosúil le async ach a fheidhmíonn ar nós cód blocach.