Mô tả

**  Reactive Kafka Mastery: Building Real-Time Data Processing Applications **

This comprehensive course is designed specifically for senior and staff level engineers who are eager to learn Reactive Kafka from scratch. By the end of the course, you will gain a high level of comfort and proficiency in working with Kafka.


Course Content:


  1. Apache Kafka Fundamentals:

    • Setting up Kafka in the latest KRaft mode using custom Docker images

    • Bootstrap server configuration

    • Kafka topic commands and options

    • Console producer and consumer usage

    • Understanding Kafka properties and their impact

    • Message publishing and consumption in Kafka

    • Serialization and deserialization mechanisms in Kafka

    • Kafka log retention and management

    • Offset concepts and resetting offset to consume messages from a specific time

    • Message formatting in Kafka

    • Scaling applications using Kafka consumer groups

    • Ensuring message ordering in Kafka

  2. Kafka With Reactive Programming

    • Developing Java Kafka producer and consumer applications using reactive programming

    • Exploring various producer and consumer configurations

    • Auto offset reset mechanisms

    • Message acknowledgment techniques

    • Testing performance by emitting millions of events

    • Seeking offsets for specific message retrieval

    • Partition assignment strategies (cooperative sticky assignor and range assignor)

  3. Kafka Cluster

    • Understanding the working of a Kafka cluster

    • Setting up a Kafka cluster using Docker Compose

    • Demonstrating fault tolerance in a Kafka cluster and its impact on producer and consumer applications

  4. Best Practices

    • Implementing producer acknowledgment for message reliability

    • Configuring minimum in-sync replicas

    • Creating idempotent producers and consumers to handle duplicate messages

    • Compression techniques for message size reduction and improved throughput

  5. Addressing Common Questions:

    • Determining the optimal number of topics, partitions, and replicas

    • Batch and parallel processing of messages for better CPU utilization

    • Error handling strategies, including retry mechanisms, dead letter topics, and poison pill messages

  6. Batch and Parallel Processing:

    • Efficiently consuming messages in parallel while maintaining proper order and utilizing available CPUs

  7. Error Handling:

    • Implementing retry mechanisms for handling errors in message processing

    • Dead letter topics for capturing and handling failed messages

    • Poison pill messages and their role in error handling

  8. Kafka Transaction:

    • Producing and consuming messages in transactional mode (similar to database transactions)

  9. Integration Tests:

    • Developing integration tests using Embedded Kafka

  10. Kafka Security:

    • Implementing security measures with plain credentials and SSL encryption

  11. Assignment

    • Applying the learned concepts to develop microservices that communicate via Kafka topics to analyze user behaviors and provide business metrics on product trending

Join this course and unlock the full potential of Apache Kafka while mastering reactive programming techniques, batch processing, parallel processing, and effective error handling strategies.

Bạn sẽ học được gì

Learn Kafka From Scratch

Spring Kafka - Event Driven Microservices

Batch & Parallel Processing

Kafka Transaction

Writing Integration Tests

Best Practices

Yêu cầu

  • Java Reactive Programming
  • Spring
  • Comfortable with Indian Accent

Nội dung khoá học

14 sections

Introduction

3 lectures
Introduction
02:17
Need For Event Driven Architecture / Kafka
08:03
Humble Request & Resources
00:25

Kafka Setup

3 lectures
Introduction
05:26
Custom Docker Image
05:37
Docker Compose Setup
05:49

Kafka Crash Course

32 lectures
Introduction
03:22
Cluster
06:12
Bootstrap Server
03:22
Topic Command
05:43
Exploring Data Directory
02:30
Documenting Commands
01:23
Console Producer
02:39
Console Consumer
02:38
Producer & Consumer Side By Side
03:50
[Properties] linger.ms vs batch.size
03:10
Consumer Push vs Pull
03:15
Serialization vs Deserialization
01:38
[Properties] Log Retention
01:19
Offset
03:41
Message Timestamp
01:13
2 Consumers Demo
03:22
Consumer Group
03:32
Consumer Group - Demo
05:27
Need For Message Ordering
02:50
Partition & Key
07:33
Who is calculating the Partition?
01:30
Topic With 2 Partitions
03:37
Consumer Group Demo with Partitions - Part 1
04:53
Consumer Group Demo with Partitions - Part 2
03:40
Consumer Group Scaling - Scenarios
06:17
Consumer Group - LAG
05:58
Multiple Consumer Group - LAG
01:40
Resetting Offset
03:06
Resetting Offset - Demo
08:14
Message Format
02:41
Summary
05:47
Quiz
6 questions

Reactor Kafka

26 lectures
Maven Dependencies
00:14
Project Setup
03:06
Consumer Config
09:59
Creating Kafka Receiver
04:24
Kafka Receiver Demo
03:21
Auto Offset Reset
03:31
Session Timeout Config
04:36
Acknowledging Message
07:17
Enabling Auto Commit
01:22
Will Messages Be Redelivered?
01:35
Out Of Order Commit
01:58
Consume From Multiple Topics
03:50
Kafka Producer Config
03:52
Creating Sender Record
06:48
Kafka Producer Demo
00:53
Sender Close
02:26
Receiver Close
00:38
Emitting 1 Million Events
04:34
Max In Flight
04:21
Message Headers
06:13
Consumer Group Demo - Part 1
04:04
Consumer Group Demo - Part 2
05:42
Cooperative Sticky Assignor
05:20
Range Assignor
01:53
Seeking Offset
06:40
Summary
00:50

Kafka Cluster

6 lectures
Introduction
04:54
Quick Note On Listeners
02:05
Cluster Properties
13:14
Cluster Demo
06:01
Kafka Fault Tolerance Demo
07:29
Summary
00:53

Best Practices

10 lectures
Producer acks
06:01
min.insync.replica
03:26
Idempotent Producer
03:30
Producing Duplicate Messages
01:39
Idempotent Consumer
03:39
Compression
03:31
How Many Topics Should I Create?
02:02
How Many Partitions Should I Create?
04:17
How Many Replication Factor Should I Have?
02:19
Summary
03:06

Batch / Parallel Processing

8 lectures
Introduction
03:10
Batch - Receiver Auto Ack / concatMap
07:43
Parallel - flatMap
03:19
Schedulers with FlatMap
01:20
Message Ordering Issue With FlatMap
04:11
GroupedFlux - Parallel and Message Ordering - Part 1
04:24
GroupedFlux - Parallel and Message Ordering - Part 2
05:01
Summary
01:20

Error Handling

17 lectures
Introduction
04:00
Simple Retry
03:23
Separating Receiver & Processor - Theory
03:08
Separating Receiver & Processor - Implementation - Part 1
05:41
Separating Receiver & Processor - Implementation - Part 2
03:20
Separating Receiver & Processor - Implementation - Part 3
01:52
Retry Depending On Error
08:37
Dead Letter Topic - Introduction
04:12
Reactive Dead Letter Topic Producer - Part 1
06:42
Reactive Dead Letter Topic Producer - Part 2
06:48
Order Event Processor
04:33
Code Cleanup
04:04
Dead Letter Topic Demo
05:17
Poison Pill Messages
05:54
Poison Pill Messages - Fix
06:04
Error Handling At Producer Side
06:11
Summary
03:21

Kafka Transaction

14 lectures
Introduction
04:31
Demo App Walkthrough
01:42
Transfer Event Consumer
06:38
Transfer Event Processor - Part 1
06:47
Transfer Event Processor - Part 2
07:33
Transfer Config
04:21
Adding Delay
00:43
Kafka Commands
02:48
Kafka Transaction Demo
07:29
How Kafka Transaction Works
07:46
read_committed vs read_uncommitted
00:48
Send Transactionally
01:25
Producer Fenced Exception
03:05
Delivery Semantics
03:41

Reactive Kafka With Spring

10 lectures
Introduction
06:53
Simple Spring Kafka Consumer
02:41
Order Event DTO
03:46
Spring Kafka Producer Config
06:12
Order Event Decoding Issue
01:23
Importance Of Type ID
03:30
Order Event Demo
02:04
Printing Type ID Header
02:38
Decoding As Custom Object
04:05
Summary
04:40

Integration Testing

12 lectures
Introduction
01:01
Embedded Kafka Test
06:40
Embedded Kafka Demo
04:04
Embedded Kafka Random Port
03:06
Project Restructure
03:19
Abstract Integration Test - Utilities - Part 1
05:05
Abstract Integration Test - Utilities - Part 2
02:57
OrderEventProducer - Test
05:53
OrderEventProducer - Demo
02:44
@DirtiesContext
03:12
Creating Sender Util
04:32
OrderEventConsumer - Demo
07:23

*** ASSIGNMENT ***

16 lectures
Introduction
07:02
R2DBC - Persistable Interface
03:09
** ASSIGNMENT **
01:40
[ASSIGNMENT SOLUTION] - Product Service Setup
03:58
[ASSIGNMENT SOLUTION] - Product Service - Implementation - Part 1
08:47
[ASSIGNMENT SOLUTION] - Product Service - Implementation - Part 2
03:48
[ASSIGNMENT SOLUTION] - Product Service - Integration Test - Part 1
07:46
[ASSIGNMENT SOLUTION] - Product Service - Integration Test - Part 2
03:33
[ASSIGNMENT SOLUTION] - Analytics Service - Setup
04:24
[ASSIGNMENT SOLUTION] - Analytics Service - Implementation - Part 1
05:47
[ASSIGNMENT SOLUTION] - Analytics Service - Implementation - Part 2
12:24
[ASSIGNMENT SOLUTION] - Analytics Service - Implementation - Part 3
07:26
[ASSIGNMENT SOLUTION] - Analytics Service - Integration Test - Part 1
06:57
[ASSIGNMENT SOLUTION] - Analytics Service - Integration Test - Part 2
07:06
Final Demo
07:42
Final Demo With Companion Flux
04:56

Kafka Security

5 lectures
Introduction
09:25
App With Kafka Credentials
06:44
SSL Introduction
04:03
Kafka SSL
05:38
Kafka SSL Demo
03:43

What's Next?

2 lectures
Event Driven Architecture & Saga Pattern
00:08
What's Next
08:51

Đánh giá của học viên

Chưa có đánh giá
Course Rating
5
0%
4
0%
3
0%
2
0%
1
0%

Bình luận khách hàng

Viết Bình Luận

Bạn đánh giá khoá học này thế nào?

image

Đăng ký get khoá học Udemy - Unica - Gitiho giá chỉ 50k!

Get khoá học giá rẻ ngay trước khi bị fix.