FastAPI इतना तेज़ क्यों है, और आप इसे इसी तरह कैसे रखते हैं?

Question

Accepted Answer

FastAPI सबसे तेज़ Python frameworks में से एक है क्योंकि यह **Starlette** (एक lightweight ASGI framework) पर बनाया गया है और **async-native** है, कई concurrent I/O-bound requests को कुशलतापूर्वक संभालता है। लेकिन इसे तेज़ रखने के लिए async का सही उपयोग करना आवश्यक है — सबसे आम गलती event loop को block करना है।

## यह तेज़ क्यों है

```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 मॉडल मुख्य है: जबकि एक request database query या API call की प्रतीक्षा करता है, server दूसरे को संभालता है — I/O-bound workloads के लिए high throughput देता है।

## इसे तेज़ रखने का #1 तरीका: event loop को block न करें

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

यह सबसे महत्वपूर्ण performance नियम है: `async def` के अंदर एक blocking call पूरे event loop को block कर देता है, requests को एक-एक करके चलने के लिए मजबूर करता है। `await` के साथ async libraries का उपयोग करें, या सादा `def` (thread pool में चलाएं)।

## इसे तेज़ रखना — checklist

```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 को सही तरीके से उपयोग करने** पर निर्भर करता है — और सबसे महत्वपूर्ण, अक्सर उल्लंघन किया जाने वाला नियम है **कभी भी event loop को block न करें**।

यह समझना कि *क्यों* FastAPI तेज़ है (async-native ASGI foundation, efficient I/O concurrency, fast Pydantic v2 core) स्पष्ट करता है कि इसका performance लाभ simultaneously संभाले जाने वाले I/O-bound workloads पर लागू होता है।

जानना कि इसे *कैसे* तेज़ रखें यह महत्वपूर्ण व्यावहारिक कौशल है: `async def` में blocking calls रखने की विनाशकारी गलती से बचना (जो सभी requests को frozen event loop के पीछे serialize करता है), async endpoints में async libraries का उपयोग करना (या blocking code के लिए सादा `def`), CPU work को offload करना, caching, database को optimize करना (अक्सर वास्तविक bottleneck), और multiple cores के लिए multiple workers चलाना।

यह combination — async को सही तरीके से leverage करना और वास्तविक bottlenecks को खोजने के लिए मापना — ही वह है जो आपको FastAPI की performance potential को realize करने देता है, जिससे यह genuine fast, scalable APIs बनाने के लिए critical senior-level knowledge बन जाता है न कि उन लोगों के बजाय जो async दिखते हैं लेकिन blocking code की तरह perform करते हैं।