Name: Kafka Streams with Spring Cloud Stream
Price: 22.99 GBP
Availability: InStock

Learn core Apache Kafka features along with creating Java, Node.js and Python producers and consumers
Explore an interactive and easy way to learn Apache Kafka with this practical guide. Featuring interesting activities to help you build projects using APIs for programming languages such as Node.js and Python, this course will ensure you get hands-on experience.
You will learn how Apache Kafka works and also understand its core features. After delving into the architecture of Kafka, you will focus on how to build custom Apache Kafka producers and consumers using native Java API. The course will gradually assist you in working through a variety of activities related to Apache Kafka, from creating a cluster with multiple brokers and developing topics with replication factors, through to launching the performance monitor for testing the performance of consumers and producers. The course will also demonstrate how to use Apache Kafka API to create your own consumers and producers using Python and Node.js.
By the end of this course, you'll be well-versed with Apache Kafka and have the skills and confidence you need to build projects using it. All codes and supporting files are available at-
https://github.com/PacktPublishing/Apache-Kafka-Complete-Developer-s-Guide

What You Will Learn
Get to grips with the Apache Kafka architecture
Create producers and consumers using a built-in console
Use Python and Node.js to produce and consume messages
Design fault-tolerant clusters with topic replication across multiple brokers
Build a Kafka cluster with multiple brokers
Delve into the components of the Apache Kafka cluster
Audience
This course is designed for beginners who want to learn Apache Kafka and its architecture. Anyone who wants to build producers and consumers in other languages such as Node.js and Python, or anyone who wants to build projects using Kafka and its APIs will find this practice-oriented course helpful.
Approach
This course uses a complete practice-based approach, which ensures that students get hands-on experience in building projects using different APIs.
Key Features
Understand how Apache Kafka works and its core features * Build custom Apache Kafka producers and consumers using native Java API * Learn and practice how to run multiple brokers on the same computer
Github Repo
https://github.com/packtpublishing/apache-kafka-complete-developer-s-guide
About the Author
Bogdan Stashchuk
Bogdan Stashchuk has over 20 years of experience as a software engineering instructor. He excels at breaking down complex topics into easy-to-follow steps. His courses are designed with hands-on exercises, ensuring that learners can actively participate and apply what they learn. From start to finish, students can follow along and complete tasks just as Bogdan demonstrates in his lectures. He also includes challenging assignments with detailed solutions. This approach helps learners understand and remember the material long after they've completed the course. Through his dedication and expertise, Bogdan ensures a valuable and effective learning experience for everyone.
Course Outline
1. Apache Kafka Installation Overview

1. Apache Kafka Installation Overview
Apache Kafka Installation Overview: Apache Kafka Installation Overview
2. Installing Apache Kafka on the Mac and Unix-like systems
Apache Kafka Installation Overview: Installing Apache Kafka on the Mac and Unix-like systems
3. Installing Apache Kafka on the Mac
Apache Kafka Installation Overview: Installing Apache Kafka on the Mac
4. Installing Ubuntu on MacOS using VirtualBox
Apache Kafka Installation Overview: Installing Ubuntu on MacOS using VirtualBox
2. Installing Apache Kafka on the remote Ubuntu server

1. SECTION 2 Introduction
Installing Apache Kafka on the remote Ubuntu server: SECTION 2 Introduction
2. Creating remote Ubuntu Virtual Private Server
Installing Apache Kafka on the remote Ubuntu server: Creating remote Ubuntu Virtual Private Server
3. Installing Apache Kafka on Virtual Private Server
Installing Apache Kafka on the remote Ubuntu server: Installing Apache Kafka on Virtual Private Server
3. Installing Apache Kafka on Windows

1. SECTION 3 Introduction
Installing Apache Kafka on Windows: SECTION 3 Introduction
2. Installing Apache Kafka on Windows
Installing Apache Kafka on Windows: Installing Apache Kafka on Windows
3. Starting Zookeeper and Kafka server on Windows
Installing Apache Kafka on Windows: Starting Zookeeper and Kafka server on Windows
4. Installing Ubuntu on Windows using VirtualBox
Installing Apache Kafka on Windows: Installing Ubuntu on Windows using VirtualBox
5. Installing Apache Kafka on Ubuntu using GUI
Installing Apache Kafka on Windows: Installing Apache Kafka on Ubuntu using GUI
4. Starting Apache Zookeeper and Kafka Broker

1. SECTION 4 Introduction
Starting Apache Zookeeper and Kafka Broker: SECTION 4 Introduction
2. Observing contents of the Kafka folder
Starting Apache Zookeeper and Kafka Broker: Observing contents of the Kafka folder
3. Reading and editing Kafka files using VisualStudio Code
Starting Apache Zookeeper and Kafka Broker: Reading and editing Kafka files using VisualStudio Code
4. Trying to start Kafka Server
Starting Apache Zookeeper and Kafka Broker: Trying to start Kafka Server
5. Observing Kafka Server logs
Starting Apache Zookeeper and Kafka Broker: Observing Kafka Server logs
6. Starting Zookeeper
Starting Apache Zookeeper and Kafka Broker: Starting Zookeeper
7. Starting Kafka Server while Zookeeper is up and running
Starting Apache Zookeeper and Kafka Broker: Starting Kafka Server while Zookeeper is up and running
8. Observing logs folder and current kafka server setup
Starting Apache Zookeeper and Kafka Broker: Observing logs folder and current kafka server setup
5. Creating and exploring Kafka Topic

1. SECTION 5 Introduction
Creating and exploring Kafka Topic: SECTION 5 Introduction
2. How to connect to Kafka cluster
Creating and exploring Kafka Topic: How to connect to Kafka cluster
3. Create new Kafka topic
Creating and exploring Kafka Topic: Create new Kafka topic
4. What happened after creation of the new topic
Creating and exploring Kafka Topic: What happened after creation of the new topic
5. Read details about topic
Creating and exploring Kafka Topic: Read details about topic
6. Producing and consuming Messages

1. SECTION 6 Introduction
Producing and consuming Messages: SECTION 6 Introduction
2. Send some messages using Kafka Console Producer
Producing and consuming Messages: Send some messages using Kafka Console Producer
3. Consuming messages using Kafka Console Consumer
Producing and consuming Messages: Consuming messages using Kafka Console Consumer
4. Consuming messages from the beginning
Producing and consuming Messages: Consuming messages from the beginning
5. Running multiple consumers
Producing and consuming Messages: Running multiple consumers
6. Running multiple producers
Producing and consuming Messages: Running multiple producers
7. What was changed in the Kafka logs
Producing and consuming Messages: What was changed in the Kafka logs
7. What is Apache Kafka and how it works

1. SECTION 7 Introduction
What is Apache Kafka and how it works: SECTION 7 Introduction:
2. What is Apache Kafka
What is Apache Kafka and how it works: What is Apache Kafka
3. Broker
What is Apache Kafka and how it works: Broker
4. Broker cluster
What is Apache Kafka and how it works: Broker cluster
5. Zookeeper
What is Apache Kafka and how it works: Zookeeper
6. Zookeeper ensemble
What is Apache Kafka and how it works: Zookeeper ensemble
7. Multiple Kafka clusters
What is Apache Kafka and how it works: Multiple Kafka clusters
8. Default ports of Zookeeper and Broker
What is Apache Kafka and how it works: Default ports of Zookeeper and Broker
9. Kafka Topic
What is Apache Kafka and how it works: Kafka Topic
10. Message structure
What is Apache Kafka and how it works: Message structure
11. Topics and Partitions
What is Apache Kafka and how it works: Topic and Partitions
12. Spreading messages across partitions
What is Apache Kafka and how it works: Spreading messages across partitions
13. Partition Leader and Followers
What is Apache Kafka and how it works: Partition Leader and Followers
14. Controller and it's responsibilities
What is Apache Kafka and how it works: Controller and it's responsibilities
15. How Producers write messages to the topic
What is Apache Kafka and how it works: How Producers write messages to the topic
16. How Consumers read messages from the topic
What is Apache Kafka and how it works: How Consumers read messages from the topic
8. GitHub Repository and Diagrams for the course

1. SECTION 8 Introduction
GitHub Repository and Diagrams for the course: SECTION 8 Introduction
2. GitHub repository and list of basic Kafka commands
GitHub Repository and Diagrams for the course: GitHub repository and list of basic Kafka commands
3. Diagrams for the course
GitHub Repository and Diagrams for the course: Diagrams for the course
9. EXAMPLE 1 - Topic with Multiple Partitions

1. SECTION 9 Introduction
EXAMPLE 1 - Topic with Multiple Partitions: SECTION 9 Introduction
2. Cleaning up existing kafka installation
EXAMPLE 1 - Topic with Multiple Partitions: Cleaning up existing kafka installation
3. Creating topic with multiple partitions
EXAMPLE 1 - Topic with Multiple Partitions: Creating topic with multiple partitions
4. How messages were spread across different partitions
EXAMPLE 1 - Topic with Multiple Partitions: How messages were spread across different partitions
5. Reading messages from specific partition
EXAMPLE 1 - Topic with Multiple Partitions: Reading messages from specific partition
6. Reading messages from specific offset in specific partition
EXAMPLE 1 - Topic with Multiple Partitions: Reading messages from specific offset in specific partition
7. Reading details about topic and __consumer_offsets topic
EXAMPLE 1 - Topic with Multiple Partitions: Reading details about topic and __consumer_offsets topic
8. Summary for multiple partitions example
EXAMPLE 1 - Topic with Multiple Partitions: Summary for multiple partitions example
10. EXAMPLE 2 - Kafka Cluster with Multiple Brokers

1. SECTION 10 Introduction
EXAMPLE 2 - Kafka Cluster with Multiple Brokers: SECTION 10 Introduction
2. Example overview - run multiple brokers
EXAMPLE 2 - Kafka Cluster with Multiple Brokers: Example overview - run multiple brokers
3. Creating separate configuration files for brokers
EXAMPLE 2 - Kafka Cluster with Multiple Brokers: Creating separate configuration files for brokers
4. Launching three brokers
EXAMPLE 2 - Kafka Cluster with Multiple Brokers: Launching three brokers
5. Getting cluster information and broker details from Zookeeper
EXAMPLE 2 - Kafka Cluster with Multiple Brokers: Getting cluster information and broker details from Zookeeper
6. Creating multiple-partition topic in the Kafka cluster
EXAMPLE 2 - Kafka Cluster with Multiple Brokers: Creating multiple-partition topic in the Kafka cluster
7. Looking at logs folders of every broker
EXAMPLE 2 - Kafka Cluster with Multiple Brokers: Looking at logs folders of every broker
8. Producing and consuming messages in the cluster
EXAMPLE 2 - Kafka Cluster with Multiple Brokers: Producing and consuming messages in the cluster
9. Details about topic in the cluster
EXAMPLE 2 - Kafka Cluster with Multiple Brokers: Details about topic in the cluster
10. Simulating broker failure in the cluster
EXAMPLE 2 - Kafka Cluster with Multiple Brokers: Simulating broker failure in the cluster
11. Summary for broker cluster and topic without replication
EXAMPLE 2 - Kafka Cluster with Multiple Brokers: Summary for broker cluster and topic without replication
11. EXAMPLE 3 - Multiple Brokers and Topic with Replication

1. SECTION 11 Introduction
EXAMPLE 3 - Multiple Brokers and Topic with Replication: SECTION 11 Introduction
2. Preparing for the next example with replication
EXAMPLE 3 - Multiple Brokers and Topic with Replication: Preparing for the next example with replication
3. Launching brokers and creating topic with replication
EXAMPLE 3 - Multiple Brokers and Topic with Replication: Launching brokers and creating topic with replication
4. Observing logs folder and details of the topic
EXAMPLE 3 - Multiple Brokers and Topic with Replication: Observing logs folder and details of the topic
5. Producing and consuming messages in the topic with replication
EXAMPLE 3 - Multiple Brokers and Topic with Replication: Producing and consuming messages in the topic with replication
6. Observing how messages were stored in the partitions on different brokers
EXAMPLE 3 - Multiple Brokers and Topic with Replication: Observing how messages were stored in the partitions on different brokers
7. Bringing down one of three brokers and observing changes
EXAMPLE 3 - Multiple Brokers and Topic with Replication: Bringing down one of three brokers and observing changes
8. Bringing down another broker in the cluster
EXAMPLE 3 - Multiple Brokers and Topic with Replication: Bringing down another broker in the cluster
9. Bringing back both brokers
EXAMPLE 3 - Multiple Brokers and Topic with Replication: Bringing back both brokers
10. Summary for replication
EXAMPLE 3 - Multiple Brokers and Topic with Replication: Summary for replication
12. EXAMPLE 4 - Kafka Consumer Groups

1. SECTION 12 Introduction
EXAMPLE 4 - Kafka Consumer Groups: SECTION 12 Introduction
2. Example with consumer groups overview
EXAMPLE 4 - Kafka Consumer Groups: Example with consumer groups overview
3. Exploring default consumer groups
EXAMPLE 4 - Kafka Consumer Groups: Exploring default consumer groups
4. Starting consumer in the custom consumer group
EXAMPLE 4 - Kafka Consumer Groups: Starting consumer in the custom consumer group
5. Starting second consumer in the same consumer group
EXAMPLE 4 - Kafka Consumer Groups: Starting second consumer in the same consumer group
6. Launching one more consumer in the same group
EXAMPLE 4 - Kafka Consumer Groups: Launching one more consumer in the same group
7. Idle consumers in the group
EXAMPLE 4 - Kafka Consumer Groups: Idle consumers in the group
8. Summary for consumer groups
EXAMPLE 4 - Kafka Consumer Groups: Summary for consumer groups
13. EXAMPLE 5 - Performance Testing

1. SECTION 13 Introduction
EXAMPLE 5 - Performance Testing: SECTION 13 Introduction
2. Overview of the performance testing example
EXAMPLE 5 - Performance Testing: Overview of the performance testing example
3. Starting cluster and launching basic performance test
EXAMPLE 5 - Performance Testing: Starting cluster and launching basic performance test
4. Increasing performance test parameters
EXAMPLE 5 - Performance Testing: Increasing performance test parameters
5. Testing consumer performance
EXAMPLE 5 - Performance Testing: Testing consumer performance
6. Getting non-zero LAG values for consumers
EXAMPLE 5 - Performance Testing: Getting non-zero LAG values for consumers
7. Performance test example summary
EXAMPLE 5 - Performance Testing: Performance test example summary
14. PROJECT 1 - Java

1. SECTION 14 Introduction
PROJECT 1 - Java: SECTION 14 Introduction
2. Project Files for the Java section
PROJECT 1 - Java: Project Files for the Java section
3. Installing IntelliJ editor
PROJECT 1 - Java: Installing IntelliJ editor
4. Creating and configuring Maven project
PROJECT 1 - Java: Creating and configuring Maven project
5. Starting Kafka Cluster
PROJECT 1 - Java: Starting Kafka Cluster
6. Creating Java Producer
PROJECT 1 - Java: Creating Java Producer
7. Continue Creating Java Producer
PROJECT 1 - Java: Continue Creating Java Producer
8. Launching Java Producer
PROJECT 1 - Java: Launching Java Producer
9. Explaining most common Producer parameters
PROJECT 1 - Java: Explaining most common Producer parameters
10. Modifying Serializer type
PROJECT 1 - Java: Modifying Serializer type
11. Producing meaningful messages with delay
PROJECT 1 - Java: Producing meaningful messages with delay
12. Refactoring Producer by adding previous example
PROJECT 1 - Java: Refactoring Producer by adding previous example
13. Creating consumer with autocommitting - PART 1
PROJECT 1 - Java: Creating consumer with autocommitting - PART 1
14. Creating consumer with autocommitting - PART 2
PROJECT 1 - Java: Creating consumer with autocommitting - PART 2
15. Consumer parameters overview
PROJECT 1 - Java: Consumer parameters overview
16. Consumer with Manual Committing
PROJECT 1 - Java: Consumer with Manual Committing
17. Consumer with Partitions Assignment
PROJECT 1 - Java: Consumer with Partitions Assignment
18. Launching multiple consumers in the same consumer group
PROJECT 1 - Java: Launching multiple consumers in the same consumer group
19. CHALLENGE - Subscribe vs Assign with consumer groups
PROJECT 1 - Java: CHALLENGE - Subscribe vs Assign with consumer groups
15. PROJECT 2 - Node.js

1. SECTION 15 Introduction
PROJECT 2 - Node.js: SECTION 15 Introduction
2. Installing Node.js with NPM
PROJECT 2 - Node.js: Installing Node.js with NPM
3. Starting up Kafka cluster with 3 brokers
PROJECT 2 - Node.js: Starting up Kafka cluster with 3 brokers
4. Initializing Node.js project
PROJECT 2 - Node.js: Initializing Node.js project
5. Final Node.js project filesv
PROJECT 2 - Node.js: Final Node.js project files
6. Creating basic Node.js producer
PROJECT 2 - Node.js: Creating basic Node.js producer
7. Producing random animal names
PROJECT 2 - Node.js: Producing random animal names
8. Creating Node.js consumer
PROJECT 2 - Node.js: Creating Node.js consumer
16. PROJECT 3 - Python

1. SECTION 16 Introduction
PROJECT 3 - Python: SECTION 16 Introduction
2. Installing Python
PROJECT 3 - Python: Installing Python
3. Final Python project files
PROJECT 3 - Python: Final Python project files
4. Launching basic Python producer
PROJECT 3 - Python: Launching basic Python producer
5. Launching consumer and receiving messages
PROJECT 3 - Python: Launching consumer and receiving messages
6. Generating fake names in the messages by producer
PROJECT 3 - Python: Generating fake names in the messages by producer
17. Course Summary

1. Course Summary
Course Summary: Course Summary

Packt

Node.js

Apache Kafka

Learn core Apache Kafka features along with creating Java, Node.js and Python producers and consumers

Apache Kafka Complete Developer's Guide

General Admission

<strong>Explore the Apache Kafka ecosystem and architecture, and learn client API programming in Java</strong>
        <p>This course is designed to get you up and running with the fundamentals and the working of Apache Kafka with the help of practical examples. You will also delve into client API programming in Java.  As you progress, you will not only cover the Apache Kafka stack, but also the architecture of Kafka components and Kafka client APIs (Producers and Consumers). The course will even guide you on how to apply the knowledge you've gained through the course to create efficient Kafka programs in Java.
This course is based on Apache Kafka 2.x. All the source code and examples used in this course on Apache Kafka 2.3 open-source distribution have been tested. Several examples in this course also make use of the Confluent Community Version of Kafka. The course will focus on the Confluent Community Version to explain and demonstrate functionalities that are only available in the Confluent Platform, such as Schema Registry and Avro Serdes.
This course will be making extensive use of IntelliJ IDEA as the preferred development IDE. However, based on your prior experience, you should be able to work with any other IDE designed for Java application development.
Although the course will be using Apache Maven as the preferred build tool, based on your prior experience, you should be able to use any other build tool designed for Java applications.
In addition to this, the course will use Log4j2 to teach you industry-standard log implementation in your applications.
This course is fully example-driven and several examples will be created in the class.
By the end of this course, you will have gained the skills you need to confidently build Kafka programs in Java.

All the codes and supporting files are available at-
https://github.com/PacktPublishing/Apache-Kafka-for-absolute-beginners</p>
        <h2>What You Will Learn</h2><p>Delve into the multi-node Confluent Community of Kafka<br>Discover the Kafka Storage architecture<br>Gain insights into the Kafka Cluster architecture<br>Understand Kafka Consumer API programming in Java<br>Get up to speed with JSON and AVRO Serialization</p>
        <h2>Audience</h2><p>This course is designed for software engineers, solution architects, and managers looking to implement Kafka and solve real-time stream processing problems. Architects who are not directly involved in Kafka implementation or anyone who is looking to implement Kafka Streams will also find this course helpful. This course is designed for both beginner and intermediate-level Apache Kafka users.</p>
        <h2>Approach</h2><p>This course features several working examples that will help you effectively apply the knowledge you gain through the course.</p>
        <h2>Key Features</h2><p>Get to grips with the Apache Kafka ecosystem and components * Delve into Kafka Producer API programming in Java</p>
        <h2>Github Repo</h2><p>https://github.com/packtpublishing/apache-kafka-for-absolute-beginners</p>
        <h2>About the Author</h2><h3>Prashant Kumar Pandey</h3><p>Prashant Kumar Pandey is passionate about helping people learn and grow in their careers by bridging the gap between their existing and required skills. In his journey to fulfill this mission, he is authoring books, publishing technical articles, and creating training videos to help IT professionals and students succeed in the industry. He is also the founder, lead author, and chief editor of the Learning Journal portal that has been providing various skill development courses, training sessions, and technical articles since 2018.</p>
        <h2>Course Outline</h2><h4>1. Kafka Ecosystem - The Big Picture</h4><p></p><br><h4>2. Apache Kafka - Getting Started</h4><p></p><br><h4>3. Apache Kafka - Storage Architecture</h4><p></p><br><h4>4. Apache Kafka - Cluster Architecture</h4><p></p><br><h4>5. Kafka Producer Internals</h4><p></p><br><h4>6. Advanced Kafka Producers</h4><p></p><br><h4>7. Types and Serialization</h4><p></p><br><h4>8. Micro Project - Summing Up the Producer</h4><p></p><br><h4>9. Kafka Consumers</h4><p></p><br><h4>10. Where to go Next</h4><p></p>

Explore the Apache Kafka ecosystem and architecture, and learn client API programming in Java
This course is designed to get you up and running with the fundamentals and the working of Apache Kafka with the help of practical examples. You will also delve into client API programming in Java. As you progress, you will not only cover the Apache Kafka stack, but also the architecture of Kafka components and Kafka client APIs (Producers and Consumers). The course will even guide you on how to apply the knowledge you've gained through the course to create efficient Kafka programs in Java.
This course is based on Apache Kafka 2.x. All the source code and examples used in this course on Apache Kafka 2.3 open-source distribution have been tested. Several examples in this course also make use of the Confluent Community Version of Kafka. The course will focus on the Confluent Community Version to explain and demonstrate functionalities that are only available in the Confluent Platform, such as Schema Registry and Avro Serdes.
This course will be making extensive use of IntelliJ IDEA as the preferred development IDE. However, based on your prior experience, you should be able to work with any other IDE designed for Java application development.
Although the course will be using Apache Maven as the preferred build tool, based on your prior experience, you should be able to use any other build tool designed for Java applications.
In addition to this, the course will use Log4j2 to teach you industry-standard log implementation in your applications.
This course is fully example-driven and several examples will be created in the class.
By the end of this course, you will have gained the skills you need to confidently build Kafka programs in Java. All the codes and supporting files are available at-
https://github.com/PacktPublishing/Apache-Kafka-for-absolute-beginners
What You Will Learn
Delve into the multi-node Confluent Community of Kafka
Discover the Kafka Storage architecture
Gain insights into the Kafka Cluster architecture
Understand Kafka Consumer API programming in Java
Get up to speed with JSON and AVRO Serialization
Audience
This course is designed for software engineers, solution architects, and managers looking to implement Kafka and solve real-time stream processing problems. Architects who are not directly involved in Kafka implementation or anyone who is looking to implement Kafka Streams will also find this course helpful. This course is designed for both beginner and intermediate-level Apache Kafka users.
Approach
This course features several working examples that will help you effectively apply the knowledge you gain through the course.
Key Features
Get to grips with the Apache Kafka ecosystem and components * Delve into Kafka Producer API programming in Java
Github Repo
https://github.com/packtpublishing/apache-kafka-for-absolute-beginners
About the Author
Prashant Kumar Pandey
Prashant Kumar Pandey is passionate about helping people learn and grow in their careers by bridging the gap between their existing and required skills. In his journey to fulfill this mission, he is authoring books, publishing technical articles, and creating training videos to help IT professionals and students succeed in the industry. He is also the founder, lead author, and chief editor of the Learning Journal portal that has been providing various skill development courses, training sessions, and technical articles since 2018.
Course Outline
1. Kafka Ecosystem - The Big Picture

2. Apache Kafka - Getting Started

3. Apache Kafka - Storage Architecture

4. Apache Kafka - Cluster Architecture

5. Kafka Producer Internals

6. Advanced Kafka Producers

7. Types and Serialization

8. Micro Project - Summing Up the Producer

9. Kafka Consumers

10. Where to go Next


Java

Big Data

Kafka

Explore the Apache Kafka ecosystem and architecture, and learn client API programming in Java

Apache Kafka for Absolute Beginners

<strong>A beginner's guide to mastering real-time stream processing using Apache Kafka and Kafka Streams API</strong>
        <p>If you want to understand the concept of stream processing, this course is for you. Using Kafka, the course will help you get to grips with real-time stream processing and enable you to apply that knowledge to learn Kafka programming techniques.
This course uses the Kafka Streams library available in Apache Kafka 2.x. All the source code and examples on Apache Kafka 2.3 open-source distribution have been tested. You'll understand and explore Confluent Platform functionalities such as Schema Registry and Avro Serdes using the Confluent Community Version. This course makes extensive use of IntelliJ IDEA and Apache Maven as the preferred development IDE. You'll leverage Log4J2 and JUnit5 for industry-standard log implementation in your application and implementing unit test cases, respectively.

The code bundle is available at https://github.com/PacktPublishing/Apache-Kafka---Real-time-Stream-Processing-Master-Class
</p>
        <h2>What You Will Learn</h2><p>Learn Apache Kafka fundamentals and Kafka Architecture<br>Understand how to create streams using the Kafka Producer APIs<br>Design, develop, and test real-time stream processing applications using the Kafka Streams library<br>Get well-versed with the Kafka Streams architecture, Streams DSL, and the Processor API<br>Support microservice architecture and implement interactive queries in Kafka Streams<br>Explore serializing and deserializing and work on JSON and AVRO messages</p>
        <h2>Audience</h2><p>The Kafka Streams - Real-time Stream Processing course is for software engineers looking to develop a stream processing application using the Kafka Streams library. This course will also help Java programmers who want to learn everything necessary to start implementing real-time streaming applications using Apache Kafka. Data architects and data engineers responsible for designing and building the organization's data-centric infrastructure will benefit from this course.</p>
        <h2>Approach</h2><p>The course uses a progressive approach to teach a complex subject. It contains some fully example-driven sections to help you grasp key concepts easily.</p>
        <h2>Key Features</h2><p>Design, develop, and test real-time stream processing applications using Kafka Streams * Explore the Kafka Streams architecture, Streams DSL, and exactly-once processing in Apache Kafka * Autogenerate Java Objects from JSON and AVRO Schema definition</p>
        <h2>Github Repo</h2><p>https://github.com/PacktPublishing/Apache-Kafka---Real-time-Stream-Processing-Master-Class</p>
        <h2>About the Author</h2><h3>Prashant Kumar Pandey</h3><p>Prashant Kumar Pandey is passionate about helping people learn and grow in their careers by bridging the gap between their existing and required skills. In his journey to fulfill this mission, he is authoring books, publishing technical articles, and creating training videos to help IT professionals and students succeed in the industry. He is also the founder, lead author, and chief editor of the Learning Journal portal that has been providing various skill development courses, training sessions, and technical articles since 2018.</p>
        <h2>Course Outline</h2><h4>1. Before you Start</h4><p></p><br><h4>2. Introduction to Real-time Streams</h4><p></p><br><h4>3. Enter the world of Apache Kafka</h4><p></p><br><h4>4. Creating Real-time Streams</h4><p></p><br><h4>5. Enter the Stream Processing</h4><p></p><br><h4>6. Foundation for Real Life Implementations</h4><p></p><br><h4>7. States and Stores</h4><p></p><br><h4>8. KTable - An Update Stream</h4><p></p><br><h4>9. Real-time Aggregates</h4><p></p><br><h4>10. Timestamps and Windows</h4><p></p><br><h4>11. Joining Streams and Tables</h4><p></p><br><h4>12. Testing Streams Application</h4><p></p><br><h4>13. Interactive Query and Micro-Service Responses</h4><p></p><br><h4>14. Appendix</h4><p></p>

A beginner's guide to mastering real-time stream processing using Apache Kafka and Kafka Streams API
If you want to understand the concept of stream processing, this course is for you. Using Kafka, the course will help you get to grips with real-time stream processing and enable you to apply that knowledge to learn Kafka programming techniques.
This course uses the Kafka Streams library available in Apache Kafka 2.x. All the source code and examples on Apache Kafka 2.3 open-source distribution have been tested. You'll understand and explore Confluent Platform functionalities such as Schema Registry and Avro Serdes using the Confluent Community Version. This course makes extensive use of IntelliJ IDEA and Apache Maven as the preferred development IDE. You'll leverage Log4J2 and JUnit5 for industry-standard log implementation in your application and implementing unit test cases, respectively. The code bundle is available at https://github.com/PacktPublishing/Apache-Kafka---Real-time-Stream-Processing-Master-Class

What You Will Learn
Learn Apache Kafka fundamentals and Kafka Architecture
Understand how to create streams using the Kafka Producer APIs
Design, develop, and test real-time stream processing applications using the Kafka Streams library
Get well-versed with the Kafka Streams architecture, Streams DSL, and the Processor API
Support microservice architecture and implement interactive queries in Kafka Streams
Explore serializing and deserializing and work on JSON and AVRO messages
Audience
The Kafka Streams - Real-time Stream Processing course is for software engineers looking to develop a stream processing application using the Kafka Streams library. This course will also help Java programmers who want to learn everything necessary to start implementing real-time streaming applications using Apache Kafka. Data architects and data engineers responsible for designing and building the organization's data-centric infrastructure will benefit from this course.
Approach
The course uses a progressive approach to teach a complex subject. It contains some fully example-driven sections to help you grasp key concepts easily.
Key Features
Design, develop, and test real-time stream processing applications using Kafka Streams * Explore the Kafka Streams architecture, Streams DSL, and exactly-once processing in Apache Kafka * Autogenerate Java Objects from JSON and AVRO Schema definition
Github Repo
https://github.com/PacktPublishing/Apache-Kafka---Real-time-Stream-Processing-Master-Class
About the Author
Prashant Kumar Pandey
Prashant Kumar Pandey is passionate about helping people learn and grow in their careers by bridging the gap between their existing and required skills. In his journey to fulfill this mission, he is authoring books, publishing technical articles, and creating training videos to help IT professionals and students succeed in the industry. He is also the founder, lead author, and chief editor of the Learning Journal portal that has been providing various skill development courses, training sessions, and technical articles since 2018.
Course Outline
1. Before you Start

2. Introduction to Real-time Streams

3. Enter the world of Apache Kafka

4. Creating Real-time Streams

5. Enter the Stream Processing

6. Foundation for Real Life Implementations

7. States and Stores

8. KTable - An Update Stream

9. Real-time Aggregates

10. Timestamps and Windows

11. Joining Streams and Tables

12. Testing Streams Application

13. Interactive Query and Micro-Service Responses

14. Appendix


A beginner's guide to mastering real-time stream processing using Apache Kafka and Kafka Streams API

Apache Kafka - Real-time Stream Processing (Master Class)

Through this course, you will learn how to arrange Kafka a producer and consumer and Kafka Streams and Connectors accurately. You will also gain the skills needed to coordinate Kafka with existing application stages and to pass the Apache Kafka certification exam.
Do you want to learn Apache Kafka to store and process multiple, nonstop streams of information faster? Or do you want to prepare for the Apache Kafka certification exam? This course is an ideal resource to learn Apache Kafka and to reach your goals. The course starts with an introduction to big data and Apache Kafka. Next, you will get into the details of a Kafka producer and consumer and grasp the techniques to tune the performance of Kafka operations. Moving along, you will explore the Kafka architecture and learn how to administer Kafka effectively. Next, you will learn to monitor server, infrastructure, and application and understand how the Schema Registry works in Kafka. Later, you will get to grips with Kafka Streams and Connectors and learn the process of integrating Kafka with Apache Storm, Spark, and Flume. Towards the end, you will learn how to perform various admin tasks using the admin clients and uncover useful tips to secure Kafka. By the end of this course, you will have developed the Kafka skills needed to handle real-time data feed and to pass the Apache Kafka certification exam.
What You Will Learn
Create a Kafka producer and a Kafka consumer
Discover Kafka reliability methods
Become familiar with MirrorMaker deployment and tuning
Build a simple stand-alone application using Kafka and Storm
Create a Flume agent for sending data from Kafka to HDFS
Configure SSL certificate in Kafka
Audience
If you are into analytics or research or are a software developer, test engineer, or a project manager, who is looking to learn Apache Kafka and achieve an Apache Kafka certification, this course is for you. A basic understanding of big data is needed to get started with this course.
Approach
With the help of demos, examples, and activities, this course helps you to get started with Apache Kafka and prepares you to pass the Apache Kafka certification exam.
Key Features
Become familiar with the design of Kafka and its use cases * Design and introduce the Kafka group in single-hub and multi-hub arrangements * Execute a Kafka consumer and Kafka producer using real-time streaming information
About the Author
Learnkart Technology Private Limited 
Learnkart understands the importance of upskilling and its impact on you. They pride themselves in creating specialized e-learning courses that will not only prepare you for certification exams but also help you gain hands-on knowledge for real-world applications. Thousands of students have developed their skills with Learnkart through a variety of courses, such as PgMP, Risk Management Professional (RMP), speech recognition, Python, Amazon Web Services (AWS), and more. Learnkart regularly adds courses to its portfolio to lend more value to your learning experience.
Course Outline
1. Course Introduction

1. Introduction
This video presents an overview of the course.
2. Getting Started with Big data and Apache Kafka

1. Learning Objectives
This video highlights the learning objectives of this section.
2. Data Evolution over Time
This video explains how data has evolved over time.
3. Big Data Overview
This video presents an overview of big data.
4. Big Data Analytics
This video introduces you to big data analytics.
5. Messaging System
This video explains the basic messaging system and how it works. It also highlights the issues and how Kafka resolves those issues.
6. Introduction and Features of Kafka
This video introduces you to Kafka and its features.
7. Kafka Use Cases
This video explains Kafka use cases, such as messaging, metrics and logging, stream processing, and more.
8. Kafka Terminologies
This video introduces you to Kafka terminologies, such as message, batch, and more.
9. Kafka Components
This video explains the different types of Kafka components.
10. Kafka Architecture
This video presents an overview of Kafka's architecture.
11. Kafka Clusters
This video explains the concept of Kafka clusters.
12. Kafka Industry Use Cases
This video highlights the concept of Kafka industry use cases.
13. Demo - Installing Zookeeper
This video demonstrates how to install Apache Zookeeper.
14. Demo - Installing Kafka
This video explains how to install Apache Kafka.
15. Demo - Setting up a Single Node and Single Broker Cluster
This video demonstrates how to set up a single node and a single broker cluster.
16. Demo - Setting up a Multi-node Single Broker Cluster
This video explains how to set up a multi-node single broker cluster.
17. Key Takeaways
This video summarizes what you have learnt in this section.
3. Kafka Producers

1. Learning Objective
This video explains the learning objectives of this section.
2. Overview of a Kafka Producer and Its Architecture
This video presents an overview of a Kafka producer and its architecture.
3. Kafka Producer Configuration
This video explains the Kafka producer configuration.
4. Kafka Producer Optional Configuration
This video explains the optional configuration of a Kafka producer.
5. Kafka Producer Configuration Objects
This video introduces you to Kafka producer configuration objects.
6. Demo - Creating a Kafka Producer
This video demonstrates how to create a Kafka producer.
7. Sending Messages
This video focuses on how a Kafka producer sends messages to broker and explains the different ways of sending messages.
8. Serializers and Custom Serializers
This video introduces you to serializers and custom serializers.
9. Demo - Creating a Custom Serializer
This video demonstrates how to create a custom serializer.
10. Serializers Challenges and Serializing Using Apache Avro
This video focuses on serializers challenges and explains how to serialize using Apache Avro.
11. Demo - Serializing Using Apache Avro
This video demonstrates how to serialize using Apache Avro.
12. Partitions
This video highlights the concept of partitions in Kafka.
13. Demo - Setting up a Custom Partition
This video explains how to set up a custom partition.
14. Key Takeaway
This video highlights what you have learnt from this section.
4. Kafka Consumers

1. Learning Objective
This video explains the learning objective of this section.
2. Overview of Kafka Consumers
This video presents an overview of Kafka consumers.
3. Consumer Groups
This video highlights the concept of consumer groups.
4. Partition Rebalance and Creating a Kafka Consumer
This video introduces you to partition rebalance and explains how to create a consumer.
5. Poll Loop and Its Functioning
This video focuses on the concept of a poll loop and explains its functioning.
6. Configuring a Kafka Consumer - Part 1
This is the first part of the two-part video that explains properties, such as fetch.min.bytes, fetch.max.wait.ms, and so on. It also explains how to configure a Kafka consumer.
7. Configuring a Kafka Consumer - Part 2
This is the second part of the two-part video that explains properties, such as auto.offset.reset, enable.auto.commit, and so on. It also explains how to configure a Kafka consumer.
8. Demo - Creating a Kafka Consumer
This video demonstrates how to create a Kafka consumer.
9. Commit and Offset
This video explains the concepts of commit and offset in Kafka.
10. Ways of Committing Offset - Automatic Offset
This video shows how to commit offset using automatic offset.
11. Ways of Committing Offset - Commit Current Offset
This video demonstrates how to commit offset using commit offset.
12. Ways of Committing Offset - Asynchronous Commit
This video explains how to commit offset using asynchronous offset.
13. Ways of Committing Offset - Combining Synchronous and Asynchronous Commits
This video shows how to commit offset using synchronous and asynchronous commits.
14. Ways of Committing Offset - Commit Specified Offset
This video demonstrates how to commit offset using commit specified offset.
15. Rebalance Listeners
This video explains the concept of rebalance listeners in Apache Kafka.
16. Consuming Records with Specific Offset
This video demonstrates how to consume records with specific offset.
17. Deserializers
This video introduces you to deserializers in Kafka.
18. Demo - Creating and Using Custom Deserializer
This video demonstrates how to create and use custom deserializer.
19. Key Takeaways
This video highlights what you have learnt in this section.
5. Kafka Operations and Performance Tuning

1. Learning Objective
This video explains the learning objectives of this section.
2. Kafka Internals Overview
This video presents an overview of Kafka Internals.
3. Replication and Replica Types
This video focuses on replication and explains the different types of replica.
4. Preferred Ladder, Request, and Request Processing
This video presents an overview of Preferred Ladder, request, and request Processing.
5. Types of Requests
This video presents an overview of the different types of requests.
6. Partition Allocation, File Management, and Segments
This video introduces you to partition allocation, file management, and segments in Apache Kafka.
7. File Format, Index, and Compaction
This video highlights the concepts of file format, index, and compaction.
8. Kafka Reliability and Reliability Methods
This video presents an overview of Kafka reliability and reliability methods.
9. Broker Configuration for Replication
This video explains the broker configuration for replication.
10. Producer in a Reliable System
This video explains the concept of a producer in a reliable system.
11. Consumer in a Reliable System
This video focuses on the concept of a consumer in a reliable system.
12. Key Takeaways
This video highlights what you have learnt in this section.
6. Kafka Cluster Architectures and Administering Kafka

1. Learning Objective
This video explains the learning objectives of this section.
2. Cluster Mirroring
This video presents an overview of cluster mirroring.
3. Multi-cluster Architecture - Hub, Spokes, and Active Architecture - Part 1
This is the first part of the two-part video that focuses on multi-cluster architecture, such as hub, spokes, and active architecture.
4. Multi-cluster Architecture - Active/Stand-by Architecture and Stretch Clusters Part - 2
This is the second part of the two-part video that provides an overview of the multi-cluster architecture, such as active/stand-by architecture and stretch clusters.
5. Configuring MirrorMaker - Part 1
This video is the first part of the two-part video that demonstrates how to configure MirrorMaker in Apache Kafka.
6. Configuring MirrorMaker - Part 2
This video is the second part of the two-part video that explains how to configure MirrorMaker in Apache Kafka.
7. Demo - Setting up MirrorMaker
This video demonstrates how to set up MirrorMaker in Kafka.
8. Administering Kafka - Topic Operations
This video presents Administering Kafka and using different CLI options.
9. Administering Kafka - Consumer Group Operations
This video provides an overview of consumer group operations
10. Dynamic Configuration Changes
This video focuses on dynamic configuration changes.
11. Partition Management
This video provides an overview of partition management.
12. Console Producer Tool
This video introduces you to the console producer tool.
13. Console Consumer Tool
This video provides an introduction to the console consumer tool.
14. Key Takeaways
This video focuses on what you have learnt in the section.
7. Monitoring Kafka and Schema Registry

1. Learning Objective
This video presents the learning objectives of this section.
2. Monitoring and Its Importance
This video presents an overview of monitoring and its importance.
3. Server or Infrastructure Monitoring and Application Monitoring
This video provides details on server or infrastructure monitoring and application monitoring.
4. Monitoring Kafka
This video demonstrates how to monitor Kafka.
5. Kafka Broker Metrics - Under-replicated Partitions - Part 1
This is the first part of the two-part video that focuses on Kafka broker metrics, such as under-replicated partitions.
6. Kafka Broker Metrics - Others- Part 2
This video provides an overview of Kafka broker metrics - Active Controller Count.
7. Topic and Partition Specific Metrics
This video focuses on topic and partition specific metrics.
8. Logging and Client Monitoring
This video focuses on logging and client monitoring.
9. Producer and Consumer Metrics
This video focuses on producer and consumer metrics.
10. Quotas and Lag Monitoring
This video focuses on quotas and lag monitoring.
11. Monitoring Dashboard
This video presents an overview of the monitoring dashboard.
12. Demo - Setting up an Open Source Health Monitor
This video demonstrates how to set up an open-source health monitor.
13. Kafka Schema Registry
This video introduces you to the Kafka Schema Registry.
14. Kafka Components and Its Architecture
This video presents an overview of Kafka components and its architecture.
15. Kafka Schema Registry - Internal working and Use cases
This video provides an overview of the Kafka Schema Registry, focusing on internal working and use cases.
16. Working of the Kafka Schema Registry
This video explains the working of the Kafka Schema Registry.
17. Demo - Using the Kafka Schema Registry with Kafka
This video demonstrates how to use the Kafka Schema Registry with Kafka.
18. Key Takeaway
This video highlights what you have learnt from this section.
8. Kafka Streams and Kafka Connectors

1. Learning Objective
This video presents the learning objectives of this section.
2. Kafka Streams Overview
This video presents an overview of Kafka Streams.
3. Kafka Streams
This video explains more about Kafka Streams.
4. Kafka Streams Architecture and Working
This video explains the Kafka Streams architecture and its working.
5. Kafka Streams Components
This video focuses on the Kafka Streams components.
6. Kafka Streams Architecture Tasks, Threading Model and Local State Store
This video focusses on Kafka Streams architecture tasks, the threading model, and the local state store.
7. Kafka Streams Architecture - Record Buffer
This video provides an overview of Kafka Streams architecture, focuses on record buffer.
8. Memory Management and Streaming Data Pipeline
This video provides an overview of memory management and streaming data pipeline.
9. Kafka Streams Domain Specific Language (DSL)
This video introduces you to Kafka Streams DSL.
10. KStream Operations
This video presents an overview of KStream operations.
11. KTable Operations
This video focuses on KTable operations.
12. KTable Operations
This video explains more about KTable operations.
13. Aggregation and Windowing
This video explains the concept of aggregation and windowing.
14. Processor Topology and Stream Processor
This video introduces you to processor topology and stream processor.
15. Stream and Processor Application Programming Interfaces (APIs)
This video focuses on Stream and Processor APIs.
16. Processor Application Programming Interfaces (APIs) and Creating Topology
This video provides an overview of Processor APIs and explains how to create topology.
17. Kafka Connectors
This video explains the concept of Kafka Connectors.
18. Stand-alone and Sink Connector Configuration
This video explains how to configure stand-alone and sink connectors.
19. Running Kafka Connect
This video demonstrates how to run Kafka Connect.
20. Kafka Connector Distributed Mode
This video focuses on the Kafka Connector distributed mode.
21. Hypertext Transfer Protocol (HTTP) Representational State Transfer (REST) Interface
This video explains the HTTP REST interface.
22. Demo - Kafka Connector
This video demonstrates the working of a Kafka Connector.
23. Demo - Creating an Application Using Kafka Streams
This video demonstrates how to create an application using Kafka Streams.
24. Key Takeaway
This video highlights what you have learnt from this section.
9. Integration of Kafka with Storm

1. Learning Objective
This video explains the learning objectives of this section.
2. Apache Storm
This video provides an overview of Apache Storm.
3. Real-time Analytics
This video provides an overview of real-time analytics.
4. Apache Storm Architecture
This video explains the architecture of Apache Storm.
5. Apache Storm Components
This video introduces you to the components of Apache Storm.
6. Apache Storm Topology Part - 1
This is the first part of the two-part video that presents an overview of the topology of Apache Storm.
7. Apache Storm Topology Part - 2
This is the second part of the two-part video that explains more about the topology of Apache Storm.
8. Kafka Spout
This video presents an overview of Kafka Spout.
9. Integration of Apache Storm and Kafka
This video explains the integration of Apache Storm and Kafka.
10. Demo - Simple Stand-alone Application Using Kafka and Storm
This video provides a demonstration of a simple stand-alone application using Kafka and Storm.
11. Key Takeaway
This video highlights what you have learnt from this section.
10. Kafka Integration with Spark and Flume

1. Learning Objective
This video presents the learning objectives of this section.
2. Introduction to Spark
This video provides an introduction to Spark.
3. Spark Components
This video explains the components of Spark.
4. Resilient Distributed Dataset
This video focuses on a resilient distributed dataset.
5. Resilient Distributed Dataset (RDD) Operations - Transformation - Map, FlatMap, and Filter
This video provides an overview of RDD operations, focusing on transformations such as map, FlatMap, and filter.
6. RDD Operations - Transformation - Join, Distinct, First, and Take
This video explains RDD operations, focusing on transformations such as join, distinct, first, and take.
7. Resilient Distributed Dataset (RDD) Operations - Actions
This video explains RDD operations, focusing on actions.
8. Data Sets and SparkSession
This video provides an introduction to data sets and SparkSession.
9. Data Sets and Spark Session Operations
This video explains more about data sets and SparkSession operations.
10. Spark Stream
This video provides an overview of Spark Stream.
11. Integrating Spark with Kafka
This video demonstrates how to integrate Spark with Kafka.
12. Demo - Running a Small Stand-alone Application in Spark with Kafka
This video explains how to run a small stand-alone application in Spark with Kafka.
13. Flume
This video introduces you to the stream capturing tool called Flume.
14. Flume Connectors
This video provides an overview of Flume Connectors.
15. Configuring Flume Kafka to Hadoop Distributed File System (HDFS)
This video explains how to configure Flume Kafka to HDFS.
16. Demo - Creating a Flume Agent and Sending Data from Kafka to Hadoop Distributed File System (HDFS)
This video demonstrates how to create a flume agent and send data from Kafka to HDFS.
17. Key Takeaways
This video highlights what you have learnt in this section.
11. Admin Client and Securing Kafka

1. Learning Objective
This video explains the learning objective of this course.
2. AdminClient
This video introduces you to AdminClient.
3. Demo - Performing Various Admin Tasks Using AdminClient
This video demonstrates how to perform various admin tasks using AdminClient.
4. Kafka Security
This video presents an overview of Kafka Security.
5. Kafka Security Components
This video introduces you to the components of Kafka Security.
6. Simple Authentication and Security Layer (SASL)
This video highlights the concept of SASL in Kafka.
7. Configuring Simple Authentication and Security Layer (SASL) in Kafka
This video explains how to configure SASL in Kafka.
8. Securing Using Access Control Lists (ACLs)
This video demonstrates how to secure Kafka using ACLs.
9. Key Takeaway
This video highlights what you have learnt from this course.

Through this course, you will learn how to arrange Kafka a producer and consumer and Kafka Streams and Connectors accurately. You will also gain the skills needed to coordinate Kafka with existing application stages and to pass the Apache Kafka certification exam.

Apache Kafka A-Z with Hands-On Learning

<div id="course-pills-1">Duration<p>2 Days</p><p>12 CPD hours</p>This course is intended for<p>This in an Introductory and beyond level course is geared for experienced Java developers seeking to be proficient in Apache Kafka.  Attendees should be experienced developers who are comfortable with Java, and have reasonable experience working with databases.</p>Overview<p>Working in a hands-on learning environment, students will explore<br />Overview of Streaming technologies<br />Kafka concepts and architecture<br />Programming using Kafka API<br />Kafka Streams<br />Monitoring Kafka<br />Tuning / Troubleshooting Kafka</p><p>Apache Kafka is a real-time data pipeline processor. It high-scalability, fault tolerance, execution speed, and fluid integrations are some of the key hallmarks that make it an integral part of many Enterprise Data architectures.  In this lab intensive two day course, students will learn how to use Kafka to build streaming solutions.</p></div><div id="course-pills-2"><h4>Introduction to Streaming Systems</h4><ul><li>Fast data</li><li>Streaming architecture</li><li>Lambda architecture</li><li>Message queues</li><li>Streaming processors</li></ul><h4>Introduction to Kafka</h4><ul><li>Architecture</li><li>Comparing Kafka with other queue systems (JMS / MQ)</li><li>Kaka concepts : Messages, Topics, Partitions, Brokers, Producers, commit logs</li><li>Kafka &amp; Zookeeper</li><li>Producing messages</li><li>Consuming messages (Consumers, Consumer Groups)</li><li>Message retention</li><li>Scaling Kafka</li></ul><h4>Programming With Kafka</h4><ul><li>Configuration parameters</li><li>Producer API (Sending messages to Kafka)</li><li>Consumer API (consuming messages from Kafka)</li><li>Commits , Offsets, Seeking</li><li>Schema with Avro</li></ul><h4>Kafka Streams</h4><ul><li>Streams overview and architecture</li><li>Streams use cases and comparison with other platforms</li><li>Learning Kafka Streaming concepts (KStream, KTable, KStore)</li><li>KStreaming operations (transformations, filters, joins, aggregations)</li></ul><h4>Administering Kafka</h4><ul><li>Hardware / Software requirements</li><li>Deploying Kafka</li><li>Configuration of brokers / topics / partitions / producers / consumers</li><li>Security: How secure Kafka cluster, and secure client communications (SASL, Kerberos)</li><li>Monitoring : monitoring tools</li><li>Capacity Planning : estimating usage and demand</li><li>Trouble shooting : failure scenarios and recovery</li></ul><h4>Monitoring and Instrumenting Kafka</h4><ul><li>Monitoring Kafka</li><li>Instrumenting with Metrics library</li><li>Instrument Kafka applications and monitor their performance</li></ul></div>

Duration
2 Days
12 CPD hours
This course is intended for
This in an Introductory and beyond level course is geared for experienced Java developers seeking to be proficient in Apache Kafka. Attendees should be experienced developers who are comfortable with Java, and have reasonable experience working with databases.
Overview
Working in a hands-on learning environment, students will explore
Overview of Streaming technologies
Kafka concepts and architecture
Programming using Kafka API
Kafka Streams
Monitoring Kafka
Tuning / Troubleshooting Kafka
Apache Kafka is a real-time data pipeline processor. It high-scalability, fault tolerance, execution speed, and fluid integrations are some of the key hallmarks that make it an integral part of many Enterprise Data architectures. In this lab intensive two day course, students will learn how to use Kafka to build streaming solutions.
Introduction to Streaming Systems
Fast data
Streaming architecture
Lambda architecture
Message queues
Streaming processors
Introduction to Kafka
Architecture
Comparing Kafka with other queue systems (JMS / MQ)
Kaka concepts : Messages, Topics, Partitions, Brokers, Producers, commit logs
Kafka & Zookeeper
Producing messages
Consuming messages (Consumers, Consumer Groups)
Message retention
Scaling Kafka
Programming With Kafka
Configuration parameters
Producer API (Sending messages to Kafka)
Consumer API (consuming messages from Kafka)
Commits , Offsets, Seeking
Schema with Avro
Kafka Streams
Streams overview and architecture
Streams use cases and comparison with other platforms
Learning Kafka Streaming concepts (KStream, KTable, KStore)
KStreaming operations (transformations, filters, joins, aggregations)
Administering Kafka
Hardware / Software requirements
Deploying Kafka
Configuration of brokers / topics / partitions / producers / consumers
Security: How secure Kafka cluster, and secure client communications (SASL, Kerberos)
Monitoring : monitoring tools
Capacity Planning : estimating usage and demand
Trouble shooting : failure scenarios and recovery
Monitoring and Instrumenting Kafka
Monitoring Kafka
Instrumenting with Metrics library
Instrument Kafka applications and monitor their performance

Nexus Human

Working with Apache Kafka (for Developers) (TTDS6760)

A beginner-level course that follows a step-by-step approach to learning the fundamentals and core concepts of Apache Kafka 3.0. You will work through interesting activities such as programming a Twitter producer and Elasticsearch consumer to understand the various concepts.
The high throughput and low latency of Apache Kafka have made it one of the leading distributed data-streaming enterprise technologies. It is used by many Fortune 500 companies such as Netflix, Airbnb, Uber, Walmart, and LinkedIn. If you want to develop Apache Kafka skills to stream data easily, then this course is for you. The course starts by explaining the architecture of the Apache Kafka ecosystem, before going on to cover the core concepts of Kafka such as topics, partitions, brokers, replicas, producers, consumers, and more. Next, you will use native Kafka binaries to launch your own Kafka cluster on Windows, Mac OS X, and Linux. As you advance, you will get hands-on experience with the Kafka command-line interface (CLI), along with an understanding of how to create producers and consumers in Java to interact with Kafka. Next, a real-world project using Wikimedia as a source of data for a producer and OpenSearch as a sink for our consumers. Moving on, you will get to grips with advanced APIs such as Kafka Connect and Kafka Streams and perform a case study on the real-world applications of Kafka. Finally, you will get an overview of advanced Kafka for administrators and understand advanced topic configurations. By the end of this course, you will be well-versed with how Apache Kafka 3.0 plays an important role in data-streaming applications.
What You Will Learn
Understand the Apache Kafka ecosystem, architecture, core concepts, and operations
Start a personal Kafka development environment
Create producers and consumers in Java to interact with Kafka
Master concepts such as topics, partitions, brokers, producers, consumers
Discover how to change a topic configuration
Practice and understand log compaction
Audience
This course is for developers who want to learn the fundamentals of Apache Kafka, software architects who want to understand how Kafka fits into their solution architecture or anyone who is looking to understand how Apache Kafka works as a distributed system. Basic knowledge of Java and the Linux command line will be beneficial to effectively understand the concepts covered in the course.
Approach
With this course, you will get hands-on experience with Apache Kafka. Through interesting examples and activities, you will learn how to use Apache Kafka to build robust distributed data-streaming applications.
Key Features
Find out why Apache Kafka is an excellent choice of distributed data-streaming platform * Learn major CLIs: kafka-topics, kafka-console-producer, kafka-console-consumer, kafka-consumer-groups, kafka-configs * Get a solid grip on Apache Kafka by understanding various real-world examples
Github Repo
https://github.com/PacktPublishing/Apache-Kafka-Series---Learn-Apache-Kafka-for-Beginners-v3
About the Author
Stéphane Maarek
Stéphane Maarek is a solutions architect, consultant, and software developer who has a particular interest in all things related to big data and analytics. He is also a bestseller instructor on Udemy for his courses on Apache Kafka, Apache NiFi, and AWS Lambda. He loves Apache Kafka and regularly contributes to the Apache Kafka project. Stéphane has also written a guest blog post that was featured on the Confluent website, the company behind Apache Kafka. He is also an AWS Certified Solutions Architect and has many years of experience with technologies such as Apache Kafka, Apache NiFi, Apache Spark, Hadoop, PostgreSQL, Tableau, Spotfire, Docker, Ansible, and more.
Course Outline
1. Kafka Introduction

1. Course Introduction
In this video, the author introduces you to the course and his experience in this field.
2. Apache Kafka in Five Minutes
This video introduces Apache Kafka.
3. Course Objectives
In this section, you will learn about topics and partitions, how to replicate topics, and much more.
2. Kafka Theory

1. Topics, Partitions, and Offsets
This video explains topics, partitions, and offsets.
2. Producers and Message Keys
This video explains the concept of producers and message keys.
3. Consumers and Deserialization
This video explains the concept of consumers and deserialization.
4. Consumer Groups and Consumer Offsets
This video explains the consumer groups and consumer offsets.
5. Brokers and Topics
This video explains the concept of Kafka brokers and topics.
6. Topic Replication
This video explains the topic replication process in Kafka.
7. Producer Acknowledgments and Topic Durability
This video explains producer acknowledgments and topic durability.
8. Zookeeper
This video explains the concept of a Zookeeper in Kafka.
9. Kafka KRaft - Removing Zookeeper
This video explains Kafka KRaft. Kafka Raft (KRaft) is the consensus protocol that was introduced to remove Apache Kafka's dependency on Zookeeper for metadata management.
10. Theory Roundup
This video provides a roundup of the theory.
3. Starting Kafka

1. Important: Starting Kafka
This video demonstrates how to start Kafka in various operating systems and how we can overcome the challenge of starting Kafka.
2. Starting Kafka with Conduktor - Multi-Platform
This video demonstrates how to start Kafka with Conduktor.
3. Mac OS X - Download Kafka and Set Up PATH
This video demonstrates how to download Kafka and set up PATH on Mac OS X.
4. Mac OS X - Start Zookeeper and Kafka
This video demonstrates how to start a Zookeeper server and install Kafka on Mac OS X.
5. Mac OS X - Using Brew
This video demonstrates how to install Kafka on Mac OS X using Brew.
6. Linux - Download and Set Up Kafka in PATH
This video demonstrates how to download Kafka and set up PATH on a Linux system.
7. Linux - Start Zookeeper and Kafka
This video demonstrates how to start a Zookeeper server and install Kafka on a Linux server.
8. Windows WSL2 - Download Kafka and PATH Setup
This video demonstrates how to download Kafka and set up PATH on Windows.
9. Windows WSL2 - Start Zookeeper and Kafka
This video demonstrates how to start a Zookeeper server and install Kafka on Windows.
10. Windows WSL2 - How to Fix Problems
This video demonstrates the bug on WSL2 and how to fix the bug.
11. Windows Non-WSL2 - Start Zookeeper and Kafka
This video demonstrates how to start a Zookeeper server and install Kafka non-WSL2.
4. Starting Kafka without Zookeeper

1. Mac OS X - Start Kafka in KRaft Mode
This video explains how to start one Kafka Broker in KRaft mode without a Zookeeper on Mac OS.
2. Linux - Start Kafka in KRaft Mode
This video explains how to start one Kafka Broker using KRaft mode on Linux without a Zookeeper in this instance.
3. Windows WSL2 - Start Kafka in KRaft Mode
This video explains how to start one Kafka Broker with Zookeeper in KRaft Mode
5. Command Line Interface (CLI) 101

1. Command Line Interface (CLI) Introduction
This video introduces you to Kafka command line interface and how it comes bundled with Kafka binaries.
2. Kafka Topics Command Line Interface (CLI)
This video explains the CLI commands related to Kafka topics.
3. Kafka Console Producer Command Line Interface (CLI)
This video explains the kafka-console-producer CLI command to start producing data into our Kafka topics.
4. Kafka Console Consumer Command Line Interface (CLI)
This video explains the Kafka-console-consumer.sh CLI.
5. Kafka Consumers in a Group
This video explains the concept of Kafka consumers in a group and the -group parameter.
6. Kafka Consumer Groups Command Line Interface (CLI)
This video explains the consumer groups CLI, in which we can reset, delete, and manage the consumer groups.
7. Resetting Offsets
This video focuses on resetting offsets using the Kafka Offsets groups command.
6. Kafka UI

1. Conduktor - Demo
This video demonstrates Kafka UI Conduktor to get the full power of the UI.
7. Kafka Java Programming 101

1. Kafka SDK List
This video explains Kafka SDK list.
2. Creating Kafka Project
This video demonstrates how to create a Kafka project.
3. Java Producer
This video explains how to write a basic producer to send data to Kafka.
4. Java Producer Callback
This video explains how to create Kafka producer in Java using the callback function.
5. Java Producer with Keys
This video explains how to send messages in Kafka using keys.
6. Java Consumer
This video explains how to write a basic consumer to receive data from Kafka.
7. Java Consumer - Graceful Shutdown
This video explains a code to respond to termination signals and how to improve our Java code.
8. Java Consumer Inside a Consumer Group
This video explains the behavior of our consumers as part of our consumer groups.
9. Java Consumer Incremental Cooperative Rebalance and Static Group Membership
This video explains Java consumer incremental cooperative rebalance and static group membership.
10. Java Consumer Incremental Cooperative Rebalance - Practice
This video explains Java consumer incremental cooperative rebalance-practice.
11. Java Consumer Auto Offset Commit Behavior
This video explains the concept of Java consumer auto offset commit behavior.
12. Programming - Advanced Tutorials
This video explains programming-advanced tutorials.
8. Kafka Real-World Project

1. Real-World Project Overview
This video provides an overview of the real-world project.
9. Kafka Wikimedia Producer and Advanced Configurations

1. IMPORTANT: Start Local Kafka with Conduktor Using Docker
This video provides an overview of how to start Kafka with Conduktor using Docker Compose.
2. Wikimedia Producer Project Setup
This video provides an overview of the Wikimedia producer project setup.
3. Wikimedia Producer Implementation
This video explains Wikimedia producer implementation.
4. Wikimedia Producer Run
This video explains Wikimedia producer run using a demo.
5. Wikimedia Producer - Producer Config Intros
This video explains Wikimedia producer-producer Config Intros.
6. Producer Acknowledgements Deep Dive
This video explains Kafka producer acknowledgements.
7. Producer Retries
This video explains producer retries.
8. Idempotent Producer
This video explains idempotent producer.
9. Safe Kafka Producer Settings
This video explains the safe Kafka producer settings.
10. Wikimedia Producer Safe Producer Implementation
This video explains Wikimedia producer safe producer implementation.
11. Kafka Message Compression
This video explains Kafka message compression.
12. linger.ms and batch.size Producer Settings
This video explains how to implement a high throughput producer in Kafka.
13. Wikimedia Producer High Throughput Implementation
This video explains Wikimedia producer high throughput implementation.
14. Producer Default Partitioner and Sticky Partitioner
This video explains producer default partitioner and sticky partitioner.
15. [Advanced] max.block.ms and buffer.memory
This video explains max.block.ms and buffer.memory.
10. OpenSearch Consumer and Advanced Consumer Configurations

1. OpenSearch Consumer - Project Overview
This video provides an OpenSearch consumer-project overview.
2. OpenSearch Consumer - Project Setup
This video explains OpenSearch consumer-project setup.
3. Setting Up OpenSearch on Docker
This video focuses on setting up OpenSearch on Docker.
4. Setting Up OpenSearch on the Cloud
This video explains setting up OpenSearch on the Cloud.
5. OpenSearch 101
This video explains OpenSearch 101.
6. OpenSearch Consumer Implementation - Part 1
This video explains OpenSearch consumer implementation - part 1.
7. OpenSearch Consumer Implementation - Part 2
This video explains the setup of Kafka consumer and improving our code.
8. Consumer Delivery Semantics
This video explains consumer delivery semantics.
9. OpenSearch Consumer Implementation Part 3 - Idempotence
This video explains how to make our consumer idempotence.
10. Consumer Offsets Commit Strategies
This video explains consumer offsets commit strategies.
11. OpenSearch Consumer Implementation Part 4 - Delivery Semantics
This video explains OpenSearch consumer implementation delivery semantics.
12. OpenSearch Consumer Implementation Part 5 - Batching Data
This video explains OpenSearch consumer implementation part 5-batching data.
13. Consumer Offset Reset Behavior
This video explains consumer offset reset behavior.
14. OpenSearch Consumer Implementation Part 6 - Replaying Data
This video explains how the Kafka consumer is used to replay data.
15. Consumer Internal Threads
This video explains consumer internal threads.
16. Consumer Replica Fetching - Rack Awareness
This video explains consumer replica fetching-rack awareness.
11. Kafka Extended APIs for Developers

1. Kafka Extended APIs - Overview
This video explains the real-world applications in Kafka.
2. Kafka Connect Introduction
This video introduces you to Kafka Connect.
3. Kafka Connect Wikimedia and ElasticSearch Hands-On
This video explains Kafka Connect Wikimedia and ElasticSearch.
4. Kafka Streams Introduction
This video introduces you to Kafka Streams.
5. Kafka Streams Hands-On
This video demonstrates running a Kafka streams application.
6. Kafka Schema Registry Introduction
This video is an introduction to Kafka Schema Registry.
7. Kafka Schema Registry Hands-On
This video explains how to start Kafka with Schema Registry and Conduktor using Docker.
8. Which Kafka API Should I Use?
This video explains which Kafka API to use.
12. Real-World Insights and Case Studies (Big Data / Fast Data)

1. Choosing Partition Count and Replication Factor
This video explains how to determine the partition count and replication factor.
2. Kafka Topics Naming Convention
This video explains Kafka Topics naming convention.
3. Case Study - MovieFlix
This video explains the MovieFlix case study in Kafka.
4. Case Study - GetTaxi
This video explains the GetTaxi case study in Kafka.
5. Case Study - MySocialMedia
This video explains the MySocialMedia case study in Kafka.
6. Case Study - MyBank
This video explains the MyBank case study in Kafka.
7. Case Study - Big Data Ingestion
This video explains the big data ingestion case study in Kafka.
8. Case Study - Logging and Metrics Aggregation
This video explains the logging and metrics aggregation case study in Kafka.
13. Kafka in the Enterprise for Admins

1. Kafka Cluster Setup High-Level Architecture Overview
This video provides an overview of the Kafka cluster setup and high-level architecture.
2. Kafka Monitoring and Operations
This video explains the Kafka monitoring setup and operations.
3. Kafka Security
This video explains the concept of Kafka security.
4. Kafka Multi-Cluster and MirrorMaker
This video explains the concept of Kafka multi-cluster and MirrorMaker tool.
5. Advertised Listeners: Kafka Client and Server Communication Protocol
This video explains advertised listeners: Kafka client and server communication protocol.
14. Advanced Topics Configurations

1. Changing a Topic Configuration
This video explains how to change the topic configuration settings.
2. Segment and Indexes
This video explains the concept of segment and indexes files in Kafka.
3. Log Cleanup Policies
This video explains the Kafka log cleanup policies.
4. Log Cleanup Delete
This video explains how to delete the log cleanup policy.
5. Log Compaction Theory
This video explains the Kafka log compaction theory.
6. Log Compaction Practice
This video explains how to allow log compaction into practice.
7. Unclean Leader Election
This video explains how to enable an unclean leader election in Kafka.
8. Large Messages in Kafka
This video explains large messages in Kafka.
15. Next Steps

1. What's Next?
This video highlights the next concepts you can learn in the world of Apache Kafka.

A beginner-level course that follows a step-by-step approach to learning the fundamentals and core concepts of Apache Kafka 3.0. You will work through interesting activities such as programming a Twitter producer and Elasticsearch consumer to understand the various concepts.

Apache Kafka Series - Learn Apache Kafka for Beginners v3

<strong>Get hands-on with Kafka monitoring setup with Prometheus and Grafana, Kafka operations and Kafka cluster upgrades Setup in AWS.</strong>
        <p>This course helps you learn Kafka administration, Kafka monitoring, Kafka operations, and Kafka upgrades. It covers the following topics:
Administration for Apache Kafka
o Setup UI tools such as Kafka Manager, Zoo Navigator, and Kafka Monitor to get a full view of your cluster
o Understand basic operations you can perform with these tools
Monitoring for Apache Kafka
o A Kafka that is not monitored is a ticking time-bomb. 
o Set up proper monitoring for Kafka and Zookeeper
o Store your metrics in Prometheus and visualize them in Grafana
Operations for Apache Kafka
o Perform the most common and difficult operations in your Apache Kafka cluster
o Roll-restart your brokers in only one command
o Update Kafka configurations safely with no downtime
o Rebalance partitions and change the replication factor of your topics
o Add, replace, and remove brokers.
Upgrades for Apache Kafka
o Understand the subtlety of upgrading a Kafka cluster
o Step-by-step explanations on upgrading a cluster with no downtime

All the code files are placed at https://github.com/PacktPublishing/Apache-Kafka-Series---Kafka-Monitoring-and-Operations</p>
        <h2>What You Will Learn</h2><p>&bull; Learn how to perform a safe and automated roll-restart of Kafka brokers<br>&bull; Update broker configurations in a safe way<br>&bull; Rebalance partitions in a Kafka cluster<br>&bull; Increase and decrease the replication factor of topics<br>&bull; Add a broker to a Kafka cluster<br>&bull; Service and replace a broker in a Kafka cluster<br>&bull; Remove a broker in a Kafka cluster<br>&bull; Install Command Line Interface (CLI) tools to automate workflows<br>&bull; Upgrade a Kafka cluster with no downtime</p>
        <h2>Audience</h2><p>Kafka administrators who want to learn how to set up monitoring, perform Kafka operations, and upgrade a Kafka cluster.</p>
        <h2>Approach</h2><p>This course will teach you Apache Kafka in depth, via practical examples.</p>
        <h2>Key Features</h2><p>&bull; Set up a multi-broker Kafka cluster in no time in AWS (using CloudFormation) * &bull; Set up administration tools such as Kafka Manager, ZooNavigator, and LinkedIn's Kafka Monitor * &bull; Set up monitoring using Grafana and Prometheus</p>
        <h2>Github Repo</h2><p>https://github.com/packtpublishing/apache-kafka-series---kafka-monitoring-and-operations</p>
        <h2>About the Author</h2><h3>Stéphane Maarek</h3><p>Stéphane Maarek is a solutions architect, consultant, and software developer who has a particular interest in all things related to big data and analytics. He is also a bestseller instructor on Udemy for his courses on Apache Kafka, Apache NiFi, and AWS Lambda. He loves Apache Kafka and regularly contributes to the Apache Kafka project.

Stéphane has also written a guest blog post that was featured on the Confluent website, the company behind Apache Kafka. He is also an AWS Certified Solutions Architect and has many years of experience with technologies such as Apache Kafka, Apache NiFi, Apache Spark, Hadoop, PostgreSQL, Tableau, Spotfire, Docker, Ansible, and more.</p>
        <h2>Course Outline</h2><h4>1. Course Overview and Introduction</h4><p></p><br><h4>2. Kafka Quick Setup in AWS</h4><p></p><br><h4>3. Kafka Administration Setup</h4><p></p><br><h4>4. Kafka Monitoring Setup: Grafana + Prometheus</h4><p></p><br><h4>5. Kafka Operations</h4><p></p><br><h4>6. Kafka Cluster Upgrade</h4><p></p><br><h4>7. Next Steps</h4><p></p>

Get hands-on with Kafka monitoring setup with Prometheus and Grafana, Kafka operations and Kafka cluster upgrades Setup in AWS.
This course helps you learn Kafka administration, Kafka monitoring, Kafka operations, and Kafka upgrades. It covers the following topics:
Administration for Apache Kafka
o Setup UI tools such as Kafka Manager, Zoo Navigator, and Kafka Monitor to get a full view of your cluster
o Understand basic operations you can perform with these tools
Monitoring for Apache Kafka
o A Kafka that is not monitored is a ticking time-bomb. o Set up proper monitoring for Kafka and Zookeeper
o Store your metrics in Prometheus and visualize them in Grafana
Operations for Apache Kafka
o Perform the most common and difficult operations in your Apache Kafka cluster
o Roll-restart your brokers in only one command
o Update Kafka configurations safely with no downtime
o Rebalance partitions and change the replication factor of your topics
o Add, replace, and remove brokers.
Upgrades for Apache Kafka
o Understand the subtlety of upgrading a Kafka cluster
o Step-by-step explanations on upgrading a cluster with no downtime All the code files are placed at https://github.com/PacktPublishing/Apache-Kafka-Series---Kafka-Monitoring-and-Operations
What You Will Learn
• Learn how to perform a safe and automated roll-restart of Kafka brokers
• Update broker configurations in a safe way
• Rebalance partitions in a Kafka cluster
• Increase and decrease the replication factor of topics
• Add a broker to a Kafka cluster
• Service and replace a broker in a Kafka cluster
• Remove a broker in a Kafka cluster
• Install Command Line Interface (CLI) tools to automate workflows
• Upgrade a Kafka cluster with no downtime
Audience
Kafka administrators who want to learn how to set up monitoring, perform Kafka operations, and upgrade a Kafka cluster.
Approach
This course will teach you Apache Kafka in depth, via practical examples.
Key Features
• Set up a multi-broker Kafka cluster in no time in AWS (using CloudFormation) * • Set up administration tools such as Kafka Manager, ZooNavigator, and LinkedIn's Kafka Monitor * • Set up monitoring using Grafana and Prometheus
Github Repo
https://github.com/packtpublishing/apache-kafka-series---kafka-monitoring-and-operations
About the Author
Stéphane Maarek
Stéphane Maarek is a solutions architect, consultant, and software developer who has a particular interest in all things related to big data and analytics. He is also a bestseller instructor on Udemy for his courses on Apache Kafka, Apache NiFi, and AWS Lambda. He loves Apache Kafka and regularly contributes to the Apache Kafka project. Stéphane has also written a guest blog post that was featured on the Confluent website, the company behind Apache Kafka. He is also an AWS Certified Solutions Architect and has many years of experience with technologies such as Apache Kafka, Apache NiFi, Apache Spark, Hadoop, PostgreSQL, Tableau, Spotfire, Docker, Ansible, and more.
Course Outline
1. Course Overview and Introduction

2. Kafka Quick Setup in AWS

3. Kafka Administration Setup

4. Kafka Monitoring Setup: Grafana + Prometheus

5. Kafka Operations

6. Kafka Cluster Upgrade

7. Next Steps


Programming

Get hands-on with Kafka monitoring setup with Prometheus and Grafana, Kafka operations and Kafka cluster upgrades Setup in AWS.

Apache Kafka Series - Kafka Monitoring?? and Operations

<strong>Learn the fundamentals and advanced concepts of Apache Kafka in this course. This course will give you a good understanding of all the concepts through hands-on practice.</strong>
        <p>This course will walk you through the Kafka concepts step by step. We will explore the Kafka internals from a theoretical perspective followed by hands-on exploring the Kafka internals. Then we will learn about building the Kafka Producer to produce messages into Kafka using the producer API. This is followed by learning the different configurations that guarantee message delivery into Kafka and building Kafka Consumer to read messages from Kafka using the consumer API.

In the next section, we will learn about consumer groups and consumer rebalance, consumer offsets, and the different strategies that are available for the consumer to commit the offsets.

Next, we will learn about consumer rebalance listeners to perform some clean-up before partition revocation or some initialization tasks during partition assignment. Then learn about the different techniques from the consumer to seek a different offset.

And finally, we will code and learn how to build custom Serializer/Deserializer and integrate it into our Kafka Producer/Consumer.

By the end of the course, you will have a complete understanding of Apache Kafka and will be able to build Kafka Consumer applications using Java.

The complete code bundle for this course is available at https://github.com/PacktPublishing/Apache-Kafka-for-Beginners---Learn-Kafka-by-Hands-On</p>
        <h2>What You Will Learn</h2><p>Understand all the Kafka concepts and Kafka core internals<br>Learn Kafka internals through practice<br>Build Kafka Producer applications using Java<br>Learn the Kafka Producer techniques for reliable data delivery<br>Build Kafka Consumer applications using Java<br>Learn to build custom Serializer and Deserializer in Kafka</p>
        <h2>Audience</h2><p>This course is designed for Kafka beginners and advanced level. Anyone interested in building Java applications using producer and consumer API or interested in learning advanced Kafka Producer and Consumer operations, then this course is for you.</p>
        <h2>Approach</h2><p>This course will walk you through the Kafka concepts step by step and all the Kafka concepts will be taught through hands-on practice.</p>
        <h2>Key Features</h2><p>Learn to build Kafka Producers/Consumers using Java * Covers advanced Kafka Producer and Consumer concepts * Hands-on oriented course</p>
        <h2>Github Repo</h2><p>https://github.com/PacktPublishing/Apache-Kafka-for-Beginners---Learn-Kafka-by-Hands-On</p>
        <h2>About the Author</h2><h3>Dilip Sundarraj</h3><p>Dilip Sundarraj is a software engineer who has experience with building software since 2008. He is passionate about learning modern technologies and staying up to date with all the modern technologies, tools, frameworks, and more. He loves to share his knowledge with the world and that is one of the key reasons for him to be in the online teaching industry.
He loves interacting with other software developers and believes that this helps him share knowledge and learn from them. During his leisure time, he loves to play cricket, watch movies, and work out in the gym to have a balance between physical and mental strength.
Dilip has a YouTube channel named Code with Dilip, where he has been sharing a lot of technical content related to languages, frameworks, best practices, and more.</p>
        <h2>Course Outline</h2><h4>1. Getting Started with Course</h4><p></p><br><h4>2. Getting Started with Kafka</h4><p></p><br><h4>3. Download and Install Kafka</h4><p></p><br><h4>4. Understanding Kafka Components and its Internals - (Theory + Hands On)</h4><p></p><br><h4>5. Kafka Producer API - Hands On</h4><p></p><br><h4>6. Kafka Producer API - Guaranteed Message Delivery Configurations</h4><p></p><br><h4>7. Kafka Consumer API - Hands On</h4><p></p><br><h4>8. Consumer Groups & Consumer Rebalance - Hands On</h4><p></p><br><h4>9. Consumer Offsets - Default and Manual Offset Management - Hands On</h4><p></p><br><h4>10. Consumer Rebalance Listeners - Hands On</h4><p></p><br><h4>11. Kafka Consumer - seekToBeginning(), seekToEnd() & seek() - Hands On</h4><p></p><br><h4>12. Custom Serializer and Deserializers in Kafka - Hands On</h4><p></p>

Learn the fundamentals and advanced concepts of Apache Kafka in this course. This course will give you a good understanding of all the concepts through hands-on practice.
This course will walk you through the Kafka concepts step by step. We will explore the Kafka internals from a theoretical perspective followed by hands-on exploring the Kafka internals. Then we will learn about building the Kafka Producer to produce messages into Kafka using the producer API. This is followed by learning the different configurations that guarantee message delivery into Kafka and building Kafka Consumer to read messages from Kafka using the consumer API. In the next section, we will learn about consumer groups and consumer rebalance, consumer offsets, and the different strategies that are available for the consumer to commit the offsets. Next, we will learn about consumer rebalance listeners to perform some clean-up before partition revocation or some initialization tasks during partition assignment. Then learn about the different techniques from the consumer to seek a different offset. And finally, we will code and learn how to build custom Serializer/Deserializer and integrate it into our Kafka Producer/Consumer. By the end of the course, you will have a complete understanding of Apache Kafka and will be able to build Kafka Consumer applications using Java. The complete code bundle for this course is available at https://github.com/PacktPublishing/Apache-Kafka-for-Beginners---Learn-Kafka-by-Hands-On
What You Will Learn
Understand all the Kafka concepts and Kafka core internals
Learn Kafka internals through practice
Build Kafka Producer applications using Java
Learn the Kafka Producer techniques for reliable data delivery
Build Kafka Consumer applications using Java
Learn to build custom Serializer and Deserializer in Kafka
Audience
This course is designed for Kafka beginners and advanced level. Anyone interested in building Java applications using producer and consumer API or interested in learning advanced Kafka Producer and Consumer operations, then this course is for you.
Approach
This course will walk you through the Kafka concepts step by step and all the Kafka concepts will be taught through hands-on practice.
Key Features
Learn to build Kafka Producers/Consumers using Java * Covers advanced Kafka Producer and Consumer concepts * Hands-on oriented course
Github Repo
https://github.com/PacktPublishing/Apache-Kafka-for-Beginners---Learn-Kafka-by-Hands-On
About the Author
Dilip Sundarraj
Dilip Sundarraj is a software engineer who has experience with building software since 2008. He is passionate about learning modern technologies and staying up to date with all the modern technologies, tools, frameworks, and more. He loves to share his knowledge with the world and that is one of the key reasons for him to be in the online teaching industry.
He loves interacting with other software developers and believes that this helps him share knowledge and learn from them. During his leisure time, he loves to play cricket, watch movies, and work out in the gym to have a balance between physical and mental strength.
Dilip has a YouTube channel named Code with Dilip, where he has been sharing a lot of technical content related to languages, frameworks, best practices, and more.
Course Outline
1. Getting Started with Course

2. Getting Started with Kafka

3. Download and Install Kafka

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

5. Kafka Producer API - Hands On

6. Kafka Producer API - Guaranteed Message Delivery Configurations

7. Kafka Consumer API - Hands On

8. Consumer Groups & Consumer Rebalance - Hands On

9. Consumer Offsets - Default and Manual Offset Management - Hands On

10. Consumer Rebalance Listeners - Hands On

11. Kafka Consumer - seekToBeginning(), seekToEnd() & seek() - Hands On

12. Custom Serializer and Deserializers in Kafka - Hands On


Learn the fundamentals and advanced concepts of Apache Kafka in this course. This course will give you a good understanding of all the concepts through hands-on practice.

Apache Kafka for Beginners - Learn Kafka by Hands-On

<strong>This course brings together all the important topics related to modern distributed applications and systems in one place. Explore the common challenges that appear while designing and implementing large-scale distributed systems, and how big-tech companies solve those problems. Throughout the course, we are going to build a distributed URL shortening service.</strong>
        <p>A significant percentage of large-scale enterprises experience performance issues with their business-critical applications. Most of the production systems have been built on top of legacy, monolith technologies. The recent popularity of micro-services will not fulfill its promise of decoupled, scalable, and fault-tolerant systems, unless 'done right'. While entering the world of micro-services, engineers start building distributed applications, where robust remote procedure calls and cluster coordination are a must.

You will look at various technologies, algorithms, and design patterns here. Some of them are Service Registry and Discovery, Service Mesh, Apache Cassandra ETCD (coordinator managing Kubernetes clusters), Apache Kafka, Idempotent service design, retry logic, Sharding, and Consistent Hashing, Client-side Load Balancing, Distributed Tracing, Canary Deployment, Sidecar Pattern, Circuit Breaker, and many more. Finally, you will also see the principles of various distributed systems designs; for example, master-less versus with leaders, poll-based versus push-based, immediate versus eventual consistency.

After completing the course, learning new distributed database technology would be easier, because you will know the commonly reused techniques, including their pros and cons.

All the resource files are available on the GitHub repository at https://github.com/PacktPublishing/Building-Modern-Distributed-Systems-with-Java</p>
        <h2>What You Will Learn</h2><p>Look at the concepts of distributed systems<br>Understand synchronous and asynchronous communication patterns<br>Study service meshes and Idempotent service design<br>Differentiate between traditional RDBMS systems and NoSQL<br>Learn deployment requirements for strongly consistent distributed systems<br>Build distributed URL-shortening services like Tiny-URL</p>
        <h2>Audience</h2><p>This course is designed for Java developers and architects who wish to broaden their knowledge of distributed computing, NoSQL databases, efficient RPC calls, messaging middleware, and cluster coordination. It is also recommended for anyone working in modern IT landscapes. The course may be a good recap for people preparing for systems design interviews.<br><br>You will need proficiency in Java programming language, and an open mind to discover the challenges of distributed computing. Beginner-level knowledge in the Spring Boot framework will help you get along with the course easily.</p>
        <h2>Approach</h2><p>The course is short yet complete with content delivered with a very practical approach. There are a lot of code examples and applied best practices to follow along at the end of every section. The author will cover Service Registry and Discovery in detail so that you will know how to implement your own framework on top of ETCD. Throughout the course, you will build a distributed URL shortening service.</p>
        <h2>Key Features</h2><p>Design and implement globally distributed, scalable, fault-tolerant, and resilience applications * Understanding of common algorithms and techniques used in the majority of NoSQL databases and streaming platforms * In-depth knowledge of Apache Cassandra, Apache Kafka, and ETCD</p>
        <h2>Github Repo</h2><p>https://github.com/PacktPublishing/Building-Modern-Distributed-Systems-with-Java</p>
        <h2>About the Author</h2><h3>Lukasz Antoniak</h3><p>Lukasz Antoniak is an IT architect who designed and implemented robust back-end systems. After falling in love with Apache Cassandra, his focus shifted toward big data technologies, microservice architecture, NoSQL databases, and distributed message brokers. He is contributing as a committer to various open-source projects, including Hibernate ORM and Apache Bahir (extensions to Apache Spark). He worked for a few years on the distributed core banking platform for a major European bank. He has also worked previously for big-tech companies such as Oracle, IBM, HP, and TIBCO. In his spare time, he enjoys sailing and photography.</p>
        <h2>Course Outline</h2><h4>1. Concepts of Distributed Systems</h4><p></p><table width='100%'><tbody><tr><td style='padding: 15px;'><p>1. Evolution of Computer Systems' Architecture</p><p style='margin: 0'>This video talks about the evolution of computer systems' architecture.</p></td></tr><tr><td style='padding: 15px;'><p>2. Challenges of Distributed Compounding</p><p style='margin: 0'>This video demonstrates the challenges of Distributed Compounding.</p></td></tr><tr><td style='padding: 15px;'><p>3. Use-Case of Course Application</p><p style='margin: 0'>This video demonstrates the use-case of course application.</p></td></tr><tr><td style='padding: 15px;'><p>4. Practice 1</p><p style='margin: 0'>This is the first practice video that focuses on the environment setup for Tiny-URL project.</p></td></tr></tbody></table><br><h4>2. Remote Procedure Call</h4><p></p><table width='100%'><tbody><tr><td style='padding: 15px;'><p>1. The Need of Communication</p><p style='margin: 0'>This video explains the need of communication.</p></td></tr><tr><td style='padding: 15px;'><p>2. Message Transport and Format</p><p style='margin: 0'>This video explains the Message transport and format.</p></td></tr><tr><td style='padding: 15px;'><p>3. Synchronous and Asynchronous Communication Patterns</p><p style='margin: 0'>This video demonstrates the synchronous and asynchronous communication patterns.</p></td></tr><tr><td style='padding: 15px;'><p>4. Traditional Load Balancers</p><p style='margin: 0'>This video explains the traditional load balancers.</p></td></tr><tr><td style='padding: 15px;'><p>5. Service Registry and Discovery</p><p style='margin: 0'>This video explains about the Service Registry and Discovery.</p></td></tr><tr><td style='padding: 15px;'><p>6. Service Meshes</p><p style='margin: 0'>This video demonstrates the Service Meshes.</p></td></tr><tr><td style='padding: 15px;'><p>7. Idempotent Service Design</p><p style='margin: 0'>This video talks about Idempotent service design.</p></td></tr><tr><td style='padding: 15px;'><p>8. Practice 2</p><p style='margin: 0'>This is the second practice video that focuses on the resilient RPC (Remote Procedure Call) configuration and service discovery technology.</p></td></tr></tbody></table><br><h4>3. Distributed Databases</h4><p></p><table width='100%'><tbody><tr><td style='padding: 15px;'><p>1. Traditional RDBMS Systems Versus NoSQL</p><p style='margin: 0'>This video differentiates between the traditional RDBMS systems and NoSQL.</p></td></tr><tr><td style='padding: 15px;'><p>2. Data Sharding and Consistent Hashing</p><p style='margin: 0'>This video talks about Data Sharding and Consistent Hashing.</p></td></tr><tr><td style='padding: 15px;'><p>3. CAP theorem</p><p style='margin: 0'>This video explains the CAP theorem.</p></td></tr><tr><td style='padding: 15px;'><p>4. Short Introduction to Apache Cassandra</p><p style='margin: 0'>This video provides a short Introduction to Apache Cassandra.</p></td></tr><tr><td style='padding: 15px;'><p>5. Practice 3</p><p style='margin: 0'>This is the third practice video that focuses on the distributed database and usage of Apache Cassandra in Tiny-URL project.</p></td></tr></tbody></table><br><h4>4. Cluster Coordination</h4><p></p><table width='100%'><tbody><tr><td style='padding: 15px;'><p>1. The Need of Cluster-Wide Coordination</p><p style='margin: 0'>This video demonstrates the need of cluster-wide coordination.</p></td></tr><tr><td style='padding: 15px;'><p>2. RAFT Consensus Algorithm</p><p style='margin: 0'>This video explains the RAFT consensus algorithm.</p></td></tr><tr><td style='padding: 15px;'><p>3. Short Introduction to ETCD</p><p style='margin: 0'>This video provides a short introduction to ETCD.</p></td></tr><tr><td style='padding: 15px;'><p>4. Implementation of Distributed Mutex</p><p style='margin: 0'>This video provides an implementation of distributed mutex.</p></td></tr><tr><td style='padding: 15px;'><p>5. Leader Election Design Pattern</p><p style='margin: 0'>This video explains the leader election design pattern.</p></td></tr><tr><td style='padding: 15px;'><p>6. Deployment Requirements for Strongly Consistent Distributed Systems</p><p style='margin: 0'>This video talks about the deployment requirements for strongly consistent distributed systems.</p></td></tr><tr><td style='padding: 15px;'><p>7. ACID Properties in Distributed System</p><p style='margin: 0'>This video demonstrates the ACID properties in distributed system.</p></td></tr><tr><td style='padding: 15px;'><p>8. Practice 4</p><p style='margin: 0'>This is the fourth practice video that shows how to introduce cluster coordination into Tiny-URL application.</p></td></tr></tbody></table><br><h4>5. Distributed Messaging Systems</h4><p></p><table width='100%'><tbody><tr><td style='padding: 15px;'><p>1. Asynchronous Communication Pattern and Message-Oriented Middleware</p><p style='margin: 0'>This video talks about the asynchronous communication pattern and message-oriented middleware.</p></td></tr><tr><td style='padding: 15px;'><p>2. Short Introduction to Apache Kafka</p><p style='margin: 0'>This video provides a short introduction to Apache Kafka.</p></td></tr><tr><td style='padding: 15px;'><p>3. Apache Kafka as a Distributed System</p><p style='margin: 0'>This video explains how Apache Kafka acts as a distributed system.</p></td></tr><tr><td style='padding: 15px;'><p>4. Event-Driven Architecture</p><p style='margin: 0'>This video talks about Event-Driven architecture.</p></td></tr><tr><td style='padding: 15px;'><p>5. Practice 5</p><p style='margin: 0'>This is the fifth practice video that focuses on the usage of distributed messaging systems.</p></td></tr></tbody></table>

This course brings together all the important topics related to modern distributed applications and systems in one place. Explore the common challenges that appear while designing and implementing large-scale distributed systems, and how big-tech companies solve those problems. Throughout the course, we are going to build a distributed URL shortening service.
A significant percentage of large-scale enterprises experience performance issues with their business-critical applications. Most of the production systems have been built on top of legacy, monolith technologies. The recent popularity of micro-services will not fulfill its promise of decoupled, scalable, and fault-tolerant systems, unless 'done right'. While entering the world of micro-services, engineers start building distributed applications, where robust remote procedure calls and cluster coordination are a must. You will look at various technologies, algorithms, and design patterns here. Some of them are Service Registry and Discovery, Service Mesh, Apache Cassandra ETCD (coordinator managing Kubernetes clusters), Apache Kafka, Idempotent service design, retry logic, Sharding, and Consistent Hashing, Client-side Load Balancing, Distributed Tracing, Canary Deployment, Sidecar Pattern, Circuit Breaker, and many more. Finally, you will also see the principles of various distributed systems designs; for example, master-less versus with leaders, poll-based versus push-based, immediate versus eventual consistency. After completing the course, learning new distributed database technology would be easier, because you will know the commonly reused techniques, including their pros and cons. All the resource files are available on the GitHub repository at https://github.com/PacktPublishing/Building-Modern-Distributed-Systems-with-Java
What You Will Learn
Look at the concepts of distributed systems
Understand synchronous and asynchronous communication patterns
Study service meshes and Idempotent service design
Differentiate between traditional RDBMS systems and NoSQL
Learn deployment requirements for strongly consistent distributed systems
Build distributed URL-shortening services like Tiny-URL
Audience
This course is designed for Java developers and architects who wish to broaden their knowledge of distributed computing, NoSQL databases, efficient RPC calls, messaging middleware, and cluster coordination. It is also recommended for anyone working in modern IT landscapes. The course may be a good recap for people preparing for systems design interviews.

You will need proficiency in Java programming language, and an open mind to discover the challenges of distributed computing. Beginner-level knowledge in the Spring Boot framework will help you get along with the course easily.
Approach
The course is short yet complete with content delivered with a very practical approach. There are a lot of code examples and applied best practices to follow along at the end of every section. The author will cover Service Registry and Discovery in detail so that you will know how to implement your own framework on top of ETCD. Throughout the course, you will build a distributed URL shortening service.
Key Features
Design and implement globally distributed, scalable, fault-tolerant, and resilience applications * Understanding of common algorithms and techniques used in the majority of NoSQL databases and streaming platforms * In-depth knowledge of Apache Cassandra, Apache Kafka, and ETCD
Github Repo
https://github.com/PacktPublishing/Building-Modern-Distributed-Systems-with-Java
About the Author
Lukasz Antoniak
Lukasz Antoniak is an IT architect who designed and implemented robust back-end systems. After falling in love with Apache Cassandra, his focus shifted toward big data technologies, microservice architecture, NoSQL databases, and distributed message brokers. He is contributing as a committer to various open-source projects, including Hibernate ORM and Apache Bahir (extensions to Apache Spark). He worked for a few years on the distributed core banking platform for a major European bank. He has also worked previously for big-tech companies such as Oracle, IBM, HP, and TIBCO. In his spare time, he enjoys sailing and photography.
Course Outline
1. Concepts of Distributed Systems

1. Evolution of Computer Systems' Architecture
This video talks about the evolution of computer systems' architecture.
2. Challenges of Distributed Compounding
This video demonstrates the challenges of Distributed Compounding.
3. Use-Case of Course Application
This video demonstrates the use-case of course application.
4. Practice 1
This is the first practice video that focuses on the environment setup for Tiny-URL project.
2. Remote Procedure Call

1. The Need of Communication
This video explains the need of communication.
2. Message Transport and Format
This video explains the Message transport and format.
3. Synchronous and Asynchronous Communication Patterns
This video demonstrates the synchronous and asynchronous communication patterns.
4. Traditional Load Balancers
This video explains the traditional load balancers.
5. Service Registry and Discovery
This video explains about the Service Registry and Discovery.
6. Service Meshes
This video demonstrates the Service Meshes.
7. Idempotent Service Design
This video talks about Idempotent service design.
8. Practice 2
This is the second practice video that focuses on the resilient RPC (Remote Procedure Call) configuration and service discovery technology.
3. Distributed Databases

1. Traditional RDBMS Systems Versus NoSQL
This video differentiates between the traditional RDBMS systems and NoSQL.
2. Data Sharding and Consistent Hashing
This video talks about Data Sharding and Consistent Hashing.
3. CAP theorem
This video explains the CAP theorem.
4. Short Introduction to Apache Cassandra
This video provides a short Introduction to Apache Cassandra.
5. Practice 3
This is the third practice video that focuses on the distributed database and usage of Apache Cassandra in Tiny-URL project.
4. Cluster Coordination

1. The Need of Cluster-Wide Coordination
This video demonstrates the need of cluster-wide coordination.
2. RAFT Consensus Algorithm
This video explains the RAFT consensus algorithm.
3. Short Introduction to ETCD
This video provides a short introduction to ETCD.
4. Implementation of Distributed Mutex
This video provides an implementation of distributed mutex.
5. Leader Election Design Pattern
This video explains the leader election design pattern.
6. Deployment Requirements for Strongly Consistent Distributed Systems
This video talks about the deployment requirements for strongly consistent distributed systems.
7. ACID Properties in Distributed System
This video demonstrates the ACID properties in distributed system.
8. Practice 4
This is the fourth practice video that shows how to introduce cluster coordination into Tiny-URL application.
5. Distributed Messaging Systems

1. Asynchronous Communication Pattern and Message-Oriented Middleware
This video talks about the asynchronous communication pattern and message-oriented middleware.
2. Short Introduction to Apache Kafka
This video provides a short introduction to Apache Kafka.
3. Apache Kafka as a Distributed System
This video explains how Apache Kafka acts as a distributed system.
4. Event-Driven Architecture
This video talks about Event-Driven architecture.
5. Practice 5
This is the fifth practice video that focuses on the usage of distributed messaging systems.

This course brings together all the important topics related to modern distributed applications and systems in one place. Explore the common challenges that appear while designing and implementing large-scale distributed systems, and how big-tech companies solve those problems. Throughout the course, we are going to build a distributed URL shortening service.

Building Modern Distributed Systems with Java

<strong>In this course, you will learn to create Kafka Streams microservices using the Spring cloud framework. This is an example-driven course, and you will learn to use Confluent Kafka distribution for all the examples. By the end of this course, you will learn to create Kafka Streams microservices using different types of serializations, Confluent schema registry, and creating stateless and stateful event processing applications.</strong>
        <p>Kafka Streams with Spring Cloud Streams will help you understand stream processing in general and apply it to Kafka Streams Programming using Spring Boot.

This course uses the Kafka Streams library compatible with Spring Cloud 2020. All the source code and examples used in this course have been tested by the author on Confluent Platform 6.0.0, which is compatible with Apache Kafka 2.6 open-source distribution.

This is a fully example-driven course, and you will be working with multiple examples during the entire session. We will be making extensive use of IntelliJ IDEA as the preferred development IDE and Apache Maven and Gradle as the preferred build tool. However, based on your prior experience, you should be able to work with any other IDE designed for Spring application development and any other build tool designed for Java applications.

This course also makes use of Log4J2 to teach you industry-standard log implementation in your application. We will be using JUnit5, which is the latest version of JUnit, to implement unit test cases.
Working examples and exercises are the most critical tool to sharpen your skills. This course consists of some programming assignments as and when appropriate. These exercises will help you validate and check your concepts and apply your learning to solve programming problems.
The code bundles for this course is available in https://github.com/PacktPublishing/Kafka-Streams-with-Spring-Cloud-Stream</p>
        <h2>What You Will Learn</h2><p>Designing, developing, and testing stream processing applications<br>Kafka Streams binder implementation for Spring cloud streams<br>Working with JSON, AVRO, and other custom serializations<br>Spring cloud streams and Kafka Streams architecture<br>Kafka Streams DSL and programming with Kafka Streams API<br>Unit-testing Kafka Streams application</p>
        <h2>Audience</h2><p>Kafka Streams with Spring Cloud Streams is designed for software engineers willing to develop a stream processing application using the Kafka Streams library and Spring Boot. This course has also been created for data architects and data engineers responsible for designing and building the organization's data-centric infrastructure. Another group of people is the managers and architects who do not directly work with Kafka implementation, but they work with the people who implement Kafka Streams at the ground level.</p>
        <h2>Approach</h2><p>Throughout the course, the author uses a unique progressive common-sense approach to teaching a complex subject. It is an interactive learning experience with working examples and exercises to convert your knowledge into a skill.</p>
        <h2>Key Features</h2><p>Explore Kafka Streams with JSON, AVRO, and other custom serialization * Learn Kafka architecture and programming with Kafka Streams API * Understand how to build applications using Spring Boot with streaming data</p>
        <h2>Github Repo</h2><p>https://github.com/PacktPublishing/Kafka-Streams-with-Spring-Cloud-Stream</p>
        <h2>About the Author</h2><h3>Prashant Kumar Pandey</h3><p>Prashant Kumar Pandey is passionate about helping people learn and grow in their careers by bridging the gap between their existing and required skills. In his journey to fulfill this mission, he is authoring books, publishing technical articles, and creating training videos to help IT professionals and students succeed in the industry. He is also the founder, lead author, and chief editor of the Learning Journal portal that has been providing various skill development courses, training sessions, and technical articles since 2018.</p>
        <h2>Course Outline</h2><h4>1. Before You Begin</h4><p></p><br><h4>2. Environment Setup on Window 10 Machine</h4><p></p><br><h4>3. Environment Setup on Mac Machine</h4><p></p><br><h4>4. Understanding the Technology Stack</h4><p></p><br><h4>5. Producing Data to Kafka</h4><p></p><br><h4>6. Processing Kafka Streams</h4><p></p><br><h4>7. Working with KStream</h4><p></p><br><h4>8. KTable and Aggregations</h4><p></p><br><h4>9. Timestamp and Windowing Aggregates</h4><p></p><br><h4>10. Joins in Kafka Streams</h4><p></p><br><h4>11. Kafka Streams in Functional Style and Unit Testing</h4><p></p><br><h4>12. Keep Learning</h4><p></p>

In this course, you will learn to create Kafka Streams microservices using the Spring cloud framework. This is an example-driven course, and you will learn to use Confluent Kafka distribution for all the examples. By the end of this course, you will learn to create Kafka Streams microservices using different types of serializations, Confluent schema registry, and creating stateless and stateful event processing applications.
Kafka Streams with Spring Cloud Streams will help you understand stream processing in general and apply it to Kafka Streams Programming using Spring Boot. This course uses the Kafka Streams library compatible with Spring Cloud 2020. All the source code and examples used in this course have been tested by the author on Confluent Platform 6.0.0, which is compatible with Apache Kafka 2.6 open-source distribution. This is a fully example-driven course, and you will be working with multiple examples during the entire session. We will be making extensive use of IntelliJ IDEA as the preferred development IDE and Apache Maven and Gradle as the preferred build tool. However, based on your prior experience, you should be able to work with any other IDE designed for Spring application development and any other build tool designed for Java applications. This course also makes use of Log4J2 to teach you industry-standard log implementation in your application. We will be using JUnit5, which is the latest version of JUnit, to implement unit test cases.
Working examples and exercises are the most critical tool to sharpen your skills. This course consists of some programming assignments as and when appropriate. These exercises will help you validate and check your concepts and apply your learning to solve programming problems.
The code bundles for this course is available in https://github.com/PacktPublishing/Kafka-Streams-with-Spring-Cloud-Stream
What You Will Learn
Designing, developing, and testing stream processing applications
Kafka Streams binder implementation for Spring cloud streams
Working with JSON, AVRO, and other custom serializations
Spring cloud streams and Kafka Streams architecture
Kafka Streams DSL and programming with Kafka Streams API
Unit-testing Kafka Streams application
Audience
Kafka Streams with Spring Cloud Streams is designed for software engineers willing to develop a stream processing application using the Kafka Streams library and Spring Boot. This course has also been created for data architects and data engineers responsible for designing and building the organization's data-centric infrastructure. Another group of people is the managers and architects who do not directly work with Kafka implementation, but they work with the people who implement Kafka Streams at the ground level.
Approach
Throughout the course, the author uses a unique progressive common-sense approach to teaching a complex subject. It is an interactive learning experience with working examples and exercises to convert your knowledge into a skill.
Key Features
Explore Kafka Streams with JSON, AVRO, and other custom serialization * Learn Kafka architecture and programming with Kafka Streams API * Understand how to build applications using Spring Boot with streaming data
Github Repo
https://github.com/PacktPublishing/Kafka-Streams-with-Spring-Cloud-Stream
About the Author
Prashant Kumar Pandey
Prashant Kumar Pandey is passionate about helping people learn and grow in their careers by bridging the gap between their existing and required skills. In his journey to fulfill this mission, he is authoring books, publishing technical articles, and creating training videos to help IT professionals and students succeed in the industry. He is also the founder, lead author, and chief editor of the Learning Journal portal that has been providing various skill development courses, training sessions, and technical articles since 2018.
Course Outline
1. Before You Begin

2. Environment Setup on Window 10 Machine

3. Environment Setup on Mac Machine

4. Understanding the Technology Stack

5. Producing Data to Kafka

6. Processing Kafka Streams

7. Working with KStream

8. KTable and Aggregations

9. Timestamp and Windowing Aggregates

10. Joins in Kafka Streams

11. Kafka Streams in Functional Style and Unit Testing

12. Keep Learning


Web Development

In this course, you will learn to create Kafka Streams microservices using the Spring cloud framework. This is an example-driven course, and you will learn to use Confluent Kafka distribution for all the examples. By the end of this course, you will learn to create Kafka Streams microservices using different types of serializations, Confluent schema registry, and creating stateless and stateful event processing applications.

Educators providing Apache Kafka courses in London delivered Online