Можно ли прочитать данные с Topic в том же порядке, в котором они записались, в Kafka?

Можно ли прочитать данные с Topic в том же порядке, в котором они записались, в Kafka?

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

Да, но с условиями. Kafka гарантирует порядок сообщений внутри одного partition'а, но не гарантирует порядок между partition'ами. Для полной гарантии порядка нужно использовать одноPartition'ный topic или применить специальные техники.

Как работает порядок в Kafka

Порядок внутри partition'а

Topic: orders (3 partitions)

Partition 0:  Order-1 -> Order-4 -> Order-7 (ПОРЯДОК ГАРАНТИРОВАН)
Partition 1:  Order-2 -> Order-5 -> Order-8 (ПОРЯДОК ГАРАНТИРОВАН)
Partition 2:  Order-3 -> Order-6 -> Order-9 (ПОРЯДОК НЕ ГАРАНТИРОВАН МЕЖДУ ПАРТИЦИЯМИ)

Esli читаешь из одного partition'а - порядок сохранится. Если из разных - нет.

Порядок между partition'ами

Каждый consumer в группе читает из своего набора partition'ов, поэтому нельзя гарантировать глобальный порядок всех сообщений.

Способ 1: Одноpartition'ный topic (простой, но ограничивает пропускную способность)

public class KafkaConfig {
    @Bean
    public NewTopic singlePartitionTopic() {
        // Только 1 partition = глобальный порядок
        return TopicBuilder.name("user-events")
                .partitions(1)
                .replicas(3)
                .build();
    }
}

Минусы:

• Только один consumer может обрабатывать сообщения (параллелизм = 1)
• Пропускная способность ограничена одной машиной
• Масштабирование невозможно

Способ 2: Использование partition key для гарантии порядка

Это рекомендуемый подход для большинства случаев:

@Service
public class OrderProducer {
    private final KafkaTemplate<String, OrderEvent> kafkaTemplate;
    
    public void sendOrder(OrderEvent event) {
        // ВСЕ заказы одного пользователя пойдут в ОДИН partition
        // благодаря partition key
        kafkaTemplate.send(
            new ProducerRecord<>(
                "order-events",
                event.getUserId(),  // ← PARTITION KEY
                event
            )
        );
    }
}

Когда используются partition keys:

• Все сообщения с одинаковым key гарантированно попадают в один partition
• Внутри partition'а порядок сохранится
• Разные partition'ы могут обрабатываться параллельно

Topic: order-events (3 partitions)

user-123 -> Partition 0  (Order-1 -> Order-2 -> Order-3 ПОРЯДОК OK)
user-456 -> Partition 1  (Order-4 -> Order-5 -> Order-6 ПОРЯДОК OK)
user-789 -> Partition 2  (Order-7 -> Order-8 -> Order-9 ПОРЯДОК OK)

Способ 3: Читать с одной partition'а явно

@Service
public class OrderListener {
    
    // Слушаем ТОЛЬКО partition 0
    @KafkaListener(
        topics = "order-events",
        groupId = "order-group",
        topicPartitions = @TopicPartition(
            topic = "order-events",
            partitions = { "0" }  // ← Только partition 0
        )
    )
    public void listenPartitionZero(OrderEvent event) {
        processOrder(event);
    }
}

Используется редко, так как теряется параллелизм.

Способ 4: Использование idempotency для восстановления порядка

Если порядок нарушился из-за retry'ев:

@Service
public class OrderService {
    private final OrderRepository orderRepository;
    
    @KafkaListener(topics = "order-events", groupId = "order-group")
    public void processOrder(OrderEvent event) {
        // Проверяем, нет ли уже обработанного заказа с меньшим sequence
        Long maxSequence = orderRepository.findMaxSequenceForUser(event.getUserId());
        
        if (event.getSequence() <= maxSequence) {
            log.warn("Старый заказ игнорируем: seq={}", event.getSequence());
            return;
        }
        
        // Обрабатываем новый заказ
        Order order = new Order(event);
        order.setSequence(event.getSequence());
        orderRepository.save(order);
    }
}

Способ 5: Использование Kafka Streams для гарантии порядка

Для сложных сценариев с требованием к порядку:

@Configuration
public class StreamsConfig {
    
    @Bean
    public StreamsBuilder streamsBuilder() {
        StreamsBuilder builder = new StreamsBuilder();
        
        KStream<String, OrderEvent> orders = builder
                .stream("order-events");
        
        // Kafka Streams гарантирует обработку в порядке внутри partition'а
        orders
            .peek((key, value) -> log.info("Processing order: {} for user: {}", 
                  value.getId(), key))
            .to("processed-orders");
        
        return builder;
    }
}

Практический пример: Биржевые заказы (требуют порядка)

@Service
public class StockOrderProcessor {
    
    @Bean
    public NewTopic stockOrdersTopic() {
        // Много partition'ов для масштабирования
        return TopicBuilder.name("stock-orders")
                .partitions(10)
                .replicas(3)
                .build();
    }
    
    public void submitOrder(StockOrder order) {
        // partition key = пользователь
        // Все его заказы будут в одном partition'е в нужном порядке
        kafkaTemplate.send(
            new ProducerRecord<>(
                "stock-orders",
                order.getUserId() + ":" + order.getSymbol(),  // Composite key
                order
            )
        );
    }
    
    @KafkaListener(
        topics = "stock-orders",
        groupId = "stock-processor",
        concurrency = "10"  // 10 потоков, каждый обрабатывает свой partition
    )
    @Transactional
    public void processOrder(StockOrder order) {
        // Порядок гарантирован внутри partition'а
        log.info("Processing order {} for user {} (seq: {})", 
                 order.getId(), order.getUserId(), order.getSequenceNumber());
        
        stockRepository.save(order);
    }
}

Таблица сравнения подходов

                    Порядок  Масштабируемость  Сложность  Рекомендация
1. 1 partition       ✓✓       ✗✗                ✓          NO
2. Partition key     ✓         ✓✓                ✓          YES ⭐
3. Single part read  ✓✓       ✗✗                ✓          Редко
4. Sequence number   ✓         ✓✓                ✗✗         Сложно
5. Kafka Streams     ✓         ✓✓                ✗          Спец.случаи

Лучшие практики

• Используй partition key для гарантии порядка в рамках сущности
• Не создавай 1-partition topics в production
• Добавляй sequence числа в сообщения для отладки
• Тестируй сценарии с перепроизводством (rebalance)
• Мониторь lag - индикатор проблем с порядком

Вывод

Порядок сообщений в Kafka гарантирован только внутри partition'а. Правильный выбор partition key - это ключ к надёжной обработке упорядоченных данных при сохранении масштабируемости.