Book Review: Apache Kafka in Action

I come across Apache Kafka at client sites quite often now. I recently purchased Apache Kafka in Action to find out what the authors really think about it.

Authors

Alexander Kropp is an architect and trainer in communications networks and cloud computing.

Anatoly Zelenin is an expert and trainer in Apache Kafka.

Both authors are part of the DataFlow Academy , a European training and consulting company.

Apache Kafka in Action

Apache Kafka is one of those technologies that seems quite simple when someone first explains it. Applications produce messages, other applications consume them, and Kafka sits in the middle. What could be easier? Of course, once you start thinking about reliability, ordering, performance, replication, and operating the system in production, things become considerably more complicated. That is where this book really earns its place.

I’ve loved working with messaging systems for a long time, and in my SQL Server work, have regularly used Service Broker, which is an amazing bit of engineering, yet not well known. I always thought it was such a waste. The team built amazing plumbing, then gave us no real tools for working with it, and didn’t really provide enterprise guidance either. That was a real pity.

What I like most about this book is that the authors clearly understand the difference between getting Kafka running (which is easy) and running Kafka well. There are plenty of tutorials that can show you how to create a topic and send a few messages. That is useful, but it barely scratches the surface. This book goes much further, and I think its strongest material is where the authors explain what happens behind the scenes and why particular design choices matter.

The book starts gently enough, introducing producers, consumers, topics, partitions, and brokers. I particularly like the explanation of Kafka as a distributed log rather than simply another messaging system. That distinction is important, especially for readers coming from traditional database or messaging backgrounds. Understanding that messages can be retained and replayed changes how you think about building applications. The diagrams are generally clear and help explain concepts that could otherwise become rather abstract.

The sections on reliability and performance are among my favourites. I see developers all the time, who decide to roll their own with messaging systems. And when you ask them how they handle things like poison messages, you usually get blank looks back.

In this book, the authors explain acknowledgments, replication, consumer groups, offsets, and delivery guarantees without pretending that these are trivial subjects. They also discuss the impact of partition counts on performance and scalability. I liked that they offer practical starting points, such as using 12 partitions in many situations, while explaining the trade-offs. I wouldn’t treat that number as a universal recommendation, but it gives readers something concrete to think about.

Another strength is the coverage of how Kafka works internally. The chapters on cluster management, producing and consuming messages, and log cleanup provide a level of detail that I suspect many developers using Kafka have never explored. The discussion of KRaft and the move away from ZooKeeper is also welcome. I also enjoyed the explanation of log compaction and tombstone messages. That will matter to you when a system starts behaving in unexpected ways.

For me, though, the most valuable part of the book is the final section on enterprise use. It covers Kafka Connect, stream processing, schema management, security, monitoring, and disaster recovery. There are useful examples involving JDBC connectors and Debezium for change data capture. These show how Kafka fits into a wider data architecture rather than existing as an isolated technology.

I was particularly pleased to see serious attention given to monitoring. Too many technical books explain how to build something but barely mention how to keep it running. Here, Alexander and Anatoly discuss broker metrics, consumer lag, alerting, and what to watch for when things go wrong. The disaster recovery material is also valuable, including the use of MirrorMaker and different approaches to running multiple clusters.

One of the best chapters is actually the last one. I appreciated the section explaining what Kafka is not. The authors make the point that Kafka isn’t a relational database, isn’t a replacement for synchronous communication, and isn’t automatically a sensible choice for small applications. I strongly agree. I’ve seen too many architectures become more complicated simply because someone wanted to use a fashionable technology, or because they wanted another buzz-word on their resume. It’s important to remind readers that good architecture matters more than choosing impressive tools.

Limitations?

I do have a few, but not many. The book covers an enormous amount of ground, and some topics inevitably receive less depth than I would have liked. The stream processing chapter, for example, provides a useful introduction but could easily have been a book of its own. The same applies to some of the enterprise architecture discussions.

Despite the title, this is also not primarily a developer’s coding handbook. There are practical examples and configuration details, but anyone expecting hundreds of Java examples may be disappointed. I see it more as a book about understanding, designing, and operating Kafka systems. That isn’t a criticism of the content, but it is worth knowing before buying it.

There is also a fair amount of terminology to absorb. The writing style is fine, but readers completely new to distributed systems may need to revisit some sections. And, as with any book on a fast-moving technology, specific configuration advice and examples will need checking against newer Kafka releases.

Summary

This is an excellent book for developers, data engineers, architects, and administrators who want a solid understanding of Kafka beyond the basics. It balances theory with practical experience and, importantly, doesn’t treat Kafka as the answer to every problem. I came away with a better appreciation of both what Kafka makes possible and the work needed to use it properly. That is exactly what I want from a technical book. Well done.

9 out of 10

2026-11-15