В чем разница между Kafka и RabbitMQ

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

RabbitMQ (Классический брокер сообщений / Message Broker)

• Модель: Использует модель очередей и обменников (exchanges). Сообщения отправляются в обменник, который затем маршрутизирует их в одну или несколько очередей на основе правил маршрутизации (routing keys, headers).
• Доставка сообщений: Ориентирован на надежную доставку сообщений. Поддерживает различные режимы подтверждения (acknowledgements) — ack/nack — для гарантии того, что сообщение было обработано потребителем.
• Потребление: Сообщения удаляются из очереди после успешной обработки потребителем. Это означает, что одно сообщение обычно потребляется только одним потребителем (в случае конкурирующих потребителей на одной очереди).
• Сценарии использования:
  • RPC (Remote Procedure Call): Задачи, требующие немедленного ответа.
  • Распределение задач: Отправка задач воркерам с гарантированной доставкой.
  • Сложная маршрутизация: Когда сообщения должны быть доставлены в разные очереди на основе сложных правил.
  • Короткоживущие сообщения: Сообщения, которые не требуют длительного хранения.
• Масштабируемость: Масштабируется горизонтально, но может быть сложнее в управлении при очень высоких нагрузках и большом количестве очередей.

Kafka (Распределенный потоковый журнал / Distributed Streaming Platform)

• Модель: Использует модель распределенного лога (log-oriented). Сообщения (записи) добавляются в конец лога (топика/партиции) и сохраняются в течение заданного времени (или до достижения определенного размера). Потребители читают сообщения из лога, отслеживая свой собственный офсет (позицию).
• Доставка сообщений: Гарантирует порядок сообщений внутри одной партиции. Сообщения не удаляются после прочтения; они остаются доступными для других потребителей или для повторного чтения.
• Потребление: Множество потребителей могут читать одни и те же сообщения из топика независимо друг от друга, каждый со своим офсетом. Это позволяет создавать множество независимых потоков обработки данных.
• Сценарии использования:
  • Сбор логов и метрик: Высокопроизводительный сбор и агрегация данных.
  • Потоковая обработка данных: Анализ данных в реальном времени (например, с помощью Kafka Streams, Flink, Spark Streaming).
  • Event Sourcing: Хранение всех изменений состояния системы как последовательности событий.
  • Репликация данных: Надежная передача данных между системами.
• Масштабируемость: Разработана для горизонтального масштабирования и обработки очень больших объемов данных с высокой пропускной способностью.

Примеры использования в Go:

RabbitMQ (с библиотекой streadway/amqp):

package main

import (
    "log"
    "github.com/streadway/amqp"
)

func main() {
    conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
    if err != nil {
        log.Fatalf("Не удалось подключиться к RabbitMQ: %v", err)
    }
    defer conn.Close()

    ch, err := conn.Channel()
    if err != nil {
        log.Fatalf("Не удалось открыть канал: %v", err)
    }
    defer ch.Close()

    q, err := ch.QueueDeclare(
        "hello", // name
        false,   // durable
        false,   // delete when unused
        false,   // exclusive
        false,   // no-wait
        nil,     // arguments
    )
    if err != nil {
        log.Fatalf("Не удалось объявить очередь: %v", err)
    }

    msgs, err := ch.Consume(
        q.Name, // queue
        "",     // consumer
        true,   // auto-ack
        false,  // exclusive
        false,  // no-local
        false,  // no-wait
        nil,    // args
    )
    if err != nil {
        log.Fatalf("Не удалось зарегистрировать потребителя: %v", err)
    }

    forever := make(chan bool)

    go func() {
        for d := range msgs {
            log.Printf("Получено сообщение: %s", d.Body)
        }
    }()

    log.Printf(" [*] Ожидание сообщений. Для выхода нажмите CTRL+C")
    <-forever
}

Kafka (с библиотекой segmentio/kafka-go):

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "github.com/segmentio/kafka-go"
)

func main() {
    // Создаем Kafka Reader
    r := kafka.NewReader(kafka.ReaderConfig{
        Brokers:  []string{"localhost:9092"}, // Адреса Kafka брокеров
        Topic:    "my-topic",                 // Топик для чтения
        GroupID:  "my-consumer-group",        // Группа потребителей
        MinBytes: 10e3,                       // 10KB
        MaxBytes: 10e6,                       // 10MB
        MaxWait:  1 * time.Second,            // Максимальное время ожидания новых сообщений
    })

    ctx := context.Background()

    fmt.Println("Начало чтения сообщений из Kafka...")
    for {
        // Читаем следующее сообщение
        m, err := r.ReadMessage(ctx)
        if err != nil {
            log.Printf("Ошибка чтения сообщения: %v", err)
            break
        }
        fmt.Printf("Сообщение из топика %s, партиции %d, офсет %d: %s = %sn",
            m.Topic, m.Partition, m.Offset, string(m.Key), string(m.Value))
    }

    // Закрываем Reader
    if err := r.Close(); err != nil {
        log.Fatal("Не удалось закрыть reader: ", err)
    }
}

Вывод:

Выбор между Kafka и RabbitMQ зависит от конкретных требований вашего проекта:

• Используйте RabbitMQ, если вам нужна надежная доставка отдельных сообщений, сложная маршрутизация, RPC-подобные взаимодействия или если сообщения не требуют длительного хранения.
• Используйте Kafka, если вам нужна высокая пропускная способность, потоковая обработка больших объемов данных, возможность многократного чтения одних и тех же данных или построение систем на основе событий (event-driven architectures).