FastAPI లో CORS ని ఎలా కాన్ఫిగర్ చేస్తారు?

Question

Accepted Answer

**CORS** (Cross-Origin Resource Sharing) అనేది ఒక బ్రౌజర్ సెక్యూరిటీ మెకానిజం, ఇది ఒక **origin** నుండి వచ్చిన వెబ్ పేజీ మీ API ను వేరేలాంటి origin న నుండి కాల్ చేయగలిగిందో లేదో నియంత్రిస్తుంది. FastAPI దీనిని బిల్ట్-ఇన్ **`CORSMiddleware`** తో కాన్ఫిగర్ చేస్తుంది. వేరేలాంటి డొమైన్/పోర్ట్ నుండి ఫ్రంటెండ్ మీ API ను కాల్ చేసినప్పుడు CORS ని ఎదుర్కుంటారు.

## CORS పరిష్కరించే సమస్య

```text
A React app at http://localhost:3000 calling an API at http://localhost:8000 is
CROSS-ORIGIN (different port). The BROWSER blocks the response unless the API
sends CORS headers permitting that origin.
(origin = scheme + host + port)
```

## CORSMiddleware ని కాన్ఫిగర్ చేయడం

```python
from fastapi.middleware.cors import CORSMiddleware

app.add_middleware(
    CORSMiddleware,
    allow_origins=["https://app.example.com", "http://localhost:3000"],  # ALLOWLIST of origins
    allow_credentials=True,         # allow cookies/auth (requires specific origins, not "*")
    allow_methods=["*"],             # or ["GET", "POST", ...]
    allow_headers=["*"],
)
```

మిడిల్‌వేర్ అవసరమైన CORS రెస్పాన్స్ హెడర్‌లను జోడిస్తుంది, ఇది బ్రౌజర్‌కు ఏ origins, methods, మరియు headers ను అనుమతించాలో చెప్పిస్తుంది. బ్రౌజర్ ఈ నియమాలను అర్థం చేసుకుంటుంది.

## సెక్యూరిటీ: origins ని పరిమితం చేయండి ("*" ఉపయోగించవద్దు)

```python
# ❌ allowing all origins — convenient but insecure for credentialed/private APIs
allow_origins=["*"]
# ✅ restrict to your known frontend origins (an allowlist)
allow_origins=["https://app.example.com"]
# NOTE: allow_credentials=True is INCOMPATIBLE with allow_origins=["*"]
```

ప్రొడక్షన్ కోసం, **`allow_origins` ను "*" కంటే allowlist కు పరిమితం చేయండి**. అలాగే, credentials (cookies/auth) ను అనుమతించడానికి నిర్దిష్ట origins అవసరం — wildcard credentials తో అనుమతించబడదు.

## ఒక ముఖ్య తప్పుగణన

```text
CORS is enforced by the BROWSER, not the server. It does NOT protect your API from
non-browser clients (curl, Postman, other servers) — those ignore CORS entirely.
CORS only governs what browser JavaScript from other origins may do.
```

## ఇది ఎందుకు ముఖ్యమైనది

CORS వెబ్ డెవలప్‌మెంట్‌లో చాలా సాధారణ సమస్యలలో ఒకటి — దాదాపు ప్రతిটి frontend-to-API సెటప్ దీనిని ఎదుర్కుంటుంది (ముఖ్యంగా వేరేలాంటి పోర్ట్‌లతో లోకల్ డెవలప్‌మెంట్‌లో, మరియు వేరు ఫ్రంటెండ్ డొమైన్‌తో ప్రొడక్షన్‌లో), కాబట్టి FastAPI యొక్క `CORSMiddleware` తో దీనిని ఎలా కాన్ఫిగర్ చేయాలో తెలుసుకోవడం ఆచరణాత్మక, తరచుగా అవసరమైన జ్ఞానం.

ఇది ఎందుకు ఉనికిలో ఉంది (బ్రౌజర్ same-origin సెక్యూరిటీ), సర్వర్ రెస్పాన్స్ హెడర్‌ల ద్వారా ఎలా opt in చేస్తుందో, మరియు దీనిని ఎలా కాన్ఫిగర్ చేయాలో (allowed origins, methods, headers, credentials) అర్థం చేసుకోవడం అవసరం, తద్వారా frontends ను FastAPI APIs లకు కనెక్ట్ చేయవచ్చు, అభ్యర్థనలు నిరోధించబడక పోవచ్చు.

సమానంగా ముఖ్యమైనది దీనిని **సురక్షితంగా** కాన్ఫిగర్ చేయడం — `allow_origins` ను "*" (permissive) కంటే నిర్దిష్ట allowlist కు పరిమితం చేయడం (మరియు credentials wildcard తో సంబంధం లేనిదని అర్థం చేసుకోవడం) — మరియు ఆ కీలక తప్పుగణన గ్రహించడం, **CORS ఒక బ్రౌజర్ మెకానిజం, API ఆధికారికత కాదు** (ఇది non-browser క్లయింట్‌ల నుండి రక్షణ ఇవ్వదు).

CORS ను సరిగ్గా మరియు సురక్షితంగా సెటప్ చేయడం ఎలాగో తెలుసుకోవడం ఏ FastAPI API కు webfront తో వినియోగించబడుతుందో తెలిసిన ప్రతిరోజు ముఖ్యమైన జ్ఞానం.