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), మరియు validates — లేని అవసరమైన విలువ లేదా తప్పు 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 చేయండి) చేస్తుంది మరియు ఒక సింగిల్ instance ను నిశ్చితం చేస్తుంది.
# .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 (apps కు dev/staging/production లో విభిన్న config అవసరం) మరియు security requirement (database URLs మరియు keys లాంటి secrets ఎప్పటికీ source control లో hardcoded ఉండకూడదు — సాధారణమైన, సీరియస్ breach).
Pydantic యొక్క BaseSettings idiomatic FastAPI solution ను ప్రదానం చేస్తుంది, మరియు దీనిని అర్థం చేసుకోవడం ముఖ్యమైన రోజువారీ జ్ఞానం.
ఇది యొక్క కీ advantages: environment variables నుండి config చదువుకోవడం (secretsలను కోడ్ నుండి దూరంగా ఉంచుతుంది, twelve-factor approach) automatic type conversion మరియు validation సహితం — కాబట్టి misconfiguration స్టార్టআప్ సమయానికి స్పష్టమైన error సందేశ తో fail fast చేస్తుంది, గందర్లుగా రన్టైమ్ failure కు బదులుగా.
Dependency injection (సెట్టింగ్లను testable మరియు singleton చేస్తుంది) మరియు local development కు gitignored .env ఫైల్ల ఆచరణతో కలిపితే, ఇది safe, validated, environment-appropriate configuration ను ఇస్తుంది.
సెట్టింగ్లను నిర్వచించడం, DI ద్వారా వాటిని ఉపయోగించడం, మరియు securely secretsలను నిర్వహించడం ఎలాగో తెలుసుకోవడం production-ready FastAPI applicationsలను నిర్మించడానికి ఫండమెంటల్.