FastAPI बैकएंड डेवलपमेंट बूटकैंप · पाठ

सामान्य निर्भरताएँ इंजेक्ट करना

डेटाबेस सत्रों, उपयोगकर्ता प्रमाणीकरण या एंडपॉइंट के बीच साझा कॉन्फ़िगरेशन के लिए सामान्य निर्भरताएँ लागू करें।

पाठ 2, कुल 4 में से11 चरण

सामान्य निर्भरताएँ इंजेक्ट करना, CoddyKit पर FastAPI बैकएंड डेवलपमेंट बूटकैंप का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह FastAPI बैकएंड डेवलपमेंट बूटकैंप सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। FastAPI बैकएंड डेवलपमेंट बूटकैंप पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

सामान्य निर्भरताओं का परिचय

FastAPI में निर्भरताएँ शक्तिशाली होती हैं। वे तर्क साझा करने, संसाधनों का प्रबंधन करने और आपके कोड को स्वच्छ रखने में सहायता करती हैं।

सामान्य निर्भरताएँ ऐसे फ़ंक्शन या क्लास होती हैं जिनका आप कई API एंडपॉइंट में पुनः उपयोग करते हैं। इससे दोहराया हुआ कोड कम होता है और आपके अनुप्रयोग का रखरखाव और परीक्षण आसान बनता है।

उन्हें अपने API के लिए पुनः उपयोग योग्य निर्माण खंड समझें।

साझा कॉन्फ़िगरेशन इंजेक्ट करना

कई अनुप्रयोगों को API कुंजियों या डेटाबेस URL जैसी वैश्विक सेटिंग्स की आवश्यकता होती है। कॉन्फ़िगरेशन इंजेक्ट करके आप वैश्विक चर का सहारा लिए बिना किसी भी एंडपॉइंट में इन सेटिंग्स तक आसानी से पहुँच सकते हैं।

इससे आपका कॉन्फ़िगरेशन लचीला और अपडेट करने में आसान रहता है।

डेमो: सरल कॉन्फ़िगरेशन निर्भरता

आइए ऐसी निर्भरता बनाएँ जो एक सरल सेटिंग्स डिक्शनरी लौटाती है। वास्तविक अनुप्रयोग में, यह Pydantic के BaseSettings का उपयोग करके पर्यावरण चरों से सेटिंग्स लोड कर सकती है।

from fastapi import FastAPI, Depends

app = FastAPI()

# This function acts as our dependency
def get_settings():
    return {"app_name": "CoddyKit API", "version": "1.0.0"}

@app.get("/info")
def read_info(settings: dict = Depends(get_settings)):
    return {"message": f"Welcome to {settings['app_name']} v{settings['version']}"}

# To run this:
# 1. Save as main.py
# 2. Run 'uvicorn main:app --reload'
# 3. Go to http://127.0.0.1:8000/info

डेटाबेस सत्र प्रबंधन

बैकएंड API के लिए डेटाबेस के साथ काम करना एक सामान्य कार्य है। आमतौर पर प्रत्येक अनुरोध को अपना अलग डेटाबेस "सत्र" या कनेक्शन चाहिए होता है।

हर एंडपॉइंट में इन सत्रों का मैन्युअल प्रबंधन करना उबाऊ और त्रुटि-प्रवण होता है। एक निर्भरता आपके लिए इन्हें अपने-आप बनाने और बंद करने का कार्य संभाल सकती है।

डेमो: डेटाबेस सत्र निर्भरता

यहाँ get_db निर्भरता का एक सरल उदाहरण है। वास्तविक अनुप्रयोग में, यह SQLAlchemy जैसे ORM का उपयोग करके डेटाबेस से कनेक्ट होगी।

यहाँ yield कीवर्ड महत्वपूर्ण है!

from fastapi import FastAPI, Depends
from typing import Generator

app = FastAPI()

# This simulates a database session.
# In a real app, this would be a SQLAlchemy session.
class MockDBSession:
    def __init__(self):
        print("Opening DB session...")
    def close(self):
        print("Closing DB session...")
    def query(self, item_id: int):
        return {"id": item_id, "name": f"Item {item_id}"}

def get_db() -> Generator:
    db = MockDBSession()
    try:
        yield db  # This is where the endpoint gets the 'db' object
    finally:
        db.close() # This runs after the request is finished

@app.get("/items/{item_id}")
def read_item(item_id: int, db: MockDBSession = Depends(get_db)):
    # The 'db' object is provided by the dependency
    return db.query(item_id)

# To run this:
# 1. Save as main.py
# 2. Run 'uvicorn main:app --reload'
# 3. Go to http://127.0.0.1:8000/items/1

`yield` का जादू

हमारे get_db फ़ंक्शन में yield कीवर्ड बहुत महत्वपूर्ण है।

yield से पहले का कोड एंडपॉइंट फ़ंक्शन से पहले चलता है। इसका उपयोग सेटअप के लिए होता है (जैसे, डेटाबेस कनेक्शन खोलना)।
yield के बाद का कोड एंडपॉइंट फ़ंक्शन और उसकी प्रतिक्रिया के बाद चलता है। इसका उपयोग समापन कार्यों के लिए होता है (जैसे, कनेक्शन बंद करना)।

इस पैटर्न को "yield वाली निर्भरता" या "संदर्भ प्रबंधक निर्भरता" कहा जाता है।

उपयोगकर्ता प्रमाणीकरण इंजेक्ट करना

अधिकांश API को यह जानना आवश्यक होता है कि अनुरोध कौन कर रहा है। प्रमाणीकरण निर्भरताएँ अनुरोध हेडर (जैसे API कुंजी या JWT टोकन) से उपयोगकर्ता की जानकारी निकालकर उसे आपके एंडपॉइंट के लिए उपलब्ध कराती हैं।

इससे आपका प्रमाणीकरण तर्क अलग और कई मार्गों में पुनः उपयोग योग्य रहता है।

डेमो: वर्तमान उपयोगकर्ता निर्भरता

यह एक सामान्य dependency है, जो वर्तमान उपयोगकर्ता को प्राप्त करने का अनुकरण करती है। वास्तविक application में request headers से token को मान्य करना शामिल होता।

यदि उपयोगकर्ता authenticated नहीं है, तो request को तुरंत रोकने के लिए यह HTTPException उत्पन्न कर सकती है।

from fastapi import FastAPI, Depends, HTTPException, status
from typing import Optional

app = FastAPI()

class User:
    def __init__(self, username: str, email: Optional[str] = None):
        self.username = username
        self.email = email

# This dependency simulates fetching the current user
def get_current_user(token: str = "some_valid_token") -> User:
    # In a real app, 'token' would come from request headers
    # and be validated against a database or auth service.
    if token != "some_valid_token":
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid authentication credentials",
            headers={"WWW-Authenticate": "Bearer"},
        )
    return User(username="jane_doe", email="jane@example.com")

@app.get("/me")
def read_current_user(current_user: User = Depends(get_current_user)):
    return {"username": current_user.username, "email": current_user.email}

# To run this:
# 1. Save as main.py
# 2. Run 'uvicorn main:app --reload'
# 3. Go to http://127.0.0.1:8000/me

Dependencies को जोड़ना और फिर से उपयोग करना

Dependencies अन्य dependencies पर भी निर्भर कर सकती हैं! इससे जटिल logic को छोटे और आसानी से प्रबंधित किए जा सकने वाले भागों में बाँटना संभव होता है।

उदाहरण के लिए, "वर्तमान admin उपयोगकर्ता" dependency पहले "वर्तमान उपयोगकर्ता" पर निर्भर हो सकती है और फिर जाँच सकती है कि उस उपयोगकर्ता के पास admin विशेषाधिकार हैं या नहीं।

यह modularity, FastAPI के dependency injection की प्रमुख ताकत है।

अपनी समझ जाँचें

निम्नलिखित FastAPI dependency पर विचार कीजिए:

from fastapi import HTTPException, status

def check_api_key(api_key: str = "SECRET_KEY"):
    if api_key != "VALID_API_KEY":
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Invalid API Key"
        )
    return True

यदि कोई endpoint Depends(check_api_key) का उपयोग करता है और सही API_KEY के बिना request आती है, तो क्या होगा?

इंटरैक्टिव पाठ में इसका उत्तर दें

सामान्य Dependencies: मुख्य बातें

हमने FastAPI में सामान्य dependencies को inject करने का तरीका देखा है:

Configuration: Application settings को विभिन्न endpoints में आसानी से साझा करें।
Database Sessions: उचित setup और teardown के लिए yield का उपयोग करके प्रत्येक request के लिए database connections को प्रबंधित करें।
User Authentication: उपयोगकर्ताओं की पहचान और validation के logic को एक जगह रखें।

Dependencies, मुख्य endpoint logic से cross-cutting concerns को अलग रखकर साफ़, दोबारा उपयोग किए जा सकने वाले और test किए जा सकने वाले code को बढ़ावा देती हैं।

शुरुआत निःशुल्क

एआई शिक्षक के साथ FastAPI बैकएंड डेवलपमेंट बूटकैंप सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 21
पाठ: 84

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “सामान्य निर्भरताएँ इंजेक्ट करना” पाठ निःशुल्क है?

हाँ — FastAPI बैकएंड डेवलपमेंट बूटकैंप अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “सामान्य निर्भरताएँ इंजेक्ट करना” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। FastAPI बैकएंड डेवलपमेंट बूटकैंप पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“सामान्य निर्भरताएँ इंजेक्ट करना” में मैं क्या सीखूँगा?

डेटाबेस सत्रों, उपयोगकर्ता प्रमाणीकरण या एंडपॉइंट के बीच साझा कॉन्फ़िगरेशन के लिए सामान्य निर्भरताएँ लागू करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ FastAPI बैकएंड डेवलपमेंट बूटकैंप का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या FastAPI बैकएंड डेवलपमेंट बूटकैंप शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर FastAPI बैकएंड डेवलपमेंट बूटकैंप शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“सामान्य निर्भरताएँ इंजेक्ट करना” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस FastAPI बैकएंड डेवलपमेंट बूटकैंप पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर FastAPI बैकएंड डेवलपमेंट बूटकैंप पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← FastAPI बैकएंड डेवलपमेंट बूटकैंप पर वापस जाएँ