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

गुप्त जानकारी प्रबंधन और कुंजी रोटेशन

वॉल्ट से गुप्त जानकारी लोड कीजिए, कुंजियाँ सुरक्षित रूप से बदलिए और लॉग या छवियों में क्रेडेंशियल लीक होने से बचिए।

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

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

Secrets को विशेष ढंग से सँभालना क्यों आवश्यक है

गुप्त मान ऐसा कोई भी मान है जो पहुँच प्रदान करता है: डेटाबेस पासवर्ड, API keys, signing keys, OAuth client secrets। FastAPI बैकएंड में ये लोगों की अपेक्षा से कहीं अधिक बार लीक हो जाते हैं।

  • स्रोत कोड में हार्डकोड करके, और हमेशा के लिए Git इतिहास में भेज देना
  • डिबगिंग के दौरान लॉग में प्रिंट कर देना
  • Docker image की परतों में शामिल कर देना
  • त्रुटि प्रतिक्रियाओं या /debug endpoints में वापस दिखा देना

इस पाठ का अनुशासन यह है: रनटाइम पर किसी विश्वसनीय स्रोत से गुप्त मान लोड करें, उन्हें कभी ऐसी जगह स्थायी रूप से न रखें जहाँ मनुष्य या images उन्हें पढ़ सकें, और उन्हें तय समय-सारणी के अनुसार बदलते रहें ताकि किसी लीक का प्रभाव सीमित रहे।

चरण 1 — Environment से Configuration लें

किसी भी production FastAPI app के लिए मूल नियम है कि गुप्त मान environment से लोड किए जाएँ, कोड से नहीं। Pydantic का BaseSettings environment variables पढ़ता है (और development के लिए वैकल्पिक स्थानीय .env भी) तथा startup पर उनका सत्यापन करता है।

यदि कोई आवश्यक गुप्त मान मौजूद न हो, तो app पहली request पर crash होने के बजाय boot के समय ही तुरंत विफल हो जाता है। ध्यान दें कि हम इसका प्रकार SecretStr रखते हैं, ताकि object कभी print हो जाए तो मान छिपा रहे।

from pydantic import SecretStr
from pydantic_settings import BaseSettings, SettingsConfigDict

class Settings(BaseSettings):
    model_config = SettingsConfigDict(env_file='.env', extra='ignore')

    database_url: SecretStr
    jwt_signing_key: SecretStr
    stripe_api_key: SecretStr

settings = Settings()
# Printing the model never reveals the raw value:
print(settings.jwt_signing_key)            # secret='**********'
print(settings.jwt_signing_key.get_secret_value()[:0])  # access only when needed

SecretStr आकस्मिक Logging रोकता है

SecretStr एक छोटा लेकिन शक्तिशाली सुरक्षा उपाय है। इसका __repr__ और __str__ '**********' लौटाते हैं, इसलिए वास्तविक मान कभी logs, tracebacks या serialized settings dump में दिखाई नहीं देता। वास्तविक string पढ़ने के लिए आपको .get_secret_value() call करना पड़ता है—यह एक स्पष्ट और आसानी से खोजी जा सकने वाली कार्रवाई है।

यह स्वतंत्र उदाहरण बिना किसी framework के masking का व्यवहार दिखाता है।

from pydantic import SecretStr

token = SecretStr('super-secret-token-123')

# Safe: these never reveal the value
print(f'token = {token}')      # token = **********
print(repr(token))            # SecretStr('**********')

# Explicit unwrap when you truly need the value
real = token.get_secret_value()
print('length of real secret:', len(real))

चरण 2 — किसी वास्तविक Vault से लोड करें

Environment variables ठीक हैं, लेकिन एक समर्पित secrets manager (HashiCorp Vault, AWS Secrets Manager, GCP Secret Manager, Azure Key Vault) auditing, access control और अंतर्निहित rotation प्रदान करता है।

हर जगह तरीका एक जैसा है: कम समय तक रहने वाली identity से authenticate करें, startup पर नाम के आधार पर गुप्त मान प्राप्त करें, और उसे memory में cache करें। नीचे boto3 के माध्यम से AWS Secrets Manager का उदाहरण है।

import json
import boto3
from functools import lru_cache

@lru_cache(maxsize=None)
def load_secret(secret_name: str) -> dict:
    client = boto3.client('secretsmanager', region_name='eu-central-1')
    resp = client.get_secret_value(SecretId=secret_name)
    return json.loads(resp['SecretString'])

# At app startup:
# secrets = load_secret('prod/fastapi/app')
# db_url = secrets['database_url']
# Credentials come from the instance/task IAM role, NOT from env files.

Vault Credentials को स्वयं कभी Hardcode न करें

एक सामान्य गलती है vault की अपनी access key को code या .env में रखना—आपने समस्या हल नहीं की, केवल उसे दूसरी जगह स्थानांतरित किया है। इसके बजाय workload identity का उपयोग करें:

  • AWS: ECS task / EC2 instance / Lambda से जुड़ी IAM role
  • GCP: workload से संबद्ध service account (Workload Identity)
  • Kubernetes: projected service-account token + IRSA / Workload Identity Federation
  • Vault: AppRole या Kubernetes auth, जिसे कम समय तक रहने वाले token के बदले बदला जाता है

स्वर्णिम नियम यह है: आपके container को केवल एक identity चाहिए, और platform उसे उपलब्ध कराता है—app के साथ कोई लंबे समय तक रहने वाली key नहीं भेजी जाती।

चरण 3 — FastAPI में Secrets को सुव्यवस्थित ढंग से Inject करें

FastAPI के भीतर settings को cached dependency के माध्यम से उपलब्ध कराएँ। @lru_cache get_settings() को singleton बनाता है, इसलिए vault से केवल एक बार संपर्क होता है और वही object दोबारा उपयोग किया जाता है। Routes globals तक सीधे पहुँचने के बजाय settings पर निर्भर करते हैं, जिससे tests में उन्हें आसानी से override किया जा सकता है।

यह framework code है, इसलिए इसे साधारण judge पर चलाया नहीं जा सकता।

from functools import lru_cache
from fastapi import Depends, FastAPI

app = FastAPI()

@lru_cache
def get_settings() -> Settings:
    return Settings()  # loads/validates secrets once

@app.get('/health')
def health(settings: Settings = Depends(get_settings)):
    # Use settings.database_url.get_secret_value() internally;
    # never return the secret in the response body.
    return {'status': 'ok'}

चरण 4 — बिना Downtime के Keys Rotate करें

Rotation का अर्थ है तय समय-सारणी के अनुसार (या संभावित leak के बाद) किसी secret को नए मान से बदलना। कठिनाई इसे requests को छोड़े बिना करने में है। उपाय यह है कि overlap window के दौरान दो मान्य keys एक साथ स्वीकार की जाएँ:

  • नए tokens पर current key से sign करें
  • current OR previous key के विरुद्ध verify करें
  • सभी पुराने tokens expire होने के बाद previous key को retire कर दें

यह dual-key window JWT signing keys, HMAC webhook secrets और API keys—सभी पर लागू होती है।

एकाधिक Keys के विरुद्ध JWTs Verify करना

यहाँ framework से स्वतंत्र और चलाने योग्य बने रहने के लिए सरल HMAC signature का उपयोग करते हुए verify-old-or-new तरीका दिया गया है। नए tokens पर current key से sign किया जाता है; overlap window के दौरान verification current या previous key—दोनों में से किसी को स्वीकार करता है। यही विचार kid header वाली python-jose JWT keys पर सीधे लागू होता है।

import hashlib
import hmac

CURRENT_KEY = b'key-v2-new'
PREVIOUS_KEY = b'key-v1-old'

def sign(payload: str, key: bytes) -> str:
    return hmac.new(key, payload.encode(), hashlib.sha256).hexdigest()

def verify(payload: str, sig: str) -> bool:
    for key in (CURRENT_KEY, PREVIOUS_KEY):
        if hmac.compare_digest(sign(payload, key), sig):
            return True
    return False

old_token_sig = sign('user=42', PREVIOUS_KEY)
new_token_sig = sign('user=42', CURRENT_KEY)
print('old still valid:', verify('user=42', old_token_sig))
print('new valid:', verify('user=42', new_token_sig))
print('tampered:', verify('user=99', new_token_sig))

Key IDs Rotation को Auditable बनाते हैं

हर key को एक key id (kid) से tag करें, ताकि token यह बता सके कि उस पर किस key से sign किया गया है। Verification सभी keys को आज़माने के बजाय matching key खोजता है, और leak होते ही आप किसी एक kid को revoke कर सकते हैं। JWTs header में kid रखते हैं; यह स्वतंत्र उदाहरण lookup logic दिखाता है।

import hashlib
import hmac

KEYS = {
    'k2': b'current-secret',
    'k1': b'previous-secret',
}
ACTIVE_KID = 'k2'

def issue(payload: str) -> dict:
    key = KEYS[ACTIVE_KID]
    sig = hmac.new(key, payload.encode(), hashlib.sha256).hexdigest()
    return {'kid': ACTIVE_KID, 'payload': payload, 'sig': sig}

def check(token: dict) -> bool:
    key = KEYS.get(token['kid'])
    if key is None:
        return False  # revoked / unknown kid
    expected = hmac.new(key, token['payload'].encode(), hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, token['sig'])

t = issue('order=7')
print('issued with kid:', t['kid'])
print('valid:', check(t))
t['kid'] = 'k0'  # pretend signed by a revoked key
print('after revoke:', check(t))

चरण 5 — Secrets को Logs से बाहर रखें

SecretStr के बावजूद custom log lines, request dumps या exception messages के माध्यम से leak हो सकता है। सुरक्षा की अतिरिक्त परत के रूप में ऐसा logging filter लगाएँ जो records emit होने से पहले ज्ञात patterns (tokens, bearer headers, connection strings) को redact कर दे।

यह filter स्वतंत्र और चलाने योग्य है।

import logging
import re

SECRET_RE = re.compile(r'(Bearer\s+)[A-Za-z0-9._-]+|(password=)[^\s&]+')

class RedactFilter(logging.Filter):
    def filter(self, record: logging.LogRecord) -> bool:
        msg = record.getMessage()
        record.msg = SECRET_RE.sub(r'\1\2[REDACTED]', msg)
        record.args = ()
        return True

logger = logging.getLogger('app')
logger.addHandler(logging.StreamHandler())
logger.addFilter(RedactFilter())
logger.setLevel(logging.INFO)

logger.info('calling api with Authorization: Bearer abc123tok')
logger.info('db dsn password=hunter2 host=db')

चरण 6 — Secrets को Images में कभी Bake न करें

Docker images परतों में बनी और भेजी जाती हैं; किसी layer में मौजूद हर चीज़ docker history से वापस प्राप्त की जा सकती है, भले ही बाद की layer उसे हटा दे। इसलिए secrets को build में कभी शामिल नहीं किया जाना चाहिए।

  • Build के समय COPY .env न करें और secrets को ARG/ENV के माध्यम से न भेजें
  • runtime पर orchestrator के माध्यम से inject करें (secret store से env, mounted file या sidecar)
  • Build-time की आवश्यकताओं (private package install) के लिए BuildKit --mount=type=secret का उपयोग करें, जो किसी layer में स्थायी रूप से नहीं रहता
  • .env और key files को .dockerignore तथा .gitignore में जोड़ें

docker history --no-trunc <image> से जाँच करें—किसी भी layer में कोई secret दिखाई नहीं देना चाहिए।

त्वरित जाँच

आपको live FastAPI API की JWT signing key rotate करनी है, लेकिन users के पास अभी मौजूद tokens को invalid नहीं करना है। कौन-सा तरीका zero-downtime rotation प्राप्त करता है?

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

पुनरावलोकन — Secrets Management और Key Rotation

अब आपके पास backend secrets के लिए पूरी सुरक्षा-श्रृंखला है:

  • Load secrets को runtime पर environment या vault से लें; BaseSettings से startup पर उनका सत्यापन करें और values को SecretStr में लपेटें
  • Authenticate vault में workload identity (IAM role / service account) से authenticate करें, कभी hardcoded key से नहीं
  • Inject cached FastAPI dependency के माध्यम से inject करें, और responses में secrets कभी वापस न दिखाएँ
  • Rotate dual-key overlap window और kid के साथ rotate करें, ताकि पुराने tokens valid रहें और किसी भी key को स्वतंत्र रूप से revoke किया जा सके
  • Redact logging filter और SecretStr masking के माध्यम से logs में secrets को redact करें
  • Exclude secrets को Docker layers से बाहर रखें; runtime पर inject करें और docker history से जाँच करें

Secrets कहाँ रहते हैं, इसे न्यूनतम करें, उन्हें कम समय तक जीवित रखें, और हर access को स्पष्ट तथा auditable बनाएँ।

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

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

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

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

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

क्या “गुप्त जानकारी प्रबंधन और कुंजी रोटेशन” पाठ निःशुल्क है?

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

“गुप्त जानकारी प्रबंधन और कुंजी रोटेशन” में मैं क्या सीखूँगा?

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

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

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

“गुप्त जानकारी प्रबंधन और कुंजी रोटेशन” पाठ पूरा करने में कितना समय लगता है?

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

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

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

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

  1. OWASP API सुरक्षा के शीर्ष 10 जोखिमों का शमन
  2. दर-सीमांकन और बॉट दुरुपयोग सुरक्षा
  3. गुप्त जानकारी प्रबंधन और कुंजी रोटेशन
  4. CORS, CSP और सुरक्षित हेडर नीतियाँ
← FastAPI बैकएंड डेवलपमेंट बूटकैंप पर वापस जाएँ