На что стоит обратить внимание при выборе очереди?

Краткий ответ

При выборе очереди сообщений нужно обратить внимание на 8-10 ключевых факторов: надёжность доставки, производительность, персистентность, масштабируемость, язык программирования, операционные затраты, гарантии очерёдности и простоту развёртывания.

1. Модель гарантий доставки

Очереди предоставляют разные гарантии:

At-most-once  — сообщение может потеряться (самое быстрое)
At-least-once — сообщение гарантировано доставлено (может быть дубликат)
Exactly-once  — сообщение доставлено ровно один раз (самое медленное)

Примеры:

• RabbitMQ - at-least-once с ручным подтверждением
• Kafka - at-least-once, exactly-once через транзакции
• AWS SQS - at-least-once
• Redis - at-most-once (подходит для некритичных задач)
• Azure Service Bus - exactly-once

# RabbitMQ - at-least-once
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

def callback(ch, method, properties, body):
    try:
        process_message(body)
        ch.basic_ack(delivery_tag=method.delivery_tag)  # Подтверждение
    except Exception as e:
        ch.basic_nack(delivery_tag=method.delivery_tag, requeue=True)  # Переотправка

channel.basic_consume(queue='my_queue', on_message_callback=callback)
channel.start_consuming()

2. Персистентность

Где хранятся сообщения:

• In-Memory (Redis) - очень быстро, теряются при перезагрузке
• Disk-based (RabbitMQ, Kafka) - медленнее, но надёжнее
• Hybrid - часть в памяти, часть на диске

# Redis - in-memory, потеря данных при crash
import redis

r = redis.Redis(host='localhost')
r.rpush('task_queue', 'task_1', 'task_2')  # На диск НЕ сохраняется автоматически!

# Kafka - дисковое хранилище, надёжность
from kafka import KafkaProducer

producer = KafkaProducer(
    bootstrap_servers=['localhost:9092'],
    acks='all',  # Ждём подтверждения от всех реплик
    retries=3
)
producer.send('my-topic', b'message')

3. Производительность (Throughput)

Сколько сообщений в секунду может обработать:

# Kafka оптимален для высоконагруженных систем
from kafka import KafkaProducer
import time

producer = KafkaProducer(
    bootstrap_servers=['localhost:9092'],
    batch_size=16384,  # Батчинг для лучшей производительности
    linger_ms=10,      # Ждём 10ms перед отправкой
    compression_type='snappy'  # Сжатие
)

start = time.time()
for i in range(100000):
    producer.send('bench-topic', f'message-{i}'.encode())
print(f'Time: {time.time() - start}s')  # ~0.5-1s для Kafka

4. Масштабируемость

Как система растёт с нагрузкой:

• Вертикальная - увеличение мощности одного сервера (проще)
• Горизонтальная - добавление новых серверов (сложнее, но мощнее)

# Kafka - хорошая горизонтальная масштабируемость
from kafka import KafkaConsumer

# Если добавить ещё consumers с той же group_id,
# сообщения автоматически распределятся
consumer = KafkaConsumer(
    'my-topic',
    bootstrap_servers=['localhost:9092'],
    group_id='my-group',  # Consumer group
    auto_offset_reset='earliest'
)

for message in consumer:
    process(message.value)

5. Гарантия порядка сообщений

• FIFO (First In, First Out) - сообщения обрабатываются в порядке
• Unordered - порядок не гарантирован

RabbitMQ        - FIFO в одной очереди
Kafka           - FIFO в одном partition (но разные партиции могут быть не упорядочены)
Redis List      - FIFO (FIFO)  
AWS SQS         - Unordered (обычно)
AWS SQS FIFO    - FIFO (но медленнее)

# RabbitMQ - гарантирует порядок в одной очереди
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# Сообщения будут обработаны в порядке отправки
for i in range(10):
    channel.basic_publish(
        exchange='',
        routing_key='ordered_queue',
        body=f'message-{i}'
    )

6. Операционная сложность

Простые в поддержке:

• Redis - одна БД, простая конфигурация
• AWS SQS/SNS - управляется облаком

Сложные в поддержке:

• Kafka - требует кластер, мониторинга, правильной конфигурации
• RabbitMQ с высокой доступностью - требует expertise

# Redis - запуск в 1 команду
docker run -d -p 6379:6379 redis

# Kafka - требует ZooKeeper и сложная конфигурация
docker-compose up kafka zookeeper

7. Случаи использования

Используй Redis для:

• Простых задач (отправка имейлов, уведомлений)
• Высокочастотных операций где потеря некритична
• Кэширования + очередь одновременно
• Прототипирования

Используй RabbitMQ для:

• Enterprise приложений требующих надёжности
• Сложной маршрутизации (routing keys, exchanges)
• Микросервисной архитектуры
• Когда нужен at-least-once с гарантией

Используй Kafka для:

• Data streaming и real-time analytics
• High throughput систем (100K+ msg/s)
• Event sourcing
• Логирования и мониторинга
• Систем требующих истории всех событий

# Пример: отправка имейлов (Redis подходит)
from celery import Celery

app = Celery('tasks', broker='redis://localhost:6379')

@app.task
def send_email(to, subject, body):
    # Асинхронная отправка
    smtp.send(to, subject, body)

send_email.delay('user@example.com', 'Hello', 'Welcome!')

8. Стоимость и ресурсы

Redis        - Низкая стоимость, потребление памяти (2-10 ГБ)
RabbitMQ     - Средняя, стабильное потребление (1-5 ГБ)
Kafka        - Высокая стоимость дискового пространства (500 ГБ+)
AWS SQS      - Плата за запросы (дешево для низких объёмов)
AWS Kinesis  - Плата за shards (~$30/месяц за shard)

9. Поддержка языков

• RabbitMQ - отличная поддержка всех языков (AMQP протокол)
• Kafka - встроенная поддержка для всех основных языков
• Redis - универсальная поддержка
• AWS SQS - подержка через SDK

# RabbitMQ - универсальный протокол AMQP
import pika
conn = pika.BlockingConnection(pika.ConnectionParameters('localhost'))

# Kafka - Python клиент тоже отличный
from kafka import KafkaProducer
producer = KafkaProducer(bootstrap_servers=['localhost:9092'])

# Redis - простейший протокол
import redis
r = redis.Redis(host='localhost')

10. Чеклист при выборе

1. Какой throughput нужен?

   • <1K msg/s → Redis или RabbitMQ

   • 100K msg/s → Kafka

2. Важен ли порядок?

   • Да → RabbitMQ или Kafka
   • Нет → Redis, SQS

3. Нужна ли персистентность?

   • Да → RabbitMQ, Kafka
   • Нет → Redis (временная очередь)

4. Бюджет на операции?

   • Минимальный → Redis
   • Средний → RabbitMQ
   • Есть бюджет → Kafka или облачные сервисы

5. Нужна ли история сообщений?

   • Да → Kafka, Event Sourcing системы
   • Нет → RabbitMQ, Redis

6. Требуется ли ровно-один раз обработка?

   • Да → RabbitMQ, Kafka с transactions, Azure Service Bus
   • Нет → Redis, SQS

Практический пример: выбор для системы

# Система с разными типами задач

# 1. Отправка уведомлений - Redis (простые, не критичные)
notification_queue = redis.Redis(host='localhost')
notification_queue.rpush('notifications', 'user_123:new_message')

# 2. Обработка платежей - RabbitMQ (надёжность важна)
from kombu import Connection, Queue
with Connection('amqp://guest:guest@localhost//') as conn:
    payment_queue = Queue('payments', exchange='payments_exchange')
    payment_queue.put(payment_data)

# 3. Логирование и аналитика - Kafka (высокий throughput)
from kafka import KafkaProducer
log_producer = KafkaProducer(bootstrap_servers=['localhost:9092'])
log_producer.send('logs', json.dumps(log_entry).encode())

Вывод: Выбирай исходя из throughput, надёжности, персистентности, порядка и стоимости операций. Для простых систем - Redis, для enterprise - RabbitMQ, для Big Data - Kafka.