Skip to content

Path 2 · lesson 7 of 8

Intermediate24 minApache Kafka 4.x, KRaft only (checked against the 4.4 documentation, KIP-500, KIP-595, KIP-630 and KIP-631) · Java 21 · Spring Boot 3.5 with Spring for Apache Kafka 3.3

KRaft: the controller quorum and the metadata log

How a Kafka 4 cluster manages itself: a Raft quorum of controllers keeps a replicated metadata log, brokers follow it, and none of it sits in the data path.

What you will learn

  • Explain what cluster metadata is and why it needs a single, ordered source of truth
  • Describe the roles in a KRaft cluster: active controller, standby controllers (voters) and brokers (observers)
  • Trace a metadata change from an admin request to every broker's metadata cache
  • Say what the controller does and does not do, and what keeps working when the quorum is lost
  • Choose between combined and dedicated controllers and size the quorum
  • Inspect a quorum with kafka-metadata-quorum.sh and read its output

Before you start

The concept

A Kafka cluster needs to agree on facts that are not in any topic: which brokers exist and are alive, which topics and partitions exist, which brokers hold each partition's replicas, which replica is the leader, which replicas are in sync, and the topic and broker configuration. This is the cluster metadata. Every broker acts on it and every client asks for it, so two brokers that disagree about it (for example about who leads a partition) is the most dangerous state a cluster can be in.

KRaft (Kafka Raft) is how Kafka stores and agrees on that metadata. A small set of servers called controllers form a quorum. They keep the metadata as an ordered log of change records in an internal single-partition topic, __cluster_metadata, replicated among themselves with a Raft-based protocol. One controller is the active controller: it is the leader of that log and the only one that makes decisions. The others are hot standbys with the same log. Brokers replicate the same log read-only and apply it to an in-memory copy of the metadata.

RoleConfigured byWhat it does with the metadata log
Active controllerprocess.roles=controller, and currently the quorum leaderDecides every metadata change, appends it as records, and commits it once a majority of controllers have it.
Standby controller (voter)process.roles=controllerFetches the log from the active controller, keeps the full state in memory, votes in controller elections and can become the active controller.
Broker (observer)process.roles=brokerFetches the log, replays committed records into its metadata cache and acts on them. It never votes and can never become the controller.
A server that sets process.roles=broker,controller plays both parts at once (combined mode).

Who knows what in the cluster

Simulation · not a real cluster

Inspect the controller and the brokers. Find the active controller, then stop a broker and look at what the controller changes in the metadata as a result.

Why it exists

Until Kafka 4.0, this job was split between two systems. Metadata lived in Apache ZooKeeper, a separate coordination service with its own servers, and one broker was elected (through ZooKeeper) to act as the controller. The controller read state from ZooKeeper, kept a copy in memory and pushed changes to the other brokers with RPCs. That design worked for years, but KIP-500, the proposal to replace it, lists problems that came from its shape:

  • Two copies that could disagree. ZooKeeper was the store of record, but the controller acted on its in-memory copy, and the two were not always the same. Partition leaders also wrote ISR changes to ZooKeeper themselves, which the controller could learn about seconds later.
  • Updates pushed one by one. The controller notified brokers of each change by RPC. A broker could receive some changes and miss others, and end up with a view that differed from the rest of the cluster with no systematic way to notice.
  • Slow controller failover. A newly elected controller had to load the whole cluster state from ZooKeeper before it could act. On clusters with very many partitions that reload was long, and during it nothing that needed the controller could happen.
  • A second distributed system to run. ZooKeeper had its own deployment, configuration, security model, monitoring and upgrade path, all of which had to be right for Kafka to be reliable.

KRaft applies Kafka's own central idea to its own metadata: store state as an ordered log and let everyone replay it. A log gives every change a position (an offset), so any node can say exactly how up to date it is, catch up by fetching what it lacks, and never apply changes out of order or skip one. The standby controllers follow the log continuously, so failover does not involve reloading state. And there is one system to deploy and secure.

How it works inside

The metadata log

__cluster_metadata has exactly one partition, stored in each node's metadata.log.dir (by default the first directory in log.dirs). Its records are typed changes: a broker registered, a topic created, a partition's leader or ISR changed, a configuration value set. The current metadata is whatever you get by applying those records in order. Clients cannot produce to or consume from this topic. It is written only by the active controller.

The quorum: Raft, adapted to Kafka

The controllers replicate that partition using the protocol from KIP-595, which its authors describe as a Raft dialect shaped by Kafka's own replication. Two things carry over from Raft unchanged: a record is committed only when a majority of the voters have it, and a new leader is chosen by a majority vote among the voters, in a numbered epoch, where a voter only grants its vote to a candidate whose log is at least as up to date as its own. One thing is done Kafka's way: replication is pull-based. Followers fetch from the leader, as partition followers do, and those fetches double as the leader's liveness signal.

If a voter gets no successful fetch from the leader within controller.quorum.fetch.timeout.ms (2 seconds), it becomes a candidate and asks for votes. A leader that stops hearing from a majority for the same time resigns. The majority rule is what makes two active controllers impossible: with 3 voters, two must agree, and any two majorities share a member. It also sets the arithmetic: a quorum of 2N+1 controllers survives N failures, so 3 survive one and 5 survive two. An even number adds a machine without adding tolerance.

Controller quorum

Simulation, not a real cluster

Watch a controller fail and a new one get elected by majority, and what goes wrong if a node promotes itself without one. The election mechanics in detail are in Leader election (Raft).

Step 1 · The pattern

One controller runs the cluster

Brokers store the data, and one active controller decides which broker leads each partition. Every broker follows the same controller, so every client gets the same map of the cluster.

  • write
  • confirmed
Open the full animated lesson

How brokers follow the metadata

Each broker is an observer of the metadata partition. It fetches the log from the active controller, tracks the offset it has applied, and replays each committed record into its metadata cache. Replaying has effects: a record that makes this broker a follower of orders.events-2 causes it to start fetching that partition from the new leader. Because every broker applies the same records in the same order, their views differ only by how far each has read, and that is a number you can monitor.

Clients get metadata from brokers, not from controllers. A producer's or consumer's Metadata request is answered by whichever broker it asks, from that broker's cache. Controllers do not appear in those responses, and bootstrap.servers in an application should list brokers only.

Broker registration, heartbeats and fencing

A starting broker registers with the active controller and then sends a heartbeat every broker.heartbeat.interval.ms (2 seconds). The heartbeat renews a lease and reports how far the broker has read the metadata log. A new broker stays fenced (registered, but not given leadership and not advertised to clients) until it has caught up. If no heartbeat arrives for broker.session.timeout.ms (9 seconds), the controller fences the broker again, removes it from the ISR of its partitions and elects new leaders for the partitions it led. That election is the subject of the next lesson. A planned shutdown uses the same channel: the broker asks in its heartbeat to shut down, the controller moves its leaderships away first, then tells it to proceed.

Snapshots

A log of every change since the cluster was created would grow without limit and take ever longer to replay. Deleting its old end, as time retention does for normal topics, would lose state. So each node periodically writes a snapshot: the full metadata as of a given offset, stored as a .checkpoint file next to the log segments. By default a snapshot is generated after 20 MiB of new records (metadata.log.max.record.bytes.between.snapshots) or one hour (metadata.log.max.snapshot.interval.ms), whichever comes first. Log segments older than the latest snapshot can then be removed. A node that restarts loads its newest snapshot and replays only the records after it, and a node that is new or far behind is sent a snapshot by the leader instead of the whole history.

What the controller does, and does not do

The active controller does

  • Register brokers, track their heartbeats, fence and unfence them
  • Create and delete topics, add partitions, place replicas
  • Elect partition leaders and record every ISR change that leaders propose
  • Run partition reassignments and preferred leader elections
  • Store topic and broker configuration, ACLs, quotas and feature versions

It does not

  • Receive, store or forward application records
  • Replicate partition data: followers fetch from partition leaders
  • Coordinate consumer groups or store offsets: the group coordinator on a broker does that
  • Coordinate transactions: the transaction coordinator on a broker does that
  • Answer client metadata or produce and fetch requests: brokers do

This split explains what happens when the quorum loses its majority. Brokers keep their last known metadata, existing leaders keep accepting produce and fetch requests, and consumers keep reading. What stops is everything that needs a metadata change: no topic can be created, no ISR can shrink or grow, and no new leader can be elected. The cluster is running without the ability to react, so the next broker failure makes partitions unavailable until the quorum is back.

Combined or dedicated controllers

A server with process.roles=broker,controller is in combined mode. It is convenient for a laptop or a test environment: one process is a whole cluster. The documentation advises against it for critical deployments, because the controller is then not isolated from broker load and you cannot restart or scale controllers separately from brokers. Production clusters use dedicated controllers: 3 (or 5) small servers with process.roles=controller and the brokers with process.roles=broker. Controllers are modest machines; the documentation suggests about 5 GB of memory and 5 GB of disk for the metadata of a typical cluster.

All nodes find the quorum through controller.quorum.bootstrap.servers. With this setting the voter set itself is stored in the metadata log (a dynamic quorum), and controllers can be added and removed with kafka-metadata-quorum.sh. Older KRaft clusters list a fixed voter set in controller.quorum.voters instead; Kafka 4.1 added an upgrade path from that static form to the dynamic one.

Architecture

Drawing diagram…

A flowchart with a controller quorum of three controllers, one active and two hot standbys that fetch the metadata log from it and vote. Three brokers send heartbeats to the active controller and fetch committed metadata. An admin client's request reaches a broker, which forwards it to the active controller. Producers and consumers talk only to brokers, and brokers replicate partition data among themselves.

flowchart TB
  subgraph Q["Controller quorum, the voters of __cluster_metadata"]
    C1["Controller 1, active, leader of the metadata log"]
    C2["Controller 2, hot standby"]
    C3["Controller 3, hot standby"]
    C2 -->|"fetch log, vote"| C1
    C3 -->|"fetch log, vote"| C1
  end
  subgraph BR["Brokers, observers of the metadata log"]
    B1["Broker 101, metadata cache"]
    B2["Broker 102, metadata cache"]
    B3["Broker 103, metadata cache"]
  end
  B1 -->|"heartbeat, fetch committed metadata"| C1
  B2 -->|"heartbeat, fetch committed metadata"| C1
  B3 -->|"heartbeat, fetch committed metadata"| C1
  ADM["Admin client, create topic"] --> B2
  B2 -->|"forwards admin request"| C1
  APP["Producers and consumers"] -->|"metadata, produce, fetch"| B1
  B1 -->|"partition replication"| B3
Three dedicated controllers and three brokers. Application traffic touches only the brokers.
  • Inside the quorum, arrows point at the active controller because replication is pull-based: standbys fetch the log from the leader. Those two standbys are also the only other voters.
  • Brokers pull too. They apply only committed records, so a broker never acts on a change that a controller failover could undo.
  • An admin request such as creating a topic can be sent to any broker. The broker forwards it to the active controller, which is the only node that can append to the metadata log.
  • The bottom of the picture is the data path: clients to partition leaders, leaders to followers. No arrow from it goes into the quorum.

Message flow

Drawing diagram…

A sequence diagram. An admin client sends CreateTopics to a broker, which forwards it to the active controller. The controller places replicas, picks leaders and appends records. The two standby controllers fetch the records, which commits them by majority. The controller replies, the brokers fetch the committed records, replay them, create their replicas and update their caches, and a later metadata request is answered by a broker.

sequenceDiagram
  participant A as Admin client
  participant B as Broker 102
  participant C1 as Active controller
  participant C2 as Controller 2
  participant C3 as Controller 3
  participant O as Brokers 101 and 103
  A->>B: CreateTopics payments.events with 6 partitions and 3 replicas
  B->>C1: Forward the request
  C1->>C1: Place replicas, pick leaders, append topic and partition records
  C2->>C1: Fetch metadata log
  C1-->>C2: New records
  C3->>C1: Fetch metadata log
  C1-->>C3: New records
  Note over C1,C3: A majority has the records so they are committed
  C1-->>B: Topic created
  B-->>A: Success
  B->>C1: Fetch committed metadata
  C1-->>B: Topic and partition records
  O->>C1: Fetch committed metadata
  C1-->>O: Topic and partition records
  Note over B,O: Each broker replays the records, creates its replicas and updates its cache
  A->>B: Metadata request for payments.events
  B-->>A: Leaders and replicas of the 6 partitions
Creating a topic: decided by the active controller, committed by the quorum, replayed by every broker.
  1. The decision (which brokers get which replicas, who leads) is made once, by the active controller, and written down as records before anything acts on it.
  2. The records count as committed when a majority of the three controllers have them: the active controller plus one standby is enough.
  3. Brokers learn about the topic by fetching the log, not by being told individually. A broker that was restarting at the time catches up from its last offset when it returns and creates its replicas then.
  4. There is a short interval in which the topic exists but a particular broker has not replayed the records yet. Clients see this as a retriable unknown topic or leader-not-available error on their first attempts.

In a real system

A typical production layout for the order system used throughout this academy: six brokers spread over three availability zones, and three dedicated controllers, one per zone.

Serversprocess.rolesCount and placementWhy
Controllerscontroller3, one per zone, small instances with a fast disk for metadata.log.dirLosing a whole zone leaves 2 of 3 voters, still a majority. They carry no application traffic, so they are small.
Brokersbroker6, two per zone, with the large data disksHold the partitions. Replication factor 3 with rack awareness puts one replica per zone.
ApplicationsnoneOrder, payment, inventory and notification servicesConnect to brokers only. Their bootstrap.servers lists brokers, never controllers.

A rolling upgrade shows the separation at work. Brokers are restarted one at a time: each asks the controller for a controlled shutdown, its leaderships move, it restarts, catches up on metadata and data, and is unfenced. The controllers are restarted separately, standbys first and the active one last, so the quorum holds a majority throughout and there is at most one controller election. With combined-mode servers these two procedures cannot be separated: every restart takes out a broker and a voter together.

Why not two zones? With controllers split 2 and 1, losing the zone with two of them leaves a single voter, which is not a majority. A quorum needs a third location to survive the loss of one. This is the most common design mistake with any majority-based system.

Java and Spring Boot

Application code does not configure or talk to the quorum, so this section is mostly server configuration and the commands for inspecting it, plus one small Spring component that reads the quorum state through the Admin API for a health dashboard.

config/controller.propertiesProperties
# A dedicated controller: one of three voters in the metadata quorum.process.roles=controllernode.id=1# Controllers listen only on the controller listener.listeners=CONTROLLER://controller1.example.com:9093controller.listener.names=CONTROLLERlistener.security.protocol.map=CONTROLLER:SSL# How every node finds the quorum. List all controllers.controller.quorum.bootstrap.servers=controller1.example.com:9093,controller2.example.com:9093,controller3.example.com:9093# Where __cluster_metadata and its snapshots live.log.dirs=/var/lib/kafka/metadata

Why it is written this way

  • node.id must be unique across controllers and brokers together. A common convention is a low range for controllers and a separate range for brokers.
  • controller.quorum.bootstrap.servers is the current way to locate the quorum. If you see controller.quorum.voters with id@host:port entries, the cluster uses the older static voter set.
  • The listener security protocol shown is an example. TLS and SASL settings for the controller listener are omitted here: see the security lesson.

Configuration

Server settings for KRaft, with defaults from the Kafka 4.4 broker configuration reference. The first four have no default and must be set on every node.

process.rolesDefault none (required)
What it does
The roles this server plays: broker, controller, or broker,controller for a combined node.
When to change it
Use separate controller and broker servers for anything that matters. Use the combined form for local development and tests.
node.idDefault none (required)
What it does
The unique id of this server, shared by its broker and controller roles.
When to change it
Never reuse an id for a different machine's data. Keep controller and broker ids in separate ranges so output is easy to read.
controller.quorum.bootstrap.serversDefault none (required)
What it does
host:port list used by brokers and controllers to find the quorum. The voter set itself is kept in the metadata log.
When to change it
List all controllers. Replaces controller.quorum.voters, the static id@host:port form used by older KRaft clusters, which must not be set on a dynamic quorum.
controller.listener.namesDefault none (required)
What it does
Name of the listener used for controller traffic. Brokers use the first name in the list to connect to controllers.
When to change it
Give the controller listener its own name, port and security settings, and keep it off networks that applications can reach.
metadata.log.dirDefault unset (the first directory in log.dirs)
What it does
Directory that holds the __cluster_metadata log and its snapshots.
When to change it
On combined nodes or brokers with busy data disks, point it at a separate fast disk so metadata writes are not delayed by data I/O.
controller.quorum.fetch.timeout.msDefault 2000 (2 seconds)
What it does
A voter that cannot fetch from the leader for this long starts an election. A leader that hears from no majority for this long resigns.
When to change it
Raise it cautiously if controllers are spread over links with unstable latency and you see needless elections. Higher values mean slower controller failover.
controller.quorum.election.timeout.msDefault 1000 (1 second)
What it does
How long a candidate waits for a majority of votes before it starts a new election round.
When to change it
Usually left alone. controller.quorum.election.backoff.max.ms (1 second) randomises retries so candidates do not keep colliding.
broker.heartbeat.interval.msDefault 2000 (2 seconds)
What it does
How often a broker sends a heartbeat to the active controller.
When to change it
Leave at the default. It should stay several times smaller than the session timeout.
broker.session.timeout.msDefault 9000 (9 seconds)
What it does
How long a broker's lease lasts without a heartbeat before the controller fences it and moves its leaderships.
When to change it
This bounds how long a crashed broker's partitions wait for a new leader. Lowering it speeds up failover but risks fencing brokers during a long pause.
metadata.log.max.record.bytes.between.snapshotsDefault 20971520 (20 MiB)
What it does
Bytes of new metadata records after which a node writes a new snapshot.
When to change it
Rarely changed. Together with metadata.log.max.snapshot.interval.ms (3600000, 1 hour) it bounds replay time after a restart.
metadata.max.retention.bytesDefault 104857600 (100 MiB)
What it does
Combined size of metadata log and snapshots above which old snapshots and segments are deleted. A soft limit, since at least one snapshot must exist first.
When to change it
Leave it unless the metadata directory is very small. metadata.max.retention.ms (7 days) is the matching age limit.

Hands-on exercise

Find the controller, then predict what a failure costs

Use the cluster explorer to separate the controller's job from the brokers' job, then work out by hand what each kind of failure stops in a cluster with three dedicated controllers.

Steps · 0 of 6 done

The controller's view of a broker failure

Simulation · not a real cluster

Find the active controller, then stop and restart a broker and follow what the controller records each time.

What can go wrong

Two or four controllers
Symptom
After one controller fails, topic creation hangs and a later broker failure leaves partitions leaderless, although another controller is still running.
Cause
A majority of 2 voters is 2, so a two-node quorum tolerates no failure. Four voters need 3, so they tolerate one failure, the same as three.
Fix
Run an odd number of controllers: 3 to survive one failure, 5 to survive two. Place them in three or more failure domains.
Combined mode in production
Symptom
A broker under heavy load or a long pause causes controller elections, and every rolling restart of brokers also takes a voter out of the quorum.
Cause
With process.roles=broker,controller the controller shares its process, memory and disks with the broker, so broker problems become metadata problems.
Fix
Use dedicated controllers for critical clusters, as the Kafka documentation recommends, and keep combined mode for development and tests.
Applications pointed at the controllers
Symptom
A service fails to start with connection or timeout errors although the cluster is healthy and other services work.
Cause
bootstrap.servers lists the controller addresses (port 9093 in many examples). Controllers do not serve produce, fetch or client metadata requests.
Fix
Point spring.kafka.bootstrap-servers at brokers. Only administrative tools use the controller endpoint, with their explicit --bootstrap-controller option.
Treating the controller as a single point of failure for traffic
Symptom
During a controller restart the team halts deployments and expects message loss, or blames a latency spike on it without evidence.
Cause
A belief that messages flow through the controller. They do not: only metadata changes wait for it.
Fix
Check what actually depends on the controller: leader elections, ISR changes and admin operations. Existing produce and fetch paths continue during a controller election.
Controller metadata on a slow or shared disk
Symptom
Topic creation and leader elections are slow, and metadata commit latency rises when brokers are busy.
Cause
Every metadata change is written to the metadata log on a majority of controllers before it takes effect. Slow writes there delay every change in the cluster.
Fix
Give controllers their own fast disk (set metadata.log.dir where the node also holds data) and monitor the quorum's commit latency.
Following ZooKeeper-era instructions
Symptom
A command fails with an unrecognised --zookeeper option, or a configuration guide asks for zookeeper.connect.
Cause
The material predates KRaft. Kafka 4.x has no ZooKeeper mode at all.
Fix
Use --bootstrap-server (or --bootstrap-controller) with the tools and the KRaft settings in this lesson. Migrate older clusters through a 3.x bridge release first.

How to troubleshoot

You need to know who the active controller is and whether the quorum is healthy

Check

`bin/kafka-metadata-quorum.sh --bootstrap-server localhost:9092 describe --status`
How to read it
LeaderId is the active controller. CurrentVoters should list all controllers and CurrentObservers all brokers. A LeaderEpoch that rises between runs means elections are happening. MaxFollowerLag should be at or near 0.
A standby controller or a broker seems to be behind on metadata

Check

`bin/kafka-metadata-quorum.sh --bootstrap-server localhost:9092 describe --replication`, and on brokers the last applied record lag in `kafka.server:type=broker-metadata-metrics`
How to read it
A node whose log end offset trails the leader's and keeps trailing is not replaying metadata. A broker in that state acts on old leadership information and will be kept fenced after a restart until it catches up.
Admin operations time out: topics cannot be created, reassignments do not start

Check

Metric `kafka.controller:type=KafkaController,name=ActiveControllerCount` on each controller, and the current state and current leader values in `kafka.server:type=raft-metrics`
How to read it
Exactly one controller should report 1. If none does, the quorum has no majority or cannot complete an election: check that a majority of controllers are running and can reach each other on the controller listener.
A broker is running but holds no leaderships and clients never connect to it

Check

Metrics `kafka.controller:type=KafkaController,name=FencedBrokerCount` and `name=ActiveBrokerCount`, then that broker's log and its `controller.quorum.bootstrap.servers`
How to read it
The broker is registered but fenced. Either it cannot reach the active controller to heartbeat, or it has not caught up with the metadata log yet. TimedOutBrokerHeartbeatCount on the active controller rising points at heartbeats not arriving.
You want to see what the metadata log actually contains

Check

`bin/kafka-dump-log.sh --cluster-metadata-decoder --files <metadata.log.dir>/__cluster_metadata-0/00000000000000000000.log` or `bin/kafka-metadata-shell.sh --snapshot <a .checkpoint file>`
How to read it
The dump prints the typed records in order. The shell lets you browse the state like a directory tree, for example a partition's leader, leaderEpoch, replicas and isr.

Key takeaways

  • Cluster metadata (brokers, topics, replicas, leaders, ISRs, configuration) is an ordered log in the internal __cluster_metadata topic, written only by the active controller.
  • Controllers are the voters of a Raft-based quorum: a change is committed by a majority, and the active controller is elected by a majority. 2N+1 controllers survive N failures.
  • Brokers are observers: they fetch the committed log, replay it into a metadata cache and serve client metadata requests from it.
  • The controller is not in the data path. Without a quorum, existing leaders keep serving, but nothing that needs a metadata change can happen.
  • Brokers heartbeat to the active controller. A broker silent for broker.session.timeout.ms (9 seconds) is fenced and loses its leaderships.
  • Snapshots bound the metadata log: nodes restart from the latest snapshot and replay only what came after.
  • Use dedicated controllers in production and combined mode only for development. Kafka 4.x has no ZooKeeper mode.

Practical check

Small scenarios, one decision each. Pick what you would do, then read why.

Scenario 1 of 3

A cluster has 3 dedicated controllers and 6 brokers. During maintenance, controller 2 is down for a disk replacement when controller 3's host loses power. All 6 brokers are healthy. The on-call engineer sees that the order service is still producing and the payment service is still consuming, and proposes to finish the disk work at a normal pace.

How urgent is it to bring a controller back?

Scenario 2 of 3

A team is moving its payments cluster to production. To save three machines they plan 3 servers with process.roles=broker,controller, the same layout as their test environment. Their runbook restarts one server at a time for upgrades, and the brokers regularly run close to their disk and CPU limits during month-end batch loads.

What do you recommend?

Scenario 3 of 3

After a network change, the inventory service logs repeated NOT_LEADER_OR_FOLLOWER errors when producing to partitions led by broker 104, although kafka-topics.sh --describe shows 104 as their leader. kafka-metadata-quorum.sh describe --replication shows the three controllers and five brokers at log end offset 88,410 and broker 102 at 61,007 and not moving.

Where is the problem, and what do you check first?

References

References: Apache Kafka documentation: Operations, KRaft ↗ · Apache Kafka documentation: Broker configuration reference ↗ · Apache Kafka documentation: Monitoring (KRaft metrics) ↗ · Apache Kafka documentation: Upgrading (ZooKeeper removal, KRaft requirements) ↗ · KIP-500: Replace ZooKeeper with a Self-Managed Metadata Quorum ↗ · KIP-595: A Raft Protocol for the Metadata Quorum ↗ · KIP-631: The Quorum-based Kafka Controller ↗ · KIP-630: Kafka Raft Snapshot ↗ · Apache Kafka Javadoc: Admin (describeMetadataQuorum) ↗ · Report a problem