К содержимому
Войти

Python Road Map

📜 Kafka изнутри

Kafka встречается в тексте 59% вакансий Go-мидла и 19% вакансий Node.js-мидла за неделю 2026-W45, и там, где она в стеке, на собеседовании про неё спрашивают глубже, чем «это лог с офсетами». Ждут, что кандидат объяснит, куда попадает сообщение, что значит acks=all, почему потребителей в группе не бывает больше партиций и откуда берутся дубли после рестарта. Здесь разобрано устройство Kafka изнутри: партиции, репликация, группы потребителей, коммит офсетов, удержание и компакция. Чем лог отличается от очереди и когда Kafka вообще нужна, описано на странице «Зачем брокер: Kafka или RabbitMQ»

🧱 Топик, партиция, сегмент

Топик — имя потока событий, например orders. Физически топик разбит на партиции: каждая — отдельный лог, в который сообщения только дописываются в конец и получают порядковый номер, офсет. Партиции разложены по брокерам кластера, поэтому запись и чтение одного топика идут на несколько машин сразу

На диске партиция — это папка с файлами сегментов. Вот что лежит у брокера для партиции emails-0 после десяти сообщений:

00000000000000000000.index
00000000000000000000.log
00000000000000000000.timeindex
leader-epoch-checkpoint
partition.metadata

В .log лежат сообщения, .index и .timeindex ищут позицию по офсету и по времени, имя файла равно офсету первого сообщения сегмента. Когда сегмент дорастает до segment.bytes (по умолчанию 1 ГиБ) или живёт дольше segment.ms (7 суток), брокер закрывает его и начинает новый. Удаляются старые данные тоже целыми сегментами

Почему Kafka держит большой поток: она пишет на диск последовательно, читает через page cache операционной системы и отдаёт данные в сеть через sendfile без копирования в память процесса. Сообщения ходят пачками, пачку можно сжать один раз у продюсера и разжать только у потребителя. Документация Kafka приводит разницу больше чем в 6000 раз между последовательной и случайной записью на диск, поэтому вся архитектура и построена вокруг лога

📮 Куда продюсер кладёт сообщение

Партицию для сообщения выбирает продюсер, а не брокер:

  • Если у сообщения есть ключ, партиция — это хэш ключа (murmur2) по модулю числа партиций. Все сообщения с одним ключом попадают в одну партицию и читаются в порядке записи
  • Если ключа нет, продюсер пишет в одну партицию, пока не наберёт пачку примерно на batch.size, потом переключается на другую. Так пачки получаются крупнее, а данные всё равно расходятся по всем партициям

Ключ выбирают по тому, что должно обрабатываться по порядку: id заказа, id пользователя, id счёта. Плата за порядок — перекос. Если один клиент шлёт половину всех событий, его партиция становится горячей, и потребитель этой партиции отстаёт, пока остальные простаивают

Продюсер не отправляет каждое сообщение отдельным запросом. Он копит пачку на партицию до batch.size (16 КБ) или до linger.ms (в Java-клиенте с Kafka 4.0 по умолчанию 5 мс, раньше было 0). Несколько миллисекунд задержки дают в разы меньше запросов и лучшее сжатие

Число партиций — решение, которое трудно отменить. Kafka не умеет уменьшать число партиций, а увеличение меняет формулу «хэш по модулю», и ключ, который жил в партиции 2, начнёт писаться в партицию 5. Старые сообщения при этом никуда не переезжают, порядок по ключу на стыке ломается. Поэтому партиций заводят с запасом под будущий параллелизм потребителей

🧬 Репликация и acks

У каждой партиции есть лидер и несколько фолловеров на других брокерах, их число задаёт replication factor. Пишут и читают через лидера, фолловеры сами забирают у него новые записи. Лидер ведёт список реплик, которые не отстают, — ISR (in-sync replicas). Реплика, которая не догнала лидера за replica.lag.time.max.ms, из ISR выпадает

Сообщение считается закоммиченным, когда его записали все реплики из ISR. Только такие сообщения видят потребители. Документация даёт гарантию: закоммиченное сообщение не потеряется, пока жива хотя бы одна реплика из ISR

Продюсер выбирает, какого подтверждения ждать:

acksКогда брокер отвечает «записано»Что можно потерять
0продюсер не ждёт ответасообщение при любом сбое сети или брокера
1лидер записал у себясообщение, если лидер упал до того, как фолловеры его забрали
allвсе реплики из ISR записалиничего, пока жива одна реплика из ISR

У acks=all есть ловушка. ISR может сжаться до одного лидера, и тогда «все реплики из ISR» — это он один, то есть та же надёжность, что у acks=1. Защищает настройка топика min.insync.replicas: при меньшем числе реплик в ISR брокер отказывает в записи с acks=all. По умолчанию она равна 1, в продакшене ставят replication factor 3 и min.insync.replicas=2

Это поведение проверено на кластере из трёх брокеров Kafka 3.9 в Docker. Топик payments: одна партиция, replication factor 3, min.insync.replicas=2, лидер на брокере 2. Брокеры гасились по одному:

== все три
Leader: 2 Isr: 2,3,1
acks=all: записано в p0/0
== без k3
Leader: 2 Isr: 2,1
acks=all: записано в p0/1
== без k3 и k1
Leader: 2 Isr: 2
acks=all: ошибка: records have timed out before they were able to be produced
acks=1: записано в p0/2
== вернулись
Leader: 2 Isr: 2,1,3
acks=all: записано в p0/3

С одним упавшим брокером запись идёт как обычно. Когда в ISR остался один лидер, запись с acks=all отказывает: брокер отвечает NOT_ENOUGH_REPLICAS, клиент повторяет попытки, пока не истечёт срок доставки, и возвращает ошибку. Запись с acks=1 при этом проходит и лежит на единственной машине. Это и есть обмен доступности на надёжность. С RF 3 и min.insync.replicas=2 топик переживает потерю одного брокера без потери данных и без остановки записи

Если лидер упал, контроллер выбирает нового лидера из ISR. Если в ISR никого не осталось, есть выбор. По умолчанию (unclean.leader.election.enable=false) партиция ждёт возвращения реплики из ISR и недоступна. С true лидером станет отставшая реплика, партиция оживёт, но записи, которых у неё не было, пропадут навсегда

Метаданные кластера (кто лидер, кто в ISR) хранит KRaft — встроенный кворум контроллеров на Raft. С Kafka 4.0 ZooKeeper больше не поддерживается, и на вопрос «зачем Kafka ZooKeeper» правильный ответ теперь такой: в новых версиях он не нужен

👥 Группа потребителей и ребаланс

Потребители с одним group.id делят партиции топика: каждую партицию в группе читает ровно один потребитель. Поэтому параллелизм группы не больше числа партиций, а лишние потребители стоят без дела

Когда состав группы меняется, происходит ребаланс: координатор группы на брокере перераспределяет партиции. Запуск на том же кластере: топик orders на 3 партиции, потребители группы billing добавлялись по одному, потом c2 остановили:

+c1            c1=[0 1 2]
+c2            c1=[0 1] c2=[2]
+c3            c1=[0] c2=[2] c3=[1]
+c4            c1=[0] c2=[2] c3=[1] c4=[]
-c2            c1=[0] c3=[1] c4=[2]

Четвёртому потребителю партиции не хватило, он подхватил партицию 2, только когда ушёл c2. Видно и другое: c1 всё время держал партицию 0. Это кооперативный ребаланс (cooperative sticky): при перераспределении забирают только те партиции, которые переезжают, остальные потребители читают без остановки. В старой схеме (eager) все потребители на время ребаланса отдавали все партиции, и группа стояла целиком

Ребаланс запускают не только новые и ушедшие потребители. Потребитель выпадает из группы, если от него нет heartbeat дольше session.timeout.ms (45 с) или если между вызовами poll прошло больше max.poll.interval.ms (5 минут). Второе — частая причина ребалансов на проде: пачка из 500 сообщений (max.poll.records) обрабатывалась дольше пяти минут, и потребителя выкинули из группы

Две вещи сокращают ребалансы:

  • Статическое членство. У потребителя задан group.instance.id, и при рестарте пода он возвращается под тем же именем. Если вернулся быстрее session.timeout.ms, ребаланса нет
  • Новый протокол групп (KIP-848, готов к продакшену с Kafka 4.0). Распределение считает брокер, а не лидер группы на клиенте, и каждый потребитель переходит к своему назначению сам, не дожидаясь остальных. В Java-клиенте включается group.protocol=consumer, по умолчанию пока classic. Автор franz-go советует включать его на брокерах Kafka 4.3 и новее

🔖 Офсеты и коммит

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

Момент коммита решает, что случится при падении. Если коммит идёт после обработки, при падении между ними сообщения обработаются ещё раз. Это at-least-once, обычный режим Kafka. Проверка: в топике 10 писем, потребитель обработал все, закоммитил офсет после четвёртого и упал. После перезапуска:

писем: 10, обработано дважды: 6

Шесть писем ушли бы клиентам второй раз. Поэтому обработчик в Kafka делают идемпотентным: повтор того же сообщения не меняет результат. Если коммитить до обработки, получится at-most-once: при падении сообщение пропадёт. Подробно гарантии и дедупликация разобраны на странице «Гарантии доставки»

По умолчанию клиент коммитит сам каждые 5 секунд (enable.auto.commit=true), и в Java-клиенте, и в franz-go коммитится то, что вернул прошлый poll. Пока обработка синхронная, это at-least-once. Если сообщения ушли в фоновые горутины, офсет может закоммититься раньше, чем горутина закончила, и при падении сообщение потеряется

Насколько группа отстала, показывает consumer lag — разница между концом лога и закоммиченным офсетом. Это первая метрика, которую выводят на дашборд для Kafka. Вывод kafka-consumer-groups.sh --describe для группы из примера выше, столбцы с id потребителя убраны:

GROUP   TOPIC   PARTITION  CURRENT-OFFSET  LOG-END-OFFSET  LAG
mailer  emails  0          4               10              6

🗄️ Удержание и компакция

Как долго хранятся сообщения, задаёт cleanup.policy топика:

  • delete (по умолчанию). Сегменты старше retention.ms (7 суток) или сверх retention.bytes на партицию удаляются целиком, прочитали их или нет
  • compact. Kafka хранит как минимум последнее значение для каждого ключа, старые значения того же ключа фоновый процесс вычищает. Топик становится снимком «ключ → текущее значение»: так хранят настройки, профили, текущий статус заказа, а Kafka Connect и Kafka Streams держат в таких топиках своё состояние

Компакция на топике user-email: записаны три адреса пользователя u1, по одному для u2 и u3, затем для u2 записан ключ с пустым значением. Пустое значение — это надгробие (tombstone), команда удалить ключ. После прохода компакции топик читается с начала так:

Offset:3   u3   c@mail.ru
Offset:4   u1   a@final.ru
Offset:5   u2   null
Offset:6   u4   d@mail.ru
Offset:7   u5   e@mail.ru

От u1 остался только последний адрес, старые значения u1 и u2 исчезли. Офсеты при этом не сдвинулись: в логе дыра с 0 по 2, офсет сообщения не меняется никогда. Порядок тоже сохранён. Надгробие лежит delete.retention.ms (по умолчанию сутки), чтобы потребители успели узнать об удалении, потом пропадает и оно. Компакция не мгновенная: последний, активный сегмент она не трогает, поэтому дубли ключей какое-то время видны

🛠️ На практике

В коде надёжность Kafka держится на двух вещах: продюсер ждёт подтверждения всех реплик, а офсет коммитится только после обработки. Пример ниже запущен на том же кластере: обработчик упал на втором сообщении, и после перезапуска вся пачка пришла снова

Go · Продюсер с надёжной записью и потребитель с ручным коммитом на franz-go

func newProducer() (*kgo.Client, error) {
	return kgo.NewClient(
		kgo.SeedBrokers("kafka-1:9092", "kafka-2:9092", "kafka-3:9092"),
		kgo.RequiredAcks(kgo.AllISRAcks()), // это и так умолчание franz-go, пишем явно
		kgo.RecordDeliveryTimeout(30*time.Second),
	)
}

func consumeOrders(ctx context.Context, handle func(*kgo.Record) error) error {
	cl, err := kgo.NewClient(
		kgo.SeedBrokers("kafka-1:9092"),
		kgo.ConsumerGroup("billing"),
		kgo.ConsumeTopics("orders"),
		kgo.ConsumeResetOffset(kgo.NewOffset().AtStart()),
		kgo.DisableAutoCommit(),
	)
	if err != nil {
		return err
	}
	defer cl.Close()
	for {
		fs := cl.PollFetches(ctx)
		if fs.IsClientClosed() || ctx.Err() != nil {
			return ctx.Err()
		}
		var handleErr error
		fs.EachRecord(func(r *kgo.Record) {
			if handleErr == nil {
				handleErr = handle(r) // обработчик обязан переживать повтор
			}
		})
		if handleErr != nil {
			return handleErr // ничего не коммитим: после рестарта пачка придёт снова
		}
		if err := cl.CommitUncommittedOffsets(ctx); err != nil {
			return err
		}
	}
}

⚠️ Где ошибаются

Ставят acks=all без min.insync.replicas=2. При сжавшемся ISR запись подтверждает один лидер, и его падение уносит сообщения, которые продюсер считает записанными

Выбирают ключ без оглядки на перекос. Ключ по стране или по крупному клиенту загоняет большую часть трафика в одну партицию. Lag растёт на одном потребителе, и новые потребители не помогают

Добавляют партиции топику с ключами на ходу. События одного заказа оказываются в двух партициях и обрабатываются параллельно. Если порядок важен, расширение планируют: останавливают запись или переезжают на новый топик

Делают долгую обработку внутри цикла poll. Обработка пачки дольше max.poll.interval.ms выкидывает потребителя из группы, пачку берёт другой, и через пять минут всё повторяется уже с ним. Лечат меньшим max.poll.records, большим интервалом или выносом медленной работы в отдельную очередь

Коммитят раньше, чем закончили. Автокоммит при обработке в фоновых горутинах или ручной коммит сразу после poll тихо теряет сообщения при падении

Не ставят алерт на consumer lag. Потребитель встал ночью, а отставание дольше retention.ms означает, что часть сообщений удалилась непрочитанной

🎯 Вопросы с собеседований

Что такое партиция и зачем она нужна?

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

Как гарантировать порядок обработки сообщений?

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

Что такое ISR и как работает acks=all?

ISR — реплики партиции, которые отстают от лидера не больше чем на replica.lag.time.max.ms. С acks=all лидер отвечает продюсеру, когда сообщение записали все реплики из ISR. Если ISR сжался до одного лидера, это та же надёжность, что acks=1, поэтому ставят min.insync.replicas=2: при меньшем ISR брокер отказывает в записи с ошибкой NOT_ENOUGH_REPLICAS. Обычная конфигурация — replication factor 3 и min.insync.replicas=2, она переживает потерю одного брокера

Может ли в группе быть больше потребителей, чем партиций?

Может, но лишние будут простаивать: одну партицию в группе читает только один потребитель. Они пригодятся как горячий резерв и возьмут партиции при уходе других. Чтобы читать параллельнее, нужно больше партиций. Исключение — share groups в Kafka 4.2+, где сообщения одной партиции делят несколько потребителей, но это уже модель очереди

Что такое ребаланс и почему он бывает проблемой?

Ребаланс — перераспределение партиций между потребителями группы, когда кто-то пришёл, ушёл или перестал слать heartbeat. В старой схеме (eager) все потребители на это время отдают все партиции, и группа стоит. Частая причина на проде — обработка дольше max.poll.interval.ms, тогда потребителя выкидывают, и пачка обрабатывается повторно. Помогают кооперативный ребаланс, статическое членство через group.instance.id и новый протокол групп из KIP-848

Откуда в Kafka дубли и как с ними жить?

Потребитель коммитит офсет после обработки. Если он упал между обработкой и коммитом, после рестарта он прочитает эти сообщения снова: это at-least-once. Дубли бывают и при записи, если продюсер повторил запрос после таймаута, их отсекает идемпотентный продюсер. Дубли при чтении убирают на стороне потребителя: обработчик делают идемпотентным, например записывают id обработанных сообщений в базу в той же транзакции, что и результат

Где Kafka хранит офсеты потребителей?

В служебном топике __consumer_offsets на брокерах. Группа коммитит туда офсет следующего сообщения для каждой своей партиции, автоматически раз в 5 секунд или вручную. В старых версиях офсеты лежали в ZooKeeper, с Kafka 4.0 его нет вовсе

Чем retention отличается от компакции?

С cleanup.policy=delete Kafka удаляет целые сегменты старше retention.ms или сверх retention.bytes, независимо от содержимого. С compact она оставляет последнее значение для каждого ключа и вычищает старые, а сообщение с ключом и пустым значением удаляет ключ. Офсеты при компакции не меняются и порядок сохраняется. Компактные топики хранят текущее состояние: настройки, профили, состояние Kafka Streams

Что будет, если упал брокер-лидер партиции?

Контроллер выберет нового лидера из реплик ISR, продюсеры и потребители обновят метаданные и переключатся на него. Закоммиченные сообщения не теряются, потому что они есть у всех реплик ISR. Если живых реплик из ISR нет, партиция недоступна, пока одна из них не вернётся. Включённый unclean.leader.election.enable вернёт доступность за счёт потери данных

📚 Что почитать

  • Design — официальное описание устройства Kafka: зачем последовательный диск и page cache, как работают репликация, ISR и компакция
  • Producer Configs и Consumer Configs — все настройки клиентов с умолчаниями, полезно прочитать про acks, linger.ms, max.poll.interval.ms и auto.offset.reset
  • Basic Kafka Operations — как смотреть lag группы, добавлять партиции и почему они ломают распределение ключей
  • KIP-848 — почему старый протокол ребаланса останавливал всю группу и как устроен новый