FastAPI કેમ ઝડપી છે, અને તમે તેને કેવી રીતે આમ રાખો છો?

Question

Accepted Answer

FastAPI સૌથી ઝડપી Python frameworks માંથી એક છે કારણ કે તે **Starlette** (હલકી ASGI framework) પર બનાવવામાં આવી છે અને **async-native** છે, ઘણા સમવર્તી I/O-bound requests ને અસરકારક રીતે હેન્ડલ કરે છે. પરંતુ તેને ઝડપી રાખવા માટે 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 મોડલ આ કીચ છે: જ્યારે એક request ડેટાબેસ ક્વેરી અથવા API કૉલની રાહ જોતી હોય, ત્યારે સર્વર અન્યને હેન્ડલ કરે છે — I/O-bound workloads માટે ઉચ્ચ થ્રુપુટ આપે છે.

## ઝડપી રાખવાનો #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` અંદર બ્લોકિંગ કૉલ આખા ઇવેન્ટ લૂપને બ્લોક કરે છે, requests ને એક સમયે ચલાવવા માટે બાધ્ય કરે છે. `await` સાથે async libraries વાપરો, અથવા સાદો `def` (thread pool માં ચલાવો).

## ઝડપી રાખવું — ચેકલિસ્ટ

```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 core) સ્પષ્ટ કરે છે કે તની પ્રફોર્મેન્સ લાભ સમવર્તી રીતે હેન્ડલ કરવામાં આવતા I/O-bound workloads માટે લાગુ થાય છે.

જાણવું કે તેને *ઝડપી* કેવી રીતે રાખવું તે નિર્ણાયક વ્યવહારિક કૌશલ્ય છે: `async def` માં બ્લોકિંગ કૉલ્સ મૂકવાની વિનાશક ભૂલથી બચવું (જે બધા requests ને ફ્રોજન ઇવેન્ટ લૂપ પછીથી સીરિયલાઇજ કરે છે), async endpoints માં async libraries વાપરવું (અથવા બ્લોકિંગ કોડ માટે સાદો `def`), CPU કાર્યને હટાવવું, કેશિંગ, ડેટાબેસને ઑપ્ટિમાઇઝ કરવું (ઘણી વાર વાસ્તવિક બોટલનેક), અને બહુવિધ cores માટે બહુવિધ workers ચલાવવું.

યہ સંયોજન — async ને યોગ્ય રીતે લાભ લેવું અને વાસ્તવિક બોટલનેક્સ શોધવા માટે માપવું — તે જ છે જે તમને FastAPI ની પ્રફોર્મેન્સ સંભાવનાને સાકાર કરવા દે છે, તેને ખરેખર ઝડપી, સ્કેલેબલ APIs બનાવવા માટે સીનિયર-લેવલ જ્ઞાન બનાવે છે બલ્કે બ્લોકિંગ કોડ જેવા દેખાય એવા APIs ને બદલે.