आप जैसे पाठक MUO का समर्थन करने में मदद करते हैं। जब आप हमारी साइट पर लिंक का उपयोग करके खरीदारी करते हैं, तो हम संबद्ध कमीशन अर्जित कर सकते हैं। और पढ़ें।

REST API बनाना अक्सर एक यांत्रिक कार्य होता है, जिसमें बहुत सारे बॉयलरप्लेट डिज़ाइन और रट प्रोग्रामिंग शामिल होते हैं। शुक्र है, FastAPI जैसे उपकरण बहुत सारे थकाऊ विवरण से छुटकारा दिला सकते हैं।

FastAPI का उपयोग करके, आप अपने CRUD एप्लिकेशन के लिए शीघ्रता से एक कुशल, पूर्ण REST API बना सकते हैं। डेटा स्रोत के रूप में MongoDB के साथ, यह ट्यूटोरियल आपको कुछ ही समय में अपना स्वयं का API सेट करने के लिए मार्गदर्शन करेगा।

फास्टएपीआई क्या है?

फास्टएपीआई एपीआई बनाने के लिए एक तेज़ और ओपन-सोर्स पायथन वेब फ्रेमवर्क है। यह अतुल्यकालिक अनुरोधों, डेटा के स्वत: सत्यापन और एपीआई समापन बिंदुओं के स्वचालित प्रलेखन के लिए अंतर्निहित समर्थन प्रदान करता है।

अन्य पायथन फ्रेमवर्क पर FastAPI के लाभ

  • FastAPI, Django और Flask जैसे अन्य फ्रेमवर्क की तुलना में अपेक्षाकृत तेज़ है। ऐसा इसलिए है क्योंकि FastAPI, asyncio के शीर्ष पर बनाता है, जो Python के लिए एक अतुल्यकालिक I/O लाइब्रेरी है जो समवर्ती अनुरोधों को अधिक तेज़ी से संसाधित कर सकता है।
    • instagram viewer
  • FastAPI न्यूनतम प्रयास के साथ API बनाने का एक स्वच्छ और सरल तरीका प्रदान करता है क्योंकि इसके लिए फ्लास्क या Django की तुलना में कम कोड की आवश्यकता होती है।
  • अंत में, FastAPI एंडपॉइंट के लिए दस्तावेज़ जनरेट करना आसान बनाता है। यह दस्तावेज़ बनाने के लिए स्वैगर का उपयोग करता है जिसका उपयोग आप अनुरोधों को चलाकर और प्रतिक्रियाओं को देखकर समापन बिंदु का परीक्षण करने के लिए कर सकते हैं।

एक मोंगोडीबी डाटाबेस सेट अप करें

आरंभ करने के लिए, आपको चाहिए MongoDB डेटाबेस को स्थानीय रूप से सेट करें. वैकल्पिक रूप से, आप के आसान विकल्प के लिए विकल्प चुन सकते हैं क्लाउड में एक मोंगोडीबी क्लस्टर स्थापित करना.

अगला, स्थापित मोंगोडीबी ग्राफिकल यूजर इंटरफेस टूल, कम्पास का उपयोग करके, डेटाबेस कनेक्शन बनाएं। क्लिक करें नया कनेक्शन बटन और स्थानीय रूप से चल रहे मोंगोडीबी सर्वर के साथ कनेक्शन स्थापित करने के लिए कनेक्शन यूआरआई प्रदान करें।

अंत में, अपना टेस्ट एपीआई डेटा रखने के लिए एक नया डेटाबेस और संग्रह बनाएं।

एक FastAPI सर्वर सेट करें

एक टर्मिनल का उपयोग करके, एक प्रोजेक्ट फ़ोल्डर बनाएँ, और उस नई निर्देशिका में प्रवेश करें।

आप इस प्रोजेक्ट का कोड इसमें पा सकते हैं गिटहब रिपॉजिटरी.

अगला, यह देखने के लिए जांचें कि आप पायथन संस्करण 3.6+ चला रहे हैं। यदि नहीं, तो नवीनतम स्थापित करें अजगर संस्करण।

अजगर --संस्करण

बाद में, एक पृथक आभासी विकास वातावरण बनाने के लिए Virtualenv स्थापित करें। यह अत्यधिक अनुशंसित है क्योंकि यह आपको संघर्षों से बचने में सक्षम बनाता है, खासकर यदि आप विभिन्न परियोजनाओं के लिए पैकेज के विभिन्न संस्करणों का उपयोग कर रहे हैं।

पिप वर्चुअलएन्व स्थापित करें

अगला, अपनी वर्तमान निर्देशिका में "वेनव" नामक एक आभासी वातावरण बनाएँ:

virtualenv venv

अंत में, आभासी वातावरण को सक्रिय करें।

# यूनिक्स या MacOS पर: 
स्रोत venv/bin/active
# विंडोज़ पर:
 .\venv\Scripts\active

एक बार जब आप वर्चुअल वातावरण को कॉन्फ़िगर कर लेते हैं, तो FastAPI, PyMongo और Uvicorn पैकेज इंस्टॉल करें।

पिप फास्टापी पाइमोंगो यूविकॉर्न स्थापित करें

PyMongo MongoDB डेटाबेस के साथ काम करने के लिए एक Python-आधारित लाइब्रेरी है। यह एक एपीआई प्रदान करता है जो मोंगोडीबी की सभी सुविधाओं का समर्थन करता है और आपको कच्चे मोंगोडीबी प्रश्न लिखने के बिना मोंगोडीबी के साथ बातचीत करने की अनुमति देता है।

दूसरी ओर, यूविकोर्न, एक अतुल्यकालिक वेब सर्वर है जो पायथन एसिन्सियो मॉड्यूल पर आधारित है। इसकी मुख्य विशेषता चलते-फिरते आपके FastAPI सर्वर को फिर से लोड करना है। यूविकोर्न का उपयोग करना समान है नोडमॉन के साथ काम करना.

FastAPI सर्वर बनाएँ

अंत में, एक साधारण FastAPI सर्वर बनाएं जो होम रूट से आने वाले अनुरोधों को सुनता है। अपने प्रोजेक्ट फोल्डर की रूट डायरेक्टरी में, एक server.py फाइल बनाएं और नीचे कोड जोड़ें।

से fastapi आयात फास्टएपीआई
ऐप = फास्टएपीआई ()
@app.get("/")
asyncडीईएफ़घर():
वापस करना {"संदेश": "हैलो वर्ल्ड"}

अंत में, डेवलपमेंट सर्वर को स्पिन करने के लिए नीचे दी गई कमांड चलाएँ। Uvicorn आपके आवेदन को पोर्ट 8000 पर सर्व करेगा।

यूवीकॉन सर्वर: ऐप --reload

आगे बढ़ें और अपने ब्राउज़र पर सर्वर प्रतिक्रिया देखें http://localhost: 8000.

CRUD ऑपरेशंस के साथ REST API बनाएं

अब REST API बनाएं जो CRUD विधियों को लागू करता है (बनाएं, पढ़ें, अपडेट करें और हटाएं)। अपने प्रोजेक्ट फोल्डर की रूट डायरेक्टरी में, चार फोल्डर बनाएं: कॉन्फिग, मॉडल, रूट और स्कीमा।

├── विन्यास
├── मॉडल
├── मार्ग
├── स्कीमा
└── server.py

1. डेटाबेस कनेक्शन कॉन्फ़िगर करें

कॉन्फ़िगरेशन निर्देशिका में, एक नई फ़ाइल db.py बनाएं और नीचे कोड जोड़ें।

से पाइमोंगो आयात MongoClient
डीबी_कनेक्शन = मोंगो क्लाइंट ("मोंगोडब: // लोकलहोस्ट: 27017")
डीबी = db_connection.database_name
संग्रह = डीबी ["संग्रह_नाम"]
  • MongoDB डेटाबेस से कनेक्शन बनाने के लिए MongoClient() विधि का उपयोग करें। यह एक कनेक्शन URI स्ट्रिंग को एक तर्क के रूप में लेता है जो MongoDB सर्वर के होस्ट और पोर्ट को निर्दिष्ट करता है।
  • दो चर निर्दिष्ट करते हैं कि आपके MongoDB सर्वर में कौन सा डेटाबेस और संग्रह सर्वर को एक्सेस करना चाहिए।

2. डेटा मॉडल को परिभाषित करें

यह मॉडल डेटाबेस में आपके डेटा की संरचना को फ़ील्ड और डेटा प्रकारों सहित परिभाषित करेगा।

मॉडल निर्देशिका में, एक नई फ़ाइल बनाएं, user_model.py, और नीचे कोड जोड़ें।

से pydantic आयात बेसमॉडल 
कक्षाउपयोगकर्ता(बेसमॉडल):
 नाम: स्ट्र
 भूमिका: स्ट्र
  • ऊपर दिया गया कोड उपयोगकर्ता नामक एक वर्ग बनाता है, जो कि पाइडेंटिक लाइब्रेरी से बेसमॉडल वर्ग का एक उपवर्ग है। उपयोगकर्ता वर्ग में दो फ़ील्ड, नाम और भूमिका होती है, जिसमें उनके डेटा प्रकार स्ट्रिंग्स पर सेट होते हैं।
  • डेटा मॉडल बनाने के लिए आप FastAPI के साथ Pydantic लाइब्रेरी का उपयोग कर सकते हैं। आप इसका उपयोग डेटा को मान्य करने के लिए भी कर सकते हैं, इसे क्रमबद्ध कर सकते हैं (JSON to Python), और इसे डी-सीरियलाइज़ कर सकते हैं (Python to JSON)।

3. डेटा स्कीमा को परिभाषित करें

निर्मित डेटा मॉडल से, आप अपने डेटा के लिए स्कीमा परिभाषित कर सकते हैं। स्कीमा निर्देशिका में, एक नई फ़ाइल बनाएँ: user_schema.py, और नीचे कोड जोड़ें।

डीईएफ़user_serializer(उपयोगकर्ता) -> तानाशाही:
वापस करना {
'पहचान': एसटीआर (उपयोगकर्ता ["_पहचान"]),
'नाम': उपयोगकर्ता ["नाम"],
'भूमिका': उपयोगकर्ता ["भूमिका"]
 }
डीईएफ़users_serializer(उपयोगकर्ता) -> सूची:
वापस करना [उपयोगकर्ता_सीरियलाइज़र (उपयोगकर्ता) के लिए उपयोगकर्ता में उपयोगकर्ता]

4. एपीआई मार्गों को परिभाषित करें

अंत में, विभिन्न सीआरयूडी परिचालनों के लिए मार्गों को परिभाषित करें।

मार्ग निर्देशिका में, एक नई फ़ाइल बनाएँ: user_routes.py, और नीचे कोड जोड़ें।

पोस्ट विधि के साथ डेटा जोड़ें

डेटा जोड़ने के लिए पोस्ट रूट बनाएं।

से fastapi आयात एपीआईराउटर
से मॉडल.उपयोगकर्ता_मॉडल आयात उपयोगकर्ता
से schemas.user_schema आयात users_serializer
से bson आयात वस्तु आईडी
से config.db आयात संग्रह
उपयोगकर्ता = एपीआईराउटर ()
@user.post("/")
asyncडीईएफ़उपयोगकर्ता बनाइये(उपयोगकर्ता: उपयोगकर्ता):
 _id = संग्रह.insert_one (तानाशाही (उपयोगकर्ता))
 उपयोगकर्ता = उपयोगकर्ता_सीरियलाइज़र (संग्रह.खोज ({"_पहचान": _id.inserted_id}))
वापस करना {"दर्जा": "ठीक है","आंकड़े": उपयोगकर्ता}
  • FastAPI APIRouter () विधि प्रदान करता है जो एक राउटर ऑब्जेक्ट को परिभाषित करता है जो एक सर्वर को एपीआई अनुरोध करने के लिए एक इंटरफ़ेस प्रदान करता है।
  • एक पोस्ट रूट निर्दिष्ट करें जो डेटाबेस में डेटा को क्रमबद्ध करने के बाद संग्रह में सम्मिलित करके एक नया उपयोगकर्ता ऑब्जेक्ट बनाता है। अगला, संग्रह में सहयोगी डेटा को खोजने के लिए सम्मिलित_आईडी को स्टोर करें और पास करें, और अंत में, प्रतिक्रिया में डेटा के साथ "ओके" की स्थिति वापस करें, यदि पोस्ट अनुरोध सफल होता है।
  • इन्सर्ट_ऑन और फाइंड मेथड्स को PyMongo क्लाइंट द्वारा परिभाषित किया गया है।

अब, मार्गों को इनिशियलाइज़ करने के लिए नीचे दिए गए कोड को server.py में जोड़ें।

से मार्ग.उपयोगकर्ता_मार्ग आयात उपयोगकर्ता
app.include_router (उपयोगकर्ता)

आगे बढ़ें और FastAPI द्वारा प्रदान किए गए स्वैगर UI API टूल का उपयोग करके अपने ब्राउज़र पर पोस्ट रूट का परीक्षण करें।

गेट मेथड के साथ डेटा पढ़ें

पोस्ट रूट को परिभाषित करने और रूट्स को इनिशियलाइज़ करने के बाद, बाकी अन्य रूट्स को परिभाषित करें।

@ user.get("/")
asyncडीईएफ़find_all_users():
 उपयोगकर्ता = उपयोगकर्ता_सीरियलाइज़र (संग्रह.फाइंड ())
वापस करना {"दर्जा": "ठीक है","आंकड़े": उपयोगकर्ता}

@ user.get("/{id}")
asyncडीईएफ़get_one_user(आईडी: स्ट्र):
 उपयोगकर्ता = उपयोगकर्ता_सीरियलाइज़र (संग्रह.खोज ({"_पहचान": ऑब्जेक्टआईडी (आईडी)}))
वापस करना {"दर्जा": "ठीक है","आंकड़े": उपयोगकर्ता}

दो प्राप्त मार्गों को परिभाषित करें जो संग्रह में सभी डेटा को पुनः प्राप्त करते हैं और आईडी के आधार पर संग्रह से विशिष्ट डेटा प्राप्त करते हैं।

पुट मेथड से डेटा अपडेट करें

डेटाबेस में संग्रहीत डेटा को अपडेट करने के लिए पुट रूट बनाएं।

@ user.put("/{id}")
asyncडीईएफ़update_user(आईडी: स्ट्र, उपयोगकर्ता: उपयोगकर्ता):
 संग्रह.find_one_and_update(
 {
"_पहचान": ऑब्जेक्ट आईडी (आईडी)
 }, 
 {
"$सेट": तानाशाही (उपयोगकर्ता)
 })
 उपयोगकर्ता = उपयोगकर्ता_सीरियलाइज़र (संग्रह.खोज ({"_पहचान": ऑब्जेक्टआईडी (आईडी)}))
वापस करना {"दर्जा": "ठीक है","आंकड़े": उपयोगकर्ता}

पुट विधि संग्रह में विशिष्ट डेटा को खोजने के लिए आईडी का उपयोग करती है और एपीआई से पास किए गए नए डेटा के साथ दस्तावेज़ में फ़ील्ड के मान को अपडेट करती है। फिर आप आईडी द्वारा अपडेट किए गए डेटा की खोज कर सकते हैं और इसे एपीआई प्रतिक्रिया में वापस कर सकते हैं।

डिलीट मेथड से डेटा डिलीट करें

डेटाबेस में संग्रहीत डेटा को हटाने के लिए डिलीट रूट बनाएं।

@user.delete("/{id}")
asyncडीईएफ़उपभोक्ता मिटायें(आईडी: स्ट्र):
 संग्रह.find_one_and_delete ({"_पहचान": ऑब्जेक्टआईडी (आईडी)})
 उपयोगकर्ता = उपयोगकर्ता_सीरियलाइज़र (संग्रह.फाइंड ())
वापस करना {"दर्जा": "ठीक है","आंकड़े": []}

डिलीट रूट उस विशिष्ट दस्तावेज़ की आईडी लेता है जिसे आप संग्रह से हटाना चाहते हैं।

FastAPI के साथ REST API बनाएं

FastAPI आसानी से बैकएंड Python वेब APIs बनाने का एक शानदार तरीका प्रदान करता है। डेटाबेस एकीकरण और स्वचालित एपीआई उत्पादन के लिए इसके अंतर्निहित उपकरण प्रक्रिया को सरल बनाते हैं।

आप इसे एक कदम आगे भी ले जा सकते हैं और पूरी तरह से विकसित ऐप्स बना सकते हैं। प्रतिक्रिया, कोणीय, या Vue जैसी लोकप्रिय तकनीकों का उपयोग करके फ्रंट-एंड क्लाइंट को एकीकृत करने का प्रयास करें।