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

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

Это две популярные системы для обработки сообщений, но с различными архитектурами и случаями использования. Давайте разберёмся подробно.

Архитектура и философия

RabbitMQ:

• Message Broker архитектура
• Сообщение доставляется ровно один раз (AT-MOST-ONCE или AT-LEAST-ONCE)
• Сообщение удаляется после обработки
• Push модель (брокер отправляет сообщение потребителю)
• Нацелена на надежную доставку

Producer → RabbitMQ (Exchange → Queue) → Consumer
Сообщение удаляется после подтверждения

Kafka:

• Distributed Streaming Platform (платформа потоковой обработки)
• Log-based архитектура
• Сообщения хранятся длительное время (по умолчанию 7 дней)
• Pull модель (потребитель запрашивает сообщения)
• Нацелена на масштабируемость и аналитику

Producer → Kafka Broker (Topics & Partitions) → Consumer
Сообщения сохраняются для повторного прочтения

Таблица сравнения

RabbitMQ в деталях

// Конфигурация RabbitMQ
@Configuration
public class RabbitConfig {
    
    @Bean
    public Queue orderQueue() {
        return new Queue("order-queue", true);
    }
    
    @Bean
    public DirectExchange orderExchange() {
        return new DirectExchange("order-exchange", true, false);
    }
    
    @Bean
    public Binding orderBinding(Queue orderQueue, DirectExchange orderExchange) {
        return BindingBuilder.bind(orderQueue)
            .to(orderExchange)
            .with("order.created");
    }
}

// Producer (отправляет сообщение)
@Service
@RequiredArgsConstructor
public class OrderProducer {
    private final RabbitTemplate rabbitTemplate;
    
    public void sendOrder(Order order) {
        rabbitTemplate.convertAndSend("order-exchange", "order.created", order);
        // Сообщение отправляется потребителю
    }
}

// Consumer (получает сообщение)
@Service
public class OrderConsumer {
    @RabbitListener(queues = "order-queue")
    public void processOrder(Order order) {
        System.out.println("Processing order: " + order.getId());
        // После успешной обработки сообщение удаляется
    }
}

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

• Exchange типы: Direct, Topic, Fanout, Headers
• Подтверждение доставки (ACK)
• Сложная маршрутизация сообщений
• Дорогостоящие подписи (TTL, Dead Letter Exchange)

Kafka в деталях

// Конфигурация Kafka
@Configuration
public class KafkaConfig {
    
    @Bean
    public ProducerFactory<String, OrderEvent> producerFactory() {
        Map<String, Object> config = new HashMap<>();
        config.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        config.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        config.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, JsonSerializer.class);
        config.put(ProducerConfig.ACKS_CONFIG, "all"); // Гарантия доставки
        return new DefaultProducerFactory<>(config);
    }
}

// Producer (отправляет сообщение в topic)
@Service
@RequiredArgsConstructor
public class OrderProducer {
    private final KafkaTemplate<String, OrderEvent> kafkaTemplate;
    
    public void sendOrder(Order order) {
        OrderEvent event = new OrderEvent(order.getId(), order.getAmount());
        
        kafkaTemplate.send("orders-topic", order.getId().toString(), event)
            .addCallback(
                result -> System.out.println("Sent: " + result),
                ex -> System.err.println("Failed: " + ex.getMessage())
            );
    }
}

// Consumer Group (несколько потребителей обрабатывают одно topic)
@Service
public class OrderConsumer {
    @KafkaListener(topics = "orders-topic", groupId = "order-service")
    public void processOrder(OrderEvent event) {
        System.out.println("Processing order: " + event.getOrderId());
        // Offset автоматически сохраняется
    }
}

// Kafka Stream для обработки потока
@Configuration
public class KafkaStreamConfig {
    
    @Bean
    public KStream<String, OrderEvent> orderStream(StreamsBuilder builder) {
        KStream<String, OrderEvent> stream = builder.stream("orders-topic");
        
        stream
            .filter((key, order) -> order.getAmount() > 1000)
            .to("high-value-orders-topic");
        
        return stream;
    }
}

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

• Topics и Partitions для масштабирования
• Consumer Groups для параллельной обработки
• Offset management (сохранение позиции)
• Kafka Streams для обработки потоков
• Идеален для Big Data и аналитики

Практическое сравнение на примерах

Сценарий 1: Обработка заказов

RabbitMQ:
- Order → Exchange → Queue → Service обрабатывает → удаляется
- Один потребитель, не нужна история

Kafka:
- Order → Topic (partition 0-3) → Service обрабатывает
- История 7 дней, можно переоткрыть и переобработать
- Несколько потребителей параллельно

Сценарий 2: Логирование событий

RabbitMQ:
- Не подходит: события удаляются после логирования

Kafka:
- Perfect: события хранятся для аналитики
- Можно запустить новый потребитель и обработать старые события

Сценарий 3: Real-time уведомления

RabbitMQ:
- Идеален: низкая задержка, надежная доставка

Kafka:
- Может использоваться, но более сложен

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

RabbitMQ, если:

• Нужна надежная доставка ONE-TO-ONE
• Логика маршрутизации сложная
• Требуется очень низкая задержка
• Масштаб умеренный (тысячи msg/sec)
• Разработчикам проще (simpler mental model)
• Task queue (Celery в Python, Sidekiq в Ruby)

// Типичный case: background job processing
@Service
public class EmailService {
    @RabbitListener(queues = "email-queue")
    public void sendEmail(EmailRequest request) {
        // Отправляем email
        mailSender.send(request.getEmail());
    }
}

Kafka, если:

• Нужна масштабируемость на миллиарды событий
• Требуется история событий (event sourcing)
• Stream processing и аналитика
• Event-driven архитектура (EventBus)
• Микросервисное взаимодействие
• Consumer должен переобработать старые события

// Типичный case: event streaming платформа
@Service
public class AnalyticsService {
    @KafkaListener(topics = "user-events")
    public void trackUserActivity(UserEvent event) {
        // Анализируем поведение пользователя
        analyticsDb.save(event);
    }
}

Гибридный подход

// Используем оба инструмента
@Service
public class OrderOrchestrator {
    @Autowired
    private KafkaTemplate<String, OrderEvent> kafkaTemplate; // История
    @Autowired
    private RabbitTemplate rabbitTemplate; // Быстрые задачи
    
    public void createOrder(Order order) {
        // Сохраняем событие в Kafka (история)
        kafkaTemplate.send("order-events", order.getId().toString(), 
            new OrderCreatedEvent(order));
        
        // Отправляем сообщение в RabbitMQ (обработка)
        rabbitTemplate.convertAndSend("order-processing", order);
    }
}

Заключение

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

Kafka — это streaming platform для event-driven архитектур и Big Data.

Выбор зависит от требований:

• Simple task queue → RabbitMQ
• Event streaming + analytics → Kafka
• High throughput + history → Kafka
• Low latency + reliable delivery → RabbitMQ