HOT
blank

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

Development

Rating4.5
Enroll Now

Apache Kafka – Real-time Stream Processing (Master Class), available at $89.99, has an average rating of 4.52, with 78 lectures, based on 2461 reviews, and has 17700 subscribers.

You will learn about Apache Kafka Foundation and Kafka Architecture Creating Streams using Kafka Producer APIs Designing, Developing and Testing Real-time Stream Processing Applications using Kafka Streams Library Kafka Streams Architecture, Streams DSL, Processor API and Exactly Once Processing in Apache Kafka Auto-generating Java Objects from JSON Schema definition, Serializing, Deserializing and working with JSON messages without Schema Registry. Auto-generating Java Objects from AVRO Schema definition, Serializing, Deserializing and working with AVRO messages using Confluent Schema Registry. Unit Testing and Integration Testing your Kafka Streams Application. Supporting Microservices architecture and implementing Kafka Streams Interactive Query. This course is ideal for individuals who are Software Engineers and Architects who are willing to design and develop a Stream Processing Application using Kafka Streams Library. or Java Programmers aspiring to learn everything necessary to start implementing real-time streaming applications using Apache Kafka It is particularly useful for Software Engineers and Architects who are willing to design and develop a Stream Processing Application using Kafka Streams Library. or Java Programmers aspiring to learn everything necessary to start implementing real-time streaming applications using Apache Kafka.

Enroll now: Apache Kafka – Real-time Stream Processing (Master Class)

Summary

Title: Apache Kafka – Real-time Stream Processing (Master Class)

Price: $89.99

Average Rating: 4.52

Number of Lectures: 78

Number of Published Lectures: 78

Number of Curriculum Items: 78

Number of Published Curriculum Objects: 78

Original Price: $19.99

Quality Status: approved

Status: Live

What You Will Learn

  • Apache Kafka Foundation and Kafka Architecture
  • Creating Streams using Kafka Producer APIs
  • Designing, Developing and Testing Real-time Stream Processing Applications using Kafka Streams Library
  • Kafka Streams Architecture, Streams DSL, Processor API and Exactly Once Processing in Apache Kafka
  • Auto-generating Java Objects from JSON Schema definition, Serializing, Deserializing and working with JSON messages without Schema Registry.
  • Auto-generating Java Objects from AVRO Schema definition, Serializing, Deserializing and working with AVRO messages using Confluent Schema Registry.
  • Unit Testing and Integration Testing your Kafka Streams Application.
  • Supporting Microservices architecture and implementing Kafka Streams Interactive Query.

Who Should Attend

  • Software Engineers and Architects who are willing to design and develop a Stream Processing Application using Kafka Streams Library.
  • Java Programmers aspiring to learn everything necessary to start implementing real-time streaming applications using Apache Kafka

Target Audiences

  • Software Engineers and Architects who are willing to design and develop a Stream Processing Application using Kafka Streams Library.
  • Java Programmers aspiring to learn everything necessary to start implementing real-time streaming applications using Apache Kafka

This course does not require any prior knowledge of Apache Kafka. We have taken enough care to explain all necessary and complex Kafka Architecture concepts to help you come up to speed and grasp the content of this course.

About the Course

I am creating Kafka Streams – Real-time Stream Processing to help you understand the stream processing in general and apply that knowledge to Kafka Streams Programming. This course is based on my bookon the same subject with the same title. My Book is already published and is available with all major online retailers as an eBook and Paperback.

My approach to creating this course is a progressive common-sense approach to teaching a complex subject. By using this unique approach, I will help you to apply your general ability to perceive, understand, and reason the concepts progressively that I am explaining in this course.

Who should take this Course?

Kafka Streams – Real-time Stream Processingcourse is designed for software engineers willing to develop a stream processing application using the Kafka Streams library. I am also creating this course for data architects and data engineers who are 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.

Kafka Version used in the Course

This course is using the Kafka Streams library available in Apache Kafka 2.x. I have tested all the source code and examples used in this course on Apache Kafka 2.3 open source distribution. Some examples of this course also make use of the Confluent Community Version of Kafka. We will be using Confluent Community Version to explain and demonstrate functionalities that are only available in the Confluent Platform, such as Schema Registry and Avro Serdes.

Source Code, Development IDE, Build Tool, Logging, and Testing Tools

This course is fully example-driven, and I will be creating many examples in the class. The source code files for all the examples are included in your study material.

This course will be making extensive use of IntelliJ IDEAas 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.

This course will be using Apache Maven as the preferred build tool. However, based on your prior experience, you should be able to use 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 for implementing Unit Test Cases.

Example and Exercises

Working examples and exercises are the most critical tool to convert your knowledge into a skill. I have already included a lot of examples in the course. This course also consists of objective questions and some programming assignments as and when appropriate. These exercises will help you to validate and check your concepts and apply your learning to solve programming problems.

Course Curriculum

Chapter 1: Before you Start

Lecture 1: Introduction

Lecture 2: About the Course

Lecture 3: About the Author

Lecture 4: What do you Need for this Course?

Lecture 5: Debugging Problems and Asking Questions

Lecture 6: Frequently Asked Questions

Lecture 7: Source Code and Other Resources

Chapter 2: Introduction to Real-time Streams

Lecture 1: Emergence of Bigdata – A Quick Recap

Lecture 2: Conception of Event Streams

Lecture 3: Real-time Streaming – Use Cases

Lecture 4: Real-time Streaming Challenges

Lecture 5: Real-time Streaming Design Consideration

Lecture 6: Section Summary

Chapter 3: Enter the world of Apache Kafka

Lecture 1: What is Apache Kafka?

Lecture 2: Kafka Storage Architecture

Lecture 3: Kafka Cluster Architecture

Lecture 4: Kafka Work Distribution Architecture – Part 1

Lecture 5: Kafka Work Distribution Architecture – Part 2

Lecture 6: Section Summary

Chapter 4: Creating Real-time Streams

Lecture 1: Streaming into Kafka

Lecture 2: Kafka Producers – Quick Start

Lecture 3: Kafka Producer Internals

Lecture 4: Scaling Kafka Producer

Lecture 5: Advanced Kafka Producers (Exactly Once)

Lecture 6: Advanced Kafka Producer (Implementing Transaction)

Lecture 7: Kafka Producer – Micro Project

Lecture 8: Kafka Producer – Final Note and References

Chapter 5: Enter the Stream Processing

Lecture 1: Stream Processing in Apache Kafka

Lecture 2: Kafka Consumer – Practical Introduction

Lecture 3: Kafka Consumer – Scalability, Fault tolerance and Missing Features

Lecture 4: Kafka Streams API – Quick Start

Lecture 5: Creating Streams Topology

Lecture 6: Implementing Streams Topology

Lecture 7: Kafka Streams Architecture

Lecture 8: Section Summary and References

Chapter 6: Foundation for Real Life Project Implementations

Lecture 1: Introduction to Types and Serialization in Kafka

Lecture 2: JSON Schema to POJO for JSON Serdes

Lecture 3: Creating and Using JSON Serdes

Lecture 4: AVRO Schema to POJO for AVRO Serdes

Lecture 5: Creating and using AVRO schema in Producers

Lecture 6: Creating and using AVRO schema in Kafka Streams

Lecture 7: Section Summary and References

Chapter 7: States and Stores

Lecture 1: Understanding States and State Stores

Lecture 2: Creating your First State Store

Lecture 3: Caution with States

Lecture 4: State Store Fault Tolerance

Lecture 5: Section Summary and References

Chapter 8: KTable – An Update Stream

Lecture 1: Introducing KTable

Lecture 2: Creating your First Update Stream – KTable

Lecture 3: Table Caching and Emit Rates

Lecture 4: Introducing GlobalKTable

Chapter 9: Real-time Aggregates

Lecture 1: Computing Your First Aggregate – Real-time Streaming Word Count

Lecture 2: Streaming Aggregates – Core Concept

Lecture 3: KStream Aggregation using Reduce()

Lecture 4: KStream Aggregation using Aggregate()

Lecture 5: Common Mistakes in Aggregation

Lecture 6: Count on KTable

Lecture 7: KTable Aggregation using Aggregate()

Chapter 10: Timestamps and Windows

Lecture 1: Timestamps and Timestamp Extractors

Lecture 2: Creating Tumbling Windows

Lecture 3: Stream Time and Grace Period

Lecture 4: Suppressing Intermediate Results

Lecture 5: Creating Hopping Windows

Lecture 6: Creating Session Windows

Chapter 11: Joining Streams and Tables

Lecture 1: Streaming Joins

Lecture 2: Joining a KStrem to another KStream

Lecture 3: Joining a KTable to another KTable

Lecture 4: Joining a KStream to a KTable and GlobalKTable

Lecture 5: Mixing Joins with Aggregates – Computing Top 3

Lecture 6: Mixing Joins with Aggregates – Advert CTR

Chapter 12: Testing Streams Application

Lecture 1: How to test a Stream Processing Application

Lecture 2: Unit Testing Your Topology

Chapter 13: Interactive Query and Micro-Service Responses in Kafka

Lecture 1: Introducing Micro-services Requirement

Lecture 2: Understanding Local Vs Remote State Store

Lecture 3: Implementing Interactive Query Micro-service in Kafka

Chapter 14: Appendix

Lecture 1: Setting up Apache Kafka Development Environment

Chapter 15: Keep Learning

Lecture 1: Final Word

Lecture 2: Bonus Lecture : Get Extra

Instructors

Rating Distribution

  • 1 stars: 18 votes
  • 2 stars: 25 votes
  • 3 stars: 169 votes
  • 4 stars: 786 votes
  • 5 stars: 1463 votes

Frequently Asked Questions


How long do I have access to the course materials?


You can view and review the lecture materials indefinitely, like an on-demand channel.


Can I take my courses with me wherever I go?


Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!

You may also like

Top 10 Ethical AI Courses to Learn in November 2024

Top 10 Game Development Courses to Learn in November 2024

Top 10 Software Testing Courses to Learn in November 2024