OpenCourser brand icon
Sign in
We may earn an affiliate commission when you visit our partners.
Course image
Udemy logo

Apache Kafka for Developers using Spring Boot[LatestEdition]

4.5 Filled star Filled star Filled star Filled star Half star
Based on 5,519 ratings
see reviews
Pragmatic Code School

This course is structured to give you a theoretical and coding experience with Apache Kafka using SpringBoot. This course is targeted for developers who would like to build enterprise standard  Kafka Client applications using SpringBoot.

If you are looking forward to learning the below-listed things:

  • Use cases where Kafka fits really well

  • Internals of Kafka and how it works

  • Built Enterprise Standard Kafka Client Applications using Producer/Consumer API using Spring Boot

  • Unit/Integration Tests for the Kafka Client Applications

Read more

This course is structured to give you a theoretical and coding experience with Apache Kafka using SpringBoot. This course is targeted for developers who would like to build enterprise standard  Kafka Client applications using SpringBoot.

If you are looking forward to learning the below-listed things:

  • Use cases where Kafka fits really well

  • Internals of Kafka and how it works

  • Built Enterprise Standard Kafka Client Applications using Producer/Consumer API using Spring Boot

  • Unit/Integration Tests for the Kafka Client Applications

Then this is the right course for you. This is a pure hands-on oriented course where you will be learning the concepts through code.

By the end of this course, you will have a complete understanding of coding and implementing Kafka Clients using SpringBoot with Producer/Consumer API.

Getting Started with Kafka

  • In this section, I will give you all a quick introduction to Apache Kafka, terminologies and different client APIs that are part of Kafka

Download and Install Kafka

  • In this section, we will download the Kafka distribution from the Kafka Website.

Understanding Kafka Components and its Internals - (Theory + Hands-On)

In this section, we will explore the Kafka internals from a theoretical perspective followed by hands-on exploring the Kafka internals.

  • Learn about the Topics and Partitions in Kafka

  • Setup a Local Kafka Cluster with Multiple Brokers

  • Producer/Consumer messages in the Kafka Cluster

  • Learn about Consumer Offsets and Consumer Groups

  • Commit Log and Retention Policy

  • Learn about Kafka Load Distribution and Fault Tolerance and Robustness

Application OverView

  • This section covers the application that we are going to build as part of this course.

Build SpringBoot Kafka Producer - Hands-On

In this section, we will learn about building a Kafka Producer using Spring Boot.

  • Build RestAPI through which the events can be posted into the application from the outside world

  • Explore KafkaTemplate to publish the data into the Kafka Topic

  • Learn different approaches to produce the message into the Kafka

  • Learn to publish the Kafka Record using Headers

Integration Testing using JUnit5 - Hands-On

In this section, we will learn about different approaches to writing Integration tests using Embedded Kafka.

  • Write Integration test cases to interact with the API using JUnit5

  • Write Integration test cases to interact with Embedded Kafka using JUnit5

Unit Testing using JUnit5- Hands-On

In this section, we will learn about different approaches to writing unit tests Kafka Producer.

  • Write Unit Tests to the controller layer using @WebMVC annotation and MockMVC

  • Add the validations to the request payload in the endpoint

  • Write Custom Error Handler for different response codes

Kafka Producer - Sending Message With Key - Hands-On

In this section, we will learn about sending the record to Kafka Topic with Key.

Kafka Producer - Important Configurations

In this section, we will learn about different key configurations to consider when it comes to reliable message delivery to Kafka

Build SpringBoot Kafka Consumer - Hands-On

In this section, we will learn about building a Kafka Consumer using Spring Boot.

  • Set up the base consumer project library-events consumer

  • Learn about different Spring Kafka Terminologies which are necessary to configure a Kafka Consumer

  • Learn about how to configure a Kafka Consumer using the @KafkListener Annotation

  • Learn about how "Spring Boot Auto Configuration works behind the scenes for Kafka Consumer"

Consumer Groups and Consumer Offset Management- Hands-On

In this section, we will code and learn about consumer groups and offset management.

  • Demonstration how Consumer Groups plays a vital role when it comes to scalable message consumption and consumer rebalance

  • Learn about the Default consumer offset management by Kafka

  • Learn about how consumer offset can be manually managed from the application

  • Demonstration of how to achieve scalable message consumption by increasing the concurrency level to greater than 1

Persisting Library Events in DB - Using H2 InMemory DataBase

In this section, we will code and learn about integrating the DB layer into the library-events-consumer using Spring JPA.

  • Configuring the H2 In-Memory DB

  • Create LibraryEvent and Book Entity

  • Build Service Layer to process LibraryEvent - ADD Event Type

  • Build Service Layer to process LibraryEvent - MODIFY Event Type

Integration Testing using Embedded Kafka - Kafka Consumer

In this section, we will code and learn to write the Integration tests for the Kafka Consumer.

  • Configure Embedded Kafka for Integration Tests

  • Write the Integration test for posting a "NEW" LibraryEvent

  • Write the Integration test for posting an "UPDATE" LibraryEvent

  • Integration Tests for Real Databases using TestContainers

Error Handling, Retry and Recovery - Kafka Consumers

In this section, we will learn about the different error handling techniques that are available for Kafka Consumer.

  • Custom Error Handler

  • Retry in Kafka Consumer

  • Retry SpecificExceptions using Custom RetryPolicy

  • Recovery in Kafka Consumer

  • Handling Recovery in Kafka Consumer

Error Handling, Retry/Recovery - Kafka Producer

  • Error Handling in Kafka Producer

  • Retry in Kafka Producer - Broker Not Available

  • Retry in Kafka Producer - Min.in.sync.replicas

  • Retain/Recover Failed Records in Kafka Producer

By the end of this you will have a complete understand and knowledge of building enterprise standard Kafka Consumers and Producers using Spring Boot with the Unit and Integration tests using EmbeddedKafka.

Enroll now

What's inside

Learning objectives

  • Apache kafka and its internals
  • Build enterprise standard kafka client applications using spring boot
  • Writing unit tests using junit
  • Writing integration tests using junit and embedded kafka
  • Build end to end application using kafka producer/consumer and spring boot

Syllabus

Getting Started With the Course

In this lecture, I will cover the course introduction and objectives of this course.

In this lecture, I will cover the prerequisites that are needed to enroll in this course.

Read more

In this lecture, I will explain about How Kafka fits in to the current software architecture and cover some of the examples where Kafka can be used.

In this lecture, I will explain about the Kafka Terminologies and different components that are part of Apache Kafka and some of its Client APIs.

In this lecture, we will learn in detail about the Kafka topics, partitions.

In this lecture, we will set up the Zookeeper and Kafka broker in local.

In this lecture, we will learn about creating a topic, produce messages, and consume messages from a Kafka Topic.

In this lecture, we will learn about producing and consuming messages with key using the command line interface.

In this lecture, we will learn about consumer offsets how it plays a major role in keeping a record of resuming processing the records from where it left off in the topic.

In this lecture, we will learn about consumer groups and how it plays a major role in scalable message consumption.

In this lecture, we will learn about the partitioned commit log and retention policy of any record that's written into Kafka.

In this lecture, I will explain in detail about how does Kafka behaves as a Streaming System.

In this lecture, we will set up a Kafka Cluster with 3 brokers to simulate a production like environment.

In this lecture, we will learn about how Kafka distributes the request between the available brokers.

In this lecture, we will learn about replication and Insync Replicas ISR.

In this lecture, I will explain the importance of minimum in-sync replica.

In this lecture, I will explain about the application that we are going to build as part of this course.

In this lecture, I will attach the source code for this course.

In this lecture, we will set up the spring boot project for the Library Event Spring Boot Kafka project.

In this lecture, we will build the domain object for the Library Event.

In this lecture, we will build the post endpoint to publish the Library Event.

In this lecture, we will learn about KafkaTemplate which is part of "spring-kafka" to produce Messages.

In this lecture, we will code and learn "how to configure" a KafkaTemplate using Spring Boot AutoConfiguration.

In this lecture, we will code and learn about "How the SpringBoot AutoConfiguration" works ?

In this lecture, we will autocreate the Kafka topic using the KafkaAdmin configuration.

In this lecture, we will code the LibraryEvents Producer and integrate KafkaTemplate to produce Messages in to the library-events topic asynchronously.

In this lecture, I will explain the behavior of the "POST" endpoint "/libraryevent"

In this lecture, we will code the LibraryEvents Producer and integrate KafkaTemplate to produce Messages in to the library-events topic synchronously.

In this lecture, we will code the kafkaTemplate to publish the ProducerRecord with KafkaHeaders.

In this lecture , I will give you all a quick introduction to Automated Tests.

In this lecture, we will write the integration test for the POST endpoint.

In this lecture, we will write the integration test for the POST endpoint

In this lecture, we will learn about the need for Embedded Kafka and how it helps with the Integration testing.

In this lecture, we will learn about how to spin up a Kafka Consumer in JUNIT and consume the published record.

In this lecture , I will give you all a quick introduction to Unit Tests.

In this lecture, we will code and learn how to write unit tests for the post endpoint using MockMVC.

In this lecture, we will code and learn about how to add validations to the request body.

In this lecture, we will code and learn about how to add Custom Error Messages to the HttpResponse.

In this lecture, we will build the put endpoint to publish the library events updates in to the Kafka topic.

In this lecture, I will highlight some of the key configurations to consider for reliable message delivery to Kafka.

In this lecture, we will code and learn how to override the default producer config values in Spring Boot using AutoConfiguration.

In this lecture, we will set up the base consumer project library-events consumer.

In this lecture, we will learn about different Spring Kafka Terminologies which are necessary to configure a Kafka Consumer.

In this lecture, we will code and learn about how to configure a Kafka Consumer using Spring Boot AutoConfiguration.

In this lecture, we will code and learn about how to configure a Kafka Consumer using the @KafkListener Annotation.

In this lecture, I will explain about how Spring Boot Auto Configuration works behind the scenes for Kafka Consumer

In this lecture, I will demonstrate how Consumer Groups plays a vital role when it comes to scalable message consumption and consumer rebalance.

In this lecture, we will code and learn about the Default consumer offset management by Kafka.

In this lecture, we will learn about how consumer offset can be manually managed from the application.

In this lecture, I will demonstrate how to achieve scalable message consumption by increasing the concurrency level to greater than 1.

In this lecture, we will configure the in-memory DB in library events consumer.

In this lecture, we will code the entity classes to map the Library and the Book Entity.

In this lecture, we will code the service layer to process the "ADD" LibraryEvent.

In this lecture, we will code the service layer to process the "MODIFY" LibraryEvent.

In this lecture, we will code and learn to set up the Integration test for the Kafka Consumer.

In this lecture, we will code the first integration test for the Library Events Consumer for the ADD LibraryEventType.

In this lecture, we will code the first integration test for the Library Events Consumer for the MODIFY LibraryEventType.

In this lecture, we will code and write the integration test for the Library Events Consumer for the MODIFY LibraryEventType with null LibraryEventId.

In this lecture, I will talk about writing the integration tests for the real databases.

In this lecture, we will code and learn about implementing the custom error handler and retry in Kafka Consumer.

In this lecture, we will code and learn about implementing the RetryListener to monitor the outcome of each retry attempt.

In this lecture, we will code and learn about retrying only specific exceptions.

In this lecture, we will code and learn about retry using the exponential backoff pattern.

In this lecture, we will learn about different recovery techniques that can be applied to the Kafka Consumer when the retries are exhausted.

In this lecture, we will code and learn about the technique to publish the failed message to the retry topic.

In this lecture, we will code and learn about the approach to reprocess the message

In this lecture, we will code and learn about the refactoring the integration test case for LibraryEvents Consumer.

In this lecture, we will code and learn about the technique to publish the failed message to the deadletter topic.

In this lecture, we will code and learn about the technique to save the failed message to the DB for later processing.

In this lecture, we will code and learn about the technique to retry the failed message thats saved in the DB.

In this lecture, we will discuss about the different error handling options available in Kafka Producer.

In this lecture we will learn about the options that are available to retry a failed record in Kafka Producer.

In this lecture, we will learn about the recovery options that are available from the Kafka Producer end.

In this lecture, we will learn about the technique to retain the record that failed because of the Kafka Cluster issue.

In this lecture, we will discuss about the need for Kafka Security and How SSL Works?

In this lecture, how enterprises request for SSL certificate from Certificate Authority(CA).

In this lecture, we will set up the SSL security in our local Kafka Cluster

In this lecture, we will code and learn about accessing the SSL secured topic from our spring boot application.

Traffic lights

Read about what's good
what should give you pause
and possible dealbreakers
Provides hands-on experience building Kafka client applications using Spring Boot, which is valuable for developers seeking practical skills
Covers integration testing using JUnit5 and Embedded Kafka, which is essential for ensuring the reliability of Kafka-based applications
Explores Kafka internals from a theoretical perspective, followed by hands-on exercises, which helps developers understand Kafka's architecture
Teaches different error handling techniques for Kafka Consumer, which is crucial for building robust and fault-tolerant applications
Requires downloading the Kafka distribution from the Kafka Website, which may take time and effort for some learners
Requires setting up Zookeeper and Kafka broker locally, which may require some familiarity with command-line tools

Save this course

Create your own learning path. Save this course to your list so you can find it easily later.
Save

Reviews summary

Practical kafka with spring boot

According to the available reviews, there is insufficient data to provide a detailed analysis of learner experiences. Based on the course's stated objectives and syllabus, it aims to provide developers with a positive hands-on experience building Kafka client applications using Spring Boot, covering topics like Producer/Consumer APIs, Unit and Integration Testing with Embedded Kafka, and Error Handling techniques. Prospective students should review the syllabus to understand the expected prerequisites and specific topics covered.
Strong emphasis on practical coding.
"The strongest aspect is the emphasis on hands-on coding. Learning concepts by building the application step-by-step made it much easier to grasp Kafka and Spring Boot integration than theory alone."
"I really valued the practical labs provided throughout the course. Coding alongside the instructor cemented my understanding of how to build actual Kafka producers and consumers."
"If you learn best by doing, this course is structured well. The pure hands-on approach described means you're coding from early on, which is great for developers."
Includes unit & integration tests.
"Covering both unit and integration testing is a major plus. Using Embedded Kafka for integration tests is a valuable skill taught here that's directly applicable to real projects."
"The sections on testing felt thorough and enterprise-relevant. Writing JUnit5 tests for Kafka producers and consumers using mocking and embedded brokers was very useful."
Addresses retry and recovery patterns.
"The course dedicates significant time to error handling, retry mechanisms, and recovery patterns like dead-letter queues, which is crucial for building robust Kafka applications in production."
"Understanding how to handle consumer failures and producer retries properly is often overlooked, so the detailed coverage of these topics was particularly valuable for building resilient systems."
Practical Kafka use with Spring.
"The seamless integration examples between Kafka and Spring Boot using KafkaTemplate and @KafkaListener make this course highly relevant for Spring developers."
"Learning how Spring Boot auto-configuration simplifies Kafka setup and how to override defaults was explained well and saves a lot of boilerplate code."
Requires Spring Boot familiarity.
"While the course is excellent for Kafka with Spring Boot, be aware it assumes you are already comfortable with core Spring Boot concepts and development practices."
"Coming into this, I needed to brush up on some Spring Boot fundamentals first, as the course focuses specifically on the Kafka integration rather than teaching Spring Boot from scratch."

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in Apache Kafka for Developers using Spring Boot[LatestEdition] with these activities:
Review Spring Boot Fundamentals
Solidify your understanding of Spring Boot fundamentals to better grasp the Kafka integration concepts.
Browse courses on Spring Boot
Show steps
  • Review Spring Boot annotations and configurations.
  • Practice building simple REST APIs with Spring Boot.
  • Familiarize yourself with Spring Data JPA for database interactions.
Review 'Spring Boot in Action'
Solidify your understanding of Spring Boot fundamentals to better grasp the Kafka integration concepts.
View Spring in Action, Sixth Edition on Amazon
Show steps
  • Read the chapters on Spring Boot basics and auto-configuration.
  • Focus on sections related to data access and testing.
  • Take notes on key concepts and configurations.
Review 'Kafka: The Definitive Guide'
Gain a deeper understanding of Kafka's architecture and core concepts.
View Kafka: The Definitive Guide: Real-Time Data and... on Amazon
Show steps
  • Read the chapters on Kafka architecture and core concepts.
  • Focus on sections related to producers, consumers, and brokers.
  • Take notes on key concepts and configurations.
Four other activities
Expand to see all activities and additional details
Show all seven activities
Build a Simple Kafka Producer/Consumer Application
Practice building a basic Kafka producer and consumer application using Spring Boot to reinforce your understanding of the core concepts.
Show steps
  • Set up a Spring Boot project with Kafka dependencies.
  • Implement a producer to send messages to a Kafka topic.
  • Implement a consumer to receive and process messages from the topic.
  • Test the application to ensure messages are sent and received correctly.
Practice Kafka Configuration Scenarios
Reinforce your understanding of Kafka configurations by working through different scenarios, such as setting up consumer groups, configuring message delivery guarantees, and handling error scenarios.
Show steps
  • Configure a consumer group with multiple consumers.
  • Implement different message delivery guarantees (at-least-once, at-most-once).
  • Simulate error scenarios and implement error handling strategies.
Write a Blog Post on Kafka Error Handling
Deepen your understanding of Kafka error handling by researching and writing a blog post that explains different error handling techniques for Kafka producers and consumers.
Show steps
  • Research different error handling techniques for Kafka.
  • Write a blog post explaining the techniques with code examples.
  • Publish the blog post on a platform like Medium or your personal blog.
Contribute to a Kafka Spring Boot Project
Enhance your skills and contribute to the Kafka community by contributing to an open-source Kafka Spring Boot project.
Show steps
  • Find an open-source Kafka Spring Boot project on GitHub.
  • Identify an issue or feature to work on.
  • Submit a pull request with your changes.

Career center

Learners who complete Apache Kafka for Developers using Spring Boot[LatestEdition] will develop knowledge and skills that may be useful to these careers:
Software Engineer
A software engineer often works on the design, development, and maintenance of software applications, and this course will be quite helpful. Specifically, this individual may be responsible for integrating messaging systems like Apache Kafka into larger architectures. This course provides hands-on experience building Kafka clients using Spring Boot, which is directly applicable to a software engineer's daily tasks. The course's focus on unit and integration testing helps build a foundation for creating reliable applications. A job as a software engineer will require a firm grasp of building message-driven applications, including error handling and recovery, all of which are covered in the course.
See salaries and explore the career path for Software Engineer
Application Developer
Application developers create, test, and maintain software applications, and this course can be quite beneficial. This often involves integrating various technologies and services, including message queues like Apache Kafka, which this course emphasizes, so a job as an application developer fits well with this course. The course provides the practical experience of building Kafka client applications using Spring Boot, testing these applications using JUnit, and ensuring reliable message delivery. An application developer who completes this course will gain the skills necessary to develop robust and scalable message-driven applications.
See salaries and explore the career path for Application Developer
Backend Developer
A backend developer constructs the logic that supports the user-facing portions of software applications, and this course may be useful. This role involves coding the server-side of software, handling data storage, and often involves integrating various services such as message queues like Kafka. This course's deep dive into Kafka internals and its hands-on approach in building producer and consumer applications using Spring Boot ensures a backend developer can more effectively implement message-driven architectures. The course covers essential aspects such as error handling, consumer groups, and offset management, which are central to building robust backend systems.
See salaries and explore the career path for Backend Developer
Integration Engineer
An integration engineer works to ensure that different software systems can communicate and share data seamlessly, and this course can help with such a role. This commonly involves implementing message queues and data streaming platforms, such as Apache Kafka, which is the core focus of this course. The course's hands-on approach to building Kafka producers and consumers with Spring Boot directly equips an integration engineer with the ability to integrate systems using these technologies. The course covers key integration aspects, including error handling, retry mechanisms, and working with embedded Kafka for testing, which is essential for developing robust and reliable systems.
See salaries and explore the career path for Integration Engineer
Data Engineer
A data engineer designs, builds, and manages the infrastructure that allows for the collection, storage, and processing of large datasets, and this course may be useful to someone in this role. Data engineers often use stream processing technologies like Kafka to build data pipelines. This course helps build a foundation for those data engineers, offering both theoretical and practical experience with Kafka and Spring Boot. It covers core concepts regarding message production and consumption, as well as error handling capabilities which are necessary for robust data processing. This kind of course will also expose a data engineer to the essentials of testing such systems.
See salaries and explore the career path for Data Engineer
Cloud Engineer
A cloud engineer is responsible for designing, implementing, and maintaining cloud computing environments, and this course may be useful for a cloud engineer. Often, this role involves integrating various cloud services, including message queues like Apache Kafka. This course's comprehensive exploration of Kafka and its integration with Spring Boot can make a cloud engineer more effective when working with cloud-based messaging systems. The course covers key aspects of the technology including building producers, consumers, and working with consumer offset management, which can be directly applied to cloud infrastructures.
See salaries and explore the career path for Cloud Engineer
DevOps Engineer
A DevOps engineer combines software development and operations to streamline the software development lifecycle, and this course may prove helpful. This role often includes managing and maintaining systems that use message queues, like Kafka, for inter-service communications. This course can build skills through hands-on experience with Kafka and Spring Boot. The course covers building Kafka producers and consumers, unit and integration testing, and error handling. All of these skills are necessary for a DevOps engineer who wishes to support message-driven applications.
See salaries and explore the career path for DevOps Engineer
Systems Architect
A systems architect designs and oversees the implementation of computer systems, and this course may be helpful in such a position. This role involves selecting technologies and designing architectures that meet business needs, which can sometimes involve using message brokers like Apache Kafka. This course's deep dive into Kafka internals and its hands-on approach in building client applications using Spring Boot allows a systems architect to make informed decisions about system design. The course covers key aspects of message delivery, error handling, and system resilience, which are central to building reliable large-scale systems.
See salaries and explore the career path for Systems Architect
Technical Lead
A technical lead manages and guides a team of developers, and this course may be beneficial. This position requires a strong understanding of various technologies, including messaging systems like Apache Kafka. This course may be useful as it provides hands-on experience building Kafka clients using Spring Boot, covering the internals of Kafka, and how to handle errors and testing. This course can allow a technical lead to guide their team effectively on projects using Kafka and message-driven architectures. Furthermore, this role often involves architectural decision making, which benefits from this course's comprehensive approach.
See salaries and explore the career path for Technical Lead
Solution Architect
A solution architect designs specific solutions to business problems, often leveraging enterprise technologies like message queues, and this course might prove useful. This individual often works with technologies like Apache Kafka, and this course offers practical experience that could help a solution architect. The course focuses on building Kafka clients using Spring Boot, covering aspects like producer/consumer APIs, unit and integration tests, and error handling, all of which are important for a solution architect when recommending and designing robust systems. The in-depth look at the internals will also benefit a solution architect who might be responsible for making such recommendations.
See salaries and explore the career path for Solution Architect
Data Analyst
A data analyst interprets data to identify trends and insights, and this course might be useful. While they don't typically build systems, understanding how data is handled in real-time through technologies like Kafka is valuable. This course could help a data analyst by providing an understanding of how data is processed in a streaming fashion via Apache Kafka. This introduction can provide the data analyst with context on the types of systems available and how messaging queues work, allowing them to work more effectively when data is processed via Kafka.
See salaries and explore the career path for Data Analyst
IT Manager
An IT manager oversees the implementation and maintenance of technology systems for a business, and this course may have limited use for this kind of position. While an IT manager may not write code, understanding technologies like Apache Kafka is helpful. This course provides insight into Kafka's capabilities, how it is used, and how it integrates with systems built on Spring Boot. While the course may be more technical for this role, it can equip an IT manager with a better understanding of the underlying technology and how it functions, which allows them to manage teams effectively.
See salaries and explore the career path for IT Manager
Project Manager
A project manager plans, organizes, and oversees the completion of projects, and this course may be of minor use. This means that a project manager works with teams that use technologies like Apache Kafka. This course, while highly technical, may be helpful in understanding the technology that the project team is working with. It could provide insight into how Kafka works and how it relates to the software being developed. This type of understanding can help a project manager better oversee a team that uses such a technology.
See salaries and explore the career path for Project Manager
Database Administrator
A database administrator manages and maintains database systems, and this course may be useful but not directly applicable. While this role is not directly involved in message queue systems like Apache Kafka, understanding how they interact with databases is valuable. This course can help by providing a window into how Kafka can be used with databases through systems built on SpringBoot. This understanding could help a database administrator work effectively with those who develop systems that use Kafka in conjunction with databases
See salaries and explore the career path for Database Administrator
Technical Writer
A technical writer creates documentation for software and technical processes, and this course may be of minor use. While a technical writer does not directly work with the systems, having a basic understanding of how they function can be helpful. This course on Apache Kafka and Spring Boot can help a technical writer understand the concepts and how software is developed. The understanding of message queues and their role in the system may help a technical writer in their work.
See salaries and explore the career path for Technical Writer

Reading list

We've selected two books that we think will supplement your learning. Use these to develop background knowledge, enrich your coursework, and gain a deeper understanding of the topics covered in Apache Kafka for Developers using Spring Boot[LatestEdition].
Cover image
Kafka: The Definitive Guide
Save
Provides a comprehensive overview of Apache Kafka, covering its architecture, core concepts, and best practices. It's a valuable resource for understanding Kafka's internals and how to effectively use it in various applications. This book serves as both a reference and a guide for developers working with Kafka. It is commonly used by industry professionals.
Kafka: The Definitive Guide: Real-Time Data and...
Paperback
$$
Kafka: The Definitive Guide
Kindle Edition
$$
Cover image
Spring in Action, Sixth Edition
Save
Provides a practical guide to building applications with Spring Boot. It covers various aspects of Spring Boot development, including auto-configuration, data access, and testing. It's a useful resource for understanding how Spring Boot simplifies application development. This book is commonly used as a textbook at academic institutions.
Spring in Action, Sixth Edition
Paperback
$$
Spring in Action, Sixth Edition
Kindle Edition
$$

Share

Help others find this course page by sharing it with your friends and followers:
Facebook
LinkedIn
Reddit
X
Link
Email

Similar courses

Similar courses are unavailable at this time. Please try again later.
Course image
Rating
4.5 Filled star Filled star Filled star Filled star Half star
Effort
8 total hours
Via
Udemy
Instructor
Pragmatic Code School
Language
English
Traffic lights
Read about what's good
what should give you pause
and possible dealbreakers
Provides hands-on experience building Kafka client applications using Spring Boot, which is valuable for developers seeking practical skills
Covers integration testing using JUnit5 and Embedded Kafka, which is essential for ensuring the reliability of Kafka-based applications
Explores Kafka internals from a theoretical perspective, followed by hands-on exercises, which helps developers understand Kafka's architecture
Teaches different error handling techniques for Kafka Consumer, which is crucial for building robust and fault-tolerant applications
Requires downloading the Kafka distribution from the Kafka Website, which may take time and effort for some learners
Requires setting up Zookeeper and Kafka broker locally, which may require some familiarity with command-line tools
Share this
Share to help others discover this course.
Facebook LinkedIn X Reddit Link Email
Begin learning today
Enroll now to gain full access to Apache Kafka for Developers using Spring Boot[LatestEdition].
Enroll now
Save for later
Add this course to your list. Find it anytime.
Save
Our mission

OpenCourser helps millions of learners each year. People visit us to learn workspace skills, ace their exams, and nurture their curiosity.

Our extensive catalog contains over 50,000 courses and twice as many books. Browse by search, by topic, or even by career interests. We'll match you to the right resources quickly.

Find this site helpful? Tell a friend about us.

Affiliate disclosure

We're supported by our community of learners. When you purchase or subscribe to courses and programs or purchase books, we may earn a commission from our partners.

Your purchases help us maintain our catalog and keep our servers humming without ads.

Thank you for supporting OpenCourser.

© 2016 - 2025 OpenCourser