Barcha yozuvlar
Dasturlash

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:

  1. Biznes ma'lumot (Order) va hodisa (OutboxEvent) bitta tranzaksiyada, bitta bazaga yoziladi. Yo ikkalasi commit bo'ladi, yo hech biri.
  2. Alohida jarayon — relay (ba'zan poller deyiladi) — outbox jadvalidan hali yuborilmagan qatorlarni o'qiydi, brokerga yuboradi va published_atni belgilaydi.
  3. 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. Bazadagi id tashqariga chiqmaydi, event_id esa hodisa bilan birga yuradi.
  • payload — JSONField. Ichiga ORM obyektini emas, aniq sxemali dict yozing. Decimal va datetimeni o'zingiz string'ga aylantiring: standart JSON encoder ularni serializatsiya qila olmaydi.
  • Qisman (partial) index faqat published_at IS NULL bo'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 INSERT paytida beriladi, commit paytida emas. T1 tranzaksiya id=10 oladi, T2 id=11 oladi, lekin T2 birinchi commit bo'ladi. Relay 11 ni yuboradi, 10 esa keyinroq ko'rinadi.
  • Bir nechta relay SKIP LOCKED bilan 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 tartibida id oladi.
  • Qat'iy tartib kerak bo'lsa, bitta relay ishlating yoki outbox'ga partition ustunini 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:

  • ProcessedEvent qatori va Invoice bitta 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 ikkinchi INSERTni birinchisi tugaguncha kuttirib qo'yadi, keyin unique xatosi beradi; get_or_create uni ushlab, created=False qaytaradi.
  • XACK commit'dan keyin. Jarayon ular orasida o'lsa, xabar pending ro'yxatida qoladi va qayta yetkaziladi — ProcessedEvent uni ushlab qoladi. O'lgan consumer'larning pending xabarlarini olish uchun XAUTOCLAIM ishlating.

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 DELETE bilan 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. attempts chegaradan oshsa, alert yuboring va qarorni inson qabul qilsin: payload'ni tuzatish yoki hodisani qo'lda chetga olish.
  • Relay replica'dan o'qimasin. SELECT ... FOR UPDATE primary'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 maxlen eski xabarlarni qachon kesishini tushunib oling.

Checklist

  • Biznes yozuv va OutboxEvent bitta transaction.atomic() ichida.
  • Request yo'lida brokerga tarmoq chaqiruvi yo'q.
  • published_at IS NULL bo'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'molchida ProcessedEvent va effekt bitta tranzaksiyada.
  • Brokerdagi ACK — faqat commit'dan keyin.
  • Yuborilgan qatorlarni batch bilan tozalash.
  • Monitoring: eng eski yuborilmagan hodisaning yoshi, attempts chegarasi, 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...

    // keyingi qadam

    Keling, birga nimadir quramiz.

    Telegramda yozish
    aslbek@asldev: ~
    ❯