FastAPI માં CORS કેવી રીતે કૉન્ફિગર કરશો?

Question

Accepted Answer

**CORS** (Cross-Origin Resource Sharing) એક બ્રાઉજર સુરક્ષા પદ્ધતિ છે જે નિયંત્રણ કરે છે કે એક **origin** થી વેબ પેજ તમારા API ને અલગ origin પર કૉલ કરી શકે છે કે નહીં. FastAPI તેને બિલ્ટ-ઇન **`CORSMiddleware`** વડે કૉન્ફિગર કરે છે. જ્યારે અલગ ડોમેન/પોર્ટ પરનો frontend તમારા 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 સેટ અપ તેને હિટ કરે છે (ખાસ કરીને સ્થાનિક ડેવલપમેન્ટમાં વિવિધ પોર્ટ્સ સાથે, અને ઉત્પાદનમાં અલગ frontend ડોમેન સાથે), તેથી FastAPI ના `CORSMiddleware` સાથે તેને કેવી રીતે કૉન્ફિગર કરવું તે જાણવું વ્યવહારિક, વારંવાર જરૂરી જ્ઞાન છે.

તે શા માટે અસ્તિત્વ ધરાવે છે તે સમજવું (બ્રાઉજર same-origin સુરક્ષા), સર્વર કેવી રીતે પ્રતિસાદ હેડર્સ દ્વારા opt in કરે છે, અને તેને કેવી રીતે કૉન્ફિગર કરવું (અલાઉ કરેલા origins, methods, headers, credentials) તે જરૂરી છે frontends ને CORS વિના requests બ્લોક થયા વિના FastAPI APIs સાથે જોડવા માટે.

સમાન રીતે મહત્વપૂર્ણ છે તેને **સુરક્ષિતપણે** કૉન્ફિગર કરવું — `allow_origins` ને વ્યાપક "*" ની જગાએ ચોક્કસ allowlist તક મર્યાદિત કરવું (અને સમજવું કે credentials wildcard સાથે અસંગત છે) — અને એક નિર્ણાયક ગેરસમજ આયોજન કરવું કે **CORS એક બ્રાઉજર પદ્ધતિ છે, API authorization નહીં** (તે બ્રાઉજર-નહીં ક્લાયન્ટ્સ પર રક્ષણ કરતું નથી).

CORS ને યોગ્ય અને સુરક્ષિતપણે સેટ અપ કરવાનું જ્ઞાન કોઈ પણ FastAPI API વાસ્તે જે વેબ frontend દ્વારા વપરાય તે માટે મહત્વપૂર્ણ દૈનિક જ્ઞાન છે.