Idempotentlik kalitlari: to'lov ikki marta yechilmasligi uchun
Javob yo'qoldi, client retry qildi va mijozdan pul ikki marta yechildi. Idempotency-Key, PostgreSQL unique constraint va bitta transaction yordamida retry'ni xavfsiz qilamiz: Django'da to'liq realizatsiya va Stripe bilan solishtirish.
Foydalanuvchi mobil ilovada "To'lash" tugmasini bosdi. So'rov serverga yetib bordi, hamyondan 150 000 so'm yechildi, Payment yozuvi yaratildi. Javob esa qaytishda yo'qoldi: telefon liftga kirdi, mobil tarmoq Wi-Fi'ga almashdi yoki load balancer 30 soniyalik timeout'ga yetdi. Ilova "Tarmoq xatosi" deb ko'rsatadi. Foydalanuvchi yana bosadi. Ilovaning o'zi ham, ehtimol, avtomatik retry qiladi.
Natijada server bir xil to'lovni ikki marta bajaradi, mijoz esa 300 000 so'm to'lagan bo'lib chiqadi. Bu tarmoqdagi oddiy holat: client so'rov bajarilmadimi yoki bajarilib, javobi yo'qoldimi, buni bilolmaydi. Ikkala holatda ham u bir xil narsani ko'radi: timeout.
Bu maqolada shu muammoning standart yechimi, idempotentlik kalitlari (idempotency keys) haqida gaplashamiz: Idempotency-Key header, kalitni so'rov hash'i va javob bilan birga saqlash, parallel so'rovlarda PostgreSQL unique constraint qanday ishlashi, kalit muddati va Stripe yondashuvi bilan solishtirish. Oxirida Django + PostgreSQL'da to'liq ishlaydigan realizatsiya bo'ladi.
Idempotentlik nima va nega POST'da u yo'q
Operatsiya idempotent deyiladi, agar uni bir marta yoki o'n marta bajarish natijasi bir xil bo'lsa. HTTP semantikasida GET, PUT, DELETE idempotent deb belgilangan: PUT /users/7 bilan bir xil ma'lumotni ikki marta yuborsangiz, holat o'zgarmaydi. POST esa idempotent emas: har bir POST /payments/ yangi to'lov yaratadi.
Retry qilish xavfsiz bo'lishi uchun serverga "bu o'sha so'rov, yangisi emas" deb aytish kerak. Buning uchun client har bir niyat (intent) uchun noyob kalit yaratadi va uni header'da yuboradi:
KEY=$(uuidgen)
curl -X POST https://api.example.com/v1/payments/ \
-H "Authorization: Bearer $TOKEN" \
-H "Idempotency-Key: $KEY" \
-H "Content-Type: application/json" \
-d '{"order_id": 4812, "amount": 15000000}'
# Timeout? Send exactly the same request with the same $KEY again.
Server kalitni birinchi marta ko'rsa, so'rovni bajaradi va javobni kalit bilan birga saqlaydi. Shu kalit bilan yana so'rov kelsa, hech narsani qayta bajarmaydi, saqlangan javobni qaytaradi. Client nuqtai nazaridan retry endi xavfsiz: natija qanday bo'lsa ham, pul faqat bir marta yechiladi.
Muhim nuqta: kalit har bir urinish uchun emas, har bir niyat uchun yaratiladi. Foydalanuvchi "To'lash"ni bosgan payt bitta UUID yaratiladi va barcha retry'lar shu UUID bilan ketadi. Har retry'da yangi kalit yaratsangiz, butun mexanizm befoyda bo'ladi.
Sodda yondashuv qayerda sinadi
Birinchi xayolga keladigan kod shunday ko'rinadi:
# WRONG: check-then-act
def create_payment(request):
key = request.headers.get("Idempotency-Key")
existing = IdempotencyKey.objects.filter(user=request.user, key=key).first()
if existing:
return JsonResponse(existing.response_body, status=existing.response_code)
code, body = charge_wallet(request.user, amount, order_id) # money moves here
IdempotencyKey.objects.create(
user=request.user, key=key, response_code=code, response_body=body
)
return JsonResponse(body, status=code)
Bu kodda uchta muammo bor.
1. Poyga holati (race condition). Ikki so'rov millisekund farq bilan keladi (masalan, client timeout'dan keyin retry qildi, birinchi so'rov esa hali ishlayapti). Ikkalasi ham filter().first() qiladi, ikkalasi ham None oladi, ikkalasi ham pul yechadi. Bu "check-then-act" xatosi: tekshirish va harakat o'rtasida boshqa jarayon kirib qoladi. Oldingi maqolalarda select_for_update haqida gapirgandik, lekin bu yerda u yordam bermaydi: hali mavjud bo'lmagan qatorni lock qilib bo'lmaydi.
2. Pul yechildi, kalit saqlanmadi. charge_wallet va create alohida bajariladi. Ular orasida jarayon o'lsa (OOM, deploy paytida worker restart), pul yechilgan, kalit esa yo'q. Keyingi retry yana pul yechadi.
3. So'rov tanasi tekshirilmaydi. Client xato qilib, bir kalitni boshqa summa bilan yuborsa, server eski javobni qaytaradi va client "100 000 to'landi" deb o'ylaydi, aslida esa 150 000 to'langan. Bu xatoni jim yutib yuborish emas, aniq ko'rsatish kerak.
Frontend'da tugmani disable qilish ham yechim emas: u ikki marta bosishdan himoya qiladi, lekin tarmoq retry'idan, proxy'dan yoki ilovaning o'z retry logikasidan himoya qilmaydi.
Mexanizm: unique constraint hakam vazifasini bajaradi
Poyga holatini yo'q qilishning eng ishonchli yo'li: "kim birinchi" degan savolni ilova kodiga emas, ma'lumotlar bazasiga topshirish. (user_id, key) ustida unique constraint bo'lsa, PostgreSQL bir xil kalitli ikkita qatorni hech qachon saqlamaydi.
Qiziq tomoni, PostgreSQL bu holatni parallel transaction'larda qanday hal qilishi. Agar A transaction kalitni INSERT qilgan, lekin hali COMMIT qilmagan bo'lsa, B transaction'ning xuddi shu kalitli INSERT'i xato bermaydi, kutadi: A commit qiladimi yoki rollback qiladimi, bilishi kerak. Buni ikkita psql oynasida tekshirib ko'rish mumkin:
-- psql session A
BEGIN;
INSERT INTO payments_idempotencykey
(user_id, key, request_hash, status, locked_at, created_at)
VALUES (1, 'k-1', 'abc', 'started', now(), now());
-- psql session B: this statement hangs until A finishes
INSERT INTO payments_idempotencykey
(user_id, key, request_hash, status, locked_at, created_at)
VALUES (1, 'k-1', 'abc', 'started', now(), now());
-- session A
COMMIT;
-- session B now fails:
-- ERROR: duplicate key value violates unique constraint "uniq_idem_user_key"
-- (if A had done ROLLBACK instead, B's INSERT would succeed)
Ya'ni unique index ikki so'rovdan faqat bittasi "g'olib" bo'lishini kafolatlaydi, ikkinchisi esa IntegrityError oladi. Hech qanday lock'ni qo'lda boshqarish shart emas.
Kalitni tekshirmang, uni egallang. INSERT muvaffaqiyatli bo'lsa, so'rov sizniki; IntegrityError bo'lsa, kimdir sizdan oldin keldi.
Shundan kelib chiqib, so'rovni qayta ishlash uch bosqichdan iborat:
- Kalitni egallash.
startedholatidagi qatorni alohida, qisqa transaction'da INSERT qilamiz va darhol commit qilamiz. Shunda boshqa so'rovlar kalit band ekanini darhol ko'radi. - Ishni bajarish. Pul yechish va javobni kalitga yozish bitta transaction'da bo'ladi. Yo ikkalasi ham saqlanadi, yo hech biri.
- Takroriy so'rovga javob. Kalit
completedbo'lsa, saqlangan status code va body qaytariladi.startedbo'lsa,409 Conflict. Hash boshqacha bo'lsa,422.
Realizatsiya: Django + PostgreSQL
Model'lardan boshlaymiz. Summalar tiyinda butun son sifatida saqlanadi (bu haqda alohida maqola bor):
# payments/models.py
from django.conf import settings
from django.db import models
class IdempotencyKey(models.Model):
class Status(models.TextChoices):
STARTED = "started"
COMPLETED = "completed"
user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
key = models.CharField(max_length=255)
request_hash = models.CharField(max_length=64)
status = models.CharField(max_length=16, choices=Status, default=Status.STARTED)
response_code = models.PositiveSmallIntegerField(null=True)
response_body = models.JSONField(null=True)
locked_at = models.DateTimeField(null=True)
created_at = models.DateTimeField(auto_now_add=True)
class Meta:
constraints = [
models.UniqueConstraint(fields=["user", "key"], name="uniq_idem_user_key"),
]
indexes = [models.Index(fields=["created_at"])]
class Wallet(models.Model):
user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
balance = models.PositiveBigIntegerField(default=0) # in tiyin
class Payment(models.Model):
user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.PROTECT)
order_id = models.PositiveBigIntegerField(unique=True) # second line of defense
amount = models.PositiveBigIntegerField() # in tiyin
created_at = models.DateTimeField(auto_now_add=True)
Payment.order_id ustidagi unique=True alohida e'tiborga loyiq. Agar domeningizda tabiiy kalit bo'lsa (bitta buyurtma faqat bir marta to'lanadi), uni ham constraint bilan himoya qiling. Idempotency key umumiy mexanizm, tabiiy unique constraint esa ikkinchi himoya qatlami.
Endi asosiy qism, kalitni egallash va tekshirish:
# payments/idempotency.py
import hashlib
import json
from datetime import timedelta
from django.db import IntegrityError, OperationalError, transaction
from django.utils import timezone
from .models import IdempotencyKey
LOCK_TIMEOUT = timedelta(seconds=60) # must be longer than your worker timeout
class IdempotencyConflict(Exception):
"""The same key is being processed right now."""
class IdempotencyMismatch(Exception):
"""The same key was used with a different request."""
def request_fingerprint(method: str, path: str, data: dict) -> str:
canonical = json.dumps(data, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
return hashlib.sha256(f"{method}:{path}:{canonical}".encode()).hexdigest()
def acquire(user, key: str, fingerprint: str) -> tuple[IdempotencyKey, bool]:
"""Return (record, replay). replay=True means a stored response exists."""
now = timezone.now()
# Step 1: try to claim the key. Short transaction, committed immediately.
try:
with transaction.atomic():
record = IdempotencyKey.objects.create(
user=user, key=key, request_hash=fingerprint, locked_at=now
)
return record, False
except IntegrityError:
pass # the key already exists (committed by someone else)
# Step 2: the key exists. Inspect it without waiting on a busy row.
try:
with transaction.atomic():
record = IdempotencyKey.objects.select_for_update(nowait=True).get(
user=user, key=key
)
if record.request_hash != fingerprint:
raise IdempotencyMismatch()
if record.status == IdempotencyKey.Status.COMPLETED:
return record, True
if record.locked_at and now - record.locked_at < LOCK_TIMEOUT:
raise IdempotencyConflict()
# Stale or released lock: take it over.
record.locked_at = now
record.save(update_fields=["locked_at"])
return record, False
except OperationalError:
# nowait=True: another transaction holds the row lock right now
raise IdempotencyConflict()
Bir necha tafsilot:
- Hash so'rov tanasidan kanonik JSON (
sort_keys=True) orqali hisoblanadi, shunda{"a":1,"b":2}va{"b":2,"a":1}bir xil hash beradi. Hash'ga method va path ham kiradi: bir kalitni boshqa endpoint'da ishlatish ham xato hisoblanadi. nowait=True. Agar qatorni hozir boshqa transaction ushlab turgan bo'lsa (ya'ni birinchi so'rov aynan shu daqiqada pul yechyapti), kutmaymiz va darhol409qaytaramiz. Busiz ikkinchi so'rov worker va connection'ni band qilib, birinchisi tugashini kutib turadi.locked_atjarayon o'lib qolgan holatlar uchun. Agarstartedholatidagi kalitLOCK_TIMEOUTdan uzoq turgan bo'lsa, uni egasi tashlab ketgan deb hisoblaymiz va o'zimiz egallaymiz.
Pul yechish logikasi oddiy, select_for_update bilan hamyon qatorini lock qiladi:
# payments/services.py
from django.db.models import F
from .models import Payment, Wallet
def charge_wallet(user, amount: int, order_id: int) -> tuple[int, dict]:
"""Must be called inside transaction.atomic()."""
wallet = Wallet.objects.select_for_update().get(user=user)
if wallet.balance < amount:
return 402, {"error": "insufficient_funds"}
wallet.balance = F("balance") - amount
wallet.save(update_fields=["balance"])
payment = Payment.objects.create(user=user, order_id=order_id, amount=amount)
return 201, {"payment_id": payment.pk, "order_id": order_id, "amount": amount}
E'tibor bering: "mablag' yetarli emas" xatosi exception emas, oddiy javob sifatida qaytadi. Bu deterministik biznes natija, uni ham saqlash kerak: shu kalit bilan retry qilsangiz, yana o'sha 402 qaytishi kerak.
Va nihoyat view:
# payments/views.py
import json
from django.contrib.auth.decorators import login_required
from django.db import transaction
from django.http import JsonResponse
from django.views.decorators.http import require_POST
from .idempotency import (
IdempotencyConflict, IdempotencyMismatch, acquire, request_fingerprint,
)
from .models import IdempotencyKey
from .services import charge_wallet
def replayed(record: IdempotencyKey) -> JsonResponse:
response = JsonResponse(record.response_body, status=record.response_code)
response["Idempotent-Replayed"] = "true"
return response
@transaction.non_atomic_requests
@login_required
@require_POST
def create_payment(request):
key = request.headers.get("Idempotency-Key", "")
if not 1 <= len(key) <= 255:
return JsonResponse({"error": "idempotency_key_required"}, status=400)
try:
data = json.loads(request.body)
amount, order_id = int(data["amount"]), int(data["order_id"])
except (ValueError, KeyError, TypeError):
return JsonResponse({"error": "invalid_request"}, status=400)
fingerprint = request_fingerprint(request.method, request.path, data)
try:
record, replay = acquire(request.user, key, fingerprint)
except IdempotencyMismatch:
return JsonResponse({"error": "idempotency_key_reused"}, status=422)
except IdempotencyConflict:
return JsonResponse({"error": "request_in_progress"}, status=409)
if replay:
return replayed(record)
try:
with transaction.atomic():
# Holding this row lock until COMMIT prevents a double run
# even if a slow request's lock was taken over as "stale".
locked = IdempotencyKey.objects.select_for_update().get(pk=record.pk)
if locked.status == IdempotencyKey.Status.COMPLETED:
return replayed(locked)
code, body = charge_wallet(request.user, amount, order_id)
locked.status = IdempotencyKey.Status.COMPLETED
locked.response_code = code
locked.response_body = body
locked.save(update_fields=["status", "response_code", "response_body"])
except Exception:
# Everything above was rolled back, so a retry is safe: release the key.
IdempotencyKey.objects.filter(
pk=record.pk, status=IdempotencyKey.Status.STARTED
).update(locked_at=None)
raise
return JsonResponse(body, status=code)
Bu yerda eng muhim joy, ichki transaction'dagi select_for_update(). Faraz qiling, birinchi so'rov juda sekin ishladi, LOCK_TIMEOUT o'tdi va ikkinchi so'rov kalitni "eskirgan" deb egalladi. Ikkinchi so'rov acquire'dan o'tadi, lekin ichki transaction'da birinchisi ushlab turgan qator lock'iga duch keladi va kutadi. Birinchisi commit qilgach, ikkinchisi qatorni completed holatida ko'radi va shunchaki saqlangan javobni qaytaradi. Pul ikki marta yechilmaydi.
500 xatoni saqlash kerakmi: Stripe bilan solishtirish
Bu sohada Stripe API yondashuvi namuna hisoblanadi. Uning hujjatlariga ko'ra, Stripe birinchi so'rovning status code va body'sini saqlaydi, 500 xatolarni ham, va shu kalit bilan kelgan keyingi so'rovlarga aynan shuni qaytaradi. Kalitlar kamida 24 soatdan keyin tozalanadi. Kalitni boshqa parametrlar bilan qayta ishlatish xato beradi. Validatsiyadan o'tmagan yoki parallel so'rov bilan to'qnashgan so'rovlar uchun natija saqlanmaydi, chunki endpoint ishni boshlamagan, ularni retry qilish mumkin.
Nega Stripe 500'ni ham saqlaydi? Chunki uning ichida operatsiya ko'plab tizimlarga tarqalgan va 500 paytida qaysidir qismi bajarilgan bo'lishi mumkin. Retry'ga ruxsat berish xavfli.
Bizning holatda boshqacha: pul yechish va javobni saqlash bitta PostgreSQL transaction'ida. Exception bo'lsa, hammasi rollback bo'ladi, demak hech narsa o'zgarmagan, retry xavfsiz. Shuning uchun except blokida kalitni bo'shatamiz (locked_at=None).
| Stripe | Bizning realizatsiya | |
|---|---|---|
| Kalit doirasi | akkaunt bo'yicha | (user, key) |
| Saqlash muddati | kamida 24 soat | sozlanadi, standart 24 soat |
| Boshqa parametrlar bilan qayta ishlatish | xato | 422 |
| Parallel so'rov | to'qnashuv xatosi, natija saqlanmaydi | 409, natija saqlanmaydi |
| Validatsiya xatosi | saqlanmaydi | saqlanmaydi (400, kalit egallanmaydi) |
| 500 xato | saqlanadi va qaytariladi | saqlanmaydi, transaction rollback, retry mumkin |
Status kodlari bo'yicha IETF'da Idempotency-Key header'ni standartlashtirish uchun draft bor (httpapi ishchi guruhi), u ham shunga o'xshash kodlarni taklif qiladi: header bo'lmasa 400, so'rov hali bajarilayotgan bo'lsa 409, kalit boshqa payload bilan ishlatilsa 422. Idempotent-Replayed: true header'i ixtiyoriy, lekin debug paytida juda qo'l keladi: client javob takrorlanganini ko'radi.
Tashqi to'lov provayderi bo'lsa
Yuqoridagi sxema barcha o'zgarishlar bitta bazada bo'lgani uchun ishlaydi. Haqiqiy to'lovda esa ko'pincha tashqi provayderga HTTP so'rov ketadi, uni transaction ichiga qo'yib bo'lmaydi: tashqi API 20 soniya javob bermasa, siz shuncha vaqt lock va connection ushlab turasiz, rollback esa provayderda yechilgan pulni qaytarmaydi.
Bunday hollarda operatsiyani alohida commit qilinadigan bosqichlarga bo'lish kerak (Brandur Leach'ning Postgres'da Stripe uslubidagi idempotentlik haqidagi maqolasida bu "atomic phases" va "recovery points" deb ataladi):
- Bir transaction'da
Payment(status="pending")yaratiladi va unga oldindan noyobprovider_refberiladi. - Transaction'dan tashqarida provayder chaqiriladi va shu
provider_refyuboriladi. Ko'p provayderlar o'z idempotency key'ini yoki merchant tomonidagi noyob transaction ID'ni qabul qiladi. - Javob kelgach, alohida transaction'da
Paymentva idempotency keycompletedqilinadi.
Jarayon 2- va 3-bosqich orasida o'lsa, "eskirgan" kalitni egallagan so'rov provayderni ko'r-ko'rona qayta chaqirmasligi kerak. Avval provider_ref bo'yicha to'lov holatini tekshiradi, keyin davom etadi.
Kalit muddati va tozalash
Kalitlarni abadiy saqlash shart emas, lekin muddat client retry qiladigan eng uzun oraliqdan uzunroq bo'lishi kerak. Mobil ilova offline navbatdagi so'rovni bir necha soatdan keyin yuborishi mumkin: agar kalit 10 daqiqada o'chirilsa, bu so'rov yangi to'lov bo'lib bajariladi.
Tozalashni Celery beat orqali periodik task bilan qilamiz, katta DELETE bilan jadvalni uzoq lock qilmaslik uchun batch'larga bo'lib:
# payments/tasks.py
from datetime import timedelta
from celery import shared_task
from django.utils import timezone
from .models import IdempotencyKey
RETENTION = timedelta(hours=24)
@shared_task
def purge_idempotency_keys(batch_size: int = 5000) -> int:
cutoff = timezone.now() - RETENTION
total = 0
while True:
ids = list(
IdempotencyKey.objects.filter(created_at__lt=cutoff)
.values_list("pk", flat=True)[:batch_size]
)
if not ids:
return total
deleted, _ = IdempotencyKey.objects.filter(pk__in=ids).delete()
total += deleted
created_at ustidagi index shu so'rov uchun kerak.
Client tomoni
Server qanchalik to'g'ri yozilmasin, client har retry'da yangi kalit yaratsa, hammasi bekor. To'g'ri client shunday ko'rinadi:
import random
import time
import uuid
import httpx
RETRYABLE = {409, 500, 502, 503, 504}
def pay(order_id: int, amount: int, token: str) -> httpx.Response:
key = str(uuid.uuid4()) # one key per user intent, NOT per attempt
for attempt in range(5):
try:
response = httpx.post(
"https://api.example.com/v1/payments/",
json={"order_id": order_id, "amount": amount},
headers={"Authorization": f"Bearer {token}", "Idempotency-Key": key},
timeout=10,
)
except httpx.TransportError:
pass # timeout, reset connection: the outcome is unknown, retry
else:
if response.status_code not in RETRYABLE:
return response
time.sleep(min(2 ** attempt, 30) + random.random()) # backoff + jitter
raise RuntimeError(f"payment outcome unknown, retry later with key {key}")
Bu yerda uchta qoida bor: kalit sikldan tashqarida yaratiladi, 409 va 5xx qayta urinish signali, 4xx (masalan 402 yoki 422) esa yakuniy javob. Jitter (random.random()) ko'plab client'lar bir vaqtda retry qilib, serverni qayta yiqitmasligi uchun kerak.
Production'da uchraydigan tuzoqlar
ATOMIC_REQUESTS = True. Bu sozlama butun view'ni bitta transaction'ga o'raydi, kalitni egallash bosqichi esa view tugamaguncha commit bo'lmaydi va boshqa so'rovlar uni ko'rmaydi. Shuning uchun@transaction.non_atomic_requestsqo'yilgan. Bu decorator view'ga eng tashqi qatlam sifatida qo'yilishi kerak.- Kalit doirasi. Unique constraint faqat
keyustida bo'lsa, bir foydalanuvchining kaliti boshqasinikiga to'g'ri kelib qolishi mumkin, eng yomoni, birovning saqlangan javobi boshqa odamga qaytadi. Har doim(user, key)yoki(merchant, key). LOCK_TIMEOUTworker timeout'idan qisqa. Masalan, gunicorn timeout 120 soniya,LOCK_TIMEOUT60 soniya bo'lsa, tirik so'rov "eskirgan" deb hisoblanadi. Ichkiselect_for_updatebizni ikki marta yechishdan himoya qiladi, lekin bunga tayanmang, timeout'larni moslang.- Response body'da maxfiy ma'lumot. Saqlangan javob bazada 24 soat yotadi. Unga karta raqami, token yoki shaxsiy ma'lumot kirmasligi kerak.
- Hash'ga o'zgaruvchan maydonlar kirishi. Client body'ga
timestampyokirequest_idqo'shsa, har retry'da hash boshqacha bo'ladi va422oladi. Hash'ga faqat biznes ma'nosi bor maydonlar kirishi kerak, yoki client'ga retry'da body'ni aynan takrorlash qoidasini qo'ying. - Kalit tozalangandan keyingi retry. Kalit o'chirilgach kelgan retry yangi so'rov sifatida bajariladi.
Payment.order_idustidagi unique constraint aynan shu holat uchun ikkinchi himoya. - Redis yetarli emas.
SET key value NX EX 86400lock uchun yaxshi, lekin Redis va PostgreSQL bitta transaction'da emas: pul yechildi, Redis'ga javob yozilmadi, yoki eviction/failover kalitni o'chirib yubordi. Pul bilan ishlaganda kalit va natija bitta bazada bo'lgani ma'qul. - Celery task'lar ham ikki marta ishlashi mumkin.
acks_latebilan worker o'lsa, task qayta bajariladi. Bu yerda ham xuddi shu g'oya: task'ga ID bering va natijani unique constraint bilan himoya qiling.
Checklist
- Har bir pul harakatlantiruvchi
POSTendpointIdempotency-Keytalab qiladi. - Client kalitni har bir niyat uchun bir marta yaratadi va barcha retry'larda qayta ishlatadi.
- Kalit
(user, key)ustidagi unique constraint bilan himoyalangan, tekshirish emas, INSERT orqali egallanadi. - So'rovning kanonik hash'i saqlanadi, boshqa payload bilan kelgan kalit
422oladi. - Biznes o'zgarish va javobni saqlash bitta transaction'da.
- Bajarilayotgan so'rov uchun
409, tugagani uchun saqlangan status va body qaytariladi. ATOMIC_REQUESTSyoqilgan bo'lsa, viewnon_atomic_requestsbilan belgilangan.- Eskirgan lock'lar uchun timeout bor va u worker timeout'idan uzun.
- Tashqi provayderga ham o'z noyob reference'ingiz uzatiladi, recovery paytida avval holat tekshiriladi.
- Kalitlar kamida 24 soat saqlanadi va batch'lab tozalanadi.
Xulosa
Tarmoq javob yo'qolishini kafolatlaydi, shuning uchun to'lov API'si retry'ga chidamli bo'lishi shart. Idempotency key buni oddiy qilib beradi: client har bir niyatga bitta kalit beradi, server esa uni unique constraint orqali egallaydi va javobni biznes o'zgarish bilan bir transaction'da saqlaydi. Qolgani tafsilotlar: hash, 409/422, muddat va tashqi provayderlar uchun recovery. Ularni bir marta to'g'ri qilsangiz, "pul ikki marta yechildi" degan murojaatlar kamayadi.
// izohlar
Izohlar yuklanmoqda...