Consumer на Go: воркеры, ack/nack и graceful shutdown
Consumer - воркер, который читает сообщения из очереди и обрабатывает их. Главное правило: ack после успешной обработки. Всё остальное - следствие этого правила.
ℹ️ Что именно означает ack
Формулировка одна на весь трек, и её стоит запомнить дословно:
ackсообщает брокеру, что consumer закончил работу с этой доставкой и брокер может удалить её из очереди. Больше ничего.Чего
ackне означает:
- что запись в базу зафиксирована;
- что письмо доставлено адресату;
- что внешний сервис принял операцию;
- что побочный эффект вообще случился.
Всё это - обязанность кода до
ack, и порядок здесь единственно возможный:бизнес-операция зафиксирована ↓ ackА не наоборот:
ack ← брокер уже забыл сообщение ↓ бизнес-операция ← упали здесь: работа не сделана и не повторитсяВторой порядок и есть
auto-ack: брокер считает доставку завершённой в момент отправки. Отсюда правило «ack после работы» - не стиль, а условие того, что сообщение вообще можно повторить.
⚠️ Manual ack закрывает один участок из трёх
«Поставил manual ack - сообщения не теряются» звучит убедительно и неверно: ack отвечает только за последний отрезок пути. Целиком путь состоит из трёх, и каждый защищается своим механизмом.
Участок Что теряет сообщение Чем закрывается Producer → брокер сбой между Publish()и приёмом на брокереpublisher confirms - ждать подтверждения, а не «отправил и забыл» Внутри брокера рестарт RabbitMQ durableу очереди и exchange плюсDeliveryMode: Persistentу сообщения - это два разных флагаБрокер → consumer падение воркера в момент обработки manual ack: подтверждаем после работы, а не по факту доставки Дыра в любом из трёх обнуляет остальные два. Consumer с идеальным ack не поможет, если producer отправлял без confirms; durable-очередь не поможет, если сообщения не persistent.
И четвёртый участок, который вообще не про брокер: щель между
COMMITв базе иPublish(). Упали в ней - данные есть, события нет, и никакойdurableтут не при чём. Закрывается только transactional outbox.
См. также гарантии доставки.
Базовый Consumer
import amqp "github.com/rabbitmq/amqp091-go"
type Consumer struct {
ch *amqp.Channel
queue string
}
func NewConsumer(ch *amqp.Channel, queue string) *Consumer {
return &Consumer{ch: ch, queue: queue}
}
func (c *Consumer) Start(ctx context.Context, handler func(ctx context.Context, body []byte) error) error {
msgs, err := c.ch.Consume(
c.queue,
"", // consumer tag (пусто = автогенерация)
false, // auto-ack: false! Мы подтверждаем вручную
false, // exclusive
false, // no-local
false, // no-wait
nil,
)
if err != nil {
return fmt.Errorf("consume: %w", err)
}
for {
select {
case <-ctx.Done():
return ctx.Err()
case msg, ok := <-msgs:
if !ok {
return fmt.Errorf("channel closed")
}
if err := handler(ctx, msg.Body); err != nil {
// Обработка не удалась - nack с requeue
msg.Nack(false, true)
log.Printf("nack message %s: %v", msg.MessageId, err)
continue
}
// Успешно обработали - ack
msg.Ack(false)
}
}
}
<?php
declare(strict_types=1);
use PhpAmqpLib\Channel\AMQPChannel;
use PhpAmqpLib\Message\AMQPMessage;
use Psr\Log\LoggerInterface;
final class Consumer
{
public function __construct(
private readonly AMQPChannel $ch,
private readonly string $queue,
private readonly LoggerInterface $logger,
) {}
/** @param callable(string $body): void $handler */
public function start(callable $handler): void
{
$this->ch->basic_consume(
queue: $this->queue,
consumer_tag: '', // пусто = автогенерация
no_local: false,
no_ack: false, // ack: вручную! не auto-ack
exclusive: false,
nowait: false,
callback: function (AMQPMessage $msg) use ($handler): void {
try {
$handler($msg->getBody());
$msg->ack(); // успешно - ack
} catch (Throwable $e) {
// Обработка не удалась - nack с requeue
$msg->nack(requeue: true);
$this->logger->error('nack message {id}: {err}', [
'id' => $msg->get('message_id') ?? '',
'err' => $e->getMessage(),
]);
}
},
);
while ($this->ch->is_consuming()) {
$this->ch->wait();
}
}
}
В Symfony Messenger consumer запускается командой bin/console messenger:consume async - все нюансы ack/nack делает встроенный worker.
import logging
from typing import Callable
from pika.adapters.blocking_connection import BlockingChannel
from pika.spec import Basic, BasicProperties
log = logging.getLogger(__name__)
# Обработчик сигнализирует о неудаче исключением, а не возвратом error
Handler = Callable[[bytes], None]
class Consumer:
def __init__(self, ch: BlockingChannel, queue: str) -> None:
self._ch = ch
self._queue = queue
def start(self, handler: Handler) -> None:
# Вместо канала msgs - callback: pika вызывает его на каждую доставку
def on_message(
ch: BlockingChannel, method: Basic.Deliver, props: BasicProperties, body: bytes
) -> None:
try:
handler(body)
except Exception as e:
# Обработка не удалась - nack с requeue
ch.basic_nack(delivery_tag=method.delivery_tag, requeue=True)
log.error("nack message %s: %s", props.message_id, e)
return
# Успешно обработали - ack
ch.basic_ack(delivery_tag=method.delivery_tag)
self._ch.basic_consume(
queue=self._queue,
on_message_callback=on_message,
consumer_tag=None, # None = автогенерация
auto_ack=False, # auto-ack: False! Мы подтверждаем вручную
exclusive=False,
)
# Блокирующий цикл. Аналог ctx.Done() - флаг и stop_consuming(),
# см. graceful shutdown ниже; закрытие канала брокером - исключение AMQPError
self._ch.start_consuming()
⚠️ auto-ack: false - всегда
С
auto-ack: trueRabbitMQ удаляет сообщение сразу после отправки consumer'у. Если consumer упал до обработки - сообщение потеряно навсегда. Всегда ставьfalseи подтверждай вручную.
Ack, Nack, Reject
Метод Что происходит Когда использовать
────── ────────────────────── ──────────────────────
msg.Ack(false) Сообщение удалено из очереди Обработка успешна
msg.Nack(false, Сообщение возвращено в очередь Временная ошибка
true) (requeue = true) (сеть, таймаут)
msg.Nack(false, Сообщение удалено или в DLQ Перманентная ошибка
false) (requeue = false) (невалидные данные)
msg.Reject(true) = Nack(false, true) для 1 msg Альтернатива Nack
msg.Reject(false) = Nack(false, false) для 1 msg Отправить в DLQ
Ключевое: requeue: true возвращает сообщение в ту же очередь - RabbitMQ
старается вернуть его на прежнее место, но гарантии позиции нет: при
нескольких consumer'ах и одновременных возвратах порядок меняется. Полагаться
можно на одно - сообщение придёт снова, и придёт скоро. Если ошибка
постоянная, это бесконечный цикл на полной скорости.
Отсюда соблазн ограничить попытки счётчиком. Вот как это обычно пишут - и почему так не работает:
// ВНИМАНИЕ: типичная, но нерабочая реализация - разбор сразу после кода.
func (c *Consumer) handleWithRetry(msg amqp.Delivery, handler func([]byte) error, maxRetries int) {
// Считаем ретраи через x-death header
retryCount := getRetryCount(msg)
if err := handler(msg.Body); err != nil {
if retryCount >= maxRetries {
// Отдаём в DLQ
msg.Nack(false, false)
log.Printf("message %s sent to DLQ after %d retries", msg.MessageId, retryCount)
return
}
// Ещё можно попробовать
msg.Nack(false, true)
return
}
msg.Ack(false)
}
func getRetryCount(msg amqp.Delivery) int {
xDeath, ok := msg.Headers["x-death"]
if !ok {
return 0
}
deaths, ok := xDeath.([]interface{})
if !ok || len(deaths) == 0 {
return 0
}
death, ok := deaths[0].(amqp.Table)
if !ok {
return 0
}
count, _ := death["count"].(int64)
return int(count)
}
<?php
declare(strict_types=1);
use PhpAmqpLib\Message\AMQPMessage;
use Psr\Log\LoggerInterface;
// ВНИМАНИЕ: типичная, но нерабочая реализация - разбор сразу после кода.
final class RetryConsumer
{
public function __construct(
private readonly LoggerInterface $logger,
private readonly int $maxRetries,
) {}
/** @param callable(string $body): void $handler */
public function handle(AMQPMessage $msg, callable $handler): void
{
// Считаем ретраи через x-death header
$retryCount = $this->getRetryCount($msg);
try {
$handler($msg->getBody());
$msg->ack();
} catch (Throwable $e) {
if ($retryCount >= $this->maxRetries) {
// Отдаём в DLQ
$msg->nack(requeue: false);
$this->logger->warning('message {id} sent to DLQ after {count} retries', [
'id' => $msg->get('message_id') ?? '',
'count' => $retryCount,
]);
return;
}
// Ещё можно попробовать
$msg->nack(requeue: true);
}
}
private function getRetryCount(AMQPMessage $msg): int
{
$headers = $msg->get_properties()['application_headers'] ?? null;
if ($headers === null) {
return 0;
}
$xDeath = $headers->getNativeData()['x-death'] ?? null;
if (!is_array($xDeath) || $xDeath === []) {
return 0;
}
return (int) ($xDeath[0]['count'] ?? 0);
}
}
import logging
from pika.adapters.blocking_connection import BlockingChannel
from pika.spec import Basic, BasicProperties
log = logging.getLogger(__name__)
# ВНИМАНИЕ: типичная, но нерабочая реализация - разбор сразу после кода.
class Consumer: # продолжение класса из блока выше
def handle_with_retry(
self,
ch: BlockingChannel,
method: Basic.Deliver,
props: BasicProperties,
body: bytes,
handler: Handler,
max_retries: int,
) -> None:
# Считаем ретраи через x-death header
retry_count = get_retry_count(props)
try:
handler(body)
except Exception:
if retry_count >= max_retries:
# Отдаём в DLQ
ch.basic_nack(delivery_tag=method.delivery_tag, requeue=False)
log.warning("message %s sent to DLQ after %d retries", props.message_id, retry_count)
return
# Ещё можно попробовать
ch.basic_nack(delivery_tag=method.delivery_tag, requeue=True)
return
ch.basic_ack(delivery_tag=method.delivery_tag)
def get_retry_count(props: BasicProperties) -> int:
# pika отдаёт заголовки обычным dict, x-death - списком dict
deaths = (props.headers or {}).get("x-death")
if not isinstance(deaths, list) or not deaths:
return 0
death = deaths[0]
if not isinstance(death, dict):
return 0
return int(death.get("count", 0))
🚫 Этот код не ограничивает попытки
Схема выше выглядит правильной и не работает:
x-deathпоявляется на сообщении только при dead-lettering, аnack(requeue: true)возвращает сообщение в очередь напрямую, минуя dead-letter exchange. В classic-очереди счётчик остаётся нулевым,retryCount >= maxRetriesне срабатывает никогда, и сообщение крутится бесконечно - ровно то, от чего мы защищались.Quorum-очереди RabbitMQ 4.x ведут себя иначе: они считают и requeue (заголовок
x-delivery-count), и по умолчанию после 20 доставок (delivery-limit) сообщение удаляется или уходит в DLX, если он настроен. Бесконечного цикла там не будет, но и счётчик изx-deathвыше всё равно не растёт.Второй дефект того же кода:
x-deathэто массив записей, сгруппированных по паре (очередь, причина), а не число.$xDeath[0]иdeaths[0]берут случайную из нескольких.Рабочая схема требует retry-очереди с TTL: consumer делает
nack(requeue: false), сообщение уходит через DLX, отлёживается и приходит обратно - и этот проходx-deathувеличивает. Целиком, вместе с поиском записи по очереди и причине, разобрано в уроке про DLQ и retry.Оставлять
requeue: trueуместно там, где счётчика попыток нет по замыслу: воркер уходит на перезапуск и отдаёт незавершённое обратно, или зависимость недоступна и ретраить надо весь поток, а не отдельное сообщение.
Prefetch (QoS)
Prefetch контролирует, сколько сообщений consumer получает до подтверждения:
// Обрабатываем по одному - безопасно, но медленно
ch.Qos(1, 0, false)
// Обрабатываем пачками по 10 - быстрее, но нужен запас памяти
ch.Qos(10, 0, false)
Prefetch Поведение Когда
───────── ──────────────────────── ──────────────────
1 Одно сообщение за раз Тяжёлая обработка (email, PDF)
10-50 Пачки сообщений Лёгкая обработка (запись в БД)
0 Без ограничений Почти никогда - см. врезку
ℹ️ Почему «никогда» здесь всё-таки «почти»
prefetch = 0значит «шли всё, что есть»: брокер набивает буфер сообщениями, которые воркер ещё не начал обрабатывать. Отсюда две беды - память процесса и распределение: один consumer забирает очередь целиком, остальные голодают, а при его падении вся пачка идёт на повторную доставку.Полного запрета всё же не выходит. Один consumer на очередь, короткие сообщения, обработка в микросекунды, память под контролем - и лимит только мешает. Так работают, например, отдельные потоки телеметрии.
Практическое правило: не «никогда 0», а «значение выбирается замером». Начни с
1, смотри, простаивает ли воркер, поднимай при простое. Полезный ориентир -prefetch ≈ пропускная способность одного воркера × RTT до брокера, но проверять его всё равно на своих сообщениях.
ℹ️ Золотое правило prefetch
Начинай с
prefetch = 1. Увеличивай, только если consumer простаивает (мониторинг покажет). Слишком большой prefetch = один consumer забирает все сообщения, остальные голодают. Цифра из таблицы выше - стартовая точка для замера, а не настройка «как правильно».
Несколько Consumer'ов (Competing Consumers)
Запусти несколько consumer'ов на одну очередь - RabbitMQ распределит сообщения между ними:
// Запускаем 3 воркера
for i := 0; i < 3; i++ {
go func(id int) {
consumer := NewConsumer(ch, "progress-worker")
consumer.Start(ctx, func(ctx context.Context, body []byte) error {
log.Printf("worker %d processing message", id)
return processMessage(body)
})
}(i)
}
<?php
declare(strict_types=1);
// В мире PHP «несколько consumer'ов на одну очередь» - это запуск нескольких процессов:
// supervisor / systemd / docker compose --scale worker=3
// Внутри одного процесса используем один Consumer и пускаем его в while-цикле.
// Пример supervisord.conf:
// [program:progress-worker]
// command=php bin/console messenger:consume async --limit=1000 --time-limit=3600
// numprocs=3
// process_name=%(program_name)s_%(process_num)02d
// autostart=true
// autorestart=true
// А внутри одного воркера обработка остаётся обычным callback'ом:
final class WorkerEntrypoint
{
public function __construct(
private readonly Consumer $consumer,
private readonly MessageProcessor $processor,
) {}
public function run(): void
{
$this->consumer->start(function (string $body): void {
$this->processor->process($body);
});
}
}
Распределение сообщений делает RabbitMQ - prefetch_count + равноценные consumer'ы дают round-robin между процессами.
import logging
import threading
import pika
log = logging.getLogger(__name__)
# Потоки, а не asyncio: BlockingConnection синхронный. Канал pika не делится
# между потоками, поэтому у каждого воркера своё соединение и канал.
# В проде чаще масштабируют процессами: docker compose --scale worker=3.
def run_worker(worker_id: int, url: str) -> None:
conn = pika.BlockingConnection(pika.URLParameters(url))
consumer = Consumer(conn.channel(), "progress-worker")
def handle(body: bytes) -> None:
log.info("worker %d processing message", worker_id)
process_message(body)
consumer.start(handle)
# Запускаем 3 воркера
for i in range(3):
threading.Thread(target=run_worker, args=(i, RABBITMQ_URL), daemon=True).start()
Queue: progress-worker
├── Consumer 1: обрабатывает msg 1, 4, 7...
├── Consumer 2: обрабатывает msg 2, 5, 8...
└── Consumer 3: обрабатывает msg 3, 6, 9...
RabbitMQ распределяет round-robin, но с учётом prefetch: свободный consumer получает следующее сообщение.
Graceful Shutdown через context
При остановке сервиса нужно дообработать текущие сообщения, а не бросать их:
func (c *Consumer) StartWithShutdown(ctx context.Context, handler func(context.Context, []byte) error) error {
// Тег задаём сами: с пустым тегом amqp091-go сгенерирует свой,
// и Cancel("") потом ничего не отменит. Тег уникален в пределах канала.
tag := c.queue + "-" + uuid.NewString()
msgs, err := c.ch.Consume(c.queue, tag, false, false, false, false, nil)
if err != nil {
return err
}
var wg sync.WaitGroup
for {
select {
case <-ctx.Done():
// Перестаём принимать новые сообщения. Уже доставленные в буфер
// (prefetch), но не начатые вернутся в очередь при закрытии канала.
if err := c.ch.Cancel(tag, false); err != nil {
log.Printf("cancel consumer: %v", err)
}
// Ждём завершения текущих
wg.Wait()
return nil
case msg, ok := <-msgs:
if !ok {
wg.Wait()
return nil
}
wg.Add(1)
go func(m amqp.Delivery) {
defer wg.Done()
// ctx отменяется сигналом остановки. Если передать его в handler,
// запросы к БД и HTTP в полёте сразу упадут с context canceled.
// Даём обработке свой контекст: не отменяемый сигналом, но с
// таймаутом на дообработку.
hctx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 30*time.Second)
defer cancel()
if err := handler(hctx, m.Body); err != nil {
m.Nack(false, true) // вернём в очередь
return
}
m.Ack(false)
}(msg)
}
}
}
<?php
declare(strict_types=1);
use PhpAmqpLib\Channel\AMQPChannel;
use PhpAmqpLib\Exception\AMQPTimeoutException;
use PhpAmqpLib\Message\AMQPMessage;
final class GracefulConsumer
{
private bool $stopping = false;
public function __construct(
private readonly AMQPChannel $ch,
private readonly string $queue,
) {
// SIGTERM от docker / k8s, SIGINT от Ctrl+C
pcntl_signal(SIGTERM, fn() => $this->stopping = true);
pcntl_signal(SIGINT, fn() => $this->stopping = true);
}
/** @param callable(string): void $handler */
public function start(callable $handler): void
{
// basic_consume возвращает тег подписки - по нему потом отменяем
$tag = $this->ch->basic_consume(
queue: $this->queue,
no_ack: false,
callback: function (AMQPMessage $msg) use ($handler): void {
try {
$handler($msg->getBody());
$msg->ack();
} catch (Throwable) {
$msg->nack(requeue: true); // вернём в очередь
}
},
);
while ($this->ch->is_consuming()) {
pcntl_signal_dispatch();
if ($this->stopping) {
// Перестаём принимать новые сообщения; текущее уже доехало:
// callback выполняется синхронно внутри wait().
$this->ch->basic_cancel($tag, nowait: false);
break;
}
try {
$this->ch->wait(timeout: 1.0);
} catch (AMQPTimeoutException) {
// За секунду сообщений не было - идём проверять флаг остановки
}
}
}
}
В Symfony Messenger graceful shutdown настроен из коробки: воркер ловит SIGTERM сам и завершает текущее сообщение перед выходом.
import signal
from types import FrameType
import pika
from pika.adapters.blocking_connection import BlockingChannel
from pika.spec import Basic, BasicProperties
class GracefulConsumer:
def __init__(self, conn: pika.BlockingConnection, ch: BlockingChannel, queue: str) -> None:
self._conn = conn
self._ch = ch
self._queue = queue
self._stopping = False
# Аналог signal.NotifyContext: SIGTERM от docker / k8s, SIGINT от Ctrl+C.
# Обработчик только ставит флаг - трогать канал из него нельзя.
signal.signal(signal.SIGTERM, self._request_stop)
signal.signal(signal.SIGINT, self._request_stop)
def _request_stop(self, signum: int, frame: FrameType | None) -> None:
self._stopping = True
def start_with_shutdown(self, handler: Handler) -> None:
def on_message(
ch: BlockingChannel, method: Basic.Deliver, props: BasicProperties, body: bytes
) -> None:
try:
handler(body)
except Exception:
ch.basic_nack(delivery_tag=method.delivery_tag, requeue=True) # вернём в очередь
return
ch.basic_ack(delivery_tag=method.delivery_tag)
tag = self._ch.basic_consume(
queue=self._queue, on_message_callback=on_message, auto_ack=False
)
# Вместо start_consuming - цикл с таймаутом, чтобы между сообщениями
# проверять флаг. Горутин и WaitGroup нет: callback выполняется в этом же
# потоке, поэтому текущее сообщение всегда дообработается до проверки.
while not self._stopping:
self._conn.process_data_events(time_limit=1.0)
# Перестаём принимать новые сообщения. Уже доставленные, но не переданные
# в callback, pika при отмене сам вернёт брокеру nack'ом.
self._ch.basic_cancel(tag)
Типичный сценарий entrypoint:
func main() {
ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer cancel()
conn, _ := amqp.Dial("amqp://guest:guest@localhost:5672/")
defer conn.Close()
ch, _ := conn.Channel()
ch.Qos(10, 0, false)
consumer := NewConsumer(ch, "progress-worker")
log.Println("consumer started, waiting for messages...")
if err := consumer.StartWithShutdown(ctx, handleMessage); err != nil {
log.Fatalf("consumer error: %v", err)
}
log.Println("consumer stopped gracefully")
}
<?php
declare(strict_types=1);
// bin/consumer.php - точка входа worker-процесса.
use PhpAmqpLib\Connection\AMQPStreamConnection;
require __DIR__ . '/../vendor/autoload.php';
$conn = new AMQPStreamConnection('rabbitmq', 5672, 'guest', 'guest');
$ch = $conn->channel();
$ch->basic_qos(prefetch_size: 0, prefetch_count: 10, a_global: false);
$consumer = new GracefulConsumer($ch, 'progress-worker');
echo 'consumer started, waiting for messages...', "\n";
$consumer->start(handleMessage(...));
echo 'consumer stopped gracefully', "\n";
$ch->close();
$conn->close();
В Symfony - то же самое, но проще: php bin/console messenger:consume async --limit=1000. Внутри стоит --time-limit, ack/nack, graceful - всё уже из коробки.
import logging
import pika
log = logging.getLogger(__name__)
def main() -> None:
logging.basicConfig(level=logging.INFO)
conn = pika.BlockingConnection(pika.URLParameters("amqp://guest:guest@localhost:5672/"))
try:
ch = conn.channel()
ch.basic_qos(prefetch_count=10)
# Подписка на SIGTERM/SIGINT - в конструкторе, аналог signal.NotifyContext
consumer = GracefulConsumer(conn, ch, "progress-worker")
log.info("consumer started, waiting for messages...")
try:
consumer.start_with_shutdown(handle_message)
except pika.exceptions.AMQPError as e:
log.critical("consumer error: %s", e)
raise SystemExit(1) from e
log.info("consumer stopped gracefully")
finally:
conn.close() # аналог defer conn.Close()
if __name__ == "__main__":
main()
Reconnect при потере соединения
Соединение с RabbitMQ может оборваться. Consumer должен уметь переподключаться:
// sleepCtx ждёт d или отмены ctx. false - сервис останавливается.
func sleepCtx(ctx context.Context, d time.Duration) bool {
select {
case <-ctx.Done():
return false
case <-time.After(d):
return true
}
}
func RunWithReconnect(ctx context.Context, dialURL, queue string, prefetch int, handler func(context.Context, []byte) error) {
for ctx.Err() == nil {
conn, err := amqp.Dial(dialURL)
if err != nil {
log.Printf("connect failed: %v, retrying in 5s", err)
if !sleepCtx(ctx, 5*time.Second) {
return
}
continue
}
ch, err := conn.Channel()
if err == nil {
// Prefetch - настройка канала: на новом канале её надо выставить заново
err = ch.Qos(prefetch, 0, false)
}
if err != nil {
log.Printf("open channel failed: %v, retrying in 5s", err)
conn.Close() // закроет и канал
if !sleepCtx(ctx, 5*time.Second) { // без паузы цикл станет горячим
return
}
continue
}
log.Println("connected to RabbitMQ")
// Новый канал - новый Consumer. StartWithShutdown вернётся либо по ctx,
// либо когда канал msgs закроется из-за обрыва соединения.
err = NewConsumer(ch, queue).StartWithShutdown(ctx, handler)
log.Printf("consumer stopped: %v", err)
ch.Close()
conn.Close()
if !sleepCtx(ctx, time.Second) { // небольшая пауза перед переподключением
return
}
}
}
<?php
declare(strict_types=1);
use PhpAmqpLib\Connection\AMQPStreamConnection;
use PhpAmqpLib\Exception\AMQPConnectionClosedException;
use PhpAmqpLib\Exception\AMQPIOException;
use Psr\Log\LoggerInterface;
final class ReconnectingConsumer
{
public function __construct(
private readonly LoggerInterface $logger,
private readonly string $host,
private readonly int $port,
private readonly string $user,
private readonly string $pass,
private readonly string $queue,
) {}
/** @param callable(string): void $handler */
public function run(callable $handler): void
{
while (true) {
try {
$conn = new AMQPStreamConnection($this->host, $this->port, $this->user, $this->pass);
$ch = $conn->channel();
$this->logger->info('connected to RabbitMQ');
$consumer = new Consumer($ch, $this->queue, $this->logger);
$consumer->start($handler);
} catch (AMQPConnectionClosedException | AMQPIOException $e) {
$this->logger->warning('connection lost: {err}, retrying in 5s', ['err' => $e->getMessage()]);
sleep(5);
continue;
} finally {
if (isset($ch)) { $ch->close(); }
if (isset($conn)) { $conn->close(); }
}
}
}
}
Symfony Messenger воркер падает при потере соединения и поднимается заново supervisor'ом - так проще и надёжнее, чем переподключение в одном процессе.
import logging
import threading
import pika
from pika.adapters.blocking_connection import BlockingChannel
from pika.exceptions import AMQPConnectionError, AMQPError
from pika.spec import Basic, BasicProperties
log = logging.getLogger(__name__)
class Consumer: # продолжение класса из блока «Базовый Consumer»
# Вместо ctx - threading.Event: его выставляет обработчик сигнала
def run_with_reconnect(self, stop: threading.Event, dial_url: str, handler: Handler) -> None:
while not stop.is_set():
try:
conn = pika.BlockingConnection(pika.URLParameters(dial_url))
except AMQPConnectionError as e:
log.warning("connect failed: %s, retrying in 5s", e)
stop.wait(5) # в отличие от time.sleep, прервётся по сигналу остановки
continue
try:
ch = conn.channel()
except AMQPError as e:
log.warning("open channel failed: %s, retrying in 5s", e)
conn.close()
stop.wait(5) # без паузы цикл станет горячим
continue
log.info("connected to RabbitMQ")
try:
ch.basic_qos(prefetch_count=10) # настройка канала: на новом - заново
self._start_consuming(stop, conn, ch, handler)
except AMQPError as e:
# Обрыв соединения pika отдаёт исключением из цикла потребления
log.warning("consumer stopped: %s, reconnecting...", e)
stop.wait(1) # пауза перед переподключением
finally:
if ch.is_open:
ch.close()
if conn.is_open:
conn.close()
def _start_consuming(
self, stop: threading.Event, conn: pika.BlockingConnection, ch: BlockingChannel, handler: Handler
) -> None:
def on_message(
ch: BlockingChannel, method: Basic.Deliver, props: BasicProperties, body: bytes
) -> None:
try:
handler(body)
except Exception:
ch.basic_nack(delivery_tag=method.delivery_tag, requeue=True)
return
ch.basic_ack(delivery_tag=method.delivery_tag)
ch.basic_consume(queue=self._queue, on_message_callback=on_message, auto_ack=False)
# Цикл с таймаутом вместо start_consuming: раз в секунду проверяем stop
while not stop.is_set():
conn.process_data_events(time_limit=1.0)
Мини-задание
- Напиши consumer с ручным ack/nack (auto-ack: false)
- Установи
prefetch = 1и обработай 10 сообщений - Добавь graceful shutdown через
signal.NotifyContext - Специально сломай обработку (return error) и проверь, что сообщение вернулось в очередь