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:
- 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.
- Argumentga butun obyekt berilgan. JSON serializer model obyektini umuman serializatsiya qila olmaydi; pickle bilan esa worker bir necha daqiqa oldingi eskirgan nusxa bilan ishlaydi.
balance += ...read-modify-write. Ikki vazifa bir vaqtda ishlasa, bittasining yozgani yo'qoladi.- 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:DoesNotExistyokiKeyErrorkabi dasturiy xatolarni sakkiz marta takrorlashdan foyda yo'q.retry_backoff=Truekechikishni1 * 2 ** retriessoniya qilib hisoblaydi,retry_backoff_max(standart 600) bilan cheklaydi.retry_jitter=True(standart yoqilgan) esa haqiqiy kechikishni 0 dan shu qiymatgacha tasodifiy tanlaydi.max_retriesstandart 3 ga teng;Nonecheksiz degani. Limit tugagandaself.retry(exc=exc)asl exception'ni qayta ko'taradi,excberilmagan bo'lsa —MaxRetriesExceededError.self.retry()exception ko'taradi, shuning uchun uniraise self.retry(...)deb yozish odat bo'lgan: undan keyingi kod bajarilmasligi aniq ko'rinadi.timeout=(3, 10)majburiy. Timeout'sizrequestscheksiz 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:
- Uzun vazifalar.
acks_latevazifa visibility timeout'dan uzoqroq ishlasa, xabar boshqa worker'ga ham beriladi — vazifa hech kim o'lmasdan turib ikki marta bajariladi. - countdown va ETA.
apply_async(countdown=...),eta=...vaself.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
terminationGracePeriodSecondsstandart 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=Truebilan worker'ni har safar OOM bilan o'ldiradigan vazifa navbatga qaytaveradi va cheksiz aylanadi. Xotira sarfini monitoring qiling vatime_limitqo'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=Truebilan 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=Truevatask_reject_on_worker_lost=True. - Har bir vazifa takrorga chidamli: shartli
UPDATE,UniqueConstraintyoki holat maydoni. - Tashqi API'larga idempotentlik kaliti va har doim
timeout. autoretry_forfaqat vaqtinchalik xatolar uchun,retry_backoff,retry_jitterva aniqmax_retriesbilan.- Argumentda faqat id va oddiy qiymatlar, JSON serializer.
delay()faqattransaction.on_commit()yokidelay_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...