🐍 Kafka, RabbitMQ и Celery из Python
Теория брокеров одна на все языки, а теряют сообщения на Python в конкретных местах: в автокоммите confluent-kafka, в message.process() у aio-pika, в настройках Celery по умолчанию. Celery на собеседовании по Python спрашивают отдельно и подробно, потому что он стоит во многих Django-проектах. Партиции, consumer group, ack и DLQ разобраны на соседних страницах модуля, здесь только клиенты, их дефолты и то, что из этого следует
🧰 Какие библиотеки брать
| Задача | Библиотека | Как работает |
|---|---|---|
| Kafka | confluent-kafka | обёртка над librdkafka, синхронный poll, есть модуль confluent_kafka.aio |
| Kafka в asyncio | aiokafka | чистый Python поверх asyncio |
| RabbitMQ в asyncio | aio-pika | AMQP 0-9-1, переподключение через connect_robust |
| События между сервисами | FastStream | фреймворк поверх aiokafka, confluent-kafka, aio-pika, NATS и Redis |
| Фоновые задачи | Celery | брокер Redis или RabbitMQ, воркеры-процессы |
confluent-kafka берут по умолчанию: его поддерживает Confluent, а librdkafka внутри та же, что у клиентов Go и .NET, поэтому настройки называются одинаково и совпадают с документацией Kafka. Классический API синхронный: consumer.poll(1.0) блокирует поток до секунды, и в корутине его вызывать нельзя по той же причине, что time.sleep, — подробнее на странице про блокирующий код в async. С версии 2.12.0 (октябрь 2025) в пакете есть AIOProducer, позже появился AIOConsumer, а в 2.13.0 с них сняли пометку experimental. Внутри блокирующие вызовы librdkafka уходят в пул потоков, его размер задают параметры max_workers и executor
aiokafka написан на asyncio целиком и долго был единственным вариантом для async-сервиса. Для нового async-кода выбирают между ним и confluent_kafka.aio, и разумный критерий — что уже используют соседние сервисы команды
📜 Kafka: когда коммитится offset
У librdkafka две настройки по умолчанию включены, и вместе они дают потерю сообщений при падении. enable.auto.offset.store сохраняет в памяти offset каждого сообщения, как только poll отдал его приложению, а enable.auto.commit раз в auto.commit.interval.ms (5000 мс) отправляет сохранённое в брокер. Консьюмер получил сообщение, через секунду таймер закоммитил offset, ещё через секунду процесс упал посреди обработки. После рестарта группа читает со следующего сообщения, и это сообщение никто не обработает
Чтобы получить at-least-once, offset двигают только после обработки. Два способа:
enable.auto.commit: Falseиconsumer.commit(message=msg)после обработки. Просто, но синхронный коммит — это поход в брокер на каждое сообщениеenable.auto.offset.store: Falseиconsumer.store_offsets(msg)после обработки. Автокоммит по таймеру остаётся, но коммитит только то, что приложение явно пометило. Сетевых походов столько же, сколько при автокоммите, а потерь нет
В обоих случаях после падения часть сообщений придёт второй раз: обработали, а коммит не успел уйти. Поэтому обработчик должен быть идемпотентным, как это сделать, разобрано на странице про идемпотентность в модуле микросервисов
Второй лимит, о котором спрашивают, — max.poll.interval.ms, по умолчанию 300 000 мс. Если между двумя вызовами poll прошло больше пяти минут, librdkafka считает консьюмер зависшим и выводит его из группы, партиции уходят другим, и начинается ребаланс. Долгая обработка одного сообщения в цикле poll упирается именно в него
Python · Консьюмер confluent-kafka, offset после обработки
import json
import signal
import threading
from confluent_kafka import Consumer, KafkaException
stop = threading.Event()
signal.signal(signal.SIGTERM, lambda *_: stop.set())
consumer = Consumer({
"bootstrap.servers": "kafka:9092",
"group.id": "billing-payments",
"auto.offset.reset": "earliest",
"enable.auto.offset.store": False, # offset сохраняем сами, после обработки
})
consumer.subscribe(["payments"])
try:
while not stop.is_set():
msg = consumer.poll(1.0) # блокирует поток до секунды
if msg is None:
continue
if msg.error():
raise KafkaException(msg.error())
handle_payment(json.loads(msg.value()))
consumer.store_offsets(message=msg) # закоммитит автокоммит по таймеру
finally:
consumer.close() # финальный коммит и выход из группыВ aiokafka автокоммит тоже включён по умолчанию (enable_auto_commit=True). Его выключают и после обработки вызывают await consumer.commit(). Если коммитят offset руками через словарь, пишут номер следующего сообщения, а не обработанного: {tp: msg.offset + 1}
consumer = AIOKafkaConsumer(
"payments",
bootstrap_servers="kafka:9092",
group_id="billing-payments",
enable_auto_commit=False,
)
await consumer.start()
try:
async for msg in consumer:
await handle_payment(json.loads(msg.value))
await consumer.commit() # позиция после уже обработанного сообщения
finally:
await consumer.stop()У продюсера своя ловушка. producer.produce() в confluent-kafka только кладёт сообщение в буфер librdkafka, отправка идёт в фоне. Скрипт или задача, которые завершились без producer.flush(), теряют всё, что не успело уйти, и ошибки при этом не видно. В долгоживущем сервисе регулярно вызывают producer.poll(0): внутри него срабатывают колбэки доставки
🐇 RabbitMQ через aio-pika
aio_pika.connect_robust переподключается после обрыва и заново объявляет каналы, очереди и консьюмеров. Сообщение, полученное до обрыва, на новом канале подтвердить нельзя: брокер вернёт его в очередь сам, и оно придёт ещё раз
channel.set_qos(prefetch_count=10) ограничивает, сколько неподтверждённых сообщений брокер выдаст этому консьюмеру. Что из этого следует для конкурентности, зависит от способа чтения:
async forпоqueue.iterator()обрабатывает сообщения по одному, prefetch тут работает как буфер в памятиqueue.consume(callback)запускает колбэки параллельно, и prefetch становится лимитом одновременных обработок
connection = await aio_pika.connect_robust("amqp://guest:guest@rabbit/")
async with connection:
channel = await connection.channel()
await channel.set_qos(prefetch_count=10)
queue = await channel.declare_queue("emails", durable=True)
async with queue.iterator() as messages:
async for message in messages:
async with message.process(): # ack при успехе, reject при исключении
await send_email(json.loads(message.body))message.process() по умолчанию отклоняет сообщение с requeue=False. Если у очереди настроен dead letter exchange, сообщение уйдёт туда, если нет — пропадёт. requeue=True тоже не выход: битое сообщение будет возвращаться бесконечно. Схема с ограниченными повторами и DLQ разобрана на странице про ретраи
FastStream закрывает всю эту обвязку декоратором в стиле FastAPI: @broker.subscriber("emails") над функцией, тело сообщения валидируется по аннотации через Pydantic, по обработчикам генерируется документация AsyncAPI. Под капотом те же aiokafka, confluent-kafka и aio-pika, поэтому всё про offset и ack выше остаётся в силе
🥬 Celery: брокер, воркер, результаты
В Celery три части. Брокер (Redis или RabbitMQ) хранит очередь задач. Воркер — отдельный процесс celery worker, который забирает задачи и выполняет их в дочерних процессах (пул prefork по умолчанию). Backend результатов хранит, чем закончилась задача. По умолчанию его нет, и result.get() без backend работать не будет. Включают его, только если результат кто-то читает
Когда задача подтверждается
По умолчанию воркер отправляет ack перед запуском задачи. Упал воркер посреди выполнения — задача потеряна, брокер считает её доставленной. С acks_late=True ack уходит после того, как задача вернулась, и упавшая задача придёт снова. Значит, задача может выполниться несколько раз и должна быть идемпотентной: повторный запуск «отправить чек по заказу 42» проверяет, не ушёл ли чек, а не шлёт второй
Есть тонкость. Даже с acks_late воркер подтверждает задачу, если её дочерний процесс убит сигналом или вызвал sys.exit(): так Celery защищается от задачи, которая роняет процесс по OOM и иначе крутилась бы по кругу. Чтобы такая задача вернулась в очередь, нужен ещё task_reject_on_worker_lost=True
Prefetch и длинные задачи
Воркер заранее берёт из брокера worker_prefetch_multiplier × concurrency задач, множитель по умолчанию 4. Для длинных задач это перекос: воркер с -c 4 забирает 16 задач по 10 минут, четыре выполняет, двенадцать держит у себя, а соседний воркер простаивает с пустой очередью. Поэтому для них ставят множитель 1. С ранним ack воркер всё равно держит по одной лишней задаче на процесс, и только связка task_acks_late=True плюс worker_prefetch_multiplier=1 даёт ровно одну задачу на процесс
Visibility timeout у Redis
В Redis нет настоящего ack, поэтому Celery имитирует его таймаутом. Задачу, которую не подтвердили за visibility_timeout (по умолчанию час), брокер отдаёт другому воркеру. С acks_late задача на полтора часа выполнится дважды, параллельно, и никто не упал. Таймаут поднимают выше самой длинной задачи через broker_transport_options. Та же проблема у задач с countdown или eta дальше таймаута: по документации они могут выполняться снова и снова. У RabbitMQ похожий лимит называется consumer_timeout, по умолчанию 30 минут: не дождавшись ack, брокер отменяет консьюмер или закрывает канал и возвращает сообщение в очередь. С RabbitMQ 4.3 этот таймаут работает только для quorum-очередей
Ретраи с backoff
import httpx
from celery import Celery
app = Celery("shop", broker="redis://redis:6379/0")
app.conf.update(
task_acks_late=True,
task_reject_on_worker_lost=True,
worker_prefetch_multiplier=1,
broker_transport_options={"visibility_timeout": 4 * 3600}, # дольше самой длинной задачи
)
@app.task(
autoretry_for=(httpx.TransportError,),
retry_backoff=True, # 1, 2, 4, 8 с, не дольше retry_backoff_max
max_retries=5,
)
def send_receipt(order_id: int) -> None:
if receipt_already_sent(order_id):
return # повторная доставка: чек уже ушёл
send_to_ofd(order_id)
mark_receipt_sent(order_id)autoretry_for перечисляет исключения, на которые задача повторяется сама. retry_backoff=True даёт экспоненту 1, 2, 4, 8 секунд, число вместо True задаёт множитель. Потолок retry_backoff_max по умолчанию 600 секунд, а retry_jitter включён по умолчанию, и реальная задержка — случайное число от нуля до вычисленной. max_retries по умолчанию 3, None значит повторять вечно. После последней попытки исключение пробрасывается, и задача заканчивается ошибкой
Beat — ровно один
celery beat — планировщик, который по расписанию кладёт задачи в очередь. Он ничего не знает о других своих копиях. Запустишь два экземпляра, например в двух репликах пода, — каждая задача из расписания уйдёт дважды. Beat держат одним отдельным процессом или деплойментом с одной репликой, а задачи из расписания всё равно пишут идемпотентными: при деплое старый и новый под могут недолго работать вместе
Celery и asyncio
Celery вызывает функцию задачи синхронно, в пуле prefork, threads, gevent или eventlet. async def задача вернёт объект корутины, который никто не дождётся. Обходной путь asyncio.run() внутри задачи создаёт новый цикл на каждый вызов. Пул соединений asyncpg или клиент httpx, созданные один раз на модуль, привязаны к первому циклу и падают на втором, а заводить их на каждую задачу дорого. Async-сервису нужна очередь задач, которая выполняет корутины сама
🔀 Альтернативы Celery
| Что | Брокер | Async | Когда брать |
|---|---|---|---|
| Dramatiq | RabbitMQ, Redis | через middleware AsyncIO | синхронный код, нужно проще Celery и с разумными дефолтами |
| arq | Redis | нативно | только старый код: проект в режиме maintenance only |
| Taskiq | Redis, RabbitMQ, NATS, Kafka | нативно | новый async-сервис на FastAPI или aiohttp |
| Задачи Django 6 | бэкенд от сторонней библиотеки | aenqueue() | единый интерфейс @task и .enqueue(), исполнитель подключаешь отдельно |
Фреймворк задач в Django 6.0 — это API, а не очередь. Встроенные бэкенды ImmediateBackend (по умолчанию, выполняет задачу сразу, в том же процессе) и DummyBackend (не выполняет вообще) годятся для разработки и тестов, воркера в коробке нет. Для прода нужен бэкенд стороннего пакета с собственным воркером
⚠️ Где ошибаются
Оставляют автокоммит confluent-kafka и считают, что сообщения не теряются. Offset уходит в брокер по таймеру, независимо от того, закончилась ли обработка. Включают ручное сохранение offset после обработки и делают обработчик идемпотентным
Включают acks_late и не трогают задачи. Повторная доставка становится нормой: рестарт воркера при деплое, OOM, истёкший visibility timeout. Задача, которая списывает деньги или шлёт письмо без проверки «уже сделано», сделает это дважды
Используют message.process() без DLX. Любое исключение в обработчике молча удаляет сообщение из очереди. Настраивают dead letter exchange на очередь или ловят временные ошибки и решают сами, повторять или отклонять
🎯 Вопросы с собеседований
Из чего состоит Celery и как настроить ретраи?
Брокер хранит очередь задач, воркер забирает их и выполняет в дочерних процессах, backend результатов хранит статус и возвращаемое значение и нужен, только если результат кто-то читает. Ретраи задают в декораторе: autoretry_for со списком исключений, retry_backoff=True для экспоненциальной задержки, max_retries для лимита, по умолчанию 3. Потолок задержки — retry_backoff_max, 600 секунд, и по умолчанию к задержке добавляется случайный разброс, чтобы повторы не били в сервис одновременно. Раз задача может повториться, побочные эффекты в ней должны быть идемпотентными
Что будет с задачей Celery, если воркер упал посреди выполнения?
По умолчанию она потеряна: ack ушёл до запуска, брокер считает задачу доставленной. С acks_late=True ack отправляется после завершения, и задача придёт снова, поэтому она должна быть идемпотентной. Если дочерний процесс убит сигналом, например OOM killer, Celery всё равно подтверждает задачу, чтобы не крутить её по кругу, и вернуть её можно только через task_reject_on_worker_lost=True. На Redis-брокере неподтверждённая задача возвращается по visibility_timeout, по умолчанию через час
Почему Celery плохо дружит с asyncio и что выбрать для async-сервиса?
Celery вызывает задачи синхронно, пул prefork или потоки, и не запускает для них цикл событий. async def задача просто вернёт корутину. asyncio.run() внутри задачи заводит новый цикл на каждый вызов, и клиенты, созданные один раз на процесс, вроде пула asyncpg, ломаются на втором цикле. Для async-сервиса берут Taskiq, где задачи — корутины, или Dramatiq с middleware AsyncIO. arq тоже нативно асинхронный, но проект в режиме maintenance only. Для событий между сервисами — FastStream поверх aiokafka или aio-pika
Как гарантировать, что сообщение из Kafka не потеряется при падении консьюмера на Python?
Двигать offset только после обработки. В confluent-kafka по умолчанию offset сохраняется, как только poll отдал сообщение, и коммитится по таймеру раз в 5 секунд, поэтому падение посреди обработки теряет сообщение. Выключают enable.auto.offset.store и после обработки вызывают store_offsets(msg) или выключают автокоммит и вызывают commit(message=msg). В aiokafka — enable_auto_commit=False и await consumer.commit() после обработки. Дубли после падения при этом возможны, поэтому обработчик идемпотентный. По SIGTERM дорабатывают текущее сообщение и закрывают консьюмер, чтобы группа сразу отдала партиции другим
Зачем prefetch и как он влияет на распределение длинных задач?
Prefetch экономит сетевые походы: следующее сообщение уже лежит у консьюмера, пока он обрабатывает текущее. В Celery воркер берёт worker_prefetch_multiplier × concurrency задач, по умолчанию 4 на процесс. Для длинных задач это перекос: один воркер набрал задачи на час вперёд, второй простаивает. Ставят worker_prefetch_multiplier=1 вместе с task_acks_late=True, тогда воркер держит ровно по задаче на процесс. В aio-pika set_qos(prefetch_count=...) при queue.consume ещё и задаёт число одновременных обработок, поэтому его подбирают под пул соединений к базе
📚 Что почитать
- Celery: Tasks — ретраи,
acks_late, поведение при убитом воркере и требование идемпотентности из первоисточника - Celery: Optimizing — prefetch, длинные задачи и почему одна задача на процесс требует позднего ack
- Celery: Using Redis — visibility timeout и повторное выполнение долгих задач
- aiokafka: Consumer client — ручной коммит, семантика offset + 1 и коммит при ребалансе