ఒక REST APIని ఎలా సురక్షితం చేస్తారు (authentication, authorization, transport)?

Question

IT Interview Practice · Accepted Answer

ఒక REST APIని సురక్షితం చేయడం అంటే ప్రతి request మీద మూడు ప్రశ్నలకు జవాబివ్వడం: **మీరు ఎవరు** (authentication), **మీరు ఏమి చేయడానికి అనుమతించబడ్డారు** (authorization), మరియు **channel ప్రైవేటా** (transport). REST **stateless** కాబట్టి, credentials ఒక server sessionలో ఉండటం బదులు ప్రతి requestతో ప్రయాణించాలి.

## Transport: ఎల్లప్పుడూ HTTPS

కింది ప్రతిదీ **TLS/HTTPS**ను ఊహిస్తుంది. అది లేకుండా, tokens మరియు API keys plaintextలో ప్రయాణించి sniff చేయబడగలవు. ఇది చర్చించలేనిది — HTTP మీద ఒక bearer token అంటే leak అయిన token.

## Authentication ఎంపికలు

**API keys** — ఒక headerలో ఒక static secret. సరళం; server-to-server కోసం మరియు ఒక *application*ను గుర్తించడానికి మంచిది, ఒక user కాదు. మరిన్నింటితో జత చేయకపోతే వాటంతట అవి బలహీనం (expiry లేదు, scope లేదు).
```http
GET /data HTTP/1.1
Authorization: Bearer sk_live_a1b2c3...
```

**OAuth 2.0** — **delegated** access కోసం standard ("నా password లేకుండా App Xను నా డేటా చదవనివ్వండి"). App ఒక flow (ఉదా. Authorization Code) ద్వారా ఒక **access token**ను పొంది దాన్ని bearer tokenగా పంపుతుంది. "Sign in with Google" మరియు third-party integrations ఇలాగే పనిచేస్తాయి.

**JWT (JSON Web Token)** — tokensకు ఒక సాధారణ *format*: claims (user id, roles, expiry) మోసే ఒక signed, స్వయం-సమగ్ర token. Server signatureను ధృవీకరిస్తుంది — database lookup అవసరం లేదు, ఇది stateless RESTకు సరిపోతుంది.
```text
header.payload.signature   (base64url)
payload: { "sub": "42", "scope": "orders:read", "exp": 1737800000 }
```

## Authorization: scopes మరియు roles

Authentication identityను నిరూపిస్తుంది; **authorization** accessను నిర్ణయిస్తుంది. Tokens **scopes** (`orders:read`, `orders:write`) లేదా rolesను మోస్తాయి; server వాటిని ప్రతి endpointకు తనిఖీ చేసి అవి సరిపోనప్పుడు `403 Forbidden`ను తిరిగి ఇస్తుంది (లేని/చెల్లని auth కోసం `401`కు వ్యతిరేకంగా).

```text
No/invalid token         → 401 Unauthorized
Valid token, no scope    → 403 Forbidden
```

## ఇతర ఆవశ్యకాలు

```text
✓ Short-lived access tokens + refresh tokens (limit blast radius if leaked)
✓ Rate limiting (429) to blunt brute-force and abuse
✓ Validate/sanitize all input; never trust the client
✓ Principle of least privilege on scopes
```

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

Security అనేది ఒక చిన్న తప్పు ఒక breach అయ్యే చోటు, కాబట్టి మీరు buzzwordలను వల్లించడం కాకుండా దాని గురించి నిర్మాణాత్మకంగా తర్కిస్తారో లేదో చూడటానికి ఇంటర్వ్యూయర్‌లు దీన్ని వాడతారు. వారు వెతికే సంకేతం మీరు **మూడు పొరలను వేరు చేస్తారని** — transport (HTTPS, ఎల్లప్పుడూ), authentication (identityను నిరూపించడం, statelessగా, bearer tokens/JWT/OAuth ద్వారా), authorization (scopes మరియు least privilege) — వాటిని కలగలపరని, ఉదా. "authenticate కాలేదు" కోసం `401`ను, "authenticate అయింది కానీ అనుమతి లేదు" కోసం `403`ను సరిగా వాడటం. బలమైన జవాబులు ఆచరణాత్మక ట్రేడ్-ఆఫ్‌ల అవగాహనను చూపుతాయి: JWTలు సౌకర్యవంతం మరియు stateless కానీ expire అయ్యేముందు revoke చేయడం కష్టం (అందుకే short lifetimes కలిపి refresh tokens), API keys usersను కాదు appsను గుర్తిస్తాయి, మరియు OAuth ప్రత్యేకంగా users తమ passwordను third partiesకు ఇవ్వకుండా ఉండటానికే ఉంది. దాన్ని REST యొక్క statelessnessకు ముడివేయడం — ప్రతి request మీద credentials, server session లేదు — API security ఎందుకు ఆ రూపంలో ఉందో మీరు అర్థం చేసుకున్నారని చూపుతుంది.

Transport: ఎల్లప్పుడూ HTTPS

Authentication ఎంపికలు

Authorization: scopes మరియు roles

ఇతర ఆవశ్యకాలు

ఇది ఎందుకు ముఖ్యం

సంబంధిత ప్రశ్నలు