Barcha yozuvlar
Dasturlash

Celery vazifasi ikki marta bajarildi: acks_late, retry va idempotent vazifalar

Deploy paytida worker o'ldi va mijoz cashback'ni ikki marta oldi. Celery'da ack qachon ketadi, retry qanday ishlaydi va vazifani takrorga chidamli qilish uchun nima kerak.

Tasavvur qiling: foydalanuvchi buyurtma uchun to'ladi, view esa Celery'ga «cashback'ni hisobga yoz va SMS yubor» degan vazifa (task) yubordi. Shu payt deploy ketyapti: Kubernetes eski worker pod'iga SIGTERM yuboradi, 30 soniya kutadi, keyin SIGKILL. Vazifa yarmida uzildi. Endi ikki xil oqibat bo'lishi mumkin va ikkalasi ham yomon: yo vazifa butunlay yo'qoladi (mijoz cashback'ni hech qachon olmaydi), yo u qayta bajariladi va mijoz hisobiga cashback ikki marta tushadi.

Qaysi biri bo'lishi Celery sozlamalariga bog'liq. Bu maqolada Celery vazifani qachon «bajarildi» deb hisoblashini, retry qanday ishlashini va vazifani qanday qilib bir necha marta bajarilsa ham zararsiz (idempotent) qilishni ko'rib chiqamiz. Oldingi maqolada HTTP so'rovlar uchun idempotentlik kalitlarini ko'rgan edik; bu yerda o'sha g'oyani fon vazifalariga qo'llaymiz.

Sodda kod va uning to'rtta xatosi

Ko'p loyihalarda birinchi versiya taxminan shunday ko'rinadi:

# orders/tasks.py — the naive version
from decimal import Decimal

from celery import shared_task

from notifications.sms import send_sms


@shared_task
def credit_cashback(order):
    user = order.user
    user.balance += order.total * Decimal("0.01")
    user.save()
    send_sms(user.phone, f"Cashback for order #{order.pk} credited")
# orders/views.py — the naive call site
from django.db import transaction
from django.http import JsonResponse

from .models import Order
from .tasks import credit_cashback


def pay_order(request, order_id):
    with transaction.atomic():
        order = Order.objects.select_for_update().get(pk=order_id, user=request.user)
        order.status = Order.Status.PAID
        order.save(update_fields=["status"])
        credit_cashback.delay(order)  # sent BEFORE commit, with a whole object
    return JsonResponse({"ok": True})

Bir qarashda hammasi joyida. Aslida bu yerda to'rtta muammo bor:

  1. Vazifa commit'dan oldin yuboriladi. Worker xabarni transaction commit bo'lmasdan olishi mumkin va bazadan buyurtmaning eski holatini ko'radi. Transaction rollback bo'lsa, to'lanmagan buyurtma uchun cashback yoziladi.
  2. Argumentga butun obyekt berilgan. JSON serializer model obyektini umuman serializatsiya qila olmaydi; pickle bilan esa worker bir necha daqiqa oldingi eskirgan nusxa bilan ishlaydi.
  3. balance += ... read-modify-write. Ikki vazifa bir vaqtda ishlasa, bittasining yozgani yo'qoladi.
  4. Vazifa idempotent emas. Qayta bajarilsa, pul yana qo'shiladi va SMS yana ketadi.

Celery'ning yetkazib berish kafolatini tushunmasdan turib, bularning eng muhimi — to'rtinchisi — nega muqarrar ekanini ko'rish qiyin.

Ack qachon ketadi: at-most-once va at-least-once

Broker (Redis yoki RabbitMQ) xabarni worker'ga beradi, worker esa uni «ack» (acknowledge) qilishi kerak — ya'ni «oldim, o'chirsang bo'ladi» deyishi. Hamma gap shu ack qachon yuborilishida.

Standart holatda Celery xabarni vazifa bajarilishidan oldin ack qiladi. Agar worker vazifa o'rtasida o'lsa, xabar brokerda yo'q — vazifa yo'qoldi. Bu at-most-once: ko'pi bilan bir marta, ba'zan nol marta.

acks_late=True bilan ack vazifa tugagandan keyin yuboriladi. Worker'ning broker bilan ulanishi uzilsa yoki server o'chib qolsa, ack qilinmagan xabar qayta yetkaziladi. Bu at-least-once: kamida bir marta, ba'zan ikki va undan ko'p.

Lekin bitta nozik joy bor. Celery'da vazifani asosiy worker jarayoni emas, pool'dagi child process bajaradi. Agar aynan shu child process o'ldirilsa (masalan, OOM killer yoki SIGKILL), asosiy jarayon acks_late bo'lsa ham xabarni ack qilib yuboradi va vazifani FAILURE deb belgilaydi. Xabarni navbatga qaytarish uchun alohida task_reject_on_worker_lost=True kerak.

Sozlama Ack qachon Pool jarayoni o'ldirilsa Butun worker/ulanish uzilsa Kafolat
Standart Bajarishdan oldin Vazifa yo'qoladi Vazifa yo'qoladi at-most-once
acks_late=True Bajarilgandan keyin Ack qilinadi, vazifa yo'qoladi Qayta yetkaziladi qisman at-least-once
acks_late + reject_on_worker_lost Bajarilgandan keyin Navbatga qaytadi Qayta yetkaziladi at-least-once

E'tibor bering: acks_late bilan ham vazifa ichida oddiy exception chiqsa, xabar ack qilinadi (standart task_acks_on_failure_or_timeout=True). Qayta urinish — bu retry'ning ishi, ack'niki emas.

«Exactly-once» degan narsa yo'q. Siz yo vazifa yo'qolishini, yo takrorlanishini tanlaysiz. Pul bilan ishlaganda deyarli har doim takrorlanishni tanlaysiz va vazifani takrorga chidamli qilasiz.

Pul bilan bog'liq vazifalar uchun men quyidagi konfiguratsiyadan boshlayman:

# config/celery.py
import os

from celery import Celery

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")

app = Celery("config")
app.config_from_object("django.conf:settings", namespace="CELERY")
app.autodiscover_tasks()
# config/settings.py
CELERY_BROKER_URL = "redis://localhost:6379/0"
CELERY_TASK_SERIALIZER = "json"
CELERY_ACCEPT_CONTENT = ["json"]

CELERY_TASK_ACKS_LATE = True              # ack after the task finishes
CELERY_TASK_REJECT_ON_WORKER_LOST = True  # requeue if the pool process dies
CELERY_WORKER_PREFETCH_MULTIPLIER = 1     # do not hoard unacked messages

# Redis: must exceed your longest task AND your longest countdown/ETA
CELERY_BROKER_TRANSPORT_OPTIONS = {"visibility_timeout": 6 * 60 * 60}

worker_prefetch_multiplier = 1 nega kerak? Worker xabarlarni oldindan olib qo'yadi (prefetch), acks_late bilan ular ack qilinmagan holda turadi. Uzun vazifalarda bu bitta worker o'zida ko'p xabarni «ushlab» o'tirishini va ular hammasi worker o'lganda qayta yetkazilishini anglatadi.

Retry: exponential backoff, jitter va max_retries

Tashqi API vaqtincha javob bermasa, vazifani darhol qayta yuborish yaxshi fikr emas: yuzlab worker bir vaqtda allaqachon qiynalayotgan servisni yana bosadi. To'g'ri usul — har urinishda kutishni ikki baravar oshirish (exponential backoff) va unga tasodifiy qism qo'shish (jitter), shunda qayta urinishlar vaqt bo'yicha tarqaladi.

# notifications/tasks.py
import requests
from celery import shared_task

from .models import Notification

SMS_URL = "https://sms.example.com/v1/messages"


@shared_task(
    bind=True,
    autoretry_for=(requests.ConnectionError, requests.Timeout),
    retry_backoff=True,      # 1, 2, 4, 8 ... seconds
    retry_backoff_max=600,   # never wait more than 10 minutes
    retry_jitter=True,       # random delay in [0, backoff]
    max_retries=8,
)
def send_sms_notification(self, notification_id: int) -> None:
    n = Notification.objects.get(pk=notification_id)
    if n.status == Notification.Status.SENT:
        return  # a previous delivery already did the job

    resp = requests.post(
        SMS_URL,
        json={"phone": n.phone, "text": n.text},
        headers={"Idempotency-Key": str(n.uuid)},
        timeout=(3, 10),
    )
    if resp.status_code == 429 or resp.status_code >= 500:
        # temporary problem on their side: retry manually with a delay
        raise self.retry(countdown=min(60 * 2 ** self.request.retries, 900))
    resp.raise_for_status()  # other 4xx: a bug in our request, retrying won't help

    Notification.objects.filter(pk=n.pk).update(status=Notification.Status.SENT)

Bu yerda nimalar sodir bo'ladi:

  • autoretry_for — faqat ro'yxatdagi exception'lar uchun avtomatik retry. autoretry_for=(Exception,) yozmang: DoesNotExist yoki KeyError kabi dasturiy xatolarni sakkiz marta takrorlashdan foyda yo'q.
  • retry_backoff=True kechikishni 1 * 2 ** retries soniya qilib hisoblaydi, retry_backoff_max (standart 600) bilan cheklaydi. retry_jitter=True (standart yoqilgan) esa haqiqiy kechikishni 0 dan shu qiymatgacha tasodifiy tanlaydi.
  • max_retries standart 3 ga teng; None cheksiz degani. Limit tugaganda self.retry(exc=exc) asl exception'ni qayta ko'taradi, exc berilmagan bo'lsa — MaxRetriesExceededError.
  • self.retry() exception ko'taradi, shuning uchun uni raise self.retry(...) deb yozish odat bo'lgan: undan keyingi kod bajarilmasligi aniq ko'rinadi.
  • timeout=(3, 10) majburiy. Timeout'siz requests cheksiz osilib qolishi mumkin va retry hech qachon boshlanmaydi.

Muhim: retry — bu o'sha vazifaning yangi xabar sifatida, countdown bilan qayta yuborilishi. Ya'ni retry ham at-least-once mexanizmining bir qismi, vazifa baribir takrorlanishga tayyor bo'lishi kerak. Idempotency-Key sarlavhasi aynan shuning uchun: agar SMS provayder so'rovni qabul qilgan-u, javob bizga yetib kelmagan bo'lsa, qayta so'rov ikkinchi SMS'ga aylanmaydi — albatta, provayder bu sarlavhani qo'llab-quvvatlasa.

Vazifani idempotent qilish

Idempotent vazifa — bir marta yoki besh marta bajarilishidan qat'i nazar, natija bir xil bo'ladigan vazifa. Bazada buni qilishning eng ishonchli yo'li — «da'vo qilish»ni (claim) bitta atomar UPDATE bilan qilish:

# orders/tasks.py — the fixed version
from decimal import ROUND_HALF_UP, Decimal

from celery import shared_task
from django.db import transaction
from django.db.models import F

from wallets.models import Wallet

from .models import Order


@shared_task(acks_late=True)
def credit_cashback(order_id: int) -> None:
    with transaction.atomic():
        # Atomic "claim": only one execution can flip the flag.
        claimed = Order.objects.filter(
            pk=order_id,
            status=Order.Status.PAID,
            cashback_credited=False,
        ).update(cashback_credited=True)
        if not claimed:
            return  # already credited, or the order is not paid

        order = Order.objects.only("total", "user_id").get(pk=order_id)
        amount = (order.total * Decimal("0.01")).quantize(
            Decimal("0.01"), rounding=ROUND_HALF_UP
        )
        Wallet.objects.filter(user_id=order.user_id).update(
            balance=F("balance") + amount
        )

Bu yerda tekshiruv va yozish alohida qadamlar emas. if order.cashback_credited: return yozib, keyin save() qilsak, ikki parallel vazifa ikkalasi ham False ni ko'rib, ikkalasi ham pul qo'shardi. Shartli UPDATE esa PostgreSQL'da shunday ishlaydi:

-- What the "claim" compiles to (simplified)
UPDATE orders_order
   SET cashback_credited = true
 WHERE id = 42
   AND status = 'paid'
   AND cashback_credited = false;
-- First transaction:  UPDATE 1
-- Second, concurrent: waits for the row lock, re-checks WHERE
--                     after the first commits -> UPDATE 0

READ COMMITTED darajasida ikkinchi transaction birinchisi ushlagan qator lock'ini kutadi, commit'dan keyin qatorning yangi versiyasida WHERE shartini qayta tekshiradi va hech narsani yangilamaydi. .update() yangilangan qatorlar sonini qaytaradi, biz shundan foydalanamiz. Balansni ham F("balance") + amount bilan yangilaymiz — Python'da o'qib-yozish emas, bazaning o'zida atomar qo'shish.

Yana kuchliroq variant — har bir operatsiyani alohida ledger qatori sifatida yozish va takrorni bazaning o'zi rad etishi:

# wallets/models.py — a ledger row makes duplicates impossible at the DB level
from django.db import models


class CashbackEntry(models.Model):
    order = models.ForeignKey("orders.Order", on_delete=models.PROTECT)
    amount = models.DecimalField(max_digits=14, decimal_places=2)
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        constraints = [
            models.UniqueConstraint(fields=["order"], name="uniq_cashback_per_order"),
        ]

Ikkinchi CashbackEntry.objects.create(order_id=...) IntegrityError beradi va transaction rollback bo'ladi. Kod qanchalik xato bo'lmasin, constraint ikkinchi yozuvni o'tkazmaydi.

Tashqi side effect'lar (SMS, email, provayderga to'lov) bilan holat boshqacha: ularni bazaning transaction'iga qo'shib bo'lmaydi. Bu yerda ikkita vosita bor: provayder qo'llab-quvvatlasa idempotentlik kaliti, bo'lmasa — holatni yozib borish (pending → sent) va kamdan-kam takrorlanishni qabul qilish. SMS'ni pul yozadigan vazifadan ajratib, alohida vazifaga chiqarishimning sababi ham shu: bittasining retry'i ikkinchisini qayta ishga tushirmasligi kerak.

Argumentga obyekt emas, id bering

credit_cashback.delay(order) o'rniga credit_cashback.delay(order.pk). Sabablari:

  • JSON (Celery'ning standart serializer'i) model obyektini serializatsiya qila olmaydi. Pickle'ni yoqish esa xavfsizlik nuqtai nazaridan yomon: pickle xabar orqali kod bajarishga yo'l ochadi.
  • Vazifa bir necha soniya, retry bilan esa bir necha daqiqa keyin bajariladi. Shu vaqt ichida qator o'zgargan bo'lishi mumkin. Id bilan worker bazadan hozirgi holatni o'qiydi.
  • Xabar kichik bo'ladi va uni broker'da o'qish oson.

Xuddi shunday, summa kabi qiymatlarni ham argument qilib uzatishdan ehtiyot bo'ling: vazifa summani o'zi bazadan olsin. Aks holda eskirgan qiymat retry'lar orqali «abadiy» yashaydi.

transaction.on_commit: vazifani commit'dan keyin yuborish

Sodda versiyadagi eng ayyor xato — delay() ni atomic() ichida chaqirish. Xabar Redis'ga darhol ketadi, commit esa keyinroq bo'ladi. Tez worker buyurtmani hali PAID bo'lmagan holatda ko'radi; transaction rollback bo'lsa, umuman mavjud bo'lmagan to'lov uchun vazifa ishlaydi.

# orders/views.py — the fixed call site
from functools import partial

from django.db import transaction
from django.http import JsonResponse

from .models import Order
from .tasks import credit_cashback


def pay_order(request, order_id):
    with transaction.atomic():
        order = Order.objects.select_for_update().get(pk=order_id, user=request.user)
        order.status = Order.Status.PAID
        order.save(update_fields=["status"])
        transaction.on_commit(partial(credit_cashback.delay, order.pk))
        # Celery 5.4+ with Django: credit_cashback.delay_on_commit(order.pk)
    return JsonResponse({"ok": True})

transaction.on_commit() callback'ni tashqi transaction muvaffaqiyatli commit bo'lgandan keyin chaqiradi, rollback bo'lsa — umuman chaqirmaydi. Celery 5.4 dan boshlab Django bilan ishlaganda task'larning standart klassi DjangoTask bo'ladi va unda xuddi shuni qiladigan delay_on_commit() va apply_async_on_commit() metodlari bor.

Testlarda TestCase har bir testni transaction ichida bajaradi va hech qachon commit qilmaydi, shuning uchun on_commit callback'lari o'z-o'zidan ishlamaydi. Ularni captureOnCommitCallbacks bilan ishga tushiring:

# orders/tests.py
from unittest import mock

from django.test import TestCase

from .models import Order


class PayOrderTests(TestCase):
    def test_task_is_sent_after_commit(self):
        order = Order.objects.create(...)  # fixture of your choice
        with mock.patch("orders.views.credit_cashback.delay") as delay:
            with self.captureOnCommitCallbacks(execute=True):
                self.client.post(f"/orders/{order.pk}/pay/")
        delay.assert_called_once_with(order.pk)

Lekin on_commit ham to'liq kafolat emas. Commit bo'ldi, callback esa Redis'ga ulana olmadi yoki aynan shu soniyada jarayon o'ldi — vazifa yo'qoldi. Pul uchun buning oldini olishning oddiy usuli — davriy «supurgi» vazifa (Celery beat orqali), u bajarilmay qolgan ishlarni topib qayta yuboradi. Vazifa idempotent bo'lgani uchun buni xavfsiz qilish mumkin:

# orders/tasks.py — a safety net for messages lost between commit and broker
from datetime import timedelta

from celery import shared_task
from django.utils import timezone

from .models import Order


@shared_task
def resend_missing_cashback() -> int:
    cutoff = timezone.now() - timedelta(minutes=10)
    ids = list(
        Order.objects.filter(
            status=Order.Status.PAID,
            cashback_credited=False,
            paid_at__lt=cutoff,
        ).values_list("pk", flat=True)[:500]
    )
    for pk in ids:
        credit_cashback.delay(pk)  # safe: the task is idempotent
    return len(ids)

Kattaroq tizimlarda buning umumlashgan shakli — outbox pattern: xabar biznes ma'lumoti bilan bitta transaction'da jadvalga yoziladi, alohida jarayon esa uni brokerga uzatadi.

Visibility timeout tuzog'i

Redis'da RabbitMQ'dagidek «ulanish uzildi — ack qilinmagan xabarlarni qaytar» degan mexanizm yo'q. Shuning uchun Celery'ning Redis transport'i olingan xabarlarni alohida unacked strukturasida saqlaydi va visibility timeout (standart 1 soat) ichida ack bo'lmasa, xabarni navbatga qaytaradi. Bu worker o'lganda xabarni qutqaradi, lekin ikkita kutilmagan oqibati bor:

  1. Uzun vazifalar. acks_late vazifa visibility timeout'dan uzoqroq ishlasa, xabar boshqa worker'ga ham beriladi — vazifa hech kim o'lmasdan turib ikki marta bajariladi.
  2. countdown va ETA. apply_async(countdown=...), eta=... va self.retry(countdown=...) bilan yuborilgan xabarlarni worker darhol oladi va vaqti kelguncha xotirasida saqlaydi. Kechikish visibility timeout'dan katta bo'lsa, xabar qayta yetkaziladi va har gal yangi worker ham uni kutishga oladi — natijada bitta vazifa bir necha nusxada bajariladi.

Yechim: visibility_timeout ni eng uzun vazifangiz va eng katta countdown'ingizdan katta qilib qo'ying (yuqoridagi sozlamalarda 6 soat). Bir kundan keyin bajarilishi kerak bo'lgan ishlar uchun countdown emas, bazadagi run_at ustuni va davriy vazifa ishlating. Retry'da esa retry_backoff_max kechikishni cheklab turadi, bu ham muhim.

RabbitMQ'da visibility timeout yo'q, lekin o'xshash cheklov bor: consumer_timeout, ack'ni kutish muddati. U oshib ketsa, broker kanalni yopadi va xabar qayta yetkaziladi. Uzun vazifalar uchun buni ham tekshiring.

Holatni Redis'da kuzatish mumkin:

# Messages taken by workers but not yet acked (Redis transport)
redis-cli HLEN unacked
# Messages waiting in the default queue
redis-cli LLEN celery

Production'da uchraydigan tuzoqlar

  • Graceful shutdown'ga yetmaydigan vaqt. SIGTERM'dan keyin Celery yangi vazifa olmaydi va joriylarini tugatishga harakat qiladi. Kubernetes'da terminationGracePeriodSeconds standart 30 soniya; vazifa uzunroq bo'lsa, pod SIGKILL oladi. Bu muddatni eng uzun vazifadan uzunroq qiling yoki vazifalarni qisqa bo'laklarga bo'ling.
  • «Zaharli» xabar. reject_on_worker_lost=True bilan worker'ni har safar OOM bilan o'ldiradigan vazifa navbatga qaytaveradi va cheksiz aylanadi. Xotira sarfini monitoring qiling va time_limit qo'ying.
  • Retry ichida yarim bajarilgan ish. Vazifa avval bazaga yozib, keyin API'ni chaqirib, xato bersa, retry birinchi qismni yana bajaradi. Yo hammasini bitta transaction'da qiling, yo har bir qadamni alohida idempotent qiling.
  • Eager rejim testlari. task_always_eager=True bilan testlar broker, serializatsiya va ack'ni chetlab o'tadi. Obyektni argument qilib bergan kod testda o'tadi, production'da esa yiqiladi.
  • Natijaga tayanish. result.get() ni boshqa vazifa ichidan chaqirmang: bu worker'larni bir-birini kutishga majbur qiladi va deadlock'ga olib kelishi mumkin.

Tekshiruv ro'yxati

  • Pul yoki holat o'zgartiradigan vazifalar: acks_late=True va task_reject_on_worker_lost=True.
  • Har bir vazifa takrorga chidamli: shartli UPDATE, UniqueConstraint yoki holat maydoni.
  • Tashqi API'larga idempotentlik kaliti va har doim timeout.
  • autoretry_for faqat vaqtinchalik xatolar uchun, retry_backoff, retry_jitter va aniq max_retries bilan.
  • Argumentda faqat id va oddiy qiymatlar, JSON serializer.
  • delay() faqat transaction.on_commit() yoki delay_on_commit() orqali.
  • Yo'qolgan xabarlar uchun davriy tekshiruv vazifasi.
  • visibility_timeout > eng uzun vazifa va eng katta countdown.
  • Shutdown muddati > eng uzun vazifa.

Xulosa

Celery sizga «aynan bir marta» bermaydi: standart holatda vazifa yo'qolishi, acks_late bilan esa takrorlanishi mumkin. Pul bilan ishlaydigan tizimda to'g'ri tanlov — at-least-once yetkazish va idempotent vazifa. Vazifani commit'dan keyin yuboring, argumentga id bering, takrorni bazaning o'zi rad etsin va visibility timeout'ni hisobga oling — shunda deploy paytidagi SIGKILL mijozning hisobidagi ikki baravar cashback'ga aylanmaydi.

// izohlar

Izohlar yuklanmoqda...

    // keyingi qadam

    Keling, birga nimadir quramiz.

    Telegramda yozish
    aslbek@asldev: ~
    ❯