Idempotency అంటే ఏమిటి, idempotency keys retryలను ఎలా సురక్షితంగా చేస్తాయి?

Question

IT Interview Practice · Accepted Answer

**Idempotency** అంటే ఒక ఆపరేషన్‌ను **అనేకసార్లు చేయడం ఒకసారి చేసిన అదే ప్రభావాన్ని** కలిగి ఉంటుంది. ఇది ముఖ్యం ఎందుకంటే networks నమ్మదగనివి: ఒక client ఒక request పంపి response ఎప్పటికీ రాకపోతే, server దాన్ని ప్రాసెస్ చేసిందో లేదో చెప్పలేదు. అది retry చేస్తే, ఒక non-idempotent ఆపరేషన్ రెండుసార్లు నడవవచ్చు.

## సమస్య

```text
Client ──POST /payments {$100}──▶ Server   (charges $100 ✓)
Client ◀────────X (timeout)────── Server   (response lost)
Client ──POST /payments {$100}──▶ Server   (charges $100 AGAIN ✗ → $200!)
```

`GET`, `PUT`, `DELETE` సహజంగా idempotent, కాబట్టి వాటిని retry చేయడం సురక్షితం. `POST` **కాదు** — నకిలీ charges మరియు నకిలీ orders సరిగ్గా ఇక్కడి నుండి వస్తాయి.

## పరిష్కారం: idempotency keys

Client తార్కిక ఆపరేషన్ కోసం ఒక **ప్రత్యేక key**ను (సాధారణంగా ఒక UUID) సృష్టించి దాన్ని ఒక headerలో పంపుతుంది. Server keyను ఫలితంతో నిల్వ చేస్తుంది; అదే key మళ్లీ వస్తే, అది తిరిగి-execute చేయడం బదులు **నిల్వ చేసిన** ఫలితాన్ని తిరిగి ఇస్తుంది.

```http
POST /payments HTTP/1.1
Idempotency-Key: 5f2b8c1e-3a4d-4e6f-9c0b-1a2b3c4d5e6f
Content-Type: application/json

{ "amount": 100, "currency": "usd" }
```

```text
Server logic on receiving a request with an Idempotency-Key:
  1. Look up the key in a store (e.g. Redis/DB).
  2. If found → return the saved response (no re-charge).      ← the retry case
  3. If not  → process, save (key → response), then return.
  (Wrap 3 in a transaction / lock so concurrent retries don't double-execute.)
```

retry మీద **అదే key** అదే `200`, అదే paymentను ఇస్తుంది — customer ఒకసారి మాత్రమే charge చేయబడతాడు. Stripe యొక్క API సరిగ్గా ఇలాగే పనిచేస్తుంది.

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

ఈ ప్రశ్న happy path కోసం డిజైన్ చేసే ఇంజనీర్‌లను **failure** కోసం డిజైన్ చేసేవారి నుండి వేరు చేస్తుంది, ఇదే production reliability అంటే. Distributed systems timeouts మరియు partial failures *జరుగుతాయని* హామీ ఇస్తాయి, కాబట్టి side effectలు ఉన్న ఏ endpoint అయినా — payments, orders, డబ్బు పంపడం — ఒక retry వ్యూహం అవసరం, మరియు `POST`కు "కేవలం retry" ప్రమాదకరం. ఇంటర్వ్యూయర్ రెండు-భాగాల అంతర్దృష్టిని వినాలనుకుంటారు: మొదటిది, idempotency అనేది మీరు *డిజైన్‌లో చేర్చగల* లక్షణం (`PUT`/`DELETE`ను సహజంగా సురక్షితం చేయడం, సాధ్యం కానప్పుడు `POST`కు ఒక **idempotency key** ఇవ్వడం), రెండవది, సూక్ష్మ concurrency వివరం — ఒకేసారి వచ్చే రెండు retryలు రెండూ execute కాకూడదు, కాబట్టి key తనిఖీ మరియు write‌కు ఒక lock లేదా unique constraint అవసరం. దీన్ని సరిగా పొందడం ఒక customerను ఒకసారి charge చేయడానికి, రెండుసార్లు charge చేయడానికి మధ్య తేడా, అందుకే ప్రతి తీవ్రమైన payments మరియు commerce API దాన్ని అమలు చేస్తుంది.

సమస్య

పరిష్కారం: idempotency keys

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

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