Skip to content

Path 2 · lesson 5 of 8

Intermediate22 minApache Kafka 4.x (defaults checked against the 4.4 documentation) · Java 21 · Spring Boot 3.5 with Spring for Apache Kafka 3.3

Log segments and retention

How a partition is stored as segment files with indexes, when segments roll, how time and size retention delete them, and what a consumer sees when its offset is gone.

What you will learn

  • Read a partition directory on a broker and say what each file is for
  • Predict when the active segment rolls from segment.bytes and segment.ms
  • Work out how long a record really stays on disk for a given retention and segment configuration
  • Size the disk a topic needs from its rate, record size, retention and replication factor
  • Explain what happens to a consumer group whose committed offset has been deleted, and choose auto.offset.reset on purpose
  • Say what tiered storage changes about retention and what it does not support

Before you start

The concept

So far a partition has been an ordered list of records with offsets. On a broker's disk it is a directory, named after the topic and the partition number (orders.events-0), and the list is cut into files called segments. Each segment holds a contiguous range of offsets. Only the newest one, the active segment, is written to. Every older segment is closed and never changes again.

Kafka does not remove a record when a consumer has read it. Records leave the log only when a retention rule says they are old enough, or the partition is large enough, and they leave a whole segment at a time. That is why the unit of storage matters to you as an application developer: it decides how long data really lives, how much disk a topic needs, and how far behind a consumer can fall before the data it wanted no longer exists.

File in the partition directoryWhat it holds
00000000000000005200.logThe record batches themselves. The file name is the offset of the first record in the segment (its base offset), padded to 20 digits.
00000000000000005200.indexOffset index: a sparse map from offset to byte position in the .log file, so a fetch does not scan the segment from its start.
00000000000000005200.timeindexTime index: a sparse map from timestamp to offset. Used for lookups by time (for example resetting a group to a point in time) and by time-based retention.
00000000000000005200.txnindexAborted transactions in this segment, so consumers reading committed data can skip them. Present only when transactions were used.
00000000000000005200.snapshotProducer state (the sequence numbers behind idempotent producers) as of this offset, so a restart does not replay the whole log to rebuild it.
leader-epoch-checkpointWhich leader epoch started at which offset. Followers use it to truncate correctly after a leader change.
One segment is a .log file plus its indexes. A partition has one such group per segment.

A partition as segments

Simulation · not a real cluster

Append records and watch the active segment fill and roll. Notice that a closed segment never changes again and that file names are base offsets.

Why it exists

Imagine the partition as a single file that grows forever. Appending is cheap, but everything else is hard. To drop data older than a week you would have to rewrite the file or punch holes in its front while producers and consumers are using it. To find offset 48,211,907 you would need one index over the whole file that also grows without bound. After a crash, the broker would have to check an enormous file for a torn write at the end.

Segments turn each of those into a cheap operation:

  • Deleting old data is deleting files. Retention never edits a file. It removes the oldest closed segments, which costs the same whether the segment held ten records or ten million.
  • Lookups stay fast. Because file names are base offsets, the broker finds the right segment by a search over file names held in memory, then uses that segment's small index.
  • Recovery is bounded. After an unclean stop only the newest segment has to be scanned and checked record by record. Closed segments were already complete.
  • Sequential I/O everywhere. Appends go to the end of one file and reads are mostly sequential scans of one file, which is what disks and the operating system's page cache handle best.

Retention exists for a different reason: Kafka is a log that many readers share, so the broker cannot know when everybody is finished with a record. Instead of tracking readers, the topic owner states a policy (keep seven days, or keep 50 GiB per partition) and every reader has to keep up with it. The documentation describes retention.ms as an SLA on how soon consumers must read their data, and that is the right way to think about it.

How it works inside

Appending and rolling

The leader appends each produced batch to the end of the active segment's .log file and, about every index.interval.bytes (4096 bytes by default), adds one entry to the offset index and, when the timestamp has advanced, one to the time index. The indexes are sparse on purpose: a few entries per megabyte are enough to land close to any offset and scan a short distance.

The active segment is rolled (closed, and a new one started with the next offset as its name) when the first of these happens: it reaches segment.bytes (1 GiB by default), or it has been open for segment.ms (7 days by default). Followers store the same records at the same offsets, but each replica rolls its own files, so segment boundaries can differ between brokers. Nothing in the protocol depends on them matching.

Serving a fetch

A fetch names an offset. The broker picks the segment whose base offset is the largest one not above it, looks in that segment's .index for the nearest entry at or below the offset, seeks to that byte position in the .log file and scans forward to the exact record. A lookup by timestamp goes through the .timeindex first to get an offset, then does the same.

Retention by time

Every log.retention.check.interval.ms (5 minutes) the broker checks each partition whose cleanup.policy includes delete. For the time rule it looks at one number per segment: the largest record timestamp in the segment. If that timestamp is older than retention.ms (7 days by default), the whole segment is eligible. A segment is never partly deleted, so one recent record keeps every older record in the same segment alive.

This has a consequence that surprises people. On a busy partition the active segment always contains a fresh record, so it is never eligible and only closed segments are deleted. The oldest record in a segment therefore lives for retention.ms plus however long the segment took to fill or roll. On a low-volume topic with defaults, a record written just after a roll waits up to 7 days for the segment to close (segment.ms) and then another 7 days for the newest record in it to expire: close to 14 days in total, not 7.

If a partition goes completely quiet, even the active segment eventually holds only expired records. In that case the broker rolls it and deletes it too, which is why an idle topic does drain to empty. The 4.x topic configuration reference states this directly: retention.ms triggers a roll of the active segment once the condition is satisfied.

Retention by size

retention.bytes is off by default (-1). When set, the broker deletes the oldest segments until the partition is back within the limit. Two details matter. The limit is per partition, not per topic, so a 12-partition topic with retention.bytes of 10 GiB may hold 120 GiB on each replica. And when both rules are set, a segment is deleted as soon as either makes it eligible: size retention can remove data that is only an hour old if a burst fills the partition.

Log start offset

When a segment is deleted the partition's log start offset moves forward to the base offset of the oldest segment that remains. The file is first renamed with a .deleted suffix and removed from disk after file.delete.delay.ms (1 minute). Offsets are never reused or renumbered: a partition whose first segments are gone simply starts at, say, offset 5,000,000. The readable range of a partition is always from the log start offset up to the high watermark.

When a consumer's offset has been deleted

A group that was stopped for longer than the retention period comes back with a committed offset below the log start offset. Its first fetch is answered with an out-of-range error, and the consumer applies auto.offset.reset:

auto.offset.resetWhere the consumer continuesWhat that means
latest (the default)At the end of the logEverything between the old position and now is skipped, including records that still exist.
earliestAt the log start offsetIt reads everything that still exists. The deleted records are gone either way.
by_duration:<ISO-8601 duration>At the first record newer than now minus the durationA bounded replay. Needs 4.x clients; check that the kafka-clients version your Spring Boot manages accepts it.
noneNowhere: poll() throwsThe application has to decide. Useful when silently skipping data is worse than stopping.
The same setting also applies when a group has no committed offset at all, which is the case people usually configure it for.

Tiered storage

Tiered storage (KIP-405, production-ready since Kafka 3.9) adds a second place to keep closed segments: the broker copies them to a remote store such as an object store, keeps only a short local window (local.retention.ms, local.retention.bytes), and fetches old data back when a consumer asks for it. retention.ms and retention.bytes then describe the total across both tiers. It is off by default: brokers need remote.log.storage.system.enable=true and the topic needs remote.storage.enable=true. Be clear about its limits. Apache Kafka ships the interface but no storage plugin, so you supply a RemoteStorageManager implementation or use a distribution that includes one, and it does not support compacted topics. It makes long retention cheaper and broker replacement faster. It does not make reads of old data as fast as local reads.

Architecture

Drawing diagram…

A flowchart of a partition directory with two closed segments and one active segment. Producers append to the active segment. A consumer fetch goes through a segment's offset index to its log file. The retention check deletes the oldest closed segment, which moves the log start offset forward.

flowchart TB
  PROD["Producer batches"] --> ACT
  subgraph DIR["Partition directory orders.events-0 on one broker"]
    direction LR
    S1["Closed segment, base offset 0"]
    S2["Closed segment, base offset 5200"]
    ACT["Active segment, base offset 10400"]
    S1 --- S2
    S2 --- ACT
  end
  subgraph FILES["Files that make up the segment with base offset 5200"]
    LOGF["00000000000000005200.log holds record batches"]
    IDX["00000000000000005200.index maps offset to byte position"]
    TIDX["00000000000000005200.timeindex maps timestamp to offset"]
  end
  S2 -.-> LOGF
  S2 -.-> IDX
  S2 -.-> TIDX
  CONS["Consumer fetch at offset 7300"] --> IDX
  IDX --> LOGF
  RET["Retention check, every 5 minutes"] --> S1
  S1 --> DEL["Segment deleted, log start offset becomes 5200"]
One partition on one broker: closed segments, one active segment, and the files behind a segment.
  • Writes touch exactly one file group: the active segment. Everything to its left is immutable, which is what makes deletion and recovery cheap.
  • A fetch for offset 7300 picks the segment with base offset 5200 because that is the largest base offset not above 7300, then uses its index to jump near the record.
  • Retention works from the left edge only. It removes the oldest segment and the log start offset jumps to the next segment's base offset, here from 0 to 5200.
  • Each replica of the partition has its own directory like this one on its own broker, so the disk cost of a topic is multiplied by the replication factor.

Message flow

Drawing diagram…

A sequence diagram. A consumer commits offset 1500 and stops. Retention deletes the segment holding offsets 0 to 4999. When the consumer returns and fetches from 1500 the leader answers out of range, the consumer applies auto.offset.reset earliest, asks for the earliest offset, gets 5000 and continues from there.

sequenceDiagram
  participant C as Consumer in group billing
  participant G as Group coordinator
  participant L as Partition leader
  participant R as Retention task on the leader
  C->>L: Fetch from offset 1200
  L-->>C: Records 1200 to 1499
  C->>G: Commit offset 1500
  Note over C: Consumer is stopped for nine days
  R->>L: Newest timestamp in segment 0 to 4999 is older than retention.ms
  L->>L: Delete the segment, log start offset is now 5000
  C->>G: Fetch committed offset
  G-->>C: 1500
  C->>L: Fetch from offset 1500
  L-->>C: OFFSET_OUT_OF_RANGE
  Note over C: auto.offset.reset is earliest
  C->>L: ListOffsets earliest
  L-->>C: 5000
  C->>L: Fetch from offset 5000
  L-->>C: Records from 5000 onward
A group that was down longer than the retention period: its committed offset no longer exists.
  1. The commit stores 1500, the next offset to read. It lives in __consumer_offsets, separately from the data, so it survives even though the records it points at do not.
  2. Retention never asks whether any group still needs a segment. Nine days against a seven-day policy means records 1500 to 4999 were deleted unread by this group.
  3. The leader reports the problem as an out-of-range error on the fetch. The consumer handles it internally according to auto.offset.reset; with none it would throw to the application instead.
  4. With earliest the group resumes at 5000 and misses 3500 records. With the default latest it would also skip everything from 5000 to the end of the log.

In a real system

A typical online shop runs two topics with very different retention needs on the same cluster.

clickstream.page-views carries page views keyed by session id, 12 partitions, replication factor 3. It averages 2,000 events per second at about 1 KB each. That is roughly 2 MB per second, or about 173 GB per day before compression. The analytics jobs that read it run continuously and nobody replays more than a couple of days, so the owner sets retention.ms to 3 days. Budget: 173 GB x 3 days is about 520 GB of log, times 3 replicas is about 1.56 TB across the cluster, plus headroom for the active segments and for the time between a segment expiring and the next retention check. If traffic doubles on a sale day, so does that number: a time limit alone does not cap disk usage. To make the cap explicit they also set retention.bytes to 20 GiB per partition (12 x 20 GiB x 3 replicas = 720 GiB at most), accepting that a spike will shorten the time window.

orders.events carries order lifecycle events keyed by order id, 6 partitions, replication factor 3, perhaps 20 events per second. Volume is small, but the billing service is sometimes paused for a weekend during migrations and a new fraud model occasionally replays a month of history. They set retention.ms to 30 days and, because the topic is slow, segment.ms to 1 day so that a segment closes daily and expiry is accurate to about a day instead of about a week.

clickstream.page-views

  • High volume, readers are always live
  • retention.ms 3 days plus retention.bytes 20 GiB per partition as a hard cap
  • Default 1 GiB segments roll every few minutes per partition
  • Risk to watch: disk fills during a traffic spike

orders.events

  • Low volume, readers are sometimes paused
  • retention.ms 30 days, no size limit
  • segment.ms 1 day, otherwise a segment would stay open a full week
  • Risk to watch: a paused consumer falling out of retention

Java and Spring Boot

Retention is topic configuration, so it belongs with the code that declares the topic. In Spring Boot, a NewTopic bean is created on startup by the auto-configured KafkaAdmin. The consumer's reaction to a deleted offset is client configuration.

src/main/java/com/example/shop/config/TopicConfiguration.javaJava
package com.example.shop.config;import java.time.Duration;import org.apache.kafka.clients.admin.NewTopic;import org.apache.kafka.common.config.TopicConfig;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.kafka.config.TopicBuilder;@Configurationpublic class TopicConfiguration {    private static final long GIB = 1024L * 1024 * 1024;    /** Low volume, long replay window: roll daily so expiry is accurate to a day. */    @Bean    NewTopic orderEvents() {        return TopicBuilder.name("orders.events")                .partitions(6)                .replicas(3)                .config(TopicConfig.CLEANUP_POLICY_CONFIG, TopicConfig.CLEANUP_POLICY_DELETE)                .config(TopicConfig.RETENTION_MS_CONFIG, millis(Duration.ofDays(30)))                .config(TopicConfig.SEGMENT_MS_CONFIG, millis(Duration.ofDays(1)))                .config(TopicConfig.MIN_IN_SYNC_REPLICAS_CONFIG, "2")                .build();    }    /** High volume, short window: a time limit plus a per-partition size cap. */    @Bean    NewTopic pageViews() {        return TopicBuilder.name("clickstream.page-views")                .partitions(12)                .replicas(3)                .config(TopicConfig.RETENTION_MS_CONFIG, millis(Duration.ofDays(3)))                .config(TopicConfig.RETENTION_BYTES_CONFIG, String.valueOf(20 * GIB))                .build();    }    private static String millis(Duration duration) {        return String.valueOf(duration.toMillis());    }}

Why it is written this way

  • Topic configuration values are strings, and durations are in milliseconds. Computing them from Duration avoids the classic off-by-a-factor-of-1000 mistake.
  • segment.ms is set only on the slow topic. On the busy one the 1 GiB segment.bytes limit rolls segments long before a day passes.
  • retention.bytes is per partition: 20 GiB here means up to 240 GiB per replica of the 12-partition topic.
  • KafkaAdmin creates missing topics and can add partitions. Do not rely on it to change the retention of a topic that already exists: change that with kafka-configs.sh or your infrastructure tooling, and keep this file in step.

Configuration

Topic-level names are shown. Each has a broker-wide default with a log. prefix that applies to topics which do not override it (for example log.segment.bytes, log.roll.ms or log.roll.hours, log.retention.ms / log.retention.minutes / log.retention.hours, log.retention.bytes). Defaults are from the Kafka 4.4 reference.

segment.bytesDefault 1073741824 (1 GiB)
What it does
Size at which the active segment is rolled. Retention and compaction work one file at a time, so this is also the granularity of deletion. The minimum allowed value is 1 MiB since Kafka 4.0.
When to change it
Leave it for busy topics. Lower it only when you need finer-grained deletion on a topic that is too slow to reach 1 GiB and segment.ms is not enough. Very small segments mean many open files.
segment.msDefault 604800000 (7 days)
What it does
Age at which the active segment is rolled even if it is not full, so that retention or compaction can act on it. Broker default: log.roll.hours = 168.
When to change it
Lower it on low-volume topics when retention must be accurate (privacy deadlines, short retention). Rolling a segment per partition every few minutes on thousands of partitions creates a lot of small files, so do not go lower than you need.
retention.msDefault 604800000 (7 days)
What it does
A segment becomes eligible for deletion when its newest record timestamp is older than this. -1 disables the time limit. Broker default: log.retention.hours = 168.
When to change it
Set it from the longest outage or replay you want consumers to survive, then check the disk it implies. Remember that actual lifetime is this plus the time a segment takes to roll.
retention.bytesDefault -1 (no size limit)
What it does
Maximum size of one partition before the oldest segments are deleted. Applies per partition, per replica.
When to change it
Use it as a disk safety cap on high-volume topics. Multiply by partitions and replication factor to get the real ceiling, and accept that under a burst it overrides the time window.
log.retention.check.interval.msDefault 300000 (5 minutes)
What it does
Broker setting: how often the broker looks for segments to delete.
When to change it
Rarely changed. It explains why data can outlive its retention by a few minutes, and why disk usage falls in steps.
file.delete.delay.msDefault 60000 (1 minute)
What it does
How long a segment marked for deletion stays on disk before the file is removed.
When to change it
Leave it. It gives in-flight reads of the old segment time to finish.
cleanup.policyDefault delete
What it does
delete applies the time and size retention described here. compact keeps the latest record per key instead. Both can be combined.
When to change it
Keep delete for event streams. Use compact for latest-state topics: see the next lesson.
message.timestamp.typeDefault CreateTime
What it does
Whether a record's timestamp is the one set by the producer or the broker's append time (LogAppendTime). Time-based retention uses this timestamp.
When to change it
Switch to LogAppendTime when producers send unreliable or historical timestamps and you want retention to mean time since arrival.
auto.offset.reset (consumer)Default latest
What it does
Where a consumer starts when its group has no committed offset or the committed offset no longer exists on the broker: earliest, latest, by_duration:<duration> or none.
When to change it
Choose earliest for services that must not skip existing records and are idempotent, none when a human should decide. Spring Boot key: spring.kafka.consumer.auto-offset-reset.
local.retention.msDefault -2 (use retention.ms)
What it does
With tiered storage enabled on the topic, how long segments also stay on the broker's local disk.
When to change it
Only relevant with remote.storage.enable=true. Size it to cover normal consumer lag so that live reads stay local.

Hands-on exercise

Find out how long a record really lives

Use the log explorer to see that retention deletes whole segments from the old end only, that the log start offset jumps, and that a consumer positioned in a deleted segment is moved by its reset policy.

Steps · 0 of 5 done

Retention on a small partition

Simulation · not a real cluster

Append records, let segments roll, and watch retention remove the oldest closed segment. Then change the segment size and compare.

What can go wrong

Low-volume topic keeps data far beyond retention.ms
Symptom
A topic has retention.ms of 1 day, yet a consumer started from the beginning still reads records that are five or six days old.
Cause
The topic writes so little that the active segment never reaches 1 GiB, so it only rolls after segment.ms, 7 days by default. While it is open and still receiving records it cannot be deleted.
Fix
Set segment.ms on that topic to roughly the accuracy you need (for example 1 hour or 1 day). Do not lower retention.ms further: it is not the limiting setting.
A paused consumer silently loses records
Symptom
After a long outage a service restarts, its lag is small or zero, there are no errors, and downstream totals do not add up.
Cause
The group's committed offsets pointed into segments that retention had deleted. The consumer applied auto.offset.reset and continued from the start or the end of what was left.
Fix
Alert when a group's lag in time approaches the retention period. Set auto.offset.reset deliberately (earliest with idempotent handlers, or none to stop). Recover the missing records from the source system, since Kafka no longer has them.
retention.bytes treated as a topic-wide limit
Symptom
Broker disks fill although every topic has a size limit that looked safe when added up.
Cause
retention.bytes applies to each partition on each replica. A 10 GiB limit on a 12-partition topic with replication factor 3 allows 360 GiB, plus the active segments.
Fix
Budget disk as limit x partitions x replication factor, add one segment per partition of headroom, and monitor the kafka.log:type=Log,name=Size metric per partition.
Backfill with old timestamps vanishes
Symptom
A migration job loads historical events into a topic. Minutes later consumers find the partitions almost empty.
Cause
Retention compares record timestamps (CreateTime, set by the producer) with the current time. Segments full of records stamped months ago are expired as soon as they roll.
Fix
For a backfill topic, set message.timestamp.type=LogAppendTime or raise retention.ms to cover the oldest timestamp before loading. Decide which one matches what retention should mean for that topic.
Using retention.ms to enforce a privacy deadline
Symptom
An audit finds personal data still readable days after the stated retention.
Cause
Retention is a lower bound plus slack: segment roll time, the 5-minute check interval and the 1-minute file deletion delay all add to it, and on slow topics the roll time dominates.
Fix
Set segment.ms well below the deadline and test with the real traffic level. For removing one person's data on request, retention is the wrong tool: avoid putting the data in the topic, or use a compacted topic with tombstones.

How to troubleshoot

A consumer group jumped forward or lost records after downtime

Check

`bin/kafka-get-offsets.sh --bootstrap-server localhost:9092 --topic orders.events --time earliest` next to `bin/kafka-consumer-groups.sh --bootstrap-server localhost:9092 --describe --group billing`, and the consumer's logs around the restart
How to read it
If the group's earlier committed offset was below the partition's earliest offset, the data was deleted before it was read. The client log will show the fetch position being reported out of range and the offset being reset.
Broker disk usage keeps growing

Check

`bin/kafka-log-dirs.sh --bootstrap-server localhost:9092 --describe --topic-list <topic>` and the metric `kafka.log:type=Log,name=Size,topic=...,partition=...`
How to read it
Find the partitions that hold the bytes. Then read their topic's retention.ms, retention.bytes and cleanup.policy: a compacted topic, a retention.ms of -1 or a traffic increase on a time-only policy are the usual causes.
Data is still there long after retention.ms

Check

`bin/kafka-configs.sh --bootstrap-server localhost:9092 --entity-type topics --entity-name <topic> --describe`, then `ls -l` in the partition directory on a broker
How to read it
One large or week-old active segment and no closed ones means nothing is eligible yet. Lower segment.ms. If closed segments exist and are old, check that cleanup.policy includes delete and look at the timestamps of the newest records in them.
A topic lost data much sooner than its retention.ms

Check

The topic's `retention.bytes`, and `bin/kafka-dump-log.sh --print-data-log --files <segment>.log` on a broker to read record timestamps
How to read it
Either the size limit was reached first (either rule is enough to delete), or the records carry old CreateTime timestamps and were already past retention when written.
You need to know how many segments a partition has without logging in to a broker

Check

Metrics `kafka.log:type=Log,name=NumLogSegments`, `name=LogStartOffset` and `name=LogEndOffset` per topic and partition
How to read it
A log start offset that advances in steps shows retention working. A segment count of 1 on a topic with short retention explains data that lives too long.

Key takeaways

  • A partition is a directory of segments. Only the active segment is written; closed segments are immutable.
  • Retention deletes whole segments from the old end, based on the newest timestamp in each segment or on partition size, whichever rule is met first.
  • Real lifetime is retention.ms plus the time a segment takes to roll. On slow topics set segment.ms or data lives up to a week longer.
  • retention.bytes is per partition and per replica. Disk for a topic is rate x record size x retention x replication factor, plus headroom.
  • Consuming never deletes anything, and retention never waits for a slow consumer.
  • A group whose offset was deleted continues wherever auto.offset.reset says, with no error by default. Choose that setting on purpose and alert on lag against retention.
  • Tiered storage moves closed segments to a remote store to make long retention cheaper. It needs a plugin and does not cover compacted topics.

Practical check

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

Scenario 1 of 3

The topic support.tickets receives about 300 small records a day. To meet a privacy rule the team set retention.ms to 86400000 (1 day) three weeks ago. A test consumer started from the beginning today still reads tickets from six days ago. All other topic settings are broker defaults.

Which change makes old tickets actually disappear about a day after they were written?

Scenario 2 of 3

The invoicing group reads orders.events (retention 7 days). The service was switched off for 10 days during a migration. It is back, its lag is 0 after a few minutes, nothing is logged at ERROR level, and finance reports that none of the orders placed during those 10 days has an invoice. The consumer uses default settings.

What happened, and what is the right response?

Scenario 3 of 3

You are adding retention.bytes=10737418240 (10 GiB) to clickstream.page-views, which has 12 partitions and replication factor 3, on a cluster of 3 brokers with 400 GiB data disks. A colleague says this caps the topic at 10 GiB so the disks are safe.

How much disk should you assume this topic can use on each broker?

References

References: Apache Kafka documentation: Implementation, Log ↗ · Apache Kafka documentation: Topic configuration reference ↗ · Apache Kafka documentation: Broker configuration reference ↗ · Apache Kafka documentation: Consumer configuration reference (auto.offset.reset) ↗ · Apache Kafka documentation: Tiered Storage ↗ · KIP-405: Kafka Tiered Storage ↗ · Spring for Apache Kafka reference: Configuring Topics ↗ · Report a problem