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

OAuth2 पासवर्ड प्रवाह और टोकन जारी करना

OAuth2PasswordBearer स्कीम लागू कीजिए, passlib से पासवर्ड का हैश बनाइए और लॉगिन पर हस्ताक्षरित एक्सेस टोकन जारी कीजिए।

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

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

OAuth2 पासवर्ड प्रवाह को सरल भाषा में समझना

OAuth2 पासवर्ड प्रवाह (जिसे Resource Owner Password Credentials अनुदान भी कहा जाता है) अपने ही क्लाइंट को प्रमाणित करने का सबसे सरल तरीका है: उपयोगकर्ता अपना उपयोगकर्ता नाम और पासवर्ड सीधे आपके API को भेजता है और API एक हस्ताक्षरित अभिगम टोकन लौटाता है।

क्लाइंट एक बार /token एंडपॉइंट पर प्रमाण-पत्र भेजता है।
सर्वर डेटाबेस के विरुद्ध उनकी जाँच करता है।
सफल होने पर यह कम अवधि वाला JWT अभिगम टोकन लौटाता है।
बाद के प्रत्येक अनुरोध में वह टोकन Authorization: Bearer <token> हेडर में भेजा जाता है।

FastAPI इसके लिए तैयार घटक देता है: OAuth2PasswordBearer और OAuth2PasswordRequestForm।

OAuth2PasswordBearer स्कीम घोषित करना

OAuth2PasswordBearer FastAPI की एक निर्भरता है, जो Authorization हेडर से bearer टोकन निकालना जानती है। इसका एक इंस्टेंस बनाएँ और इसके tokenUrl को उस लॉगिन एंडपॉइंट पर इंगित करें जो टोकन जारी करता है।

tokenUrl एक सापेक्ष पथ है — यह दस्तावेज़ UI को बताता है कि क्लाइंट को टोकन कहाँ माँगना चाहिए।
स्कीम को निर्भरता के रूप में इस्तेमाल करने से एंडपॉइंट के लिए टोकन आवश्यक हो जाता है; अनुपस्थित या गलत हेडर पर अपने-आप 401 लौटता है।

from fastapi import Depends, FastAPI
from fastapi.security import OAuth2PasswordBearer

app = FastAPI()

# 'token' matches the path of our login route below
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")


@app.get("/users/me")
async def read_me(token: str = Depends(oauth2_scheme)):
    # FastAPI extracts the raw bearer token string for us
    return {"token": token}

passlib से पासवर्ड का हैश बनाना

आपको कच्चे पासवर्ड कभी भी संग्रहीत नहीं करने चाहिए। उनका मज़बूत, नमकयुक्त एल्गोरिदम से हैश बनाएँ। passlib लाइब्रेरी साफ़-सुथरे CryptContext API के पीछे bcrypt उपलब्ध कराती है।

hash() ऐसा नमकयुक्त डाइजेस्ट बनाता है जिसे आप डेटाबेस में संग्रहीत करते हैं।
verify() सादे-पाठ वाले प्रयास की तुलना संग्रहीत हैश से लगभग समान समय में करता है।
bcrypt जानबूझकर धीमा है, जिससे बलपूर्वक अनुमान लगाने वाले हमले कठिन हो जाते हैं।

from passlib.context import CryptContext

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")


def hash_password(plain: str) -> str:
    return pwd_context.hash(plain)


def verify_password(plain: str, hashed: str) -> bool:
    return pwd_context.verify(plain, hashed)


stored = hash_password("s3cret")
print("stored looks like:", stored[:7], "...")
print("correct ->", verify_password("s3cret", stored))
print("wrong   ->", verify_password("nope", stored))

उपयोगकर्ताओं का मॉडल और एक छोटी नकली डेटाबेस बनाना

टोकन जारी करने से पहले हमें उपयोगकर्ताओं को खोजने के लिए किसी स्थान की आवश्यकता होती है। उत्पादन में यह आपका वास्तविक डेटाबेस होगा; सीखने के लिए हम मेमोरी में मौजूद डिक्शनरी का उपयोग करते हैं। ध्यान दें कि संग्रहीत फ़ील्ड hashed_password है, सादा-पाठ पासवर्ड कभी नहीं।

Pydantic मॉडल उपयोगकर्ता के लिए एक निश्चित प्रकार वाला ढाँचा देता है।
get_user() सहायक फ़ंक्शन खोज को एक ही स्थान पर केंद्रित करता है।

from pydantic import BaseModel


class UserInDB(BaseModel):
    username: str
    hashed_password: str
    disabled: bool = False


fake_users_db = {
    "alice": UserInDB(
        username="alice",
        hashed_password="$2b$12$exampleexampleexamplehashvalue",
    )
}


def get_user(username: str):
    return fake_users_db.get(username)

प्रमाण-पत्रों का प्रमाणीकरण

प्रमाणीकरण सभी हिस्सों को जोड़ता है: पहले उपयोगकर्ता खोजें, फिर दिए गए पासवर्ड की संग्रहीत हैश से जाँच करें। सफल होने पर उपयोगकर्ता लौटाएँ, अन्यथा गलत मान लौटाएँ।

पहले उपयोगकर्ता खोजें; न मिलने पर विफल हो जाएँ।
फिर verify_password चलाएँ — हैश बनाने से पहले प्रक्रिया को छोटा न करें, ताकि समय लगभग समान रहे।
उत्तर कैसे देना है, यह कॉल करने वाला तय करता है (आमतौर पर 401)।

def authenticate_user(db, username: str, password: str):
    user = db.get(username)
    if not user:
        return None
    if not verify_password(password, user.hashed_password):
        return None
    return user

JWT वास्तव में क्या है

JSON Web Token तीन base64url खंडों से बना होता है, जिन्हें बिंदुओं से जोड़ा जाता है: header.payload.signature।

हेडर एल्गोरिदम का नाम बताता है, जैसे HS256।
पेलोड में दावे होते हैं, जैसे sub (विषय) और exp (समाप्ति)।
हस्ताक्षर आपकी गुप्त कुंजी का उपयोग करके हेडर और पेलोड का HMAC होता है।

JWT हस्ताक्षरित होते हैं, एन्क्रिप्टेड नहीं — कोई भी पेलोड पढ़ सकता है, लेकिन गुप्त कुंजी के बिना कोई इसे जाली नहीं बना सकता। पेलोड में पासवर्ड या संवेदनशील डेटा कभी न रखें।

हस्ताक्षरित अभिगम टोकन एन्कोड करना

हम python-jose लाइब्रेरी (या PyJWT) से टोकन पर हस्ताक्षर करते हैं। टोकन की समय-सीमा समाप्त करने के लिए हमेशा exp दावा शामिल करें। sub दावे में उपयोगकर्ता नाम रखें — इससे पता चलता है कि टोकन किसका है।

SECRET_KEY लंबी और यादृच्छिक होनी चाहिए तथा स्रोत कोड नियंत्रण से बाहर रखी जानी चाहिए।
अभिगम टोकन के लिए कम अवधि निर्धारित करें (जैसे 15–30 मिनट)।

from datetime import datetime, timedelta, timezone
from jose import jwt

SECRET_KEY = "replace-with-a-long-random-secret"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30


def create_access_token(data: dict) -> str:
    to_encode = data.copy()
    expire = datetime.now(timezone.utc) + timedelta(
        minutes=ACCESS_TOKEN_EXPIRE_MINUTES
    )
    to_encode.update({"exp": expire})
    return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)


token = create_access_token({"sub": "alice"})
print("issued token segments:", token.count(".") + 1)

टोकन उत्तर का ढाँचा

OAuth2 विनिर्देश यह तय करता है कि आपका /token एंडपॉइंट कौन-सा JSON लौटाएगा। कम-से-कम इसमें access_token और token_type शामिल होने चाहिए, जहाँ प्रकार शाब्दिक स्ट्रिंग "bearer" हो।

क्लाइंट token_type पढ़कर जानता है कि प्रमाण-पत्र वापस कैसे भेजना है।
Pydantic का Token मॉडल उत्तर का दस्तावेज़ीकरण और सत्यापन करता है।

from pydantic import BaseModel


class Token(BaseModel):
    access_token: str
    token_type: str


example = Token(access_token="eyJhbGci...", token_type="bearer")
print(example.model_dump())

/token लॉगिन एंडपॉइंट जोड़ना

लॉगिन मार्ग OAuth2PasswordRequestForm पर निर्भर करता है, जो फ़ॉर्म-एन्कोडेड username और password फ़ील्ड पढ़ता है (JSON नहीं) — ठीक वही जो OAuth2 पासवर्ड प्रवाह के लिए आवश्यक है। सफल होने पर यह Token उत्तर लौटाता है।

विफल प्रमाणीकरण WWW-Authenticate: Bearer हेडर के साथ 401 उत्पन्न करता है।
sub दावा उपयोगकर्ता नाम को टोकन में आगे ले जाता है।

from fastapi import Depends, FastAPI, HTTPException, status
from fastapi.security import OAuth2PasswordRequestForm

app = FastAPI()


@app.post("/token", response_model=Token)
async def login(form: OAuth2PasswordRequestForm = Depends()):
    user = authenticate_user(fake_users_db, form.username, form.password)
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Incorrect username or password",
            headers={"WWW-Authenticate": "Bearer"},
        )
    access_token = create_access_token({"sub": user.username})
    return Token(access_token=access_token, token_type="bearer")

वर्तमान उपयोगकर्ता खोजने के लिए टोकन डिकोड करना

सुरक्षित मार्ग कच्चा टोकन प्राप्त करने के लिए oauth2_scheme पर निर्भर करता है और फिर उसे डिकोड करता है। यदि हस्ताक्षर अमान्य हो या टोकन की समय-सीमा समाप्त हो गई हो, तो jwt.decode JWTError उत्पन्न करता है और हम 401 लौटाते हैं।

sub दावे से उपयोगकर्ता नाम पढ़ें।
यह पुष्टि करने के लिए उपयोगकर्ता को डेटाबेस से फिर लोड करें कि वह अभी भी मौजूद और सक्रिय है।

from fastapi import Depends, HTTPException, status
from jose import JWTError, jwt


async def get_current_user(token: str = Depends(oauth2_scheme)):
    credentials_exc = HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="Could not validate credentials",
        headers={"WWW-Authenticate": "Bearer"},
    )
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        username = payload.get("sub")
        if username is None:
            raise credentials_exc
    except JWTError:
        raise credentials_exc
    user = get_user(username)
    if user is None:
        raise credentials_exc
    return user

महत्वपूर्ण सुरक्षा अभ्यास

यांत्रिकी काम करती है, लेकिन उत्पादन-स्तर की सुरक्षा उन्हें सुरक्षित बनाती है:

गुप्त कुंजी: SECRET_KEY को पर्यावरण चर से लोड करें; लीक होने पर इसे बदल दें।
केवल HTTPS: हेडर में मौजूद टोकन नेटवर्क पर सादे-पाठ में होते हैं — TLS अनिवार्य है।
कम अवधि: अभिगम टोकन की अवधि कम रखें और उन्हें अधिक अवधि वाले रिफ्रेश टोकन के साथ इस्तेमाल करें।
एल्गोरिदम निश्चित करें: alg: none हमले को रोकने के लिए jwt.decode में स्पष्ट algorithms=["HS256"] सूची दें।
सामान्य त्रुटियाँ: "उपयोगकर्ता नाम या पासवर्ड गलत है" कहें; यह कभी न बताएँ कि इनमें से कौन-सा गलत था।

त्वरित जाँच: /token एंडपॉइंट

अब यह जाँचने का समय है कि FastAPI का /token लॉगिन मार्ग प्रमाण-पत्रों को कैसे उपयोग करता है।

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

पुनरावलोकन: पासवर्ड से bearer टोकन तक

आपने FastAPI में OAuth2 पासवर्ड प्रवाह को पूरी तरह लागू किया:

OAuth2PasswordBearer bearer स्कीम घोषित करता है और Authorization हेडर से टोकन निकालता है।
passlib + bcrypt पासवर्ड का हैश बनाते और उसकी जाँच करते हैं, इसलिए सादा-पाठ कभी संग्रहीत नहीं होता।
authenticate_user उपयोगकर्ता खोजता है और हैश की जाँच करता है; विफल होने पर 401 लौटाता है।
/token मार्ग OAuth2PasswordRequestForm के माध्यम से फ़ॉर्म प्रमाण-पत्र पढ़ता है और sub दावे तथा exp समाप्ति वाले हस्ताक्षरित JWT को जारी करता है।
get_current_user टोकन को डिकोड और सत्यापित करता है तथा जालसाज़ी रोकने के लिए एल्गोरिदम निश्चित करता है।

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

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

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

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

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

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

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

क्या “OAuth2 पासवर्ड प्रवाह और टोकन जारी करना” पाठ निःशुल्क है?

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

“OAuth2 पासवर्ड प्रवाह और टोकन जारी करना” में मैं क्या सीखूँगा?

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

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

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

“OAuth2 पासवर्ड प्रवाह और टोकन जारी करना” पाठ पूरा करने में कितना समय लगता है?

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

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

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

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

OAuth2 पासवर्ड प्रवाह और टोकन जारी करना
python-jose के साथ JWT पर हस्ताक्षर और सत्यापन
रिफ्रेश टोकन और टोकन रोटेशन
स्कोप-आधारित प्राधिकरण और भूमिका गार्ड

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