FastAPI किन कारणबाट छिटो छ, र तपाइँ यसलाई त्यस अवस्थामा कसरी राख्नुहुन्छ?

Question

Accepted Answer

FastAPI सबैभन्दा छिटो Python frameworks मध्ये एक हो किनभने यो **Starlette** (एक हल्का ASGI framework) मा निर्मित छ र **async-native** छ, धेरै समवर्ती I/O-bound requests लाई कुशलतापूर्वक सम्भाल्छ। तर यसलाई छिटो राख्नको लागि async लाई सही तरिकाले प्रयोग गर्नुपर्छ — सबैभन्दा सामान्य गल्ती event loop लाई ब्लक गर्नु हो।

## किन यो छिटो छ

```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 को प्रतीक्षा गरिरहेको हुन्छ, सर्भर अन्यलाई सम्भाल्छ — I/O-bound कार्यभारको लागि उच्च throughput दिन्छ।

## यसलाई छिटो राख्नको #1 तरिका: event loop लाई ब्लक नगर्नुहोस्

```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` भित्र एक ब्लकिङ कल सम्पूर्ण event loop लाई ब्लक गर्छ, requests लाई एक पछि एक चलाउन बाध्य गर्छ। `await` संग async libraries प्रयोग गर्नुहोस्, वा plain `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 को गति teams को एक प्राथमिक कारण हो यसलाई छनौट गर्नको लागि, तर अभ्यासमा त्यो गति प्राप्त गर्नु **async लाई सही तरिकाले प्रयोग गर्न** मा निर्भर गर्छ — र सबैभन्दा महत्त्वपूर्ण, बारम्बार-उल्लंघन नियम हो **कहिले पनि event loop लाई ब्लक नगर्नु**।

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

यसलाई छिटो कसरी राख्ने भनेर जान्न critically महत्त्वपूर्ण व्यावहारिक कौशल हो: `async def` मा ब्लकिङ calls राख्नको विनाशकारी गल्ति वर्जन गर्न (जसले सबै requests लाई एक फ्रोजन event loop को पछाडि क्रमबद्ध गर्छ), async endpoints मा async libraries प्रयोग गर्न (`async def` को लागि blocking code को plain `def` वा), CPU काम अलग गर्न, caching गर्न, database को अनुकूलन गर्न (अक्सर वास्तविक병, र multiple cores को लागि multiple workers चलाउन।

यो combination — async लाई सही तरिकाले leverage गर्न र real bottlenecks खोज्न को लागि measure गर्न — FastAPI को performance potential लाई realize गर्न दिन्छ, यो महत्त्वपूर्ण senior-level ज्ञान बनाउँछ genuinely छिटो, scalable APIs निर्माण गरनको लागि बरु ones जो async देखिन्छ तर blocking code जस्तो काम गरिरहेको छ।