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

URL, हेडर और मीडिया-प्रकार संस्करण निर्धारण

संस्करण निर्धारण के तरीकों की तुलना कीजिए और सुव्यवस्थित मार्ग समूह लागू कीजिए, ताकि क्लाइंट बिना बाधा के अपग्रेड कर सकें।

पाठ 1, कुल 4 में से13 चरण

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

API का संस्करण आखिर बनाएँ ही क्यों?

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

संस्करण-निर्धारण आपको पुराने व्यवहार को जारी रखते हुए, नए नाम के अंतर्गत ऐसे बदलाव जारी करने देता है जो पुराने क्लाइंट के साथ संगत नहीं हैं। क्लाइंट अपनी सुविधानुसार अपग्रेड कर सकते हैं।

  • गैर-विघटनकारी बदलाव (जैसे वैकल्पिक फ़ील्ड जोड़ना) के लिए सामान्यतः नए संस्करण की आवश्यकता नहीं होती।
  • विघटनकारी बदलाव (फ़ील्ड हटाना/नाम बदलना, प्रकार या अर्थ बदलना) के लिए संस्करण सीमा आवश्यक होती है।

इस पाठ में तीन पारंपरिक रणनीतियों की तुलना की गई है: URL पथ, Header और Media-Type संस्करण-निर्धारण।

रणनीति 1: URL पथ संस्करण-निर्धारण

सबसे सामान्य और सबसे स्पष्ट तरीका है: संस्करण को सीधे पथ में रखें, जैसे /v1/users और /v2/users।

  • लाभ: लॉग और ब्राउज़र में स्पष्ट, रूट करना आसान, कैश करना सरल और दस्तावेज़ बनाना आसान।
  • हानियाँ: संस्करण हर URL में दिखाई देता है; तकनीकी रूप से URL को संसाधन की पहचान करनी चाहिए, उसके प्रतिनिधित्व की नहीं।

FastAPI में इसे APIRouter पर prefix के माध्यम से व्यक्त किया जाता है। प्रत्येक संस्करण को अपना राउटर और अपना प्रीफ़िक्स मिलता है।

from fastapi import APIRouter, FastAPI

app = FastAPI()

v1 = APIRouter(prefix="/v1", tags=["v1"])
v2 = APIRouter(prefix="/v2", tags=["v2"])

@v1.get("/users/{user_id}")
def get_user_v1(user_id: int):
    return {"id": user_id, "name": "Ada Lovelace"}

@v2.get("/users/{user_id}")
def get_user_v2(user_id: int):
    # v2 splits name into first/last
    return {"id": user_id, "first_name": "Ada", "last_name": "Lovelace"}

app.include_router(v1)
app.include_router(v2)

सब-राउटर से साफ़ रूट समूह बनाना

हर एंडपॉइंट को एक बहुत बड़े संस्करण राउटर में न जोड़ें। पहले संसाधन के आधार पर समूह बनाएँ, फिर प्रत्येक संसाधन राउटर को संस्करण राउटर के अंतर्गत माउंट करें, ताकि API बढ़ने पर संरचना साफ़ रहे।

यहाँ users_router स्वतंत्र रूप से बनाया गया है और फिर v1 में शामिल किया गया है। संयुक्त पथ /v1/users/... बन जाता है।

from fastapi import APIRouter, FastAPI

app = FastAPI()

users_router = APIRouter(prefix="/users", tags=["users"])

@users_router.get("/{user_id}")
def get_user(user_id: int):
    return {"id": user_id, "name": "Grace Hopper"}

v1 = APIRouter(prefix="/v1")
v1.include_router(users_router)   # -> /v1/users/{user_id}

app.include_router(v1)

रणनीति 2: हेडर संस्करण-निर्धारण

इसमें URL साफ़ रहता है (/users/42) और क्लाइंट सामान्यतः X-API-Version: 2 जैसे कस्टम अनुरोध हेडर के माध्यम से संस्करण बताता है।

  • लाभ: URL संस्करण-मुक्त और स्थिर रहते हैं; संसाधन पथ कभी नहीं बदलता।
  • हानियाँ: ब्राउज़र में परीक्षण कठिन, हेडर भूलना आसान और कैशिंग परतों को इसके आधार पर अलग-अलग कैश करने के लिए बताना पड़ता है।

FastAPI में आप हेडर को टाइप किए गए पैरामीटर से पढ़कर उसके आधार पर शाखा बनाते (या अनुरोध भेजते) हैं।

from fastapi import FastAPI, Header

app = FastAPI()

@app.get("/users/{user_id}")
def get_user(user_id: int, x_api_version: int = Header(default=1)):
    if x_api_version >= 2:
        return {"id": user_id, "first_name": "Ada", "last_name": "Lovelace"}
    return {"id": user_id, "name": "Ada Lovelace"}

संस्करण निर्धारित करने वाली निर्भरता

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

अब कोई भी एंडपॉइंट api_version पर निर्भर हो सकता है और भरोसा कर सकता है कि उसमें समर्थित मानों में से एक ही होगा।

from fastapi import FastAPI, Header, HTTPException, Depends

app = FastAPI()
SUPPORTED = {1, 2}

def api_version(x_api_version: int = Header(default=1)) -> int:
    if x_api_version not in SUPPORTED:
        raise HTTPException(
            status_code=406,
            detail=f"Unsupported API version {x_api_version}",
        )
    return x_api_version

@app.get("/users/{user_id}")
def get_user(user_id: int, version: int = Depends(api_version)):
    return {"id": user_id, "version": version}

रणनीति 3: मीडिया-प्रकार (सामग्री वार्ता) संस्करण-निर्धारण

यह सबसे REST-संगत, लेकिन सबसे कम सामान्य तरीका है। क्लाइंट विक्रेता मीडिया प्रकार का उपयोग करके Accept हेडर के माध्यम से किसी विशिष्ट प्रतिनिधित्व का अनुरोध करता है:

  • Accept: application/vnd.myapp.v1+json
  • Accept: application/vnd.myapp.v2+json

URL संसाधन की पहचान करता है; मीडिया प्रकार प्रतिनिधित्व/संस्करण की पहचान करता है। यही वास्तविक HTTP सामग्री वार्ता है।

  • लाभ: URL साफ़ और अर्थ की दृष्टि से शुद्ध रहते हैं; आप संसाधन का नहीं, उसके प्रतिनिधित्व का संस्करण बनाते हैं।
  • हानियाँ: विस्तृत, सामान्य क्लाइंट के लिए कठिन, उपकरणों का कमजोर समर्थन और टाइपिंग की गलती होना आसान।

विक्रेता मीडिया प्रकार को पार्स करना

मीडिया-प्रकार संस्करण-निर्धारण का मुख्य भाग विक्रेता स्ट्रिंग को संस्करण संख्या में पार्स करना है। यह शुद्ध Python है और किसी भी फ़्रेमवर्क से स्वतंत्र रूप से स्वयं इकाई-परीक्षण करना आसान है।

नीचे हम Accept मान से vN टोकन निकालते हैं और उसके अनुपस्थित या विकृत होने पर v1 को डिफ़ॉल्ट मानते हैं।

import re

PATTERN = re.compile(r"application/vnd\.myapp\.v(\d+)\+json")

def parse_version(accept: str, default: int = 1) -> int:
    match = PATTERN.search(accept or "")
    return int(match.group(1)) if match else default

# A few quick checks
print(parse_version("application/vnd.myapp.v2+json"))  # 2
print(parse_version("application/json"))                # 1 (default)
print(parse_version("application/vnd.myapp.v10+json")) # 10

मीडिया-प्रकार संस्करण-निर्धारण को FastAPI में जोड़ना

पार्सर तैयार होने पर उसे ऐसी निर्भरता में जोड़ें जो Accept हेडर पढ़ती हो। एंडपॉइंट साफ़ और संसाधन-केंद्रित रहते हैं, जबकि संस्करण सामग्री वार्ता से प्राप्त होता है।

import re
from fastapi import FastAPI, Header, Depends

app = FastAPI()
PATTERN = re.compile(r"application/vnd\.myapp\.v(\d+)\+json")

def accept_version(accept: str = Header(default="")) -> int:
    m = PATTERN.search(accept)
    return int(m.group(1)) if m else 1

@app.get("/users/{user_id}")
def get_user(user_id: int, version: int = Depends(accept_version)):
    if version >= 2:
        return {"id": user_id, "first_name": "Ada", "last_name": "Lovelace"}
    return {"id": user_id, "name": "Ada Lovelace"}

रूपांतरणकर्ताओं से संस्करणों को DRY रखना

प्रत्येक संस्करण के लिए व्यावसायिक तर्क की नकल जल्दी ही खराब हो जाती है। अधिक साफ़ तरीका यह है: डेटा की गणना किसी मानक आंतरिक संरचना में एक बार करें, फिर प्रत्येक संस्करण के लिए एक छोटा रूपांतरणकर्ता चलाएँ, जो उसे उस संस्करण द्वारा वादा किए गए अनुबंध के अनुरूप बनाए।

इससे पूरे हैंडलर की अलग-अलग प्रतियाँ बनाने के बजाय अनुबंध के अंतर छोटे और आसानी से परीक्षण किए जा सकने वाले फ़ंक्शनों में अलग रहते हैं।

def canonical_user(user_id: int) -> dict:
    return {"id": user_id, "first": "Ada", "last": "Lovelace"}

def to_v1(u: dict) -> dict:
    return {"id": u["id"], "name": f"{u['first']} {u['last']}"}

def to_v2(u: dict) -> dict:
    return {"id": u["id"], "first_name": u["first"], "last_name": u["last"]}

VERSIONS = {1: to_v1, 2: to_v2}

def render(user_id: int, version: int) -> dict:
    return VERSIONS[version](canonical_user(user_id))

print(render(42, 1))  # {'id': 42, 'name': 'Ada Lovelace'}
print(render(42, 2))  # {'id': 42, 'first_name': 'Ada', 'last_name': 'Lovelace'}

कैशिंग, Vary और दस्तावेज़ीकरण की समस्याएँ

हेडर और मीडिया-प्रकार संस्करण-निर्धारण में एक गंभीर समस्या होती है: कैश। यदि कोई प्रॉक्सी आपके संस्करण हेडर से अनजान होकर /users/42 को कैश करता है, तो v1 क्लाइंट को कैश किया हुआ v2 मुख्य भाग मिल सकता है।

  • हमेशा Vary: X-API-Version भेजें (या मीडिया-प्रकार संस्करण-निर्धारण के लिए Vary: Accept), ताकि कैश उसकी कुंजी में इसे शामिल करें।
  • URL संस्करण-निर्धारण इस समस्या से पूरी तरह बचता है, क्योंकि प्रत्येक संस्करण का URL अलग होता है।
  • स्वचालित रूप से बनाए गए /docs स्कीमा में हेडर/मीडिया-प्रकार संस्करणों को देखना भी कठिन होता है, क्योंकि सभी संस्करणों में पथ एक जैसा दिखता है।

रणनीति चुनना और व्यवस्थित रूप से अप्रचलित करना

बूटकैंप के लिए व्यावहारिक मार्गदर्शन:

  • URL संस्करण-निर्धारण सार्वजनिक REST API के लिए डिफ़ॉल्ट है: स्पष्ट, कैश-अनुकूल और नए उपयोगकर्ताओं के लिए अपनाना आसान।
  • हेडर संस्करण-निर्धारण उन आंतरिक सेवाओं के लिए उपयुक्त है जो स्थिर URL चाहती हैं और क्लाइंट तथा सर्वर दोनों पर नियंत्रण रखती हैं।
  • मीडिया-प्रकार संस्करण-निर्धारण हाइपरमीडिया/REST के सिद्धांतों पर ज़ोर देने वालों के लिए उपयुक्त है; व्यवहार में दुर्लभ है।

आप जो भी चुनें, अप्रचलन योजना जारी करें: समाप्ति की तारीख घोषित करें, पुराने संस्करणों पर Deprecation/Sunset हेडर लौटाएँ और क्लाइंट के स्थानांतरण के लिए उन्हें पर्याप्त समय तक चालू रखें।

from fastapi import APIRouter
from fastapi.responses import JSONResponse

v1 = APIRouter(prefix="/v1")

@v1.get("/users/{user_id}")
def get_user_v1(user_id: int):
    body = {"id": user_id, "name": "Ada Lovelace"}
    headers = {
        "Deprecation": "true",
        "Sunset": "Wed, 31 Dec 2025 23:59:59 GMT",
        "Link": '</v2/users>; rel="successor-version"',
    }
    return JSONResponse(content=body, headers=headers)

त्वरित जाँच: सही संस्करण-निर्धारण तरीका चुनना

तीनों रणनीतियों के बीच के लाभ-हानियों के बारे में आपने जो सीखा है, उसे लागू करें।

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

पुनरावलोकन: बिना टूट-फूट के संस्करण-निर्धारण

आपने FastAPI API के संस्करण निर्धारित करने के तीन तरीकों की तुलना की:

  • URL पथ (/v1/users): दिखाई देता है, कैश के लिए अनुकूल है और प्रत्येक संस्करण के APIRouter उपसर्गों के माध्यम से आसानी से रूट किया जा सकता है। सार्वजनिक API के लिए यह डिफ़ॉल्ट विकल्प है।
  • हेडर (X-API-Version): URL साफ़ रहते हैं और इसका समाधान एक निर्भरता के माध्यम से किया जाता है; कैश के लिए Vary याद रखें।
  • मीडिया-प्रकार (Accept: application/vnd.myapp.vN+json): शुद्ध REST तरीका, जिसे Accept हेडर से पार्स किया जाता है; कम प्रचलित और विस्तृत।

रूट को संसाधन के अनुसार समूहित रखें और उन्हें संस्करण राउटर के अंतर्गत माउंट करें। अनुबंध के अंतरों को प्रत्येक संस्करण के छोटे ट्रांसफ़ॉर्मर में अलग रखें और नए संस्करण के साथ हमेशा स्पष्ट बहिष्करण/समाप्ति योजना दें, ताकि क्लाइंट आसानी से अपग्रेड कर सकें।

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

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

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

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

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

क्या “URL, हेडर और मीडिया-प्रकार संस्करण निर्धारण” पाठ निःशुल्क है?

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

“URL, हेडर और मीडिया-प्रकार संस्करण निर्धारण” में मैं क्या सीखूँगा?

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

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

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

“URL, हेडर और मीडिया-प्रकार संस्करण निर्धारण” पाठ पूरा करने में कितना समय लगता है?

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

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

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

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

  1. URL, हेडर और मीडिया-प्रकार संस्करण निर्धारण
  2. बड़े पैमाने पर कर्सर बनाम ऑफसेट पृष्ठांकन
  3. गतिशील फ़िल्टरिंग और क्रमबद्धता पैरामीटर
  4. स्थिर प्रतिक्रिया आवरणों का डिज़ाइन
← FastAPI बैकएंड डेवलपमेंट बूटकैंप पर वापस जाएँ