Loading audiobook...

Strimzi: Apache Kafka on Kubernetes — Comprehensive Curriculum

Subject: Strimzi: Apache Kafka on Kubernetes — Comprehensive Curriculum

62 chapters

1. 1 Kubernetes Refresher

[Verse 1]
Pods are the atomic units, smallest things that run
Containers wrapped in metadata, workloads have begun
Deployments manage replicas, rolling updates clean
StatefulSets keep order when persistence must be seen
Services route the traffic through selectors they define
Cluster IP or NodePort, LoadBalancer's divine

[Chorus]
Kube foundations, storage nations
Pods Deploy State Serve remember
ConfigMaps and Secrets guard the data
RBAC locks it down, Helm spins it round
Operators watch and CRDs extend the ground

[Verse 2]
Persistent Volumes claim the disk, StorageClass decides
Dynamic provisioning kicks in when your app provides
The volumeClaimTemplate, retention policies set
What happens to your data when the pods are met
With termination signals and the workload disappears
Storage outlives the lifecycle through the cluster years

[Chorus]
Kube foundations, storage nations
Pods Deploy State Serve remember
ConfigMaps and Secrets guard the data
RBAC locks it down, Helm spins it round
Operators watch and CRDs extend the ground

[Verse 3]
ConfigMaps hold the settings, environment in text
Secrets base64 encoded, sensitive context
ServiceAccounts authenticate, RBAC controls the flow
ClusterRoles and RoleBindings dictate what pods can know
NetworkPolicies firewall, ingress and egress rules
Kubernetes becomes your distributed computing tools

[Bridge]
Helm templates package everything you need
Charts and values, dependencies feed
Kustomize patches without the template weight
Operators reconcile the custom resource state
CRDs extend the API, new types you create
Controllers watch the cluster, keeping desired fate

[Chorus]
Kube foundations, storage nations
Pods Deploy State Serve remember
ConfigMaps and Secrets guard the data
RBAC locks it down, Helm spins it round
Operators watch and CRDs extend the ground

[Outro]
From Pod to Operator, the patterns interweave
Kubernetes orchestration, what distributed systems achieve

2. 2 Apache Kafka Fundamentals

[Verse 1]
Brokers scattered cross the cluster nodes
Topics split in partitions down the roads
Replicas mirror data, three by three
Leader writes while followers guarantee
ZooKeeper coordinates the cluster state
But KRaft consensus seals a modern fate

[Chorus]
Producers push, consumers pull the stream
Partitions parallel the data dream
Brokers, topics, replicas align
Kafka's architecture by design
Log compacted, segments retained
Distributed messaging unchained

[Verse 2]
Consumer groups balance partition load
Each member claims a different episode
Offsets mark where reading last occurred
Sequential processing, never blurred
Connect plugins bridge external stores
Streams transform what flows through data doors

[Chorus]
Producers push, consumers pull the stream
Partitions parallel the data dream
Brokers, topics, replicas align
Kafka's architecture by design
Log compacted, segments retained
distributed messaging unchained

[Bridge]
Schema Registry validates the shape
Serialized messages can't escape
Retention policies purge the old
While compaction keeps the keys we hold
Throughput climbs when durability bends
Latency waits where consistencyends

[Verse 3]
Segments roll when size limits break
Cleanup threads determine what to take
Acks configure how writes confirm
Zero, one, or all brokers affirm
KRaft eliminates the ZooKeeper layer
Metadata lives where partition players

[Chorus]
Producers push, consumers pull the stream
Partitions parallel the data dream
Brokers, topics, replicas align
Kafka's architecture by design
Log compacted, segments retained
Distributed messaging unchained

[Outro]
From producers to the final sink
Every message forms a data link
Kafka orchestrates the flowing tide
Where scalability and order collide

3. 3 Why Strimzi?

[Verse 1]
Kubernetes loves to spin up pods that vanish in the night
But Kafka needs its data persisted, volumes holding tight
StatefulSets promise order, numbered replicas aligned
While ephemeral containers clash with streaming's grand design

[Chorus]
Strimzi speaks the operator tongue
CNCF stamp, community strong
Custom resources dance with kubectl's hand
No more bare metal's scattered land

[Verse 2]
Confluent's operator costs dollars by the hour
Enterprise features locked behind their paywall tower
While bare metal Kafka sprawls across machines you own
But scaling up means SSH and scripts you've grown

[Chorus]
Strimzi speaks the operator tongue
CNCF stamp, community strong
Custom resources dance with kubectl's hand
No more bare metal's scattered land

[Bridge]
Declarative state describes your cluster's dream
Watch loops reconcile what is with what should gleam
Controllers monitor every broker's beating heart
Rolling updates orchestrate without falling apart

[Verse 3]
CNCF graduation proves the project's mature spine
Sandbox to incubating, then the graduation line
Vendor-neutral governance keeps corporate capture at bay
While GitHub issues welcome every developer's say

[Chorus]
Strimzi speaks the operator tongue
CNCF stamp, community strong
Custom resources dance with kubectl's hand
No more bare metal's scattered land

[Outro]
From stateful challenges to automated grace
Strimzi brings Apache streams to container space
Lifecycle management through the operator's eyes
Cloud-native Kafka finally flies

4. 1 Strimzi Operators

[Verse 1]
Deep in the cluster where containers spin
Strimzi deploys its guardian twins
Cluster Operator takes the helm
Managing Kafka's entire realm
ZooKeeper, Connect, and Bridge components
MirrorMaker flows in synchronized moments

[Chorus]
Three operators in the Kubernetes dance
Cluster, Entity, reconciliation's trance
Topic and User nested inside
Watching CRDs with vigilant eyes
Leader election keeps the peace
Custom resources never cease

[Verse 2]
Entity Operator holds a secret pair
Topic Operator manages with care
KafkaTopic CRDs declare the schema
User Operator weaves the ACL enigma
KafkaUser resources authenticate and authorize
Permissions flowing where security lies

[Chorus]
Three operators in the Kubernetes dance
Cluster, Entity, reconciliation's trance
Topic and User nested inside
Watching CRDs with vigilant eyes
Leader election keeps the peace
Custom resources never cease

[Bridge]
Reconciliation loops spin endlessly round
Desired state versus what is found
Controllers observe the delta difference
Applying changes with persistent persistence
One leader emerges when multiples compete
Election algorithms make the heartbeat complete

[Verse 3]
Cluster Operator orchestrates the symphony
Kafka brokers humming in perfect harmony
Entity splits the workload clean
Topic management and user routine
Custom Resource Definitions paint the blueprint
While operators execute each fingerprint

[Chorus]
Three operators in the Kubernetes dance
Cluster, Entity, reconciliation's trance
Topic and User nested inside
Watching CRDs with vigilant eyes
Leader election keeps the peace
Custom resources never cease

[Outro]
Strimzi operators never sleep
Kubernetes promises they always keep
Declarative magic in YAML streams
Fulfilling Apache Kafka dreams

5. 2 Custom Resource Definitions (CRDs)

[Verse 1]
Eight resources define your cluster's fate
Kafka reigns supreme, the primary gate
Topics and Users follow close behind
Declarative magic, perfectly aligned

[Chorus]
CRDs are the blueprint, custom and clean
K-T-U for the basics, then Connect's machine
Bridge and Mirror, Rebalance the load
NodePool completes what operators bestowed

[Verse 2]
KafkaTopic speaks in YAML tongue
No more command-line battles to be sung
Partitions and replicas, retention time
Configuration living in cluster rhyme

[Chorus]
CRDs are the blueprint, custom and clean
K-T-U for the basics, then Connect's machine
Bridge and Mirror, Rebalance the load
NodePool completes what operators bestowed

[Verse 3]
KafkaUser grants access with ACL grace
SCRAM or mTLS, security's embrace
KafkaConnect spawns connectors alive
Source and sink channels help data thrive

[Bridge]
MirrorMaker2 spans the void between
Clusters mirrored in replication scene
KafkaBridge opens HTTP's door
REST requests knock where protocols soar

[Verse 4]
KafkaRebalance calls Cruise Control's might
Optimization algorithms burning bright
KafkaNodePool groups your brokers neat
Thirty-six and beyond makes scaling sweet

[Chorus]
CRDs are the blueprint, custom and clean
K-T-U for the basics, then Connect's machine
Bridge and Mirror, Rebalance the load
NodePool completes what operators bestowed

[Outro]
Custom definitions, Kubernetes-born
Strimzi's vocabulary since platform dawn
Eight resources dancing, perfectly timed
Apache Kafka's future, declaratively designed

6. 3 How Strimzi Maps Kafka to Kubernetes Primitives

[Verse 1]
Kafka brokers need a home to land
Strimzi builds with StatefulSet's command
Each broker gets a numbered name that stays
Even when the pods restart their ways
Configuration maps hold every setting tight
Properties spread across the cluster bright

[Chorus]
Brokers become StatefulSets in rows
ConfigMaps where every setting goes
Secrets guard the TLS keys we need
PVCs give storage guaranteed
Services route the traffic through
Strimzi maps it all for you

[Verse 2]
Certificates hide in Secret vaults below
TLS encryption makes the data flow
Persistent volumes claim their storage space
StorageClasses define the backing place
No broker loses what it wrote before
Even when containers hit the floor

[Chorus]
Brokers become StatefulSets in rows
ConfigMaps where every setting goes
Secrets guard the TLS keys we need
PVCs give storage guaranteed
Services route the traffic through
Strimzi maps it all for you

[Bridge]
LoadBalancers expose to world outside
NodePorts punch through the cluster wide
Ingress controllers route by name
Services keep internal traffic tame
Every Kafka piece finds Kubernetes twin
Primitives that let the messages in

[Chorus]
Brokers become StatefulSets in rows
ConfigMaps where every setting goes
Secrets guard the TLS keys we need
PVCs give storage guaranteed
Services route the traffic through
Strimzi maps it all for you

[Outro]
From Apache's streams to container orchestration
Strimzi builds the perfect translation

7. 1 Prerequisites

[Verse 1]
Before we sail the Kafka seas, foundations must be laid with care
A Kubernetes cluster needs to breathe, minikube floating in the air
Or kind containers dancing light, EKS in Amazon's embrace
AKS from Microsoft's domain, GKE in Google's rapid space
OpenShift for enterprise minds, each platform holds its sacred ground

[Chorus]
kubectl helm, two tools in hand
CPU memory storage planned
Four cores spinning, eight gigs RAM
Twenty storage, that's the span
Prerequisites unlock the door
Strimzi waits for nothing more

[Verse 2]
Command line warriors need their blades, kubectl speaks to clusters deep
Helm charts package wisdom tight, templates that the system keeps
Install them both with careful thought, your terminal becomes the bridge
Between intentions and the cloud, where container orchestration lives
Version numbers matter here, compatibility's the silent king

[Chorus]
kubectl helm, two tools in hand
CPU memory storage planned
Four cores spinning, eight gigs RAM
Twenty storage, that's the span
Prerequisites unlock the door
Strimzi waits for nothing more

[Bridge]
Resource starvation kills the dream
Undersized clusters crack and scream
Monitor metrics, watch the load
Kafka brokers need their code
Persistent volumes claim their space
Network policies find their place

[Verse 3]
Minimum specs are not suggestions, they're the bedrock of success
Four CPU cores humming strong, eight gigabytes under stress
Twenty gigs of storage waiting, persistent data finds its home
Health checks ping through every node, no worker stands alone
Architecture patterns emerge when prerequisites align

[Chorus]
kubectl helm, two tools in hand
CPU memory storage planned
Four cores spinning, eight gigs RAM
Twenty storage, that's the span
Prerequisites unlock the door
Strimzi waits for nothing more

[Outro]
Check your cluster, test your tools
Follow all the setup rules
Ready now for Kafka's flight
Prerequisites burning bright

8. 2 Installing Strimzi

[Verse 1]
Three pathways converge where containers meet streams
Helm charts whisper secrets through templated schemes
GitHub releases hold the manifests tight
YAML declarations painted black and white

[Chorus]
Helm, YAML, Operator Hub
Three doors to the Kafka club
Cluster Operator must breathe and run
Single namespace or watching everyone
Strimzi spinning, pods beginning
Installation's just the start of winning

[Verse 2]
Helm repository adds with simple commands
Values override whatever your cluster demands
Charts unfurl like blueprints across the nodes
Custom resource definitions decode the codes

[Chorus]
Helm, YAML, Operator Hub
Three doors to the Kafka club
Cluster Operator must breathe and run
Single namespace or watching everyone
Strimzi spinning, pods beginning
Installation's just the start of winning

[Verse 3]
GitHub releases tagged with version names
Download the bundle, extract the claims
Kubectl apply spreads resources wide
Operators wake up with nothing to hide

[Bridge]
OpenShift Marketplace gleams
OperatorHub fulfills the dreams
OLM orchestrates the dance
Subscription gives the second chance

[Verse 4]
Namespace boundaries draw the lines
Single scope or multi-shrine watching
RBAC permissions must align
ClusterRoles grant the power divine

[Chorus]
Helm, YAML, Operator Hub
Three doors to the Kafka club
Cluster Operator must breathe and run
Single namespace or watching everyone
Strimzi spinning, pods beginning
Installation's just the start of winning

[Outro]
kubectl get pods reveals the truth
Running status shows the proof
Strimzi Cluster Operator lives
Ready now for what Kafka gives

9. 3 Deploying Your First Kafka Cluster

[Verse 1]
Custom resource YAML in your hands tonight
Kafka kind with metadata, spec defined just right
Minimal configuration, three replicas will do
Bootstrap servers waiting for the messages to flow through
ZooKeeper or KRaft mode, architectural choice
Legacy coordination or consensus with one voice

[Chorus]
Deploy, watch, verify - the Strimzi trinity
Ephemeral fades away, persistent stays with me
Kubectl get kafka shows the reconciliation dance
Producer consumer testing gives your cluster its chance
Deploy, watch, verify - memorize this refrain
Three steps to mastery in the Kubernetes domain

[Verse 2]
Storage configurations split the architect's mind
Ephemeral volumes vanish, leave no trace behind
Persistent claims endure through pod restarts and more
Volume templates carve out space on the storage floor
Size and class annotations painted in your spec
Retention policies guarding every message's trek

[Chorus]
Deploy, watch, verify - the Strimzi trinity
Ephemeral fades away, persistent stays with me
Kubectl get kafka shows the reconciliation dance
Producer consumer testing gives your cluster its chance
Deploy, watch, verify - memorize this refrain
Three steps to mastery in the Kubernetes domain

[Bridge]
Operator logs cascading, watch the magic unfold
Reconciliation cycles, stories being told
Ready status flickers green, the cluster comes alive
Bootstrap three nine zero nine two, connection will arrive
Echo test messages bouncing through the queues
Consumption proves the pipeline, deployment never blues

[Verse 3]
KRaft eliminates the ZooKeeper dependency chain
Metadata stored in topics, consensus without pain
Controller quorum elected, simplified design
But ZooKeeper still reliable, battle-tested and fine
Choose your coordination, both paths lead to success
Production workloads humming with distributed finesse

[Chorus]
Deploy, watch, verify - the Strimzi trinity
Ephemeral fades away, persistent stays with me
Kubectl get kafka shows the reconciliation dance
Producer consumer testing gives your cluster its chance
Deploy, watch, verify - memorize this refrain
Three steps to mastery in the Kubernetes domain

[Outro]
Custom resource submitted, watch the pods ignite
Messages flowing freely through the distributed night

10. 4 Lab: Hello Strimzi

[Verse 1]
Fire up your kind cluster, three brokers we'll deploy
Persistent storage volumes, no data we'll destroy
Strimzi operator watches, YAML specs unfold
Kafka pods awakening, distributed stories told

[Chorus]
Three brokers, three partitions, three replicas align
Topic creation magic through the Kubernetes design
Console producer speaking, consumer ears will hear
Messages flow through pipelines, crystal engineered

[Verse 2]
KafkaTopic resource spawns with partition trinity
Replication factor matching, fault-tolerance spree
Persistent volume claims anchor data to the ground
While services expose endpoints where connections are found

[Chorus]
Three brokers, three partitions, three replicas align
Topic creation magic through the Kubernetes design
Console producer speaking, consumer ears will hear
Messages flow through pipelines, crystal engineered

[Bridge]
Inspect the pod array, secrets tucked away
ConfigMaps hold wisdom for the streaming ballet
StatefulSets maintain order, volumes never fade
Kubernetes orchestration, perfectly displayed

[Verse 3]
Kafka console producer sends messages inside
Bootstrap servers calling through the cluster wide
Consumer groups are listening, offsets mark the trail
Partition distribution ensures we never fail

[Final Chorus]
Three brokers, three partitions, three replicas align
Topic creation magic through the Kubernetes design
Producer speaks its wisdom, consumer comprehends
Strimzi lab completed, where learning never ends

[Outro]
Hello Strimzi calling, your Kafka dreams take flight
Persistent data streaming through the orchestrated night

11. 1 Kafka Broker Configuration

[Verse 1]
Deep in Kubernetes pods, the brokers wake
Config section holds the keys we'll make
Spec dot kafka dot config defines the way
Message handling rules that guide each day

[Verse 2]
JVM options tuning memory's dance
Resource limits give your pods a chance
Request the minimum, set limits high
Heap and stack balanced reaching for the sky

[Chorus]
Configure, orchestrate, the broker's brain
Listeners speak in TLS refrain
Storage mounted, logs persist and grow
Strimzi magic makes the data flow

[Verse 3]
Log directories scattered cross the drives
Retention policies keep old data alive
Segment rolling when the size gets large
Compaction cleaning what's no longer charged

[Verse 4]
Internal listeners cluster nodes connect
External gateways client traffic direct
SASL authentication guards the door
Plain and scrambled secrets by the score

[Chorus]
Configure, orchestrate, the broker's brain
Listeners speak in TLS refrain
Storage mounted, logs persist and grow
Strimzi magic makes the data flow

[Bridge]
Bootstrap servers advertise their names
Port nine zero nine two plays the games
Security protocols wrap each exchange
Custom resource definitions rearrange

[Verse 5]
Persistent volumes claim the storage space
Kafka class selects the storage base
Mount paths directing where the logs reside
Replica factors spread data far and wide

[Chorus]
Configure, orchestrate, the broker's brain
Listeners speak in TLS refrain
Storage mounted, logs persist and grow
Strimzi magic makes the data flow

[Outro]
From YAML specs to running broker nodes
Kubernetes orchestrates what Kafka loads
Configuration mastery unlocks the stream
Apache messaging living the dream

12. 2 ZooKeeper Configuration

[Verse 1]
Three nodes minimum, that's the magic number
ZooKeeper ensemble won't split or slumber
Odd counts prevent the dreaded brain split scenario
Two gigs of RAM, four cores for the show

CPU steady, memory consistent
Persistent volumes make data resistant
XFS or ext4, fast disks are key
Network latency under ten millisecond spree

[Chorus]
Size it right, store it tight
ZooKeeper needs resources burning bright
Tick time, sync time, parameters aligned
Keep your cluster's heartbeat refined

Size it right, store it tight
Configuration tuned for cluster flight
Memory maps and journal logs combined
ZooKeeper's secrets now defined

[Verse 2]
InitLimit sets the follower's first chance
SyncLimit keeps the heartbeat dance
TickTime controls the basic pulse
Two thousand millis, that's the default result

MaxClientConnections, sixty by design
PreAllocSize sixty-four meg baseline
SnapCount one hundred thousand transactions deep
AutoPurge keeps old snapshots from heap

[Chorus]
Size it right, store it tight
ZooKeeper needs resources burning bright
Tick time, sync time, parameters aligned
Keep your cluster's heartbeat refined

Size it right, store it tight
Configuration tuned for cluster flight
Memory maps and journal logs combined
ZooKeeper's secrets now defined

[Bridge]
ForceSync true for durability's sake
JVM heap size, careful choices make
Garbage collection tuned for low pause time
Storage IOPS matter, performance climbs

DataDir and DataLogDir split apart
Transaction logs need their dedicated heart

[Verse 3]
MinSessionTimeout, MaxSessionTimeout range
Forty seconds, four minutes, don't rearrange
GlobalOutstandingLimit, one thousand max
Client request queue, prevent overload attacks

Strimzi operator handles the heavy lifting
Kafka depends on ZooKeeper's shifting
Persistent volume claims hold the state
Configuration maps seal the ensemble's fate

[Chorus]
Size it right, store it tight
ZooKeeper needs resources burning bright
Tick time, sync time, parameters aligned
Keep your cluster's heartbeat refined

Size it right, store it tight
Configuration tuned for cluster flight
Memory maps and journal logs combined
ZooKeeper's secrets now defined

[Outro]
Three nodes strong, parameters flowing
ZooKeeper's wisdom, Kafka's growing
Storage persistent, tuning complete
Your distributed system can't be beat

13. 3 KRaft Mode (ZooKeeper-less Kafka)

[Verse 1]
ZooKeeper's reign is fading fast, coordination's changing guard
KRaft mode rises, self-contained, no external keeping hard
Strimzi charts this evolution, roadmap drawn with careful lines
Preview status, not production, but the future it defines

[Chorus]
KRaft removes the keeper's burden
Controller nodes, the cluster's curtain
No more zoo, just Kafka pure
KafkaNodePool makes roles sure
Combined or split, you choose the way
Metadata flows where brokers stay

[Verse 2]
Migration pathways wind through versions, careful steps from old to new
Backup first your precious data, rolling updates see you through
Controller-only nodes stand watching, metadata guardians of state
Combined nodes wear double hats, both controller and data's fate

[Chorus]
KRaft removes the keeper's burden
Controller nodes, the cluster's curtain
No more zoo, just Kafka pure
KafkaNodePool makes roles sure
Combined or split, you choose the way
Metadata flows where brokers stay

[Bridge]
KafkaNodePool CRD arrives
Role-based management comes alive
Controller replicas decide the quorum size
Broker pools scale where your data flies

[Verse 3]
Three controllers minimum needed, quorum math protects your cluster
Odd numbers prevent split-brain, consensus keeps away the bluster
Strimzi wraps complexity, Kubernetes native all the way
Custom resources guide the transition to KRaft's brighter day

[Chorus]
KRaft removes the keeper's burden
Controller nodes, the cluster's curtain
No more zoo, just Kafka pure
KafkaNodePool makes roles sure
Combined or split, you choose the way
Metadata flows where brokers stay

[Outro]
Preview today, production tomorrow
KRaft mode leads where clusters follow
Self-sufficient, streamlined, clean
The future's here, the change is seen

14. 4 Storage Strategies

[Verse 1]
When your Kafka brokers need multiple drives working as one team
JBOD configuration makes the storage scheme
Just a Bunch of Disks, no RAID complexity
Each volume independent, pure simplicity
Mount them separately, let Kafka decide the flow
Data spreads across them, balanced as they grow

[Chorus]
Four strategies to master, storage done right
JBOD for flexibility, performance takes flight
Cloud classes matter - gp3, io2, Premium grade
Expand when you need it, benchmarks never fade
Storage strategies, storage strategies
Your Kafka cluster's foundation dependencies

[Verse 2]
Cloud providers offer classes, choose them carefully now
GP3 for general purpose, cost-effective somehow
IO2 for mission-critical, IOPS you can guarantee
Premium SSD on Azure, consistency you'll see
Match your workload patterns to the storage tier you pick
Throughput versus latency, that's the balancing trick

[Chorus]
Four strategies to master, storage done right
JBOD for flexibility, performance takes flight
Cloud classes matter - gp3, io2, Premium grade
Expand when you need it, benchmarks never fade
Storage strategies, storage strategies
Your Kafka cluster's foundation dependencies

[Bridge]
Volume expansion online, no downtime required
Resize your persistent claims, capacity acquired
File system grows automatically, Kubernetes handles the rest
But benchmark first, then measure - put performance to the test
Throughput metrics, latency graphs, IOPS under load
Validate your storage choices before you hit the road

[Verse 3]
Kafka tool for benchmarking, producer consumer test
Generate synthetic load, see which setup works best
Sequential writes and random reads, measure every case
Network bandwidth, disk IO, find the bottleneck's place
Monitor your storage metrics, watch the queue depths climb
Optimal configuration takes patience and time

[Chorus]
Four strategies to master, storage done right
JBOD for flexibility, performance takes flight
Cloud classes matter - gp3, io2, Premium grade
Expand when you need it, benchmarks never fade
Storage strategies, storage strategies
Your Kafka cluster's foundation dependencies

[Outro]
From JBOD arrays to cloud storage classes refined
Volume expansion, benchmarks - all strategies combined
Strimzi makes it possible, Kubernetes makes it scale
Storage architecture solid, your Kafka will not fail

15. 5 Resource Tuning

[Verse 1]
Brokers wake with memory blueprints drawn
CPU requests whisper minimum spawn
Limits guard the ceiling, won't let burst
ZooKeeper nodes need planning from the first
Set your boundaries careful, watch the scale
Resource starvation makes clusters fail

[Chorus]
Heap size minus X-M-S starts the game
Minus X-M-X caps the memory frame
Garbage collection sweeps the JVM clean
Tune your threads for the fastest machine
Request-limit-heap-thread harmony
That's the Strimzi symphony

[Verse 2]
Network threads accept connections at the door
I-O threads handle messages and more
Replica fetchers sync across the rack
Balance all three or performance cracks
Too few threads create bottleneck pain
Too many threads drain resources again

[Chorus]
Heap size minus X-M-S starts the game
Minus X-M-X caps the memory frame
Garbage collection sweeps the JVM clean
Tune your threads for the fastest machine
Request-limit-heap-thread harmony
That's the Strimzi symphony

[Bridge]
Pod affinity pulls workloads near
Anti-affinity spreads them crystal clear
Topology spread constraints paint the map
Zone distribution fills each gap
Schedule smart across your cluster wide
Let Kubernetes be your placement guide

[Verse 3]
G-One garbage collector for the small
Parallel G-C when heaps grow tall
Watch your pause times, measure throughput flow
Concurrent mark sweep lets applications go
ZGC and Shenandoah break the pause
Low latency without memory laws

[Final Chorus]
Heap size minus X-M-S starts the game
Minus X-M-X caps the memory frame
Garbage collection sweeps the JVM clean
Tune your threads for the fastest machine
Affinity rules and topology spread
Keep your Kafka cluster well-fed
Request-limit-heap-thread harmony
That's the Strimzi symphony

[Outro]
Monitor metrics, adjust with care
Resource tuning gets you there

16. 1 Listener Types

[Verse 1]
When your pods need to connect inside the cluster walls
ClusterIP whispers secrets through internal protocol calls
No external gateway needed, just the service mesh divine
Container conversations flowing through that dotted line

[Chorus]
Six pathways to your Kafka streams
Internal, Route, and LoadBalancer dreams
NodePort opens every door
Ingress, ClusterIP and more
Choose your listener, choose your fate
Six connections to navigate

[Verse 2]
OpenShift Routes paint the highway from outside to in
SSL termination dancing where the traffic begins
LoadBalancer summons clouds to balance every byte
AWS and Azure armies keeping throughput burning bright

[Chorus]
Six pathways to your Kafka streams
Internal, Route, and LoadBalancer dreams
NodePort opens every door
Ingress, ClusterIP and more
Choose your listener, choose your fate
Six connections to navigate

[Verse 3]
NodePort carves a tunnel straight to thirty-thousand-plus
Direct access to the metal, no service layer fuss
While Ingress controllers juggle NGINX magic tricks
Traefik routing symphonies with reverse proxy flicks

[Bridge]
ClusterIP with custom DNS
Resolving names that never guess
Internal calls know where to go
Through the service mesh they flow

[Verse 4]
Configure listeners carefully, each type serves its role
External clients need the routes, internal traffic stays whole
Kubernetes orchestration with Strimzi at the helm
Six connection architectures ruling this streaming realm

[Final Chorus]
Six pathways to your Kafka streams
Internal, Route, and LoadBalancer dreams
NodePort opens every door
Ingress, ClusterIP and more
Choose your listener, choose your fate
Six connections to navigate

[Outro]
From cluster walls to cloud providers
Every listener type divides
The streaming data finds its course
Through Kubernetes connection force

17. 2 Configuring External Access

[Verse 1]
When clients knock from outside the cluster wall
Kafka brokers need addresses they can call
Advertised listeners hold the sacred key
Broadcasting hostnames that external eyes can see

Internal pods speak cluster dot local tongue
But outside clients need domains properly sung
Bootstrap servers guide the first connection dance
Then brokers whisper their true addresses in advance

[Chorus]
Configure the gateway, open up the door
TLS passthrough keeps encryption pure and raw
Termination strips it at the proxy line
DNS resolution makes the hostnames shine
Per-broker endpoints or shared service gate
External access seals your Kafka fate

[Verse 2]
Passthrough tunnels encrypted streams intact
Load balancer forwards every TLS pact
But termination breaks the crypto shell
Proxy decrypts then re-encrypts to tell

NodePort exposes ports on every node
LoadBalancer provisions cloud IP zones
Ingress routes traffic through HTTP streams
Route and OpenShift fulfill external dreams

[Chorus]
Configure the gateway, open up the door
TLS passthrough keeps encryption pure and raw
Termination strips it at the proxy line
DNS resolution makes the hostnames shine
Per-broker endpoints or shared service gate
External access seals your Kafka fate

[Bridge]
Three brokers need three separate names
Wildcard certificates ease the DNS games
Bootstrap discovers the topology map
Then direct connections bridge the cluster gap

[Verse 3]
Hostname overrides control the advertised call
External DNS must resolve them all
Certificate SANs must match the chosen names
Or TLS handshakes burst into flames

Shared bootstrap funnels initial requests
Per-broker services handle all the rest
Network policies guard the exposed doors
Security groups define the traffic wars

[Chorus]
Configure the gateway, open up the door
TLS passthrough keeps encryption pure and raw
Termination strips it at the proxy line
DNS resolution makes the hostnames shine
Per-broker endpoints or shared service gate
External access seals your Kafka fate

[Outro]
From cluster-internal to worldwide reach
External listeners bridge what networks teach
Strimzi orchestrates the connection flow
Your Kafka streams wherever clients go

18. 3 Network Policies

[Verse 1]
Three gatekeepers patrol your cluster's gates
NetworkPolicy shields where data waits
Broker traffic locked behind ingress rules
Only trusted pods can use these tools
Selectors match the labels on each port
Deny by default keeps invaders short

[Chorus]
Lock the brokers, cage the zoo
Label selectors know what's true
Three policies guard the wire
Ingress, egress, namespace choir
Lock the brokers, cage the zoo
Traffic rules will see you through

[Verse 2]
ZooKeeper whispers secrets in the dark
Internal chatter needs a special mark
Isolate the quorum from outside reach
Port twenty-one-eighty-one stays out of breach
ClusterIP masks the ensemble's dance
No external eyes get half a chance

[Chorus]
Lock the brokers, cage the zoo
Label selectors know what's true
Three policies guard the wire
Ingress, egress, namespace choir
Lock the brokers, cage the zoo
Traffic rules will see you through

[Bridge]
Namespace selectors carve the boundaries clean
App equals kafka in the matching scene
Pod selectors drill down to the core
Component equals broker opens the door
Allow from specific namespaces only
Deny all others, keep it lonely

[Verse 3]
Third policy paints the allowed list white
Specific pods get the connection right
MatchLabels filter who can speak
PodSelector finds what you seek
From development namespace to production zone
Each gets its tunnel, each stands alone

[Chorus]
Lock the brokers, cage the zoo
Label selectors know what's true
Three policies guard the wire
Ingress, egress, namespace choir
Lock the brokers, cage the zoo
Traffic rules will see you through

[Outro]
Three walls standing guard tonight
Kafka sleeps secure and tight
Network policies hold the line
Your streaming fortress, by design

19. 4 Lab: External Access

[Verse 1]
Behind the cluster walls, your Kafka waits alone
Pods speaking secretly in languages unknown
But clients need connection from the world outside
LoadBalancer listeners become your bridge and guide

Configure the resource with external type declared
Bootstrap servers ready, endpoints freshly prepared
The service allocates an IP address to share
Your cluster breaks its silence, responding to your prayer

[Chorus]
Load it up, balance out, external access found
TLS certificates spinning all around
Produce and consume from any client machine
LoadBalancer magic makes your Kafka seen

[Verse 2]
Download the certificates, your trust store needs them tight
Client configuration pointing to the light
Bootstrap servers calling through the network maze
Truststore password unlocks encrypted pathways

Test your connection with a simple produce call
Messages flowing past the firewall
Consumer groups awakening from their patient sleep
External access promises that you can keep

[Chorus]
Load it up, balance out, external access found
TLS certificates spinning all around
Produce and consume from any client machine
LoadBalancer magic makes your Kafka seen

[Bridge]
When connections fail and timeouts appear
Check your security groups and network peers
DNS resolution might be playing tricks
Port forwarding rules need careful fix

Service mesh interference blocks your way
Ingress controllers leading you astray
Certificate expiration dates run dry
Troubleshoot the symptoms, ask yourself why

[Verse 3]
Verify your listeners are properly exposed
Network policies haven't left you closed
Load balancer health checks passing green
External IP addresses clearly seen

Client logs revealing what went wrong
Network packets singing error songs
Telnet tests confirming ports are live
External access finally learns to thrive

[Chorus]
Load it up, balance out, external access found
TLS certificates spinning all around
Produce and consume from any client machine
LoadBalancer magic makes your Kafka seen

[Outro]
From localhost producer to remote consumer calls
Kafka serves beyond Kubernetes walls
External access mastered, networking complete
Your distributed streaming can't be beat

20. 1 TLS Encryption

[Verse 1]
Strimzi boots with secrets locked inside
Certificate Authority spawns to life
Auto-generating keys that multiply
Trust chains weaving through the Kafka hive
Default cycles spin at ninety days
But you can stretch or shrink those time displays

[Chorus]
TLS wraps every whisper tight
CA signs, clients verify
Keystores hold the private might
Truststores let the good ones by
Encryption dancing through the night
One-way, mutual, lock and key

[Verse 2]
Bring your own certificates if you dare
Override the built-in signing pair
Configure validity spans with care
Months or years, declare them in your yaml layer
Client pods need truststores filled with roots
To shake hands with brokers bearing fruits

[Chorus]
TLS wraps every whisper tight
CA signs, clients verify
Keystores hold the private might
Truststores let the good ones by
Encryption dancing through the night
One-way, mutual, lock and key

[Bridge]
When renewal time approaches near
Strimzi rotates without your fear
Rolling restarts cascade through
Old certs fade as new break through
PEM formats, JKS stores
Pick your poison, open doors

[Verse 3]
External CAs can join the game
Import your enterprise certificate chain
Set the validity periods to your claim
Thirty-six-five or custom timeframe
Client authentication optional
Mutual TLS makes it invincible

[Chorus]
TLS wraps every whisper tight
CA signs, clients verify
Keystores hold the private might
Truststores let the good ones by
Encryption dancing through the night
One-way, mutual, lock and key

[Outro]
Certificates expire but trust remains
Strimzi keeps your secrets safe from prying gains
TLS encryption flows through Kubernetes veins
Your Kafka fortress never breaks its chains

21. 2 Authentication

[Verse 1]
Three guardians protect your streaming gate
TLS certificates for mutual handshake
Client proves its worth with cryptographic key
Server validates before you're running free
SCRAM-SHA-512 brings passwords to the dance
Salted hashing makes brute force lose its chance

[Chorus]
Auth-en-ti-cate, validate every connection
mTLS, SCRAM, OAuth for protection
Kafka-User custom resource defines the trust
Configure listeners, authentication's a must
Lock it down, verify the crown
Every client must prove their ground

[Verse 2]
OAuth twenty flows through modern gates
Keycloak, Azure, Okta validates
Bearer tokens carry digital proof
JSON Web signatures keep hackers aloof
Each listener binds to its chosen scheme
Multiple methods in one cluster's dream

[Chorus]
Auth-en-ti-cate, validate every connection
mTLS, SCRAM, OAuth for protection
Kafka-User custom resource defines the trust
Configure listeners, authentication's a must
Lock it down, verify the crown
Every client must prove their ground

[Bridge]
Certificate authority chains the mutual trust
Distinguished names in X-five-oh-nine dust
Username stored in Kubernetes secret space
SCRAM iterations slow the hacking race
Resource definitions declare who belongs
Strimzi orchestrates the authentication songs

[Verse 3]
Per-listener configs segment your access
Plain text, encrypted, each with its process
Client ID and secret for OAuth flow
OIDC discovery lets the tokens glow
Principal extraction maps the identity
Authorization waits for what's verified

[Final Chorus]
Auth-en-ti-cate, validate every connection
mTLS, SCRAM, OAuth for protection
Kafka-User custom resource defines the trust
Configure listeners, authentication's a must
Lock it down, verify the crown
Every client must prove their ground
Streaming secured, messages assured

22. 3 Authorization

[Verse 1]
KafkaUser holds the access keys tonight
Spec authorization draws the boundary lines  
Simple ACLs guard your topic streams
Read and write permissions, granular schemes
Literal matches lock down exact names
While prefix patterns handle namespace games

[Chorus]
Three doors to authorization's maze
Simple, Keycloak, OPA ways
Literal, prefix, wildcard dance
Every client needs its access chance
ACL patterns weave the net
Fine-grained policies you won't forget

[Verse 2]
Keycloak Authorization Services rise
Policy-based control behind the scenes
Resource servers validate each call
Permission tickets flowing through it all
Role-based access meets attribute tests
Context-aware decisions at their best

[Chorus]
Three doors to authorization's maze
Simple, Keycloak, OPA ways
Literal, prefix, wildcard dance
Every client needs its access chance
ACL patterns weave the net
Fine-grained policies you won't forget

[Bridge]
Open Policy Agent speaks in Rego tongue
Custom authorizer plugin gets things done
JSON payloads carry every claim
Decision engine plays the judgment game
Wildcard asterisk opens wider gates
While literal strings seal particular fates

[Verse 3]
Producer principal seeks topic write
Consumer groups need subscription rights
Admin operations demand higher ground
Delete and alter privileges are found
Each pattern type serves its special role
Authorization's three-pronged goal

[Chorus]
Three doors to authorization's maze
Simple, Keycloak, OPA ways
Literal, prefix, wildcard dance
Every client needs its access chance
ACL patterns weave the net
Fine-grained policies you won't forget

[Outro]
From KafkaUser specs to complex rules
Authorization's comprehensive tools
Guard your streams with patterns true
Access control depends on you

23. 4 Encrypting Data at Rest

[Verse 1]
Your Kafka secrets sleep on spinning disks tonight
Vulnerable whispers in the storage bay
Data dreams exposed to prying eyes so bright
Unless you encrypt what rests where servers stay
Etcd holds the keys to Kubernetes crown
CSI drivers mount the volumes secure and sound

[Chorus]
Lock it down at rest, encrypt the sleeping giant
Etcd scrambles secrets, CSI stays compliant
AWS EBS, Azure Disk encryption
GCP Persistent, cryptographic friction
Data sleeps in cipher, never plain text dreams
Kubernetes guardians weave protective schemes

[Verse 2]
Cloud providers wrap your volumes tight in code
Amazon's EBS with KMS keys in hand
Azure Disk encryption on the storage road
Google Cloud Persistent volumes take their stand
CSI drivers speak the language of the vault
Mounting encrypted realms without a fault

[Chorus]
Lock it down at rest, encrypt the sleeping giant
Etcd scrambles secrets, CSI stays compliant
AWS EBS, Azure Disk encryption
GCP Persistent, cryptographic friction
Data sleeps in cipher, never plain text dreams
Kubernetes guardians weave protective schemes

[Bridge]
Layer upon layer, shields within the shell
Cluster secrets wrapped in cryptographic spell
Storage class annotations mark the sacred ground
Where encrypted volumes spin without a sound

[Verse 3]
Configure etcd with encryption keys that bind
Every secret resource locked away from sight
Storage classes define what security minds
Demand from persistent volumes through the night
Multi-layer fortress guards your Kafka streams
Nothing leaks in plaintext from encrypted dreams

[Chorus]
Lock it down at rest, encrypt the sleeping giant
Etcd scrambles secrets, CSI stays compliant
AWS EBS, Azure Disk encryption
GCP Persistent, cryptographic friction
Data sleeps in cipher, never plain text dreams
Kubernetes guardians weave protective schemes

[Outro]
Rest assured your data slumbers safe and sound
Encrypted volumes spin on cryptographic ground

24. 5 Lab: Securing a Strimzi Cluster

[Verse 1]
Your Kafka cluster runs exposed and bare
Plain text flowing through the Kubernetes air
Time to lock it down with TLS encryption tight
SCRAM authentication makes permissions right
Bootstrap servers need their certificates clean
Security layers thick as you've ever seen

[Chorus]
TLS on every port, SCRAM for every user
ACLs guard your topics, certificates renew-sir
Zero downtime rotation, passwords hashed secure
Strimzi keeps it locked down, enterprise-grade pure
Lock it, hash it, ACL and rotate
Security patterns that you won't forget

[Verse 2]
KafkaUser yaml with SCRAM-SHA-512
Authentication secrets that hackers can't delve
Topic-level access controls define the scope
Read and write permissions keep bad actors broke
Client configs updated with the truststore path
SASL mechanisms protect from cyber wrath

[Chorus]
TLS on every port, SCRAM for every user
ACLs guard your topics, certificates renew-sir
Zero downtime rotation, passwords hashed secure
Strimzi keeps it locked down, enterprise-grade pure
Lock it, hash it, ACL and rotate
Security patterns that you won't forget

[Bridge]
Rolling update magic when the certs expire
Pods restart sequentially, cluster stays on fire
Client reconnects seamlessly to the new TLS
Messages keep flowing through the secured mess
Trust between the brokers, clients authenticate
Strimzi orchestrates what would complicate

[Verse 3]
Producer configuration with security protocol
Bootstrap servers wrapped in encrypted protocol
Consumer groups protected by the ACL rules
Authorization simple with the Strimzi tools
Certificate authority rotating on schedule
Security automation that's completely flexible

[Chorus]
TLS on every port, SCRAM for every user
ACLs guard your topics, certificates renew-sir
Zero downtime rotation, passwords hashed secure
Strimzi keeps it locked down, enterprise-grade pure
Lock it, hash it, ACL and rotate
Security patterns that you won't forget

[Outro]
From plain text chaos to encrypted streams
Strimzi security fulfills your wildest dreams
Lab five complete, your cluster fortress-strong
Kafka runs protected, nothing can go wrong

25. 1 Kafka Connect on Strimzi

[Verse 1]
Deploy the KafkaConnect CRD today
Custom Resource Definition shows the way
Cluster springs to life with YAML configuration
Kubernetes orchestrates the data transformation

[Chorus]
Connect, Connect, bridging every stream
Build it, bake it, connectors in the beam
REST API calls through the Kubernetes gate
Strimzi makes the data flow and integrate

[Verse 2]
Build system crafts your custom container bright
Connectors baked inside, sealed up tight
No runtime downloads, everything's prepared
Dependencies resolved, complexity's been spared

[Chorus]
Connect, Connect, bridging every stream
Build it, bake it, connectors in the beam
REST API calls through the Kubernetes gate
Strimzi makes the data flow and integrate

[Bridge]
Strimzi build feature works its magic spell
Include connector plugins, configure them well
From source to sink the data pipeline flows
REST endpoints exposed where your service goes

[Verse 3]
Within the cluster walls, API calls ring
Service mesh routing makes the connectors sing
Kubernetes networking handles every request
Connect REST interface puts your skills to test

[Chorus]
Connect, Connect, bridging every stream
Build it, bake it, connectors in the beam
REST API calls through the Kubernetes gate
Strimzi makes the data flow and integrate

[Outro]
KafkaConnect CRD, the cornerstone and key
Custom images built for scalability
Strimzi builds your connectors, REST API's free
Kubernetes-native streaming destiny

26. 2 Managing Connectors Declaratively

[Verse 1]
KafkaConnector CRD defines the blueprint clean
Declarative magic replaces manual machine
Source connectors pull data from external stores
Sink connectors push streams through Kafka doors
YAML specifications tell the cluster what to build
Tasks multiply when workload volumes get fulfilled

[Chorus]
Declare your connectors, watch them come alive
Source pulls in, sink sends out, keep your data streams in drive
Scale the tasks, handle faults, dead letter queues survive
Strimzi orchestrates the flow, declarative power thrives

[Verse 2]
Configuration maps hold secrets and settings tight
Connector instances spawn workers left and right
Task scaling happens when partition counts grow
Parallel processing lets your throughput really show
Each task grabs a slice of the connector's workload
Distributed engines on the Kubernetes node

[Chorus]
Declare your connectors, watch them come alive
Source pulls in, sink sends out, keep your data streams in drive
Scale the tasks, handle faults, dead letter queues survive
Strimzi orchestrates the flow, declarative power thrives

[Bridge]
When errors strike, tolerance levels decide the fate
Dead letter queues catch poison messages that can't wait
Retry policies cycle through attempts with delays
Error handling strategies prevent complete cascade
Transform failures into manageable streams
Recovery mechanisms fulfill your data dreams

[Verse 3]
Source connects databases, files, and APIs
Sink delivers payloads where your target system stays
Connector plugins expand the ecosystem wide
Custom transforms reshape data on the ride
Kubernetes operators watch the connector state
Healing broken instances before it gets too late

[Chorus]
Declare your connectors, watch them come alive
Source pulls in, sink sends out, keep your data streams in drive
Scale the tasks, handle faults, dead letter queues survive
Strimzi orchestrates the flow, declarative power thrives

[Outro]
CRDs manage connectors with elegant design
Kafka Connect clustering keeps your pipeline fine
Declarative patterns make complexity fade
Strimzi connector mastery, perfectly displayed

27. 3 Common Connector Patterns

[Verse 1]
Debezium watches every table row transform
Captures every insert, update, delete with charm
PostgreSQL whispers secrets through its WAL
MySQL binlog spills the truth for all
MongoDB oplog streams each document's tale
Change data capture never seems to fail

[Chorus]
Three patterns weaving data streams
CDC, Sink, and Mirror schemes
Debezium tracks the database dreams
S3 buckets catch the flowing beams
JDBC bridges old and new
Elasticsearch makes search come through
Mirror Maker copies clusters true
Connector patterns, tried and true

[Verse 2]
S3 Sink connector drains the topic dry
Parquet files arranged beneath the sky
Azure Blob receives the structured flood
Data lake ingestion in the cloud
JDBC Source pulls from tables clean
Sink writes back to relational scene

[Chorus]
Three patterns weaving data streams
CDC, Sink, and Mirror schemes
Debezium tracks the database dreams
S3 buckets catch the flowing beams
JDBC bridges old and new
Elasticsearch makes search come through
Mirror Maker copies clusters true
Connector patterns, tried and true

[Bridge]
Elasticsearch Sink builds indexes bright
Documents nested, searchable tonight
MirrorMaker 2 spans the cluster divide
Cross-region replication, data multiplied
Source and sink connectors dance in pairs
Moving information everywhere

[Verse 3]
Configure JSON tells each connector's role
Transforms and routing make the data whole
Strimzi orchestrates on Kubernetes ground
Custom resources where configs are found
Three common patterns rule the enterprise stage
CDC, Sink, and Mirror turn the page

[Outro]
From database logs to search and store
Connector patterns open every door
Strimzi manages what flows between
The most elegant data pipeline scene

28. 4 Lab: CDC Pipeline with Debezium

[Verse 1]
KafkaConnect cluster spinning up tonight
Debezium PostgreSQL connector locked and loaded
JSON manifests declaring what we need
Source database trembling, changes about to be decoded

[Chorus]
CDC pipeline pumping data through the stream
Kafka-Connect, Debezium, S-three dream
Capture every insert, update, delete
From PostgreSQL to topics, the circle's complete

[Verse 2]
KafkaConnector resource hits the wire
Database tables mapped to topic names
Connector class pointing to the source
Every transaction logged, nothing stays the same

[Chorus]
CDC pipeline pumping data through the stream
Kafka-Connect, Debezium, S-three dream
Capture every insert, update, delete
From PostgreSQL to topics, the circle's complete

[Bridge]
Watch the events cascade like digital rain
Before and after snapshots in the payload
Tombstone markers when records disappear
Sink connector catches all, to S3 deployed

[Verse 3]
MinIO buckets waiting for the feed
Parquet files accumulating row by row
Real-time replication without missing beats
From OLTP to analytics, watch the data flow

[Chorus]
CDC pipeline pumping data through the stream
Kafka-Connect, Debezium, S-three dream
Capture every insert, update, delete
From PostgreSQL to topics, the circle's complete

[Outro]
Schema registry tracking every change
Connect workers balanced, tasks distributed
Your database mirror lives in object storage now
CDC mastery finally executed

29. 1 MirrorMaker 2 Architecture

[Verse 1]
Clusters connected, source to target bound
Mirror Maker Two will replicate what's found
Three connectors work in harmony's dance
Source and Checkpoint, Heartbeat's vigilance

[Chorus]
Source moves topics, Checkpoint tracks the place
Heartbeat proves connection, offset translation space
Remote dot source name, that's the naming game
Three connectors spinning, replication's claim

[Verse 2]
MirrorSourceConnector pulls the data streams
Topics cross the boundary, fulfilling mirror dreams
Consumer groups and metadata journey far
From origin cluster to destination star

[Chorus]
Source moves topics, Checkpoint tracks the place
Heartbeat proves connection, offset translation space
Remote dot source name, that's the naming game
Three connectors spinning, replication's claim

[Bridge]
Checkpoint connector maps the offset shifts
Consumer positions get their translated lifts
Heartbeat connector sends its pulse alive
Monitoring health so mirrors can survive

[Verse 3]
Topic renaming follows strict convention rules
Remote dot source cluster, using naming tools
Original topic becomes prefixed version
Cross-cluster consumption needs this conversion

[Chorus]
Source moves topics, Checkpoint tracks the place
Heartbeat proves connection, offset translation space
Remote dot source name, that's the naming game
Three connectors spinning, replication's claim

[Outro]
Architecture elegant, three parts align
MirrorMaker Two keeps clusters in design
Kafka Connect foundation, Strimzi's might
Mirroring perfection through Kubernetes light

30. 2 Strimzi MirrorMaker 2 Configuration

[Verse 1]
KafkaMirrorMaker2 lives as custom resource definition
Bridging clusters across the void with data transmission
YAML specs declare the source and destination endpoints
While replication flows like rivers through these waypoints

[Chorus]
Mirror, mirror on the wall
Which direction serves them all?
Uni flows one way clean
Bi-directional active-active scene
Filters catch what should pass through
Include exclude patterns true
Sync intervals keep the beat
Replication policies complete

[Verse 2]
One direction streams data like a waterfall cascade
Source to target, never back, decisions cleanly made
But active-active dances both ways round the floor
Each cluster writes and reads while syncing more and more

[Chorus]
Mirror, mirror on the wall
Which direction serves them all?
Uni flows one way clean
Bi-directional active-active scene
Filters catch what should pass through
Include exclude patterns true
Sync intervals keep the beat
Replication policies complete

[Verse 3]
Topic filters act like sieves with regex magic spells
Include patterns welcome topics, exclude rings the bells
Group filters work the same way for consumer coordination
Controlling which assemblies cross the federation

[Bridge]
Sync intervals set the rhythm
Heartbeats pulsing through the system
Replication policies decide
How the naming rules collide
Rename topics as they travel
Watch the threading patterns unravel

[Chorus]
Mirror, mirror on the wall
Which direction serves them all?
Uni flows one way clean
Bi-directional active-active scene
Filters catch what should pass through
Include exclude patterns true
Sync intervals keep the beat
Replication policies complete

[Outro]
Configuration carved in stone
Custom resources you now own
Mirror maker understands
Data flowing cross the lands

31. 3 Multi-Region / Disaster Recovery Patterns

[Verse 1]
When disaster strikes your clusters, cities burning down
Active-passive holds the crown, standby waits around
Primary region serves requests while backup sleeps in wait
Mirror-maker replicates, no conflicts to debate

[Chorus]
Three patterns for survival when the networks fall apart
Active-passive, active-active, choose your beating heart
RPO measures data lost, RTO time to heal
Monitor that replication lag, keep your clusters real

[Verse 2]
Active-active spreads the load, both regions running hot
Conflict resolution needed when the same keys hit the spot
Last-writer-wins is simple but data might get dropped
Custom merge strategies help when logic can't be stopped

[Chorus]
Three patterns for survival when the networks fall apart
Active-passive, active-active, choose your beating heart
RPO measures data lost, RTO time to heal
Monitor that replication lag, keep your clusters real

[Bridge]
Recovery point objective counts the seconds data's gone
Recovery time objective tracks how long before we're on
Lag metrics tell the story of how far behind we trail
Prometheus alerts firing when replication starts to fail

[Verse 3]
Stretch clusters span geography but split-brain makes you weep
Rack awareness spreads replicas, availability runs deep
Cross-region network latency will slow your throughput down
Bandwidth costs and vendor locks can make your budget frown

[Chorus]
Three patterns for survival when the networks fall apart
Active-passive, active-active, choose your beating heart
RPO measures data lost, RTO time to heal
Monitor that replication lag, keep your clusters real

[Outro]
When earthquakes shake your data centers, floods wash servers clean
These patterns keep Kafka flowing through disaster's darkest scene

32. 4 Lab: Multi-Cluster Replication

[Verse 1]
Two kingdoms separate, namespaces divided
Each hosting their own Kafka throne
Producer one speaks secrets to cluster alpha
Consumer two waits by cluster beta's phone
Mirror Maker stands between these realms
Copying messages across the void
Active-passive dance begins to unfold
When disaster strikes, who gets deployed?

[Chorus]
Mirror mirror, replicate it all
Topics flowing through the Kubernetes wall
Source to target, offset synchrony
Mirror mirror, failover guarantee
When the primary tumbles down
Mirror maker wears the crown

[Verse 2]
Deploy the first with yaml specifications
Namespace alpha claims its territorial space
Bootstrap servers establish their foundation
Three brokers humming in their designated place
Now spin up beta in its separate zone
Identical config but different domain
Mirror Maker Two connects the distant shores
Replication lag becomes our refrain

[Chorus]
Mirror mirror, replicate it all
Topics flowing through the Kubernetes wall
Source to target, offset synchrony
Mirror mirror, failover guarantee
When the primary tumbles down
Mirror maker wears the crown

[Bridge]
Simulate the chaos, kill the source cluster
Watch consumers scramble for new ground
Offset translation maps the message history
Zero data loss when failover's found
Consumer groups resume from where they paused
Mirror maker's magic saves the day

[Verse 3]
Kafka Mirror Maker Two resource deployed
Connect clusters with connector threads
Checkpoints written, heartbeats detected
Replication flows where data spreads
Test the failover, validate the switch
Consumer offsets properly aligned
Active-passive becomes passive-active
Disaster recovery by design

[Chorus]
Mirror mirror, replicate it all
Topics flowing through the Kubernetes wall
Source to target, offset synchrony
Mirror mirror, failover guarantee
When the primary tumbles down
Mirror maker wears the crown

[Outro]
Multi-cluster mastery achieved
Strimzi orchestrates the grand ballet
High availability through replication
Mirror maker saves the day

33. 1 Metrics with Prometheus

[Verse 1]
Strimzi ships with secrets hiding deep inside
JMX to Prometheus, the bridge we need to ride
Metrics flow like whispers from each broker's beating heart
Configure the exporter, let the monitoring start

[Chorus]
Metrics config, unlock the vault
Under-replicated nightmares halt
Request latency tells the tale
Consumer lag will make or break the scale
Prometheus pulls what Kafka sends
Monitor the stream that never ends

[Verse 2]
In your Kafka resource, nest the metrics section tight
Point to config maps that hold your scraping appetite
Prometheus operator lands with custom resources bright
ServiceMonitor discovers what to capture through the night

[Chorus]
Metrics config, unlock the vault
Under-replicated nightmares halt
Request latency tells the tale
Consumer lag will make or break the scale
Prometheus pulls what Kafka sends
Monitor the stream that never ends

[Verse 3]
Under-replicated partitions scream when brokers fall
Request latency spikes reveal the chokepoints in it all
Throughput numbers paint the highway traffic in your queue
Consumer lag exposes when your apps can't make it through

[Bridge]
JMX speaks in numbers, Prometheus translates the code
Every millisecond matters on this data-heavy road
Grafana draws the pictures from the metrics that you've stored
Dashboard revelations keep your clusters battle-scored

[Chorus]
Metrics config, unlock the vault
Under-replicated nightmares halt
Request latency tells the tale
Consumer lag will make or break the scale
Prometheus pulls what Kafka sends
Monitor the stream that never ends

[Outro]
When your brokers whisper secrets through the exporter's ear
Prometheus catches every breath, the truth becomes crystal clear

34. 2 Dashboards with Grafana

[Verse 1]
Download the Strimzi package, extract the prize inside
Grafana folder holds the JSON treasures, dashboards certified
Import each template through the interface, drag and drop with ease
Kafka metrics spring to vivid life across your monitor screens

[Chorus]
Broker beats and ZooKeeper peaks, Connect flows in between
Custom charts for business hearts, the clearest you've ever seen
Graph-a-na, Graph-a-na, painting data streams
SLIs that never lie, monitoring your dreams

[Verse 2]
Broker dashboard shows the throughput, messages per second fly
CPU usage, memory pressure, disk space climbing high
Partition leadership elections, replica synchronization
Network IO and request latency, cluster optimization

[Chorus]
Broker beats and ZooKeeper peaks, Connect flows in between
Custom charts for business hearts, the clearest you've ever seen
Graph-a-na, Graph-a-na, painting data streams
SLIs that never lie, monitoring your dreams

[Verse 3]
ZooKeeper ensemble watching, coordination never sleeps
Election timeouts, session counts, the metadata it keeps
Outstanding requests and watch events, ensemble health displayed
Quorum status, leader switches, distributed state parade

[Verse 4]
Connect dashboard tracks the workers, connector tasks in motion
Failed attempts and transformation throughput across the ocean
Sink and source connectors flowing, pipeline health revealed
Custom panels for your business metrics, insights now unsealed

[Bridge]
Build your own with query magic, PromQL expressions bright
Business SLIs and golden signals, operational insight
Revenue metrics, user journeys, conversion rates that matter
Transform raw Kafka data into business intelligence chatter

[Chorus]
Broker beats and ZooKeeper peaks, Connect flows in between
Custom charts for business hearts, the clearest you've ever seen
Graph-a-na, Graph-a-na, painting data streams
SLIs that never lie, monitoring your dreams

[Outro]
Three dashboards imported, one custom creation
Grafana visualization, Kafka observation

35. 3 Distributed Tracing

[Verse 1]
Messages whisper through the cluster maze
OpenTelemetry captures every phase
Traces bloom like breadcrumbs in the stream
Producer speaks, the broker starts to dream

[Chorus]
Follow the thread from source to destination
Jaeger maps the conversation
Zipkin shows the path between
Every hop along the pipeline scene
Trace IDs keep the story clean

[Verse 2]
Strimzi weaves the telemetry inside
Kafka topics with instrumentation tied
Headers carry context through the flow
Spans connect what happened high and low

[Chorus]
Follow the thread from source to destination
Jaeger maps the conversation
Zipkin shows the path between
Every hop along the pipeline scene
Trace IDs keep the story clean

[Bridge]
Parent spans birth children in cascade
Consumer pulls what producer made
Latency revealed in colored bars
Performance bottlenecks show their scars
Distributed systems need these eyes
To catch where communication dies

[Verse 3]
Configure collectors in your YAML files
Service mesh integration reconciles
Sampling rates control the data flood
Observability flows through Kafka's blood

[Final Chorus]
Follow the thread from source to destination
Jaeger maps the conversation
Zipkin shows the path between
Every hop along the pipeline scene
Trace IDs keep the story clean
OpenTelemetry makes it seen

[Outro]
From producer through broker to consumer's end
Distributed tracing is your debugging friend

36. 4 Logging

[Verse 1]
Kafka brokers whisper secrets in their logs
Debug level drowns you, warnings cut the fog
ERROR saves your sanity when clusters start to break
INFO strikes the balance for production's sake
Operators need their verbosity dialed down
Root logger catches all the noise around

[Chorus]
Ship it out, stream it clean
Fluentd carries every scene
Elasticsearch holds the treasure
Loki stores beyond all measure
Structure matters, JSON flows
Every field the system knows

[Verse 2]
Connect workers chattering with tasks they can't complete
TRACE reveals the mysteries beneath your feet
Fluent Bit weighs lighter when resources run thin
Buffer sizes matter when the data floods in
Parsing timestamps, routing streams by namespace
Every pod confession finds its rightful place

[Chorus]
Ship it out, stream it clean
Fluentd carries every scene
Elasticsearch holds the treasure
Loki stores beyond all measure
Structure matters, JSON flows
Every field the system knows

[Bridge]
Correlation IDs thread the needle
Request spans make debugging feeble
Labels, annotations, metadata rich
Query patterns scratch the itch
Retention policies trim the fat
Structured fields where insights sat

[Verse 3]
Appenders write to console, file, or socket
Log4j configurations in your pocket
Rolling policies prevent disk explosion
Async writers smooth the data motion
Custom formatters shape the message flow
Grafana dashboards make the patterns show

[Chorus]
Ship it out, stream it clean
Fluentd carries every scene
Elasticsearch holds the treasure
Loki stores beyond all measure
Structure matters, JSON flows
Every field the system knows

[Outro]
When exceptions cascade and systems strain
Structured logs illuminate the pain
From broker heartbeat to consumer lag
Every metric tells its story in the bag

37. 5 Alerting

[Verse 1]
Prometheus watches every heartbeat of your cluster
Rules defined to catch the chaos before it ruptures
When brokers vanish from the network's pulse
Alert manager screams the fault

[Chorus]
Four alarms that never sleep
Broker down runs canyon deep
Under-replicated partitions cry
Disk usage climbing to the sky
Consumer lag trails behind the stream
Critical alerts guard the dream

[Verse 2]
Kafka dot server dot replica dot manager
Counts the copies, sounds the danger
When partitions lose their backup twins
The reliability story begins

[Chorus]
Four alarms that never sleep
Broker down runs canyon deep
Under-replicated partitions cry
Disk usage climbing to the sky
Consumer lag trails behind the stream
Critical alerts guard the dream

[Verse 3]
Storage threshold hits the red zone marker
Ninety percent means trouble's darker
PagerDuty buzzes through the midnight hour
Slack channels flood with warning power

[Bridge]
OpsGenie routes the escalation ladder
Teams respond when metrics scatter
Alert manager config holds the keys
Notification channels guarantee

[Verse 4]
Consumer groups fall behind the offset
Lag accumulates, data's not fresh yet
Milliseconds stretch to minutes long
Monitor the queue before it's gone

[Final Chorus]
Four alarms that never sleep
Broker down runs canyon deep
Under-replicated partitions cry
Disk usage climbing to the sky
Consumer lag trails behind the stream
Critical alerts guard the stream
Prometheus keeps the Kafka dream

[Outro]
Rules in YAML, targets defined
Strimzi metrics intertwined
Alert when the cluster needs your care
Monitoring magic everywhere

38. 6 Lab: Full Observability Stack

[Verse 1]
Prometheus Operator lands on our cluster stage
Grafana joins the monitoring brigade
YAML manifests unfold like blueprints drawn
Custom resources spawning at the break of dawn
Strimzi waits with metrics locked away
Time to crack the code and light the observability display

[Chorus]
P-O-G stack rising up
Prometheus, Operator, Grafana cup
Metrics flowing, dashboards glowing
Consumer lag alerts are showing
P-O-G stack, never stop
Monitor every Kafka hop

[Verse 2]
Enable metrics in your Kafka configuration
JMX exporters bridge the gap to revelation
Pods restart with telemetry streams alive
Nine-oh-four-oh port where numbers thrive
Import dashboards from the Strimzi treasure chest
Visualize the pulse within your message fest

[Chorus]
P-O-G stack rising up
Prometheus, Operator, Grafana cup
Metrics flowing, dashboards glowing
Consumer lag alerts are showing
P-O-G stack, never stop
Monitor every Kafka hop

[Bridge]
Pause that consumer group and watch the magic
Numbers climbing, situation turns dramatic
Threshold breached, alerts are screaming loud
Your observability makes the system proud
Kafka heartbeat echo through the dashboard maze
Full stack vision cuts through data haze

[Verse 3]
PrometheusRule defines the trigger point
Consumer lag exceeding every joint
AlertManager catches signals in the night
Notification channels burning bright
Grafana panels paint the story clear
Your Kafka cluster whispers in your ear

[Chorus]
P-O-G stack rising up
Prometheus, Operator, Grafana cup
Metrics flowing, dashboards glowing
Consumer lag alerts are showing
P-O-G stack, never stop
Monitor every Kafka hop

[Outro]
Full observability achieved at last
Present, future connected to the past
Strimzi metrics dancing in the light
Your monitoring fortress burning bright

39. 1 Rolling Updates & Upgrades

[Verse 1]
Strimzi orchestrates the pods like clockwork gears
Rolling restart cascades through brokers without tears
One by one they cycle down, then spring back to life
Zero downtime maintenance cuts through operational strife

[Chorus]
Roll and upgrade, never skip a beat
Pod annotation triggers make the cycle complete
Version by version, protocol aligned
Log format follows, leaving nothing behind
Roll and upgrade, Strimzi leads the way

[Verse 2]
Operator version bumps require careful choreography
Download the YAML, apply with topology
Custom resources migrate through conversion hooks
Schema evolution written in Kubernetes books

[Chorus]
Roll and upgrade, never skip a beat
Pod annotation triggers make the cycle complete
Version by version, protocol aligned
Log format follows, leaving nothing behind
Roll and upgrade, Strimzi leads the way

[Verse 3]
Kafka version jumps need inter-broker sync
Protocol negotiation prevents the missing link
First upgrade the binaries, keep protocol low
Then bump protocol version, watch compatibility grow

[Bridge]
Canary pods test the waters first
Single instance validates before the burst
Staged rollout spreads across the fleet
Monitoring confirms each step's complete

[Chorus]
Roll and upgrade, never skip a beat
Pod annotation triggers make the cycle complete
Version by version, protocol aligned
Log format follows, leaving nothing behind
Roll and upgrade, Strimzi leads the way

[Outro]
Log message format waits until the end
When all brokers speak the same, then format can ascend
Rolling updates master the Kubernetes dance
Strimzi automation gives resilience a chance

40. 2 Scaling

[Verse 1]
When your cluster hits the ceiling, time to multiply
Add more brokers to the fleet, watch throughput amplify
Edit your Kafka custom resource, bump the replica count
Strimzi orchestrates the growth, every instance paramount

[Chorus]
Scale up, scale down, brokers join the dance
Partition shuffle follows every scaling chance
Cruise Control and KafkaRebalance hold the key
Connect workers flex and bend with workload's spree

[Verse 2]
Partitions cling to old nodes when you shrink the pool
Reassignment algorithms become your sharpest tool
Leaders migrate, replicas shift to active hosts
Balance the load distribution across remaining posts

[Chorus]
Scale up, scale down, brokers join the dance
Partition shuffle follows every scaling chance
Cruise Control and KafkaRebalance hold the key
Connect workers flex and bend with workload's spree

[Verse 3]
Deploy KafkaRebalance custom resource with care
Cruise Control analyzes metrics hanging in the air
CPU and network bandwidth, disk utilization stats
Generate optimization proposals, iron out the stats

[Bridge]
Connect clusters scale independently from broker nodes
Increase worker replicas when connector workloads explode
Task distribution spreads across the worker pool
Parallel processing keeps the data pipeline cool

[Chorus]
Scale up, scale down, brokers join the dance
Partition shuffle follows every scaling chance
Cruise Control and KafkaRebalance hold the key
Connect workers flex and bend with workload's spree

[Outro]
Elastic infrastructure bends but never breaks
Strimzi manages the complexity that scaling makes
From single broker testing to production's mighty roar
Kubernetes orchestration opens every scaling door

41. 3 Cruise Control for Rebalancing

[Verse 1]
Partitions scattered like autumn leaves across the cluster floor
CPU burning hot on node three while node one barely snores
Enter Cruise Control, the architect with algorithmic eyes
Scanning every replica, optimizing where each topic flies

[Chorus]
KafkaRebalance, KafkaRebalance
Proposal waits for your approval dance
Full mode shifts everything around
Add-broker spreads the data crown
Remove-broker pulls it tight
Monitor the graceful flight

[Verse 2]
Create the resource, watch it calculate the perfect plan
Disk utilization evening out according to its scan
Network throughput balanced like a symphony in tune
But nothing moves until you say "approved" beneath the moon

[Chorus]
KafkaRebalance, KafkaRebalance
Proposal waits for your approval dance
Full mode shifts everything around
Add-broker spreads the data crown
Remove-broker pulls it tight
Monitor the graceful flight

[Bridge]
Ready state holds its breath
Proposing whispers what comes next
Rebalancing starts the dance
Stopped means something broke the trance
Watch the status like a hawk
If disaster strikes, just walk it back

[Verse 3]
Three modes spinning like a carousel of redistribution
Full rebalance reshuffles all with mathematical precision
Add-broker welcomes newcomers with partitions spread their way
Remove-broker gracefully evacuates the one that cannot stay

[Chorus]
KafkaRebalance, KafkaRebalance
Proposal waits for your approval dance
Full mode shifts everything around
Add-broker spreads the data crown
Remove-broker pulls it tight
Monitor the graceful flight

[Outro]
When the cluster tips uneven
Cruise Control becomes your beacon
Partition assignment salvation
Through calculated automation

42. 4 Backup and Recovery

[Verse 1]
When your Kafka cluster crumbles in the night
Topic configs vanish from your sight
Export the metadata while systems breathe
Custom resources hold what you believe
Store those YAML treasures safe and sound
Before disaster brings your world around

[Chorus]
Backup, restore, the cycle never ends
Mirror, snapshot, on these you depend
TSAR keeps your topics, offsets in their place
PVC snapshots guard your storage space
When chaos strikes, you'll stand your ground
Recovery magic, safe and sound

[Verse 2]
Consumer offsets tell the reading tale
Where each partition left its paper trail
Export the positions, timestamp every mark
Internal topics hold data in the dark
Committed offsets stored in special zones
Recovery scripts rebuild from these stones

[Chorus]
Backup, restore, the cycle never ends
Mirror, snapshot, on these you depend
TSAR keeps your topics, offsets in their place
PVC snapshots guard your storage space
When chaos strikes, you'll stand your ground
Recovery magic, safe and sound

[Bridge]
MirrorMaker Two spans the cloudy divide
Source to target, streams flowing wide
Heartbeat connectors pulse the vital signs
Checkpoint clusters crossing distant lines
Automated failover when primaries fall
Disaster recovery answers the call

[Verse 3]
Persistent volumes hold your precious state
Snapshot APIs seal your cluster's fate
CSI drivers capture disk at rest
Kubernetes storage puts backups to test
Point-in-time recovery rolls back the clock
Frozen moments when your data stops

[Chorus]
Backup, restore, the cycle never ends
Mirror, snapshot, on these you depend
TSAR keeps your topics, offsets in their place
PVC snapshots guard your storage space
When chaos strikes, you'll stand your ground
Recovery magic, safe and sound

[Outro]
Four pillars strong, your fortress complete
Topics, offsets, mirrors, snapshots neat
Strimzi guardians watch over all
Ready to catch you when systems fall

43. 5 Troubleshooting Common Issues

[Verse 1]
Pods are spinning wheels of death, CrashLoopBackOff appears
Memory limits squeeze too tight, storage claims disappear
Configuration maps gone wrong, secrets missing from the game
Check your YAML syntax close, restart policy to blame

[Chorus]
Five alarms ring through the cluster night
CRASH-CERT-NET-PART-OP burning bright
Memory-Storage-Config-DNS
Under-replicated mess
Certificate rotation stress
Operator reconciliation distress

[Verse 2]
Certificates expire fast, handshakes failing left and right
TLS connections break apart, authentication out of sight
Rotation schedules missed their mark, trust stores need refreshing now
KeyStore passwords lost in time, certificate chains somehow

[Chorus]
Five alarms ring through the cluster night
CRASH-CERT-NET-PART-OP burning bright
Memory-Storage-Config-DNS
Under-replicated mess
Certificate rotation stress
Operator reconciliation distress

[Verse 3]
Network packets drop like stones, DNS queries hit the wall
Firewall rules block the ports, security groups stall
Service mesh misconfigured, ingress routes lead nowhere
Load balancer health checks fail, endpoints vanish in thin air

[Bridge]
In-Sync-Replicas shrinking down
Partitions scattered all around
Consumer groups rebalance wild
RBAC permissions filed

[Verse 4]
Under-replicated partitions cry, ISR numbers fall below
Leader elections stumble blind, followers refuse to grow
Consumer storms rebalance mad, groups reassigned each second
Partition ownership chaos spreads, stability never beckoned

[Verse 5]
Operator sleeps through reconcile loops, RBAC denies the way
Custom Resource Definitions old, versions lead astray
Finalizers block deletion paths, webhooks timeout expired
Controller manager permissions locked, desired state never fired

[Chorus]
Five alarms ring through the cluster night
CRASH-CERT-NET-PART-OP burning bright
Memory-Storage-Config-DNS
Under-replicated mess
Certificate rotation stress
Operator reconciliation distress

[Outro]
Troubleshoot the Kafka maze
Fix these problems, count the ways
Strimzi mastery takes its toll
Kubernetes control

44. 6 Lab: Cluster Upgrade & Rebalance

[Verse 1]
Your cluster's running version three point eight
But four point zero's knocking at the gate
Edit your Kafka Custom Resource file
Bump the version number, test and smile
Rolling update starts its careful dance
Each broker restarts when it gets the chance
Zero downtime while the pods transform
Keeping all your data safe and warm

[Chorus]
Upgrade, rebalance, distribute the load
Version N to N plus one we go
Add a broker, watch partitions flow
Cruise Control knows which way to grow
Upgrade, rebalance, stability's key
Consumer groups running happily
Cluster evolution, smooth as can be

[Verse 2]
New broker joins the Kafka federation
Scale your replicas through configuration
Strimzi operator sees the change
Schedules pods across the cluster range
Fresh broker's hungry for some work to do
Partitions scattered like morning dew
Time to trigger rebalancing power
Cruise Control will orchestrate this hour

[Chorus]
Upgrade, rebalance, distribute the load
Version N to N plus one we go
Add a broker, watch partitions flow
Cruise Control knows which way to grow
Upgrade, rebalance, stability's key
Consumer groups running happily
Cluster evolution, smooth as can be

[Bridge]
Create a rebalance annotation
Watch the partition migration
Even spread across machines
Check consumer group routines
Lag monitors stay in the green
Smoothest upgrade you've ever seen

[Verse 3]
Verify the cluster's in perfect health
Partitions spread like distributed wealth
Each broker carries its equal share
Consumer groups process without a care
Offset commits flowing just like before
Throughput metrics better than before
Version four point zero running strong
Your upgrade journey's complete, sing along

[Chorus]
Upgrade, rebalance, distribute the load
Version N to N plus one we go
Add a broker, watch partitions flow
Cruise Control knows which way to grow
Upgrade, rebalance, stability's key
Consumer groups running happily
Cluster evolution, smooth as can be

[Outro]
From old to new with zero pain
Kafka clusters upgraded again
Strimzi magic, Kubernetes might
Your streaming platform shines so bright

45. 1 High Availability

[Verse 1]
Three brokers minimum standing in formation
Like guardians scattered across the constellation
When one falls silent, the others remain
Kafka keeps flowing through digital rain
Min insync replicas set to two
Guarantees your data makes it through

[Chorus]
Three brokers, two replicas in sync
Pod budgets hold the missing link
Spread across zones like seeds in soil
Anti-affinity prevents the coil
High availability, never break
That's the promise Kafka makes

[Verse 2]
Pod disruption budgets draw the line
How many can vanish at one time
Kubernetes rolling updates must wait
Till the minimum threshold you create
Topology spread constraints take control
Distribution is the ultimate goal

[Chorus]
Three brokers, two replicas in sync
Pod budgets hold the missing link
Spread across zones like seeds in soil
Anti-affinity prevents the coil
High availability, never break
That's the promise Kafka makes

[Bridge]
Zone alpha, beta, gamma apart
Each broker plays its crucial part
Never let them share the same machine
Anti-affinity keeps the distance clean
Preferred scheduling finds the way
Required rules that pods obey

[Verse 3]
When disaster strikes a single zone
Other regions carry on alone
Fault domains scattered far and wide
Message streams continue their ride
Partition leaders switch with grace
No single point becomes the case

[Final Chorus]
Three brokers, two replicas in sync
Pod budgets hold the missing link
Spread across zones like seeds in soil
Anti-affinity prevents the coil
High availability, systems wake
To the promises that Strimzi makes

[Outro]
Distribution, separation, replication flow
High availability wherever you go

46. 2 Performance Optimization

[Verse 1]
Producers pack their messages tight, batch size determines flight
Ten thousand records bundled clean, or just sixteen lean and mean
Linger milliseconds pause the stream, wait for payload dreams
Compression algorithms squeeze the load, gzip or snappy decode

[Chorus]
Tune the knobs and twist the dials
Batch and linger, compression files
Fetch and poll with measured grace
Brokers threading at your pace
Storage spinning, memory humming
JVM garbage collector coming
Performance peaks when settings align
Kafka clusters running fine

[Verse 2]
Consumer fetch brings megabytes, five hundred max poll records bite
Buffer sizes control the flood, prevent the overwhelming mud
Network threads handle the chatter, IO threads make data matter
Eight by eight the golden ratio, broker scaling portfolio

[Chorus]
Tune the knobs and twist the dials
Batch and linger, compression files
Fetch and poll with measured grace
Brokers threading at your pace
Storage spinning, memory humming
JVM garbage collector coming
Performance peaks when settings align
Kafka clusters running fine

[Bridge]
Benchmark IOPS on your drives
Throughput metrics come alive
G1 garbage collector sweeps
Memory regions, generational heaps
Parallel marking, concurrent cycles
Young and old space memory tricycles

[Verse 3]
Millisecond latencies drop, when producer batches never stop
Consumer lag begins to fade, with fetch size properly arrayed
CPU cores spinning calculations, network bandwidth utilizations
Storage layers optimized for speed, Kubernetes pods fulfill the need

[Chorus]
Tune the knobs and twist the dials
Batch and linger, compression files
Fetch and poll with measured grace
Brokers threading at your pace
Storage spinning, memory humming
JVM garbage collector coming
Performance peaks when settings align
Kafka clusters running fine

[Outro]
Metrics dashboard glowing green
Smoothest pipeline ever seen
Strimzi operators orchestrate
Performance tuning worth the wait

47. 3 Capacity Planning

[Verse 1]
Storage math unfolds in three dimensions clear
Retention times throughput, replication near
Seven days of messages at fifty meg per second
Times your replica factor, disk space is reckoned
Multiply and calculate, the bytes will tell their tale
Terabytes accumulate when Kafka ships at scale

[Chorus]
R-T-R, retention throughput replication
Size your cluster right with proper calculation
Two gigs RAM per broker, four cores spinning fast
Network pipes must carry what replication broadcasts

[Verse 2]
Memory per broker starts at two gigabytes minimum
CPU cores quadruple when your workload's growing premium
JVM heap settings take their quarter of the RAM
Producer batches, consumer groups all need their diagram
Monitor your utilization, watch the metrics climb
Scale horizontally before you're fighting against time

[Chorus]
R-T-R, retention throughput replication
Size your cluster right with proper calculation
Two gigs RAM per broker, four cores spinning fast
Network pipes must carry what replication broadcasts

[Bridge]
Partitions multiply your throughput potential
But keep them reasonable, performance is essential
Thousand partitions per broker, that's your ceiling line
Network bandwidth doubles when replicas align
Leader election storms when partition counts explode
Choose your shard strategy, balance the load

[Verse 3]
Bandwidth calculations factor replication streams
Producer traffic doubled in your capacity schemes
Cross-rack networking carries follower updates
Ten gigabit connections prevent replication waits
Disk throughput matters when consumers lag behind
Sequential writes and reads keep Kafka aligned

[Chorus]
R-T-R, retention throughput replication
Size your cluster right with proper calculation
Two gigs RAM per broker, four cores spinning fast
Network pipes must carry what replication broadcasts

[Outro]
Plan your capacity with mathematics sound
Storage, CPU, memory, network all compound
Kafka clusters prosper when resources align
Measure twice, deploy once, performance will shine

48. 4 GitOps & Infrastructure as Code

[Verse 1]
Code repos whisper secrets in the night
ArgoCD pulls the changes, syncs them right
Declarative state becomes our guiding star
While Flux watches branches from afar
Strimzi clusters dance to Git's command
Infrastructure spun from version-controlled hands

[Chorus]
GitOps flows, infrastructure grows
Helm charts hold what every cluster knows
Kustomize layers, environment prayers
CI CD delivers without human errors
Version controlled dreams in YAML streams
GitOps flows, infrastructure grows

[Verse 2]
Helm templates breathing values from the source
Custom overlays chart our deployment course
Staging mirrors production's sacred form
Kustomize patches weather every storm
Base configurations spread their wings
While overlays tune environment-specific things

[Chorus]
GitOps flows, infrastructure grows
Helm charts hold what every cluster knows
Kustomize layers, environment prayers
CI CD delivers without human errors
Version controlled dreams in YAML streams
GitOps flows, infrastructure grows

[Bridge]
Topics birthed in pipelines automated
Connectors configured, never manually created
Merge requests trigger Kafka's transformation
GitOps orchestrates across every nation
Pull not push becomes our battle cry
Infrastructure truth that cannot lie

[Verse 3]
Values files scattered across namespaced terrain
Dev test prod each singing their refrain
Continuous integration tests our schemas clean
While deployment pipelines paint the cluster scene
Kafka operators read our Git intentions
Transform them into running dimensions

[Chorus]
GitOps flows, infrastructure grows
Helm charts hold what every cluster knows
Kustomize layers, environment prayers
CI CD delivers without human errors
Version controlled dreams in YAML streams
GitOps flows, infrastructure grows

[Outro]
Git commits echo through distributed space
Kubernetes clusters mirror their embrace
Strimzi dances to our version control beat
GitOps makes infrastructure complete

49. 5 Multi-Tenancy

[Verse 1]
In the kingdom of Kafka streams, tenants need their space
Namespace walls divide the realm, each with their own place
Customer A gets their corner, Customer B their zone
Kubernetes labels mark the borders, none shall walk alone

[Chorus]
Multi-tenancy mastery, isolation is the key
Quotas guard the gateway, ACLs set you free
Shared or dedicated, choose your cluster fate
Name your topics wisely, don't let permissions wait

[Verse 2]
Bytes per second flowing fast, producers at the gate
Rate limits keep the balance, before it's far too late
Consumer quotas throttle down when appetites run wild
Request rates monitor the pulse, keep traffic flow styled

[Chorus]
Multi-tenancy mastery, isolation is the key
Quotas guard the gateway, ACLs set you free
Shared or dedicated, choose your cluster fate
Name your topics wisely, don't let permissions wait

[Verse 3]
Topic names tell stories clear, prefixes hold the truth
Customer-underscore-events reveals the tenant's proof
ACL patterns match the scheme, wildcards dance in line
Permission matrices unfold, yours and mine defined

[Bridge]
Shared clusters save your coins but mix the tenant soup
Dedicated pods cost more but keep each group's own loop
Security requirements whisper which path you should take
Performance isolation hangs upon the choice you make

[Chorus]
Multi-tenancy mastery, isolation is the key
Quotas guard the gateway, ACLs set you free
Shared or dedicated, choose your cluster fate
Name your topics wisely, don't let permissions wait

[Outro]
Strimzi orchestrates the dance, Kubernetes holds the stage
Every tenant gets their spotlight in this streaming age

50. 1 Strimzi on OpenShift

[Verse 1]
Red Hat's commercial wrapper gleaming bright
AMQ Streams packaging Strimzi's might
Operators certified through OLM's embrace
Lifecycle management sets the deployment pace
Security contexts constrain what pods can do
SCCs define the boundaries running through

[Chorus]
Routes expose the clusters externally
OLM orchestrates operators seamlessly  
SCCs secure containers carefully
OpenShift amplifies Kafka's symphony
Monitor metrics flowing endlessly
Strimzi on Big Red runs beautifully

[Verse 2]
Service monitors scrape the Prometheus way
Grafana dashboards paint performance data's play
AlertManager rules trigger when thresholds break
Custom resource definitions frameworks make
ImageStreams track the container versions' flow
BuildConfigs compile what developers bestow

[Chorus]
Routes expose the clusters externally
OLM orchestrates operators seamlessly
SCCs secure containers carefully  
OpenShift amplifies Kafka's symphony
Monitor metrics flowing endlessly
Strimzi on Big Red runs beautifully

[Bridge]
Projects namespace the multi-tenant space
DeploymentConfigs orchestrate each workload's place
Templates parameterize repeatable designs
While Routes and Services connect the dotted lines

[Verse 3]
Commercial support when production systems fail
Enterprise subscriptions keep clusters on the trail
Anyuid SCC lets containers break the mold
While restricted contexts keep security controlled
OperatorHub catalogs the certified stack
Subscription updates keep versions on track

[Chorus]
Routes expose the clusters externally
OLM orchestrates operators seamlessly
SCCs secure containers carefully
OpenShift amplifies Kafka's symphony
Monitor metrics flowing endlessly
Strimzi on Big Red runs beautifully

[Outro]
Enterprise Kafka streaming without the pain
OpenShift and Strimzi dancing in the rain
Red Hat's platform makes complexity tame
Kafka clusters running strong in the enterprise game

51. 2 Kafka Bridge (HTTP API)

[Verse 1]
When legacy systems need a modern voice
HTTP becomes your messaging choice
Deploy KafkaBridge with Strimzi's grace
REST endpoints dancing in Kubernetes space
No native clients, no protocol shift
Bridge translates with performance drift

[Chorus]
Bridge the gap with REST today
POST your messages, GET replies
Consumer groups in JSON arrays
KafkaBridge simplifies
Legacy speaks to streaming queues
Through HTTP, old meets new

[Verse 2]
Serverless functions need event-driven feeds
Lambda talking Kafka through HTTP needs
IoT devices with simple requests
Bridge handles routing while Kafka digests
Configuration sets the listening port
Topic mapping keeps data transport short

[Chorus]
Bridge the gap with REST today
POST your messages, GET replies
Consumer groups in JSON arrays
KafkaBridge simplifies
Legacy speaks to streaming queues
Through HTTP, old meets new

[Bridge]
Performance trade-offs you must weigh
Throughput lower than native way
Stateless nature brings connection cost
Batch operations help what's lost
Scaling pods spreads the load
But memory pressure breaks the code

[Verse 3]
Custom Resource Definition takes its place
Replicas and resources set the pace
Authentication flows through bearer tokens
CORS policies keep browser hopes unbroken
Monitor metrics for bottleneck signs
Tune timeouts where latency climbs

[Chorus]
Bridge the gap with REST today
POST your messages, GET replies
Consumer groups in JSON arrays
KafkaBridge simplifies
Legacy speaks to streaming queues
Through HTTP, old meets new

[Outro]
When protocol barriers block your way
KafkaBridge opens REST highway
Integration patterns find their groove
Old systems learn new streaming moves

52. 3 Schema Registry Integration

[Verse 1]
Deploy Apicurio beside your Strimzi cluster
Confluent Schema Registry waits in wings
Custom resources spinning up the structure
Data contracts that every message brings
YAML manifests declare the endpoints clearly
Service discovery binds the registry tight

[Chorus]
Schema evolution, compatibility flowing
Avro Protocol JSON growing
Forward backward transitive modes
Full compatibility explodes
Registry guards the data throne
Never breaks what's already known

[Verse 2]
Avro binary compression makes it faster
Protobuf definitions carved in stone
JSON Schema validates each transaction master
Type safety built into every zone
Serializers check against the central catalog
Before producers push to Kafka streams

[Chorus]
Schema evolution, compatibility flowing
Avro Protocol JSON growing
Forward backward transitive modes
Full compatibility explodes
Registry guards the data throne
Never breaks what's already known

[Bridge]
Version numbers climbing up the ladder
Field additions optional by design
Remove a field and consumers won't shatter
Backwards compatibility keeps the line
Subject names map to topic architecture
Schema IDs embedded in each byte

[Verse 3]
Strimzi operators orchestrate the marriage
Between your registry and Kafka pods
Network policies control the data carriage
Authentication serves the schema gods
Helm charts deploy the integrated fortress
Message evolution stays controlled

[Final Chorus]
Schema evolution, compatibility flowing
Avro Protocol JSON growing
Forward backward transitive modes
Full compatibility explodes
Registry guards the data throne
Never breaks what's already known
Strimzi schemas perfectly grown

53. 4 Kafka Streams & ksqlDB on Kubernetes

[Verse 1]
Your Streams app containers need a home beside
The Strimzi brokers running synchronized
Deploy them side by side within the same namespace
Where topics flow and processing takes place
Configure your dockerfile with the JAR inside
Mount volumes where your state stores will reside

[Chorus]
State stores persist, queries resist the crash
RocksDB beneath, data you can rehash
Scale horizontal, partitions divisional
Interactive calls through REST provisional
Streams and ksqlDB, deploy strategically
Kubernetes pods orchestrating seamlessly

[Verse 2]
Persistent volumes claim the storage space
RocksDB files need a permanent place
When pods restart your changelog topics restore
The local state from Kafka's durable store
Set cleanup policy to compact not delete
Keep your state stores consistent and complete

[Chorus]
State stores persist, queries resist the crash
RocksDB beneath, data you can rehash
Scale horizontal, partitions divisional
Interactive calls through REST provisional
Streams and ksqlDB, deploy strategically
Kubernetes pods orchestrating seamlessly

[Verse 3]
Interactive queries expose internal state
REST endpoints serve data without the wait
Discovery service maps which pod holds what
Partition assignments determine the slot
Configure your service mesh for pod-to-pod calls
Load balance requests across processing walls

[Bridge]
Scaling patterns match your partition count
One consumer per partition paramount
Add replicas when your load increases high
StatefulSets ensure consistent node supply
ksqlDB clusters join the Kubernetes dance
Push queries streaming, pull queries on demand

[Outro]
Monitor your lag and watch the throughput flow
Persistent storage keeps your state below
Streams applications, ksqlDB in formation
Kubernetes orchestrates the stream transformation

54. 5 Custom Operator Extensions

[Verse 1]
Deep in the cluster where operators reign
Strimzi's heartbeat pumps through every vein
But custom logic waits beyond the wall
Time to craft extensions, hear the call
Reconcilers dancing with their loops
Reading desired state through message groups

[Chorus]
Watch, Compare, Act, that's the flow
Custom operators steal the show
Extend behavior, make it yours
Through Java libraries, open doors
C-R-U-D operations in your hand
Building bridges across Kafka land

[Verse 2]
Import the client libraries with care
KafkaClient speaks to clusters everywhere
AdminClient whispers secrets to the core
TopicOperator opens up the store
Your reconciler inherits abstract might
Overriding methods through the night

[Chorus]
Watch, Compare, Act, that's the flow
Custom operators steal the show
Extend behavior, make it yours
Through Java libraries, open doors
C-R-U-D operations in your hand
Building bridges across Kafka land

[Bridge]
Fork the repository, clone it down
Pull requests dancing all around
Contributing patches to the source
Open collaboration charts the course
Your operator joins the constellation
Part of Strimzi's automation

[Verse 3]
Status updates bubble to the top
Conditions tell you when to start and stop
Event handlers catch the webhook calls
Custom resources scale beyond the walls
Namespace scoped or cluster wide domain
Your extension rides the data plane

[Chorus]
Watch, Compare, Act, that's the flow
Custom operators steal the show
Extend behavior, make it yours
Through Java libraries, open doors
C-R-U-D operations in your hand
Building bridges across Kafka land

[Outro]
From reconciler to production stage
Your custom operator turns the page
Strimzi ecosystem grows and thrives
Through the code that your extension drives

55. 1 Data Governance

[Verse 1]
Topics wear their badges, classified and neat
Sensitive or public, every stream complete
Tagging flows like ribbons through the message queue
PII and financial, marked in crimson hue
Kafka knows its secrets, metadata reveals
Every byte's ancestry, lineage unseals

[Chorus]
Classify, tag, and trace the line
Governance rules by design
Retention ticks the compliance clock
GDPR, PIPEDA, HIPAA lock
Data flows but never hides
When governance is your guide

[Verse 2]
Thirty days for shopping carts, seven years for health
PIPEDA wants deletion, GDPR stealth
Right to be forgotten echoes through the logs
Tombstone markers cleansing what the audit clogs
Compaction sweeps the remnants, policies align
Legal frameworks dancing with the retention time

[Chorus]
Classify, tag, and trace the line
Governance rules by design
Retention ticks the compliance clock
GDPR, PIPEDA, HIPAA lock
Data flows but never hides
When governance is your guide

[Bridge]
Schema registry whispers what the fields contain
Lineage graphs map the data's migration chain
From producer birth to consumer's final breath
Kubernetes orchestrates compliance until death
Topic configurations paint the legal scene
Audit trails illuminate what the flow has been

[Chorus]
Classify, tag, and trace the line
Governance rules by design
Retention ticks the compliance clock
GDPR, PIPEDA, HIPAA lock
Data flows but never hides
When governance is your guide

[Outro]
Strimzi wraps the promise in containers tight
Data governance sailing through the legal night
Classification, lineage, retention's sacred three
Kafka streams compliant, flowing wild and free

56. 2 Audit Logging

[Verse 1]
When Kafka serves requests across your cluster wide
The authorizer whispers secrets it cannot hide
Every grant and denial leaves a breadcrumb trail
Permission checks and user claims in detail

Access patterns emerge from shadows cast
Who touched what topic when the queries passed
Broker decisions etched in structured lines
Security forensics reading between the signs

[Chorus]
Audit trails never lie, never fade away
CRD changes tracked, Kubernetes displays
Immutable streams preserve compliance gold
Every click and config change, the story's told
Logs don't vanish, logs don't bend
Accountability from start to end

[Verse 2]
Custom resource definitions shifting shape
API server captures every configuration drape
Kubectl applies and Helm releases flow
Kubernetes audit engine records what you sow

Strimzi operators morphing cluster state
Admission webhooks validating at the gate
Each mutation logged with timestamp precision
Compliance officers smile at every revision

[Chorus]
Audit trails never lie, never fade away
CRD changes tracked, Kubernetes displays
Immutable streams preserve compliance gold
Every click and config change, the story's told
Logs don't vanish, logs don't bend
Accountability from start to end

[Bridge]
Pipeline architecture sealed and tight
No tampering with evidence in sight
Append-only ledgers growing strong
Regulatory frameworks singing the same song

[Verse 3]
Fluentd collectors gather streaming proof
Elasticsearch indexes bulletproof
Retention policies spanning years ahead
Auditors dancing where paper trails once led

[Final Chorus]
Audit trails never lie, never fade away
CRD changes tracked, Kubernetes displays
Immutable streams preserve compliance gold
Every click and config change, the story's told
Kafka whispers, Kubernetes knows
Compliance evidence forever flows

[Outro]
In the realm of distributed trust
Logging pipelines are a must
Every action leaves its mark
Illuminating what was dark

57. 3 Encryption & Key Management

[Verse 1]
Data travels naked through the wire
Producers craft their payload armor
TLS wraps the transport layer tight
But messages need fortress stronger
Application-level shields emerge
Encrypt before the topic merge

[Chorus]
Lock it down from source to sink
End-to-end without a chink
Vault and KMS hold the keys
Certificate mysteries
Rotate, validate, comply
Encryption's how we fortify

[Verse 2]
HashiCorp Vault becomes the keeper
Secret engine serves the cipher
Dynamic secrets, leased and timed
Policy controls who gets assigned
AWS KMS in the cloud
Hardware security makes us proud

[Chorus]
Lock it down from source to sink
End-to-end without a chink
Vault and KMS hold the keys
Certificate mysteries
Rotate, validate, comply
Encryption's how we fortify

[Bridge]
Certificate lifecycle spins around
Issue, deploy, renew, then ground
Compliance reports track every move
Audit trails help us prove
PKCS twelve bundles up the store
Keystores guard what we adore

[Verse 3]
Consumer code decrypts the stream
Symmetric keys fulfill the scheme
Envelope method wraps it neat
Data encryption key complete
Key encryption key protects
Architecture interconnects

[Chorus]
Lock it down from source to sink
End-to-end without a chink
Vault and KMS hold the keys
Certificate mysteries
Rotate, validate, comply
Encryption's how we fortify

[Outro]
Trust stores validate the chain
Security without the strain
Strimzi makes Kafka secure
Enterprise grade, that's for sure

58. 4 Access Control Documentation

[Verse 1]
Sarah needs producer access to payment topics now
Map her KafkaUser to departmental vows
Finance team requires consume permissions wide
While developers need admin rights to guide
Documentation trails must capture every grant
Organizational charts become our compliance chant

[Chorus]
M-A-P the roles, document the flow
Access Control Lists help auditors know
R-B-A-C patterns, evidence so clear
SOC2 and ISO want to see it here
Change workflows locked, approvals in sight
Kafka permissions done exactly right

[Verse 2]
Marketing reads analytics, sales writes leads
Engineering clusters need administrative deeds
Each KafkaUser spec reflects the human role
JSON manifests tell the access story whole
Quarterly reviews check entitlements align
Delete unused accounts before compliance time

[Chorus]
M-A-P the roles, document the flow
Access Control Lists help auditors know
R-B-A-C patterns, evidence so clear
SOC2 and ISO want to see it here
Change workflows locked, approvals in sight
Kafka permissions done exactly right

[Bridge]
Topic creation needs approval gates
User modifications can't tempt fate
Pull request reviews before deploy
GitOps pipelines that we employ
Separation duties, dual controls
Evidence gathering for audit goals

[Verse 3]
Principal mappings trace to employee ID
Resource patterns group by sensitivity
Allow and deny rules precisely drawn
Revocation happens when staff moves on
Matrix spreadsheets cross-reference clean
Best documented system auditors have seen

[Chorus]
M-A-P the roles, document the flow
Access Control Lists help auditors know
R-B-A-C patterns, evidence so clear
SOC2 and ISO want to see it here
Change workflows locked, approvals in sight
Kafka permissions done exactly right

[Outro]
Documentation fortress stands secure
Compliance frameworks we endure
Strimzi access patterns crystal pure
Organizational mapping we ensure

59. Appendix A: Quick Reference — Strimzi CRD Cheat Sheet

[Verse 1]
Nine CRDs control your streaming fate
Kafka starts the cluster, don't be late
Spec dot kafka holds your broker dreams
Spec dot zookeeper keeps the schemes
EntityOperator manages the flow
Three main fields are all you need to know

[Chorus]
CRDs dancing in the Kubernetes night
Spec configurations burning bright
Kafka, Topics, Users in a row
Connect and Bridge help the data flow
Nine resources, memorize their names
Strimzi orchestrates the streaming games

[Verse 2]
KafkaNodePool splits the roles apart
KRaft mode gives your cluster heart
Spec dot roles define what nodes will do
Replicas and storage see you through
Topic lifecycle needs three friends to meet
Partitions, replicas, config complete

[Chorus]
CRDs dancing in the Kubernetes night
Spec configurations burning bright
Kafka, Topics, Users in a row
Connect and Bridge help the data flow
Nine resources, memorize their names
Strimzi orchestrates the streaming games

[Bridge]
KafkaUser locks authentication tight
Authorization keeps your data right
Connect clusters build and configure streams
Connectors run with class and max task schemes
MirrorMaker2 bridges distant lands
Clusters mirror what your business demands

[Verse 3]
KafkaBridge speaks HTTP tongue
Replicas keep the service young
KafkaRebalance calls Cruise Control
Mode and goals achieve your streaming goal
Nine CRDs, each purpose crystal clear
Kubernetes native, engineered with care

[Outro]
From Kafka core to rebalancing weights
These resources seal your streaming fates
Spec fields guide you through the maze
Strimzi CRDs light your Kafka days

60. Appendix B: Recommended Learning Resources

[Verse 1]
When Kafka meets Kubernetes, where do you begin?
Strimzi documentation, that's where knowledge wins
Navigate to strimzi dot io slash documentation
Every operator secret, every configuration

[Chorus]
GitHub holds the source code, blog posts show the way
Confluent Developer teaches fundamentals every day
CNCF webinars streaming, Kafka docs complete
Six essential fountains make your learning sweet

[Verse 2]
GitHub dot com slash strimzi, where the magic lives
Custom resource definitions, all the power it gives
Pull requests and issues, community debate
Watch the repository, don't let updates wait

[Chorus]
GitHub holds the source code, blog posts show the way
Confluent Developer teaches fundamentals every day
CNCF webinars streaming, Kafka docs complete
Six essential fountains make your learning sweet

[Verse 3]
Strimzi blog reveals the patterns, real-world use cases shine
Production insights flowing, enterprise design
New features get announced here, migration stories told
Best practices crystallize, worth their weight in gold

[Bridge]
Kafka dot apache dot org slash documentation
Core concepts and protocols, solid foundation
Before you tackle Strimzi, understand the beast
Partitions, topics, brokers, knowledge feast

[Verse 4]
CNCF webinars archive, search for Strimzi talks
Expert presentations, where the wisdom walks
Developer dot confluent dot io, fundamentals reign
Schema registry, Connect, reduces learning pain

[Chorus]
GitHub holds the source code, blog posts show the way
Confluent Developer teaches fundamentals every day
CNCF webinars streaming, Kafka docs complete
Six essential fountains make your learning sweet

[Outro]
Documentation, GitHub, blog and Kafka core
CNCF wisdom, Confluent store
Six resources dancing, mastery complete
Strimzi expertise flowing, victory sweet

61. Appendix C: Lab Environment Setup

[Verse 1]
Three pathways split before your screen tonight
Kind in Docker wraps clusters light and tight
Local playground spins with minimal weight
Perfect for testing at a rapid rate
Minikube needs eight gigs to breathe and grow
Single-node comfort for the skills you'll show

[Chorus]
Three nodes dancing, four cores each
Sixteen gigs of RAM within reach
One hundred storage, SSD fast
Build your lab that's built to last
Kind, Minikube, cloud above
Choose your stage for Kafka love

[Verse 2]
Amazon's EKS or Azure's AKS throne
Google's GKE where managed clusters roam
Small node pools with enterprise-grade spine
Production flavors in a test design
Cloud providers handle all the heavy lifting
While you focus on your Kafka gifting

[Chorus]
Three nodes dancing, four cores each
Sixteen gigs of RAM within reach
One hundred storage, SSD fast
Build your lab that's built to last
Kind, Minikube, cloud above
Choose your stage for Kafka love

[Bridge]
Docker Desktop spins Kind clusters clean
Minikube VM sits in between
Cloud consoles offer scaling dreams
Pick your poison, build your schemes
Local laptops or remote machines
All roads lead to Strimzi scenes

[Verse 3]
Resource specs matter when operators deploy
Insufficient memory kills the streaming joy
CPU cycles feed the broker swarm
Storage persistence keeps your data warm
Choose your battlefield, prepare the ground
Where Kafka messages will soon be found

[Outro]
Lab foundations set the streaming stage
Infrastructure wisdom for the Kafka age

62. Appendix D: Certification Pathways

Back to Home

Strimzi: Apache Kafka on Kubernetes — Comprehensive Curriculum | 93