FastAPI ਐਪਲੀਕੇਸ਼ਨਾਂ pydantic-settings (BaseSettings) ਨਾਲ ਕੌਨਫਿਗਰੇਸ਼ਨ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦੀਆਂ ਹਨ — ਇਹ ਇੱਕ ਕਲਾਸ ਹੈ ਜੋ environment variables (ਅਤੇ .env ਫਾਈਲਾਂ) ਤੋਂ ਕੌਨਫਿਗ ਪੜ੍ਹਦੀ ਹੈ ਨਾਲ, ਰਾਜ਼ਾਂ ਨੂੰ ਕੋਡ ਤੋਂ ਬਾਹਰ ਰੱਖਦੀ ਹੈ ਅਤੇ ਸ਼ੁਰੂਆਤ ਵਿੱਚ ਕੌਨਫਿਗ ਨਿਸ਼ਚਿਤ ਕਰਦੀ ਹੈ।
from pydantic_settings import BaseSettings
class Settings(BaseSettings):
app_name: str = "My API"
database_url: str # required — must be provided
secret_key: str # required (a secret)
debug: bool = False
max_connections: int = 10
class Config:
env_file = ".env" # also read from a .env file
settings = Settings() # reads & VALIDATES env vars at startup
BaseSettings ਆਪਣੇ ਆਪ ਹਰ ਫੀਲਡ ਨੂੰ ਮੇਲ ਖਾਂਦੇ environment variable ਤੋਂ ਪੜ੍ਹਦਾ ਹੈ (ਜਿਵੇਂ DATABASE_URL), types ਨੂੰ ਬਦਲਦਾ ਹੈ ("true" → bool, "10" → int), ਅਤੇ validate ਕਰਦਾ ਹੈ — ਇੱਕ ਗਾਇਬ ਲੋੜੀਂਦੀ ਮੂੰਹ ਜਾਂ ਗਲਤ type ਤੁਰੰਤ ਫੇਲ ਹੋ ਜਾਂਦਾ ਹੈ ਸ਼ੁਰੂਆਤ ਵਿੱਚ ਸਪਸ਼ਟ error ਦੇ ਨਾਲ (fail-fast)।
from functools import lru_cache
from fastapi import Depends
@lru_cache # create the Settings once (cached)
def get_settings():
return Settings()
@app.get("/info")
def info(settings: Settings = Depends(get_settings)):
return {"app": settings.app_name, "debug": settings.debug}
ਸੈਟਿੰਗਜ਼ ਨੂੰ ਇੱਕ cached dependency ਦੇ ਜ਼ਰੀਏ inject ਕਰਨਾ ਉਹਨਾਂ ਨੂੰ testable ਬਣਾਉਂਦਾ ਹੈ (tests ਵਿੱਚ override ਕਰੋ) ਅਤੇ ਇੱਕ ਸਿੰਗਲ ਮਾਮਲਾ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ।
# .env — local config, GITIGNORED (never commit secrets)
DATABASE_URL=postgresql://localhost/mydb
SECRET_KEY=dev-secret
DEBUG=true
✓ Keep secrets in env vars / .env (gitignored); commit a .env.example documenting keys
✓ In production, inject config via the platform's environment / secret manager
✓ Validation at startup catches misconfiguration immediately (not deep in a request)
ਸਹੀ ਸੈਟਿੰਗਜ਼ ਪ੍ਰਬੰਧਨ ਇੱਕ operational necessity (ਐਪਸ ਨੂੰ dev/staging/production ਵਿੱਚ ਵੱਖ ਵੱਖ ਕੌਨਫਿਗ ਦੀ ਜ਼ਰੂਰਤ ਹੈ) ਅਤੇ ਇੱਕ security requirement (database URLs ਅਤੇ keys ਵਰਗੇ ਰਾਜ਼ ਕਦੇ ਵੀ source control ਵਿੱਚ hardcoded ਨਹੀਂ ਹੋਣੇ ਚਾਹੀਦੇ — ਇੱਕ ਆਮ, ਗੰਭੀਰ ਭੰਗ) ਦੋਵੇਂ ਹਨ।
Pydantic ਦਾ BaseSettings idiomatic FastAPI ਹੱਲ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਰੋਜ਼ਮਰਾਹ ਗਿਆਨ ਹੈ।
ਇਸ ਦੇ ਮੁੱਖ ਫਾਇਦੇ: environment variables ਤੋਂ ਕੌਨਫਿਗ ਪੜ੍ਹਨਾ (ਰਾਜ਼ਾਂ ਨੂੰ ਕੋਡ ਤੋਂ ਬਾਹਰ ਰੱਖਣਾ, the twelve-factor ਪਹੁੰਚ) automatic type conversion ਅਤੇ validation ਦੇ ਨਾਲ — ਤਾਂ ਕਿ misconfiguration ਸ਼ੁਰੂਆਤ ਵਿੱਚ fail ਹੋਵੇ ਇੱਕ ਸਪਸ਼ਟ error ਦੇ ਨਾਲ ਇੱਕ ਉਲਝਨ ਵਾਲੀ runtime failure ਦੀ ਥਾਂ।
Dependency injection ਦੇ ਨਾਲ (ਸੈਟਿੰਗਜ਼ ਨੂੰ testable ਅਤੇ singleton ਬਣਾਉਂਦਾ ਹੈ) ਅਤੇ gitignored .env ਫਾਈਲਾਂ ਲਈ local development ਦੇ ਅਭਿਆਸ ਦੇ ਨਾਲ, ਇਹ ਤੁਹਾਨੂੰ ਸੁਰੱਖਿਅਤ, validated, environment-appropriate ਕੌਨਫਿਗਰੇਸ਼ਨ ਦਿੰਦਾ ਹੈ।
Jogging ਪ੍ਰਬੰਧਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ, ਸੈਟਿੰਗਜ਼ ਨੂੰ DI ਦੇ ਜ਼ਰੀਏ ਵਰਤਣਾ, ਅਤੇ ਰਾਜ਼ਾਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਤਰੀਕੇ ਨਾਲ ਹੈਂਡਲ ਕਰਨਾ production-ready FastAPI ਐਪਲੀਕੇਸ਼ਨਾਂ ਬਣਾਉਣ ਦੇ ਲਈ ਬੁਨਿਆਦੀ ਹੈ।