FastAPI एक आधुनिक Python फ्रेमवर्क है जो टाइप हिंट्स, वैलिडेशन और स्वचालित OpenAPI डॉक्यूमेंटेशन के साथ तेज़ी से APIs बनाने के लिए बनाया गया है। इस गाइड में बुनियादी बातें और उपयोग के मामले बताये गए हैं।
FastAPI एक Python फ्रेमवर्क है जो वेब API तेज़ी से बनाने में मदद करता है, कोड को स्पष्ट रखता है और ऑटोमेटिक दस्तावेज़ बनाता है। आप छोटे फ़ंक्शन लिखते हैं (जिन्हें “एंडपॉइंट” कहते हैं) जो यह घोषित करते हैं कि आपका API किस डेटा को स्वीकार करता है और क्या लौटाता है, और FastAPI वेब के कस्से—रूटिंग, वैलिडेशन, और JSON प्रतिक्रियाएँ—को संभालता है।
API URLs का एक सेट है जो एक सॉफ़्टवेयर को दूसरे से बात करने देता है।
उदाहरण के लिए, आपके फ़ोन का मौसम ऐप GET /weather?city=Berlin जैसा URL कॉल कर सकता है। सर्वर संरचित डेटा (आम तौर पर JSON) के साथ जवाब देता है, जैसे तापमान और भविष्यवाणी। फोन ऐप को सर्वर के डेटाबेस तक सीधे पहुंच की आवश्यकता नहीं होती—यह बस API से पूछता है और परिणाम दिखाता है।
FastAPI आपको ऐसे URLs और प्रतिक्रियाएँ Python में बनाने में मदद करता है।
आपको async विशेषज्ञ होने की ज़रूरत नहीं—सरल एंडपॉइंट लिखकर शुरू करें और ज़रूरत के साथ उन्नत पैटर्न अपनाएं।
FastAPI जल्दी लोकप्रिय हुआ क्योंकि यह उन रोज़मर्रा की परेशानियों को दूर करता है जो Python में API बनाते समय आती हैं।
पारंपरिक API प्रोजेक्ट अक्सर धीमी शुरुआत और बहुत सारा “प्लंबिंग” के साथ शुरू होते हैं:
FastAPI की कोर सुविधाएँ इन समस्याओं को सीधे लक्षित करती हैं, जिससे टीमें एंडपॉइंट डिज़ाइन करने में ज़्यादा समय बिताती हैं और फ्रेमवर्क के बुनियादी कामों से कम जूझती हैं।
FastAPI बहुत हद तक Python टाइप हिंट्स पर निर्भर करता है। जब आप घोषित करते हैं कि कोई फ़ील्ड int है, वैकल्पिक है, या किसी चीज़ की सूची है, तो FastAPI उस जानकारी का उपयोग इनपुट्स को वैलिडेट करने और आउटपुट के स्वरूप को तय करने के लिए करता है।
यह “stringly-typed” गलतियों को कम करता है (जैसे किसी जगह ID को टेक्स्ट और दूसरी जगह नंबर मान लेना) और फ़ंक्शन सिग्नेचर्स में स्पष्ट उम्मीदें डालता है।
क्योंकि API स्कीमा कोड से निकला है, FastAPI इंटरैक्टिव डॉक्यूमेंटेशन स्वतः जेनरेट कर सकता है (OpenAPI + Swagger UI/ReDoc)। यह सहयोग के लिए महत्वपूर्ण है: फ्रंटएंड डेवलपर्स, QA और इंटीग्रेटर्स बिना अलग डॉक्यूमेंट के एंडपॉइंट एक्सप्लोर कर सकते हैं, रिक्वेस्ट ट्राय कर सकते हैं और मॉडल सीधे देख सकते हैं।
FastAPI एक खराब डिज़ाइन की गई API को ठीक नहीं कर देगा। आपको अभी भी अच्छे नामकरण, वर्ज़निंग, एरर हैंडलिंग, और सुरक्षा निर्णय लेने होंगे। जो यह देता है वह है “idea” से “well-defined API” तक का साफ़ रास्ता, कम अप्रत्याशितताओं के साथ।
FastAPI कुछ कोर आइडियाज़ पर आधारित है। आपको इंटर्नल्स याद रखने की ज़रूरत नहीं—बस उन हिस्सों को पहचानें जिन्हें आप रोज़ाना उपयोग करेंगे।
एक फ्रेमवर्क उपकरणों और कन्वेंशंस का सेट है जो एक API बिना ज़ीरो से शुरुआत किए बनाना आसान बनाता है। FastAPI कॉमन API टास्क के लिए “प्लंबिंग” प्रदान करता है: एंडपॉइंट्स परिभाषित करना, इनपुट पढ़ना, आउटपुट लौटाना, एरर संभालना, और कोड को मेंटेन करने योग्य संरचना में व्यवस्थित करना।
रूटिंग वह तरीका है जिससे आप URL और HTTP मेथड को Python कोड के एक भाग से जोड़ते हैं।
उदाहरण के लिए, आप GET /users को “list users” से और POST /users को “create a user” से जोड़ सकते हैं। FastAPI में आप अक्सर @app.get(...) और @app.post(...) जैसे डेकोरेटर्स से रूट्स परिभाषित करते हैं, जिससे यह देखना आसान हो जाता है कि आपका API क्या प्रदान करता है।
हर API कॉल एक रिक्वेस्ट (क्लाइंट क्या भेजता है) और एक रिस्पॉन्स (सर्वर क्या लौटाता है) होती है।
FastAPI आपकी मदद करता है:
/users/{id}), क्वेरी स्ट्रिंग (?page=2), हेडर्स और रिक्वेस्ट बॉडी से डेटा पढने में200, 201, 404) के साथ संरचित JSON रिस्पॉन्स लौटाने मेंFastAPI ASGI पर चलता है, जो Python वेब सर्वरों के लिए एक आधुनिक मानक है। प्रैक्टिकली इसका मतलब है कि FastAPI कई कनेक्शनों को कुशलता से हैंडल करने के लिए डिज़ाइन किया गया है, और यह लॉन्ग-लिव्ड कनेक्शनों (उदाहरण के लिए, WebSockets) का समर्थन कर सकता है—बिना लो-लेवल नेटवर्किंग को संभाले।
Python टाइप हिंट्स (जैसे str, int, list[Item]) FastAPI में सिर्फ डॉक्यूमेंटेशन नहीं हैं—वे इनपुट हैं। FastAPI इन्हें समझकर इनकमिंग वैल्यूज़ को सही टाइप में कन्वर्ट और वैलिडेट करता है, और अधिक स्पष्ट व पूर्वानुमानित APIs बनाता है।
Pydantic मॉडल आपको डेटा का रूप (फ़ील्ड, टाइप, वैकल्पिक मान) एक जगह पर परिभाषित करने देते हैं। FastAPI इन मॉडलों का उपयोग करके इनकमिंग JSON को वैलिडेट करता है, गलत इनपुट को उपयोगी एरर मैसेज के साथ रिजेक्ट करता है, और आउटपुट को सुसंगत रूप से सीरियलाइज़ करता है—ताकि क्लाइंट्स के पास भरोसेमंद व्यवहार हो।
FastAPI ऐप्स एंडपॉइंट्स के चारों ओर बनाए जाते हैं: एक URL पाथ प्लस HTTP मेथड। एक एंडपॉइंट को "क्लाइंट क्या माँग रहा है" और "कैसे माँग रहा है" के रूप में सोचें। उदाहरण: क्लाइंट GET /users करके यूज़र्स की सूची माँग सकता है, या POST /users करके नया यूज़र बना सकता है।
एक पाथ रूट है, और मेथड एक्शन है:
GET /products → डेटा फ़ेच करेंPOST /products → कुछ बनाने के लिए डेटा भेजेंPUT /products/123 → कुछ बदलें/अपडेट करेंDELETE /products/123 → कुछ हटाएँFastAPI पाथ का हिस्सा होने वाले डेटा को और वैकल्पिक "फ़िल्टर" वाले डेटा को अलग रखता है।
GET /users/42 → 42 यूज़र ID है।? के बाद जोड़े जाते हैं और आमतौर पर वैकल्पिक होते हैं।
GET /users?limit=10&active=true → limit और active परिणामों को नियंत्रित करते हैं।जब क्लाइंट संरचित डेटा भेजता है (आम तौर पर JSON), तो वह रिक्वेस्ट बॉडी में होता है, ज़्यादातर POST या PUT के साथ।
उदाहरण: POST /orders JSON के साथ { "item_id": 3, "quantity": 2 }।
FastAPI साधारण Python ऑब्जेक्ट्स (जैसे dicts) लौट सकता है, लेकिन यह तब चमकता है जब आप response model परिभाषित करते हैं। वह मॉडल एक कॉन्ट्रैक्ट की तरह काम करता है: फ़ील्ड्स सुसंगत रहते हैं, अतिरिक्त डेटा फ़िल्टर किया जा सकता है, और टाइप्स लागू होते हैं। नतीजा साफ़ API होता है—क्लाइंट्स जानते हैं क्या उम्मीद करनी है और आप अप्रत्याशित रिस्पॉन्स से बचते हैं।
“Async” या asynchronous एक तरीका है जिससे आपका API कई रिक्वेस्ट्स को कुशलता से हैंडल कर सकता है जब ज़्यादातर समय वेटिंग में जाता है।
किसी बारिस्ता की कल्पना करें जो ऑर्डर ले रहा है। अगर उसे तब तक खड़ा रहना पड़े जब तक एस्प्रेसो मशीन काम कर रही है, तो वह कम ग्राहकों की सेवा कर पाएगा। बेहतर तरीका है: कॉफ़ी शुरू करें, फिर अगला ऑर्डर लें जबकि मशीन काम कर रही है।
Async ऐसा ही काम करता है। आपका FastAPI एप किसी लंबी ऑपरेशन को शुरू करके—जैसे नेटवर्क रिक्वेस्ट या डेटाबेस क्वेरी—वहीँ इंतज़ार करने के बजाय अन्य इनकमिंग रिक्वेस्ट्स को हैंडल कर सकता है।
Async तब सबसे बेहतर होता है जब आपका API बहुत सारी I/O वर्क करता है—ऐसी चीज़ें जो इंतज़ार में समय बिताती हैं बजाय कंप्यूटेशन के। सामान्य उदाहरण:
यदि आपके एंडपॉइंट्स अक्सर इन ऑपरेशंस का इंतज़ार करते हैं, तो async थ्रूपुट बढ़ा सकता है और लोड के तहत रिक्वेस्ट्स के पाइल-अप होने की संभावना घटा सकता है।
Async हर चीज के लिए जादुई तेज़ी बटन नहीं है। यदि आपका एंडपॉइंट मुख्यतः CPU-भारी है—जैसे बड़ी छवियों का रीसाइज़िंग, भारी डेटा साइंस कैलकुलेशन, या बड़े पेलोड का एन्क्रिप्शन—तो async स्वयं कंप्यूटेशन को तेज़ नहीं करेगा। ऐसे मामलों में बैकग्राउंड वर्कर्स, प्रोसेस पूल, या स्केल आउट जैसी रणनीतियाँ चाहिए।
आपको सब कुछ दोबारा लिखने की ज़रूरत नहीं। आप सामान्य (sync) रूट फ़ंक्शन लिख सकते हैं और FastAPI उन्हें ठीक चला देगा। कई प्रोजेक्ट्स दोनों शैली मिलाकर चलते हैं: सरल एंडपॉइंट्स सिंक में रखें और async def उन जगहों पर उपयोग करें जहाँ यह स्पष्ट रूप से मदद करता है (आमतौर पर डेटाबेस कॉल या बाहरी HTTP रिक्वेस्ट के चारों ओर)।
वैलिडेशन बाहरी दुनिया और आपके कोड के बीच एक चेकपॉइंट है। जब API इनपुट स्वीकार करता है (JSON बॉडी, क्वेरी/पाथ पैरामीटर), आप यह सुनिश्चित करना चाहेंगे कि डेटा पूरा, सही टाइप का और सीमाओं में हो—उसके बाद ही आप DB लिखें, किसी और सर्विस को कॉल करें, या बिज़नेस लॉजिक ट्रिगर करें।
FastAPI Pydantic मॉडलों पर निर्भर करता है। आप एक बार परिभाषित करते हैं कि “अच्छा डेटा” कैसा दिखता है, और FastAPI स्वतः:
यदि कोई क्लाइंट गलत आकार का डेटा भेजता है, FastAPI 422 Unprocessable Entity और एक संरचित एरर पेलोड लौटाता है जो सही फ़ील्ड और कारण बताता है। इससे क्लाइंट डेवलपर्स जल्दी गलतियाँ ठीक कर सकते हैं।
यहाँ एक छोटा मॉडल है जो आवश्यक फ़ील्ड, टाइप्स, min/max constraints और फॉर्मैट दिखाता है:
from pydantic import BaseModel, EmailStr, Field
class UserCreate(BaseModel):
email: EmailStr
age: int = Field(ge=13, le=120)
username: str = Field(min_length=3, max_length=20)
email होना चाहिए।age integer होना चाहिए।age 13–120 के बीच सीमित है।EmailStr वैध ईमेल स्वरूप लागू करता है।इसी मॉडलों का उपयोग आउटपुट को आकार देने के लिए भी किया जा सकता है, जिससे आपके API रिस्पॉन्स आकस्मिक रूप से आंतरिक फ़ील्ड लीक ना कर दें। आप Python ऑब्जेक्ट लौटाते हैं; FastAPI (Pydantic के माध्यम से) उन्हें सही फ़ील्ड नामों और टाइप्स के साथ JSON में बदल देता है।
FastAPI की एक बेहद प्रैक्टिकल विशेषता यह है कि यह आपके लिखे कोड के आधार पर API डॉक्यूमेंटेशन स्वतः जेनरेट कर देता है।
OpenAPI एक मानक है जो API को संरचित फ़ॉर्मेट (आमतौर पर JSON) में वर्णित करता है। इसे आप एक “कॉन्ट्रैक्ट” समझें जो बताता है:
GET /users/{id})क्योंकि यह मशीन-पठनीय है, टूल्स इसका उपयोग क्लाइंट जेनरेट करने, रिक्वेस्ट वैलिडेट करने और टीमों को सिंक में रखने के लिए कर सकती हैं।
FastAPI दो मानव-मैत्री डॉक पेज अपने आप सर्व करता है:
सामान्यतः ये पाते हैं:
/docs (Swagger UI)/redoc (ReDoc)जब आप पाथ पैरामीटर, रिक्वेस्ट/रिस्पॉन्स मॉडल या वैलिडेशन नियम बदलते हैं, OpenAPI स्कीमा (और डॉक्स पेज) स्वतः अपडेट हो जाते हैं। अलग से “डॉक्स मेंटेनेंस” की ज़रूरत नहीं।
एक FastAPI ऐप छोटा भी हो सकता है और फिर भी "रियल" महसूस कर सकता है। आप एक Python ऑब्जेक्ट app परिभाषित करते हैं, कुछ रूट जोड़ते हैं और लोकल सर्वर चलाकर ब्राउज़र में आज़मा सकते हैं।
सबसे छोटा उपयोगी उदाहरण:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Hello, FastAPI"}
बस: एक रूट (GET /) जो JSON लौटाता है।
इसे API जैसा महसूस कराने के लिए, आइटम्स को एक लिस्ट में स्टोर करें। यह डेटाबेस नहीं है—डेटा सर्वर रिस्टार्ट पर रीसेट होगा—पर सीखने के लिए परफेक्ट है।
from fastapi import FastAPI
app = FastAPI()
items = []
@app.post("/items")
def create_item(name: str):
item = {"id": len(items) + 1, "name": name}
items.append(item)
return item
@app.get("/items")
def list_items():
return items
अब आप कर सकते हैं:
POST /items?name=Coffee के साथ एक आइटम जोड़ेंGET /items से लिस्ट प्राप्त करेंआम स्टार्टर स्ट्रक्चर:
main.py (जहाँ app और रूट हैं)requirements.txt या pyproject.toml (डिपेंडेंसीज़)आम तौर पर आप:
uvicorn main:app --reload)http://127.0.0.1:8000 खोलकर एंडपॉइंट्स आज़माएँFastAPI "डिपेंडेंसीज़" वे साझा इनपुट हैं जिनकी आपकी एंडपॉइंट्स को ज़रूरत होती है—जैसे डेटाबेस सेशन, करंट लॉग्ड-इन यूज़र, ऐप सेटिंग्स, या सामान्य क्वेरी पैरामीटर। हर रूट में इन्हें मैन्युअली बनाम पार्स करने के बजाय, आप उन्हें एक बार परिभाषित करते हैं और FastAPI ज़रूरत होने पर प्रदान करता है।
एक डिपेंडेंसी आम तौर पर एक फ़ंक्शन (या क्लास) है जो एक वैल्यू लौटाती है जिसे आपका एंडपॉइंट उपयोग कर सकता है। FastAPI उसे कॉल करेगा, उसके पैरामीटर्स के आधार पर पता लगाएगा कि उसे क्या चाहिए, और परिणाम आपके पाथ ऑपरेशन फ़ंक्शन में इंजेक्ट कर देगा।
इसे डिपेंडेंसी इंजेक्शन कहा जाता है, पर आप इसे ऐसे समझ सकते हैं: "जो चाहिए उसे घोषणा करें, और FastAPI उसे जोड़ देगा।"
बिना डिपेंडेंसीज़ के आप:
डिपेंडेंसीज़ के साथ, आप लॉजिक को केंद्रीकृत करते हैं। बाद में अगर आप DB सेशन बनाने या करंट यूज़र लोड करने का तरीका बदलते हैं, तो आप एक ही जगह अपडेट करते हैं—ना कि दर्जनों एंडपॉइंट्स में।
page/limit पार्सिंग और वैलिडेशन पुन:उपयोग करें।सिद्धांतगत पैटर्न:
from fastapi import Depends, FastAPI
app = FastAPI()
def get_settings():
return {"items_per_page": 20}
@app.get("/items")
def list_items(settings=Depends(get_settings)):
return {"limit": settings["items_per_page"]}
आप Depends(...) के साथ डिपेंडेंसी घोषित करते हैं, और FastAPI उसका परिणाम आपके एंडपॉइंट पर पास कर देता है। यही तरीका और जटिल बिल्डिंग ब्लॉक्स (जैसे get_db() या get_current_user()) के लिए भी काम करता है, जिससे आपका कोड बड़ा होने पर भी साफ़ रहता है।
FastAPI आपकी API को "ऑटो-सेक्योर" नहीं करता—आप स्कीम चुनते हैं और उसे एंडपॉइंट्स में जोड़ते हैं। अच्छी बात यह है कि FastAPI डिपेंडेंसी सिस्टम के माध्यम से सामान्य सुरक्षा पैटर्न लागू करना सीधा बनाता है।
Authentication उत्तर देता है: "आप कौन हैं?" Authorization उत्तर देता है: "आप क्या करने की अनुमति रखते हैं?"
उदाहरण: एक यूज़र प्रमाणीकृत हो सकता है (वैध लॉगिन/टोकन) पर फिर भी किसी एडमिन-ओनली रूट तक पहुँचने के लिए अधिकृत नहीं हो सकता।
X-API-Key) के जरिए भेजी जाती हैं। रोटेशन और रिवोकेशन का प्रबंधन करें।FastAPI fastapi.security जैसे यूटिलिटीज़ के माध्यम से इन पैटर्न्स का समर्थन करता है और OpenAPI में साफ़ डॉक्यूमेंटेशन देता है।
यदि आप यूज़र पासवर्ड स्टोर करते हैं, तो कभी भी प्लेनटेक्स्ट में न रखें। एक सॉल्टेड, स्लो हैश (उदा., bcrypt/argon2) का उपयोग करें। रेट लिमिटिंग और अकाउंट लॉकआउट पॉलिसीज़ पर भी विचार करें।
सुरक्षा विवरणों की बात है: टोकन स्टोरेज, CORS सेटिंग्स, HTTPS, सीक्रेट प्रबंधन, और हर संवेदनशील एंडपॉइंट पर सही ऑथोराइज़ेशन चेक। बिल्ट-इन हेल्पर्स एक शुरुआत हैं—उन्हें प्रोडक्शन में भरोसा करने से पहले रिव्यू और टेस्ट करें।
टेस्टिंग वह जगह है जहाँ FastAPI का "यह मेरे मशीन पर काम करता है" वादा आपको विश्वास में बदलता है। अच्छी बात: FastAPI Starlette पर बना है, इसलिए आपको मजबूत टेस्टिंग टूल्स बिना ज़्यादा सेटअप के मिलते हैं।
Unit tests छोटे हिस्सों पर केंद्रित होते हैं: कोई फ़ंक्शन जो एक वैल्यू कैलकुलेट करता है, कोई डिपेंडेंसी जो करंट यूज़र लोड करता है, या कोई सर्विस मेथड जो डेटाबेस को कॉल करता है (अक्सर मॉक्ड)।
Integration tests API एंड-टू-एंड परिक्षण करते हैं: आप एक एंडपॉइंट को कॉल करते हैं और पूरे HTTP रिस्पॉन्स पर असर्शन करते हैं। ये टेस्ट रूटिंग, डिपेंडेंसी वायरिंग और वैलिडेशन समस्याओं को पकड़ते हैं।
एक स्वस्थ टेस्ट सूई आम तौर पर ज़्यादा यूनिट टेस्ट (तेज़) और कम इंटीग्रेशन टेस्ट (उच्च विश्वास) रखती है।
FastAPI ऐप्स को Starlette के TestClient के साथ "क्लाइंट की तरह" टेस्ट किया जा सकता है—इन-प्रोसेस रिक्वेस्ट्स भेजकर, सर्वर की ज़रूरत नहीं।
from fastapi.testclient import TestClient
from app.main import app
client = TestClient(app)
def test_healthcheck():
r = client.get("/health")
assert r.status_code == 200
पूर्वानुमेय डेटा का उपयोग करें, बाहरी सर्विसेज़ को आइसोलेट करें (मॉक या टेस्ट DB), और टेस्ट्स के बीच साझा स्टेट से बचें। तेज़ टेस्ट्स चलती हैं; धीमे टेस्ट्स अक्सर स्किप हो जाते हैं।
FastAPI ऐप को ऑनलाइन लाना ज़्यादातर सही “रनर” चुनने और कुछ प्रोडक्शन ज़रूरतें जोड़ने का मामला है।
जब आप लोकल में uvicorn main:app --reload चलाते हैं, तो आप डेवलप सेटअप चला रहे हैं: ऑटो-रीलोड, विस्तारपूर्ण एरर, और सुविधाजनक सेटिंग्स।
प्रोडक्शन में आप आम तौर पर Uvicorn को बिना --reload के चलाते हैं, अक्सर Gunicorn के साथ Uvicorn वर्कर्स के पीछे, या किसी रिवर्स प्रॉक्सी के पीछे। लक्ष्य है स्थिरता: नियंत्रित रीस्टार्ट, भविष्यवाणी योग्य प्रदर्शन और सुरक्षित डिफ़ॉल्ट्स।
एक सामान्य पैटर्न:
इससे एक ही कोडबेस कई एन्वायर्नमेंट्स में बिना फाइल एडिट किए डिप्लॉयेबल रहता है।
डिप्लॉय करने से पहले सुनिश्चित करें:
/health जैसे एंडपॉइंट मॉनिटरिंग और लोड बैलेंसर्स के लिए।यदि आप "लोकल पर काम कर रहा है" से "शिप योग्य" में जा रहे हैं, तो OpenAPI आउटपुट को CI में वेरिफाई करने, क्लाइंट जनरेट करने और कॉन्ट्रैक्ट मैनेज करने जैसे वर्कफ़्लोज़ बनाना मददगार होता है। कुछ टीमें FastAPI के OpenAPI को ऑटोमेशन पाइपलाइन्स के साथ जोड़ती हैं—उदाहरण के लिए क्लाइंट जनरेट करना, CI में रिक्वेस्ट्स सत्यापित करना, और निरंतरता से डिप्लॉय करना।
FastAPI एक मजबूत विकल्प है जब आप Python में साफ़, आधुनिक तरीके से REST APIs बनाना चाहते हैं—खासकर जब आप अनुरोध/प्रतिक्रिया मॉडल्स और बढ़ती API के साथ पूर्वानुमानित व्यवहार चाहते हैं।
FastAPI आम तौर पर निम्न स्थितियों में अच्छा लगता है:
FastAPI हमेशा सबसे सरल उत्तर नहीं है:
FastAPI व्यवहार में बहुत तेज़ हो सकता है, पर गति आपके डेटाबेस कॉल्स, नेटवर्क लैटेंसी और बिज़नेस लॉजिक पर निर्भर करती है। सामान्य API वर्कलोड्स के लिए बढ़िया थ्रूपुट और स्वीकार्य लैटेंसी की उम्मीद रखें—बस फ्रेमवर्क से ही धीमी I/O या गैरकुशल क्वेरीज़ ठीक होने की उम्मीद न रखें।
यदि FastAPI मेल खाता है, तो आगे फोकस करें: रूटिंग पैटर्न, Pydantic मॉडल्स, डेटाबेस इंटीग्रेशन, बैकग्राउंड टास्क और बेसिक ऑथेंटिकेशन।
एक प्रैक्टिकल रास्ता है: एक छोटा एंडपॉइंट सेट बनाइए, फिर रीउसबल डिपेंडेंसीज़ और टेस्ट जोड़ते जाएँ। शुरुआती स्कैफोल्डिंग (रूट्स, मॉडल्स, और डिप्लॉयमेंट-रेडी स्ट्रक्चर) को तेज़ करने के लिए आप उपायों का उपयोग कर सकते हैं—उदाहरण के लिए एक प्लान/स्पेक से कोड जनरेट करना और फिर सामान्य समीक्षा/डिप्लॉय पाइपलाइन में इंटीग्रेट करना।
FastAPI एक ऐसा Python वेब फ्रेमवर्क है जो न्यूनतम बुनियादी कोड के साथ APIs बनाने में मदद करता है। आप एंडपॉइंट फ़ंक्शन लिखते हैं (जैसे @app.get("/users")) और FastAPI रूटिंग, अनुरोध पार्सिंग, वैलिडेशन और JSON प्रतिक्रियाएँ संभालता है।
एक प्रमुख लाभ यह है कि आपके टाइप_HINTS और Pydantic मॉडल यह स्पष्ट कर देते हैं कि API क्या स्वीकार करता है और क्या लौटाता है।
API URL (एंडपॉइंट) का एक सेट होता है जिसे अन्य सॉफ़्टवेयर डेटा के आदान-प्रदान के लिए बुलाते हैं।
उदाहरण के लिए, एक क्लाइंट मौसम डेटा प्राप्त करने के लिए GET /weather?city=Berlin जैसे अनुरोध कर सकता है, और सर्वर संरचित JSON के साथ उत्तर देता है। क्लाइंट को सीधे डेटाबेस की ज़रूरत नहीं होती—यह सिर्फ API से पूछता है और परिणाम दिखाता है।
रूटिंग एक HTTP मेथड + पाथ को किसी Python फ़ंक्शन से जोड़ देती है।
FastAPI में आप आम तौर पर डेकोरेटर्स का उपयोग करते हैं:
@app.get("/items") पढ़ने के लिए@app.post("/items") बनाने के लिए@app.put("/items/{id}") अपडेट/रिप्लेस करने के लिएपाथ पैरामीटर URL संरचना का हिस्सा होते हैं और आम तौर पर किसी विशिष्ट संसाधन की पहचान करते हैं (आवश्यक)।
GET /users/42 → 42 पाथ पैरामीटर हैक्वेरी पैरामीटर ? के बाद जुड़े होते हैं और सामान्यतः वैकल्पिक फ़िल्टर या नियंत्रण होते हैं।
Pydantic मॉडल यह परिभाषित करते हैं कि आपका डेटा कैसा होना चाहिए (टाइप्स, आवश्यक फ़ील्ड, सीमाएँ)। FastAPI इनका उपयोग करके:
यदि वैलिडेशन गलत होती है, तो FastAPI आमतौर पर 422 Unprocessable Entity के साथ उस फ़ील्ड और कारण का विवरण देता है।
FastAPI स्वतः ही आपके एंडपॉइंट्स, टाइप हिंट्स और मॉडलों से OpenAPI स्कीमा बनाता है।
आप आम तौर पर स्वचालित इंटरैक्टिव डॉक्स पाते हैं:
/docs/redocचूंकि स्कीमा कोड से निकला होता है, डॉक्यूमेंटेशन आपके बदलावों के साथ स्वतः अपडेट रहती है।
जब आपका एंडपॉइंट बहुत समय I/O पर खर्च करता है (डेटाबेस कॉल, बाहरी HTTP कॉल, फ़ाइल/ऑब्जेक्ट स्टोरेज), तब async def उपयोग करने से लाभ मिलता है।
नीचे पर विचार करें:
async तब सहायक है जब आप नेटवर्क/डिस्क वेट करते हैंdef तब ठीक है जब कोड सिंक्रोनस है, लाइब्रेरी async का समर्थन नहीं करती, या काम CPU-भारी हैएक ही एप में sync और async दोनों प्रकार के रूट अक्सर मिश्रित होते हैं।
डिपेंडेंसीज़ पुन:उपयोग योग्य बिल्डिंग ब्लॉक्स हैं जिन्हें FastAPI Depends() के माध्यम से एंडपॉइंट्स में इंजेक्ट करता है।
यह सामान्यतः उपयोग होते हैं:
यह दोहराव घटाता है और क्रॉस-कटिंग लॉजिक को केंद्रीकृत करता है ताकि बदलाव एक ही जगह पर करें।
FastAPI अपने आप आपकी API को सुरक्षित नहीं करता—आपको स्कीम चुनकर उसे लागू करना होता है। सामान्य पैटर्न:
सुनिश्चित करें:
टेस्टिंग के लिए आप FastAPI/Starlette के TestClient का उपयोग करके अपने API को इन-प्रोसेस कॉल कर सकते हैं (सर्वर की ज़रूरत नहीं)।
प्रैक्टिकल चेकलिस्ट:
डिप्लॉयमेंट के लिए ASGI सर्वर (जैसे Uvicorn), लॉगिंग, हेल्थ चेक (), टाइमआउट्स और एन्वायर्नमेंट-आधारित कॉन्फ़िग सुनिश्चित करें।
@app.delete("/items/{id}") हटाने के लिएयह आपके API की सतह (surface) को सीधे कोड से पढ़ने में आसान बनाता है।
GET /users?limit=10&active=true → limit, active क्वेरी पैरामीटर हैं/health