Transactional outbox: buyurtma saqlandi, xabar esa yo'qoldi
Bazaga yozib, keyin brokerga xabar yuborish — bu ikki tizimga yozish, ular orasida jarayon o'lsa, xabar jimgina yo'qoladi. Outbox jadvali, SKIP LOCKED bilan relay va idempotent iste'molchi bu bo'shliqni qanday yopishini ko'rib chiqamiz.
Muammo: buyurtma bor, xabar yo'q
Tasavvur qiling: foydalanuvchi buyurtma beradi. Django view Order qatorini PostgreSQL'ga yozadi, so'ng order.created hodisasini Redis Stream'ga yuboradi (RabbitMQ yoki Kafka bo'lsa ham farqi yo'q). Bu hodisani billing xizmati o'qib hisob-faktura yaratadi, ombor xizmati tovarni band qiladi, notification xizmati SMS jo'natadi.
Ko'p kun hammasi ishlaydi. Keyin deploy paytida pod SIGKILL oladi — aynan COMMIT tugagan, lekin publish() hali chaqirilmagan millisekundlarda. Buyurtma bazada bor, mijoz to'lov qilgan, billing esa undan bexabar. Logda hech qanday xato yo'q, chunki xato bo'lmagan: jarayon shunchaki o'ldi.
Teskari holat ham bor: xabar brokerga ketdi, keyin tranzaksiya rollback bo'ldi. Endi ombor xizmati umuman mavjud bo'lmagan buyurtma uchun tovar band qilyapti.
Bu dual write muammosi: bitta biznes amalni ikki mustaqil tizimga yozyapmiz, ular o'rtasida esa umumiy tranzaksiya yo'q. Bugun shu bo'shliqni yopadigan naqsh — transactional outbox haqida gaplashamiz: jadval, relay jarayoni, SKIP LOCKED, tartib, dublikatlar va iste'molchi tomonidagi idempotentlik.
Nega oddiy yechimlar ishlamaydi
Birinchi urinish odatda shunday ko'rinadi:
# orders/services.py — NAIVE
from django.db import transaction
from orders.events import publish
from orders.models import Order
def place_order(user, cart):
with transaction.atomic():
order = Order.objects.create(user=user, total=cart.total)
publish("order.created", {"order_id": order.pk, "total": str(order.total)})
# if this raises, the order rolls back,
# but the event is already in the broker
reserve_stock(order, cart)
return order
Bu yerda publish() tranzaksiya ichida. reserve_stock() xato tashlasa, buyurtma rollback bo'ladi, xabar esa allaqachon brokerda — phantom hodisa. Bundan tashqari, broker sekinlashsa tranzaksiya ham ochiq qoladi va qatorlardagi lock'lar ushlanib turadi. Broker o'chsa, buyurtma umuman o'tmaydi: ikkinchi darajali tizim asosiy biznes oqimini to'xtatib qo'yadi.
Tajribali dasturchi buni transaction.on_commit() bilan "tuzatadi":
def place_order(user, cart):
with transaction.atomic():
order = Order.objects.create(user=user, total=cart.total)
reserve_stock(order, cart)
transaction.on_commit(
lambda: publish(
"order.created",
{"order_id": order.pk, "total": str(order.total)},
)
)
return order
Endi phantom hodisa yo'q: callback faqat muvaffaqiyatli COMMITdan keyin chaqiriladi. Lekin COMMIT va callback o'rtasida hali ham oyna qoladi. Jarayon shu oynada o'lsa, broker o'sha daqiqada ishlamasa yoki tarmoq timeout bersa — hodisa yo'qoladi va uni qayta yuborish uchun hech qanday iz qolmaydi. on_commit xotirada yashaydi, diskda emas.
"Unda ikki fazali commit (2PC) ishlataylik" degan fikr ham keladi. PostgreSQL'da PREPARE TRANSACTION bor, lekin Redis va ko'pchilik brokerlar bunday taqsimlangan tranzaksiyada qatnasha olmaydi, koordinatorning o'zi esa alohida ishonchlilik muammosi. Amalda bu yo'ldan deyarli hech kim bormaydi.
Ikki tizimga atomik yozib bo'lmaydi. Lekin bitta tizimga — bazaga — atomik yozish mumkin. Outbox g'oyasi shu: hodisani ham bazaga yozamiz.
Mexanizm: outbox jadvali bir tranzaksiyada
G'oya uch qadamdan iborat:
- Biznes ma'lumot (
Order) va hodisa (OutboxEvent) bitta tranzaksiyada, bitta bazaga yoziladi. Yo ikkalasi commit bo'ladi, yo hech biri. - Alohida jarayon — relay (ba'zan poller deyiladi) — outbox jadvalidan hali yuborilmagan qatorlarni o'qiydi, brokerga yuboradi va
published_atni belgilaydi. - Relay xabarni yuborib, lekin belgilashga ulgurmay o'lishi mumkin. Shuning uchun hodisa kamida bir marta (at-least-once) yetkaziladi va iste'molchi dublikatlarga tayyor bo'lishi kerak.
Natijada "xabar yo'qoldi" muammosi "xabar ikki marta keldi" muammosiga aylanadi. Ikkinchisini idempotentlik bilan hal qilish esa ancha oson.
Model:
# orders/models.py
import uuid
from django.db import models
class OutboxEvent(models.Model):
id = models.BigAutoField(primary_key=True)
event_id = models.UUIDField(default=uuid.uuid4, unique=True, editable=False)
aggregate_type = models.CharField(max_length=50)
aggregate_id = models.CharField(max_length=64)
event_type = models.CharField(max_length=100)
payload = models.JSONField()
created_at = models.DateTimeField(auto_now_add=True)
published_at = models.DateTimeField(null=True, blank=True)
attempts = models.PositiveIntegerField(default=0)
last_error = models.TextField(blank=True, default="")
class Meta:
indexes = [
models.Index(
fields=["id"],
name="outbox_pending_idx",
condition=models.Q(published_at__isnull=True),
),
]
Bir nechta qaror haqida:
id—BigAutoField, tartib uchun.event_id— UUID: iste'molchi dublikatni aniqlashi uchun global identifikator. Bazadagiidtashqariga chiqmaydi,event_idesa hodisa bilan birga yuradi.payload—JSONField. Ichiga ORM obyektini emas, aniq sxemali dict yozing.Decimalvadatetimeni o'zingiz string'ga aylantiring: standart JSON encoder ularni serializatsiya qila olmaydi.- Qisman (partial) index faqat
published_at IS NULLbo'lgan qatorlarni qamraydi. Jadvalda millionlab yuborilgan qator bo'lsa ham, relay so'rovi kichkina index bo'yicha ishlaydi.
Buyurtma yaratish endi shunday ko'rinadi (reserve_stock — loyihangizdagi oddiy funksiya):
# orders/services.py
from django.db import transaction
from orders.models import Order, OutboxEvent
def place_order(user, cart):
with transaction.atomic():
order = Order.objects.create(user=user, total=cart.total)
reserve_stock(order, cart)
OutboxEvent.objects.create(
aggregate_type="order",
aggregate_id=str(order.pk),
event_type="order.created",
payload={
"version": 1,
"order_id": order.pk,
"user_id": user.pk,
"total": str(order.total),
},
)
return order
E'tibor bering: request yo'lida brokerga hech qanday tarmoq chaqiruvi yo'q. Tranzaksiya qisqa, broker o'chiq bo'lsa ham buyurtmalar qabul qilinadi — hodisalar jadvalda navbat kutib turadi.
Relay: SKIP LOCKED bilan parallel o'qish
Relay har bir necha yuz millisekundda yuborilmagan hodisalarni oladi. Bir nechta relay nusxasi bir vaqtda ishlasa (masalan, ikkita pod), ular bitta qatorni ikki marta olmasligi va bir-birini kutib qolmasligi kerak. Buning uchun PostgreSQL'ning FOR UPDATE SKIP LOCKED imkoniyatidan foydalanamiz:
# orders/outbox.py
import json
import redis
from django.conf import settings
from django.db import transaction
from django.utils import timezone
from orders.models import OutboxEvent
r = redis.Redis.from_url(settings.REDIS_URL, socket_timeout=5)
def publish_to_stream(event: OutboxEvent) -> None:
r.xadd(
f"events:{event.aggregate_type}",
{
"event_id": str(event.event_id),
"type": event.event_type,
"aggregate_id": event.aggregate_id,
"payload": json.dumps(event.payload),
},
maxlen=1_000_000,
approximate=True,
)
def relay_batch(publish=publish_to_stream, batch_size: int = 100) -> tuple[int, bool]:
"""Publish one batch of pending events. Returns (sent, failed)."""
with transaction.atomic():
events = list(
OutboxEvent.objects.select_for_update(skip_locked=True)
.filter(published_at__isnull=True)
.order_by("id")[:batch_size]
)
now = timezone.now()
touched, failed = [], False
for event in events:
try:
publish(event)
except Exception as exc:
event.attempts += 1
event.last_error = repr(exc)[:2000]
touched.append(event)
failed = True
break # later events must not overtake this one
event.published_at = now
touched.append(event)
if touched:
OutboxEvent.objects.bulk_update(
touched, ["published_at", "attempts", "last_error"]
)
return len(touched) - int(failed), failed
Django bu queryset'ni mohiyatan quyidagi SQL'ga aylantiradi:
SELECT *
FROM orders_outboxevent
WHERE published_at IS NULL
ORDER BY id
LIMIT 100
FOR UPDATE SKIP LOCKED;
Ichkarida nima bo'ladi: FOR UPDATE tanlangan qatorlarga row lock qo'yadi. SKIP LOCKED esa boshqa tranzaksiya allaqachon lock qilgan qatorlarni kutmasdan tashlab o'tadi. Birinchi relay 1–100 qatorlarni oladi; ikkinchisi shu paytda kelsa, ularni ko'rmaydi va keyingi 100 tasini oladi. Hech kim hech kimni kutmaydi, bitta qator ikki relay'ga tushmaydi. Lock'lar relay tranzaksiyasi commit yoki rollback bo'lganda bo'shaydi.
Nozik joy shundaki, lock'lar brokerga tarmoq chaqiruvi davomida ushlab turiladi. Shuning uchun Redis klientida socket_timeout bor va batch kichik: broker osilib qolsa, tranzaksiya cheksiz ochiq turmasligi kerak.
Xato bo'lsa, relay o'sha joyda to'xtaydi (break): muvaffaqiyatsiz hodisa navbat boshida qoladi va undan keyingilar uni quvib o'tmaydi. Shu paytgacha yuborilganlari published_at bilan saqlanadi. Xato bergan hodisaning attempts hisoblagichi oshadi — bu keyinroq alert uchun kerak.
Relay'ni alohida jarayon sifatida ishga tushiramiz:
# orders/management/commands/outbox_relay.py
import time
from django.core.management.base import BaseCommand
from django.db import close_old_connections
from orders.outbox import relay_batch
class Command(BaseCommand):
help = "Publish pending outbox events to the broker"
def handle(self, *args, **options):
backoff = 1.0
while True:
close_old_connections()
sent, failed = relay_batch()
if failed:
time.sleep(backoff)
backoff = min(backoff * 2, 30.0)
continue
backoff = 1.0
if sent == 0:
time.sleep(0.5)
python manage.py outbox_relay
Uni systemd, supervisor yoki Kubernetes Deployment orqali ishga tushiring: baza bilan aloqa uzilib jarayon yiqilsa, orkestrator uni qayta ko'taradi. Kechikish (latency) muhim bo'lsa, sleep o'rniga relay'ni PostgreSQL LISTEN/NOTIFY bilan uyg'otish mumkin — NOTIFY faqat commit'dan keyin yetkaziladi. Lekin davriy poll'ni baribir qoldiring: relay ulanmagan paytda yuborilgan notification yo'qoladi, outbox jadvalidagi qator esa yo'qolmaydi.
Tartib va dublikatlar
Bu yerda ikki narsani halol tan olish kerak.
Dublikatlar muqarrar. Relay xadd muvaffaqiyatli bo'lgandan keyin, lekin COMMITdan oldin o'lsa, tranzaksiya rollback bo'ladi va keyingi relay o'sha hodisani yana yuboradi. Yoki xadd timeout bilan qaytadi, aslida esa Redis xabarni qabul qilgan bo'ladi. Bu xato emas — at-least-once kafolatining narxi.
Global tartib yo'q. Buning uchta sababi bor:
- Sequence qiymati
INSERTpaytida beriladi, commit paytida emas. T1 tranzaksiyaid=10oladi, T2id=11oladi, lekin T2 birinchi commit bo'ladi. Relay 11 ni yuboradi, 10 esa keyinroq ko'rinadi. - Bir nechta relay
SKIP LOCKEDbilan parallel ishlasa, ikkinchi relay'ning batch'i birinchisinikidan oldin brokerga yetib borishi mumkin. - Broker va iste'molchilarning o'zi ham parallel ishlaydi.
Amalda odatda bitta agregat (masalan, bitta buyurtma) doirasidagi tartib kerak bo'ladi. Uni ta'minlash yo'llari:
- Bitta agregatni o'zgartiradigan tranzaksiyalarni ketma-ket qiling: buyurtma qatorini
select_for_update()bilan lock qiling. Shunda bir buyurtmaning hodisalari commit tartibidaidoladi. - Qat'iy tartib kerak bo'lsa, bitta relay ishlating yoki outbox'ga
partitionustunini qo'shing (crc32(aggregate_id) % N) va har bir relay faqat o'z partitsiyasini o'qisin. - Iste'molchida versiyani tekshiring: payload'da agregat versiyasi bo'lsa, eskirgan hodisani e'tiborsiz qoldirish oson.
Iste'molchida idempotentlik
Dublikatlar kelishi aniq ekan, iste'molchi har bir event_idni faqat bir marta qayta ishlashi kerak. Eng ishonchli usul — qayta ishlangan hodisalar jadvali va biznes effektni bitta tranzaksiyada yozish:
# billing/models.py
from django.db import models
class ProcessedEvent(models.Model):
event_id = models.UUIDField(primary_key=True)
processed_at = models.DateTimeField(auto_now_add=True)
# billing/consumers.py
import json
import redis
from django.conf import settings
from django.db import transaction
from billing.models import Invoice, ProcessedEvent
r = redis.Redis.from_url(settings.REDIS_URL)
STREAM, GROUP = "events:order", "billing"
def handle(event_id: str, event_type: str, payload: dict) -> None:
with transaction.atomic():
_, created = ProcessedEvent.objects.get_or_create(event_id=event_id)
if not created:
return # duplicate delivery: the effect is already applied
if event_type == "order.created":
Invoice.objects.create(order_id=payload["order_id"], amount=payload["total"])
def run(consumer: str) -> None:
try:
r.xgroup_create(STREAM, GROUP, id="0", mkstream=True)
except redis.ResponseError as exc:
if "BUSYGROUP" not in str(exc):
raise
while True:
resp = r.xreadgroup(GROUP, consumer, {STREAM: ">"}, count=50, block=5000)
for _stream, messages in resp or []:
for msg_id, fields in messages:
handle(
fields[b"event_id"].decode(),
fields[b"type"].decode(),
json.loads(fields[b"payload"]),
)
r.xack(STREAM, GROUP, msg_id) # only after the DB commit
Muhim tafsilotlar:
ProcessedEventqatori vaInvoicebitta tranzaksiyada. Handler xato tashlasa, ikkalasi ham rollback bo'ladi va hodisa keyingi urinishda qaytadan qayta ishlanadi.event_id— primary key. Ikki worker bir vaqtda bitta hodisani olsa, PostgreSQL ikkinchiINSERTni birinchisi tugaguncha kuttirib qo'yadi, keyin unique xatosi beradi;get_or_createuni ushlab,created=Falseqaytaradi.XACKcommit'dan keyin. Jarayon ular orasida o'lsa, xabar pending ro'yxatida qoladi va qayta yetkaziladi —ProcessedEventuni ushlab qoladi. O'lgan consumer'larning pending xabarlarini olish uchunXAUTOCLAIMishlating.
Ba'zan effektning o'zi tabiiy ravishda idempotent: UPDATE ... SET status = 'paid' ikki marta bajarilsa ham natija bir xil, yoki Invoice.order_idga unique constraint qo'yish yetarli. Bu mavzuni idempotentlik kalitlari va Celery vazifalari haqidagi maqolalarda batafsilroq yozganman.
CDC: poller'siz variant
Poller o'rniga Change Data Capture ham ishlatiladi. Debezium kabi vosita PostgreSQL'ning logical decoding imkoniyati orqali WAL'ni o'qiydi (wal_level = logical, replication slot, pgoutput plugin) va outbox jadvaliga qo'shilgan har bir qatorni Kafka'ga uzatadi. Debezium'da aynan shu naqsh uchun Outbox Event Router transformatsiyasi bor.
Afzalliklari: polling so'rovlari yo'q, hodisalar commit tartibida keladi, kechikish kichik. Kamchiligi: Kafka Connect infratuzilmasi kerak va replication slot'ni kuzatish shart — iste'molchi to'xtab qolsa, PostgreSQL slot uchun WAL fayllarini o'chirmaydi va disk to'lib qolishi mumkin. Outbox jadvali baribir kerak: CDC faqat relay'ni almashtiradi.
| Yondashuv | Hodisa yo'qolishi | Phantom hodisa | Nima kerak |
|---|---|---|---|
Tranzaksiya ichida publish() |
yo'q, lekin broker o'chsa buyurtma ham o'tmaydi | ha | hech narsa |
on_commit + publish() |
ha, crash bo'lsa | yo'q | hech narsa |
| Outbox + poller | yo'q | yo'q | jadval, relay jarayoni, idempotent iste'molchi |
| Outbox + CDC | yo'q | yo'q | Debezium/Kafka Connect, replication slot monitoringi |
Production'dagi tuzoqlar
- Outbox jadvali shishadi. Yuborilgan qatorlarni davriy o'chiring — bitta katta
DELETEbilan emas, batch'lar bilan. Har bir o'chirilgan qator dead tuple bo'lib qoladi, shuning uchun autovacuum bu jadvalga ulgurayotganini kuzating:
# orders/outbox.py (continued)
from datetime import timedelta
def purge_published(older_than=timedelta(days=7), batch_size=5000) -> None:
cutoff = timezone.now() - older_than
while True:
ids = list(
OutboxEvent.objects.filter(published_at__lt=cutoff)
.values_list("id", flat=True)[:batch_size]
)
if not ids:
break
OutboxEvent.objects.filter(id__in=ids).delete()
- "Zaharli" hodisa navbatni to'xtatadi. Relay xato bergan joyda to'xtaydi, demak bitta buzuq hodisa qolganlarini ushlab turadi.
attemptschegaradan oshsa, alert yuboring va qarorni inson qabul qilsin: payload'ni tuzatish yoki hodisani qo'lda chetga olish. - Relay replica'dan o'qimasin.
SELECT ... FOR UPDATEprimary'da bajarilishi kerak; database router sozlamalarini tekshiring. - Uzun relay tranzaksiyasi. Broker sekinlashsa, ochiq tranzaksiya VACUUM'ga xalaqit beradi. Timeout'lar va kichik batch shart.
on_commit+ Celery — bu outbox emas.task.delay()ham brokerga tarmoq chaqiruvi va commit'dan keyin xuddi shunday yo'qolishi mumkin.- Payload sxemasi — bu API. Iste'molchilar unga bog'lanadi.
event_type, versiya va faqat kerakli maydonlar. Keraksiz shaxsiy ma'lumotlarni (PII) qo'shmang: outbox jadvali ham log kabi saqlanadi va backup'ga tushadi. - Broker durability. Outbox hodisani brokergacha yetkazadi, undan keyin javobgarlik brokerda. Redis Streams ishlatsangiz, persistence (AOF) sozlamalarini va
maxleneski xabarlarni qachon kesishini tushunib oling.
Checklist
- Biznes yozuv va
OutboxEventbittatransaction.atomic()ichida. - Request yo'lida brokerga tarmoq chaqiruvi yo'q.
published_at IS NULLbo'yicha partial index.- Relay:
select_for_update(skip_locked=True), kichik batch, broker timeout'i. - Global tartibga tayanmang; agregat tartibi kerak bo'lsa — lock yoki partitsiya.
- Har bir hodisada global
event_id; iste'molchidaProcessedEventva effekt bitta tranzaksiyada. - Brokerdagi ACK — faqat commit'dan keyin.
- Yuborilgan qatorlarni batch bilan tozalash.
- Monitoring: eng eski yuborilmagan hodisaning yoshi,
attemptschegarasi, autovacuum.
Xulosa
Ikki tizimga atomik yozib bo'lmaydi, shuning uchun hodisani biznes ma'lumot bilan birga bazaga yozamiz va brokerga alohida relay orqali yetkazamiz. Bu "yo'qolgan xabar"ni "takroriy xabar"ga almashtiradi, takroriy xabarni esa iste'molchidagi idempotentlik zararsizlantiradi. SKIP LOCKED relay'ni xavfsiz parallellashtiradi, lekin tartibni faqat agregat doirasida va o'zingiz ta'minlaysiz.
// izohlar
Izohlar yuklanmoqda...