В чем разница между Kafka и RabbitMQ c точки зрения модели обмена сообщениями?

Разница между Kafka и RabbitMQ

Kafka и RabbitMQ — это два популярных message broker, но они имеют фундаментально разные подходы к доставке и хранению сообщений. Давайте разберём их отличия.

1. Архитектура и модель обмена

RabbitMQ — очередь сообщений (Queue-based)

RabbitMQ использует классическую модель producer-consumer с очередями:

Producer → Exchange → Binding → Queue → Consumer

• Producer отправляет сообщение
• Exchange маршрутизирует сообщение на основе правил (routing key, topic и т.д.)
• Queue хранит сообщение
• Consumer получает и обрабатывает сообщение
• После обработки сообщение удаляется из очереди

# Python пример с RabbitMQ
import pika

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

# Объявляем очередь
channel.queue_declare(queue='hello', durable=True)

# Producer: отправляет сообщение
def send_message(message):
    channel.basic_publish(
        exchange='',
        routing_key='hello',
        body=message,
        properties=pika.BasicProperties(delivery_mode=2)  # persistent
    )

# Consumer: получает одно сообщение
def callback(ch, method, properties, body):
    print(f"Received: {body}")
    ch.basic_ack(delivery_tag=method.delivery_tag)  # Подтверждение

channel.basic_consume(
    queue='hello',
    on_message_callback=callback
)

print('Waiting for messages...')
channel.start_consuming()

Особенности RabbitMQ:

• Сообщение удаляется из очереди после подтверждения consumer
• Поддержка разных типов exchange (direct, topic, fanout, headers)
• Гарантирует, что каждое сообщение обработано (хотя бы один раз)
• Низкая задержка
• Идеален для асинхронных задач, уведомлений

Kafka — распределённый журнал (Log-based)

Kafka использует модель publish-subscribe с логом сообщений:

Producer → Topic → Partition → Log (дисковое хранилище) → Consumer

• Producer отправляет сообщение в topic
• Topic разбит на несколько partitions для масштабирования
• Log — это последовательность сообщений, сохраняемая на диск
• Consumer читает сообщения с определённого offset
• Сообщения остаются в логе (по умолчанию, можно настроить retention policy)

# Python пример с Kafka
from kafka import KafkaProducer, KafkaConsumer
import json

# Producer: отправляет сообщение
producer = KafkaProducer(
    bootstrap_servers=['localhost:9092'],
    value_serializer=lambda v: json.dumps(v).encode('utf-8')
)

def send_message(message):
    producer.send('events', value=message)
    producer.flush()

# Consumer: читает сообщения с определённого offset
consumer = KafkaConsumer(
    'events',
    bootstrap_servers=['localhost:9092'],
    auto_offset_reset='earliest',  # Начать с начала
    value_deserializer=lambda m: json.loads(m.decode('utf-8'))
)

for message in consumer:
    print(f"Received: {message.value}")
    # Offset сохраняется автоматически

Особенности Kafka:

• Сообщения сохраняются в логе на неопределённый срок (или до истечения retention policy)
• Несколько consumer могут читать одни и те же сообщения
• Гарантирует порядок сообщений в partition
• Высокая пропускная способность
• Идеален для потоковой обработки данных и аудита

2. Сравнительная таблица

3. Практические различия

RabbitMQ: типичный сценарий

# Отправить email асинхронно
from celery import Celery

app = Celery('tasks', broker='amqp://guest:guest@localhost//')

@app.task
def send_email(recipient, subject, body):
    # Отправляем email
    pass

# В вебе
def register_user(email):
    # Регистрируем пользователя
    # Асинхронно отправляем приветственный email
    send_email.delay(email, 'Welcome!', 'Welcome to our platform')

После отправки email, сообщение удалится из RabbitMQ.

Kafka: типичный сценарий

# Логирование событий для аналитики
from kafka import KafkaProducer, KafkaConsumer

# Producer: логирует все события
producer = KafkaProducer(bootstrap_servers=['localhost:9092'])

def log_user_action(user_id, action):
    event = {
        'user_id': user_id,
        'action': action,
        'timestamp': datetime.now().isoformat()
    }
    producer.send('user-events', value=event)

# Consumer 1: обновляет аналитику в реальном времени
def analytics_consumer():
    consumer = KafkaConsumer(
        'user-events',
        bootstrap_servers=['localhost:9092'],
        group_id='analytics'
    )
    for message in consumer:
        update_analytics(message.value)

# Consumer 2: обновляет рекомендации (другой process)
def recommendation_consumer():
    consumer = KafkaConsumer(
        'user-events',
        bootstrap_servers=['localhost:9092'],
        group_id='recommendations'
    )
    for message in consumer:
        update_recommendations(message.value)

Оба consumer могут читать одни и те же сообщения независимо.

4. Типы exchange в RabbitMQ

RabbitMQ позволяет маршрутизировать сообщения разными способами:

# Direct: точная маршрутизация по routing_key
channel.exchange_declare(exchange='direct_logs', exchange_type='direct')
channel.queue_bind(exchange='direct_logs', queue='error_queue', routing_key='error')
channel.queue_bind(exchange='direct_logs', queue='info_queue', routing_key='info')

# Topic: маршрутизация по pattern
channel.exchange_declare(exchange='topic_logs', exchange_type='topic')
channel.queue_bind(exchange='topic_logs', queue='q1', routing_key='logs.error.*')
channel.queue_bind(exchange='topic_logs', queue='q2', routing_key='logs.*')

# Fanout: broadcast всем очередям
channel.exchange_declare(exchange='broadcast', exchange_type='fanout')
channel.queue_bind(exchange='broadcast', queue='q1')
channel.queue_bind(exchange='broadcast', queue='q2')

5. Consumer Groups в Kafka

В Kafka несколько consumer в группе распределяют partitions:

from kafka import KafkaConsumer

# Consumer 1 в группе
consumer1 = KafkaConsumer(
    'events',
    bootstrap_servers=['localhost:9092'],
    group_id='my_group',  # Группа
    auto_offset_reset='earliest'
)

# Consumer 2 в той же группе
consumer2 = KafkaConsumer(
    'events',
    bootstrap_servers=['localhost:9092'],
    group_id='my_group',  # Та же группа
    auto_offset_reset='earliest'
)

# Если topic имеет 4 partition, то consumer1 может читать
# partition 0,1, а consumer2 — partition 2,3
# Это обеспечивает балансирование нагрузки

6. Гарантии доставки

Оба обеспечивают at-least-once, но по-разному:

RabbitMQ

# Если consumer упадёт до подтверждения,
# сообщение вернётся в очередь
def callback(ch, method, properties, body):
    try:
        process_message(body)
        ch.basic_ack(delivery_tag=method.delivery_tag)  # OK
    except Exception:
        ch.basic_nack(delivery_tag=method.delivery_tag, requeue=True)  # Requeue

Kafka

# Consumer сохраняет offset после обработки
def process_messages():
    for message in consumer:
        try:
            process_message(message.value)
            consumer.commit()  # Сохраняем offset
        except Exception:
            pass  # При перезапуске начнём заново

7. Когда использовать что

Используй RabbitMQ если:

• Нужна низкая задержка (< 100ms)
• Работаешь с асинхронными задачами (email, уведомления)
• Нужна сложная маршрутизация сообщений
• Размер сообщений мал (KB)
• Нужна простота в настройке

Примеры: отправка email, SMS, push-notification, обработка заказов

Используй Kafka если:

• Нужна высокая пропускная способность (миллионы сообщений/сек)
• Нужна история всех событий (audit trail)
• Нужна потоковая обработка данных (stream processing)
• Нужен replay сообщений
• Работаешь с big data
• Нужна горизонтальная масштабируемость

Примеры: логирование событий, аналитика в реальном времени, машинное обучение, логирование кликов

8. Примеры архитектур

RabbitMQ-based система

Вебёр → RabbitMQ → Celery Worker → БД
              ↓
           Email Worker

Kafka-based система

Приложение (логирование событий)
        ↓
     Kafka Topic
     ↙  ↓  ↘
Aналитика  Рекомендации  Аудит
(real-time) (ML model)   (хранилище)

Вывод

RabbitMQ — это классический message broker для асинхронных задач и уведомлений, сосредоточенный на доставке и удалении сообщений.

Kafka — это распределённый журнал событий для потоковой обработки данных, сосредоточенный на хранении и повторном использовании истории событий.

Выбор между ними зависит от конкретной задачи: нужна ли тебе быстрая доставка сообщений (RabbitMQ) или высокая пропускная способность с возможностью replay (Kafka).