FastAPI ఎందుకు వేగవంతమైనది మరియు దానిని ఎలా వేగవంతంగా ఉంచాలి?

Question

Accepted Answer

FastAPI అత్యంత వేగవంతమైన Python ఫ్రేమ్‌వర్క్‌లలో ఒకటి ఎందుకంటే ఇది **Starlette** (లైట్‌వెయిట్ ASGI ఫ్రేమ్‌వర్క్) పై నిర్మితమైనది మరియు **async-native**, అనేక సమకాలీన I/O-bound అభ్యర్థనలను సమర్థవంతంగా నిర్వహిస్తుంది. కానీ దానిని వేగవంతంగా ఉంచడానికి async సరిగ్గా ఉపయోగించాలి — అత్యంత సాధారణ తప్పు ఈవెంట్ లూప్‌ను బ్లాక్ చేయడం.

## ఇది వేగవంతమైనది ఎందుకు

```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
```

async మోడల్ కీలకం: ఒక అభ్యర్థన డేటాబేస్ ప్రశ్నకు లేదా API కాల్‌కు ఎదుర్కొంటున్నప్పుడు, సర్వర్ ఇతరులను నిర్వహిస్తుంది — I/O-bound వర్క్‌లోడ్‌ల కోసం అధిక థ్రూపుట్ ఇస్తుంది.

## ఇది వేగవంతంగా ఉంచడానికి #1 మార్గం: ఈవెంట్ లూప్‌ను బ్లాక్ చేయవద్దు

```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()
```

ఇది ఏకైక అత్యంత ముఖ్యమైన పనితీరు నియమం: `async def` లోపల బ్లాక్ చేసే కాల్ మొత్తం ఈవెంట్ లూప్‌ను బ్లాక్ చేస్తుంది, అభ్యర్థనలను ఒక్కసారి నడిపిస్తుంది. `await` తో async లైబ్రరీలను ఉపయోగించండి, లేదా సాదా `def` (థ్రెడ్ పూల్‌లో రన్ చేయండి).

## దానిని వేగవంతంగా ఉంచడం — చెక్‌లిస్ట్

```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
```

## ఎందుకు ముఖ్యమైనది

FastAPI యొక్క వేగం టీమ్‌లు దానిని ఎన్నుకోవడానికి ప్రధాన కారణం, కానీ ఆచరణలో ఆ వేగాన్ని సాధించడం **async సరిగ్గా ఉపయోగించడం**పై ఆధారపడి ఉంటుంది — మరియు అత్యంత ముఖ్యమైన, తరచుగా ఉల్లంఘించిన నియమం **ఈవెంట్ లూప్‌ను ఎప్పుడూ బ్లాక్ చేయవద్దు**.

FastAPI ఎందుకు వేగవంతమైనది చేతనను అర్థం చేసుకోవడం (async-native ASGI ఫাউండేషన్, సమర్థవంతమైన I/O సమకాలీనత, వేగవంతమైన Pydantic v2 కోర్) దాని పనితీరు లాభం I/O-bound వర్క్‌లోడ్‌లకు సమకాలీనంగా నిర్వహించిన వారికి వర్తిస్తుందని స్పష్టం చేస్తుంది.

దీనిని ఎలా ఉంచాలో తెలుసుకోవడం వేగవంతంగా ఉంటుంది నిర్ణయాత్మక ఆచరణ నైపుణ్యం: `async def`లో బ్లాక్ చేసే కాల్‌లను రోకడం (ఇది మొత్తం అభ్యర్థనలను గడిబిళ్లలో ఆఫ్రికన్ చేస్తుంది), async ఎండ్‌పాయింట్‌లలో async లైబ్రరీలను ఉపయోగించడం (లేదా బ్లాక్ చేసే కోడ్ కోసం సాదా `def`), CPU పనిని అవుట్‌లోడ్ చేయడం, క్యాచింగ్, డేటాబేస్ను ఆప్టిమైజ్ చేయడం (తరచుగా నిజమైన బాటిల్ నెక్), మరియు బహుళ కోర్‌ల కోసం బహుళ కార్మికులను నడుపుట.

ఈ కలయిక — async సరిగ్గా ఉపయోగించడం మరియు నిజమైన బాటిల్ నెక్‌లను కనుగొనడానికి కొలవడం — FastAPI యొక్క పనితీరు సామర్థ్యాన్ని సాకారం చేయడానికి మిమ్మల్ని అనుమతిస్తుంది, ఇది నిజమైన వేగవంతమైన, స్కేలేబుల్ API లను నిర్మించడానికి ముఖ్యమైన సీనియర్-స్థర కీలకాన్ని చేస్తుంది, కానీ బ్లాక్ చేసే కోడ్ వంటి పనితీరుపై విసిరిన async లను కాదు.