github/awesome-kubernetes
1
0
Fork 0
mirror of https://github.com/nubenetes/awesome-kubernetes.git synced 2026-07-12 09:51:00 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
2d42e5b0a4720062083f014cf6002fed6a4727d1
awesome-kubernetes/v2-docs/message-queue.md

143 KiB
Raw Blame History

Cloud Based Integration & Messaging. Data Processing & Streaming (aka Data Pipeline). Open Data Hub

!!! info "Architectural Context" Detailed reference for Cloud Based Integration & Messaging. Data Processing & Streaming (aka Data Pipeline). Open Data Hub in the context of Data & Advanced Analytics.

Standard Reference

Architecture

Data Mesh

Azure

  • (2021) mrpaulandrew.com: BUILDING A DATA MESH ARCHITECTURE IN AZURE – PART 2 [N/A CONTENT] [ADVANCED LEVEL] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — A deep technical implementation guide focused on constructing a logical Data Mesh within Microsoft Azure. It reviews how to use Azure Synapse, Purview, and Data Lake Storage (ADLS Gen2) to establish federated security models and self-serve storage layers for localized domains.

Data Products

  • (2020) towardsdatascience.com: Data Domains and Data Products [N/A CONTENT] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — An exploration of how to define domain boundaries and formalize data products in a modern Data Mesh framework. It outlines criteria for establishing data ownership, SLA specifications, and technical standards to build reliable, discoverable, and interoperable dataset products.

Foundations

  • (2020) martinfowler.com: Data Mesh Principles and Logical Architecture [N/A CONTENT] [ADVANCED LEVEL] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — The seminal architectural document by Zhamak Dehghani outlining Data Mesh principles: decentralized domain ownership, data as a product, self-serve data platforms, and federated computational governance. It details how to break down monolithic data lake infrastructures into domain-driven microservices.

Migration

  • (2019) martinfowler.com: How to Move Beyond a Monolithic Data Lake to a Distributed Data Mesh [N/A CONTENT] [ADVANCED LEVEL] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — The primary architectural playbook for transitioning away from monolithic data lakes to a distributed, domain-centric Data Mesh. It highlights the organizational transformations, interface structures, and self-serve platform mechanics necessary to implement this architecture.

Syntheses

  • (2020) infoq.com: Data Mesh Principles and Logical Architecture Defined [N/A CONTENT] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — An analytical synthesis of the core tenets of logical Data Mesh architectures. It reviews decentralized data management strategies, illustrating how organizations can enforce federated policy controls while treating internal analytics streams as high-value, self-describing products.

Hybrid Cloud

App Modernization

Google Anthos

  • (2021) confluent.fr: Infrastructure Modernization with Google Anthos and Apache Kafka [N/A CONTENT] [ADVANCED LEVEL] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — This architectural study outlines app modernization paradigms using Google Anthos alongside Confluent Kafka. It covers cross-cloud synchronization models, data residency strategies, and how to maintain high availability for hybrid event-driven systems.

Infrastructure as Code

Event-Driven

IoT

Protocols

Microservices Patterns

Decoupling

  • (2019) developers.redhat.com: Decoupling microservices with Apache Camel and Debezium [JAVA CONTENT] [ADVANCED LEVEL] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — This guide covers the integration of Apache Camel and Debezium to decouple microservice database dependencies. By leveraging Camel's rich Enterprise Integration Patterns (EIP) to consume and route Debezium change event logs, organizations can eliminate dual-write risks and ensure resilient distributed transactions.

No-Code CDC

  • (2020) developers.redhat.com: Change data capture for microservices without writing any code [N/A CONTENT] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — This article demonstrates how to establish a low-maintenance, zero-code Change Data Capture (CDC) pipeline using Debezium and Kafka Connect. It explains how to decouple microservice databases using declarative configurations, bypassing custom transactional outbox implementation code entirely.

Schema Governance

  • (2021) redhat.com: Using a schema registry to ensure data consistency between microservices [N/A CONTENT] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — A strategic whitepaper discussing the foundational role of schema registries in ensuring runtime compatibility and message consistency across distributed microservice systems. It details forward/backward compatibility models and best practices for automated API version upgrades.

Scalability

Case Studies

  • (2021) shopify.engineering: Capturing Every Change From Shopify’s Sharded Monolith [N/A CONTENT] [ADVANCED LEVEL] [CASE STUDY] [CASE STUDY] [COMMUNITY-TOOL] — This engineering case study details how Shopify captured transactional data changes across thousands of sharded MySQL databases. It describes the design of their highly scalable CDC ingestion architecture, focusing on reliability, throughput optimization, and multi-tenant event routing at scale.

Cloud Infrastructure

Kubernetes

Data Storage

  • (2022) thenewstack.io: The Path to Getting the Full Data Stack on Kubernetes [ADVANCED LEVEL] [COMMUNITY-TOOL] — This article reviews the architectural evolution of running stateful database instances inside Kubernetes. It analyzes how modern storage interfaces (CSI) and specialized Operators now safely support stateful structures next to stateless applications.

Message Brokers

PaaS

Google Cloud

  • (2023) Google Cloud Platform Pub/Sub [DOCUMENTATION] [COMMUNITY-TOOL] — Documentation for GCP Pub/Sub, a fully managed, globally scaled messaging backbone. It outlines its multi-tenant event delivery model, dynamic push/pull queues, and integrations with modern data pipelines.

Cloud Native Infrastructure

Enterprise Messaging

Kafka on Kubernetes

Architecture Overview
  • (2020) speakerdeck.com: Apache Kafka with Red Hat AMQ Streams 🌟 [N/A CONTENT] [COMMUNITY-TOOL] — A deep-dive slide deck exploring the deployment patterns of Apache Kafka on Kubernetes via Red Hat AMQ Streams. It reviews the Operator Pattern implemented by Strimzi, showing how it automates the deployment, scaling, and management of Kafka clusters, ZooKeeper/KRaft nodes, Kafka Connect, and MirrorMaker using Custom Resource Definitions (CRDs).
Security
  • (2020) Set up Red Hat AMQ Streams custom certificates on OpenShift [YAML CONTENT] [ADVANCED LEVEL] [COMMUNITY-TOOL] — This architectural guide details how to integrate custom TLS certificates with Red Hat AMQ Streams (a Strimzi-based Kafka distribution) on OpenShift. It focuses on replacing the auto-generated self-signed Certificate Authorities (CAs) with enterprise-trusted certificates for the Kafka listener endpoints. Key operations include configuring Listener Custom Certs and Secret mapping to secure external consumer and producer traffic.

Kubernetes Operators

Strimzi

Day-2 Operations
  • (2020) blog.jromanmartin.io: How to upgrade Strimzi Operator using the CLI [SHELL CONTENT] [ADVANCED LEVEL] [COMMUNITY-TOOL] — A practical operational guide focused on executing safe command-line upgrades of the Strimzi Kafka Operator on active clusters. It steps through updating Custom Resource Definitions (CRDs), applying modified RBAC resources, updating the Operator Deployment manifests, and verifying cluster reconciliation states to ensure zero downtime for dependent message streams.

Cloud Native Serverless

Knative

Eventing Integration

  • (2022) rogulski.it: Consume Kafka events with Knative service and FastAPI on kubernetes 🌟 [COMMUNITY-TOOL] — A hands-on implementation guide showing how to connect Knative serverless triggers with Python-based FastAPI services on Kubernetes. Demonstrates configuring custom event subscriptions to feed incoming Kafka payloads directly to serverless worker containers.
  • (2021) piotrminkowski.com: Knative Eventing with Kafka and Quarkus [ADVANCED LEVEL] [COMMUNITY-TOOL] — Walks through the configuration of Knative Eventing infrastructure coupled with Apache Kafka topics using Quarkus-based microservices. It illustrates how to leverage the low memory footprint of GraalVM-compiled Quarkus microservices to handle event-driven workloads.
  • (2021) piotrminkowski.com: Knative Eventing with Quarkus, Kafka and Camel [ADVANCED LEVEL] [COMMUNITY-TOOL] — Demonstrates the integration of Apache Camel integrations, Quarkus microservices, and Knative serverless platforms connected via Apache Kafka brokers. Details how to design reactive pipelines that auto-scale based on incoming Kafka topic load.
  • (2021) itnext.io: Configuring Kafka Sources and Sinks declaratively in Kubernetes using Knative [ADVANCED LEVEL] [COMMUNITY-TOOL] — An operational guide focusing on declarative source and sink bindings within Kubernetes using Knative Eventing components. Demonstrates how to write custom resources (CRDs) to map Kafka topics directly to serverless HTTP endpoints without writing broker plumbing.

Data Engineering

Change Data Capture

Audit Systems

Connectors

  • (2021) developers.redhat.com: Db2 and Oracle connectors coming to Debezium 1.4 GA [N/A CONTENT] [GUIDE] [GUIDE] [LEGACY] — This release documentation highlights the arrival of enterprise-grade DB2 and Oracle connectors in Debezium 1.4 GA. It covers technical deployment requisites, schema configuration processes, and performance considerations for transitioning legacy mainframe and relational databases into modern stream architectures.

Debezium

  • (2026) ==Debezium:== [JAVA CONTENT] [ADVANCED LEVEL] 🌟🌟🌟🌟🌟 [DE FACTO STANDARD] — Debezium is the industry-standard distributed platform for log-based Change Data Capture (CDC). Built on top of Apache Kafka Connect, it translates row-level database changes into real-time event streams with minimal database overhead. This ensures strict transactional consistency across decoupled microservice architectures.

Foundations (1)

  • (2021) vladmihalcea.com: A beginner’s guide to CDC (Change Data Capture) [N/A CONTENT] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — A foundational guide outlining the core concepts and mechanics of modern Change Data Capture (CDC). It compares traditional, high-overhead polling-based models against low-latency, log-based CDC architectures, highlighting why transaction log parsers like Debezium are ideal for decoupling databases.

Kafka Connect

  • (2021) developers.redhat.com: Improve your Kafka Connect builds of Debezium. [YAML CONTENT] [ADVANCED LEVEL] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — An operational guide focusing on optimizing Kafka Connect builds when integrating Debezium connectors. It provides best practices for crafting container images via Kubernetes operators and custom resources (CRDs) to guarantee deterministic dependency resolution and streamlined cluster deployments.
  • (2020) developers.redhat.com: Capture database changes with Debezium Apache Kafka connectors [N/A CONTENT] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — A duplicate entry detailing the setup and configuration of log-based Debezium connectors. It remains an essential developer guide on streaming real-time transactional updates from relational engines into Kafka topic topologies.

Pipelines

  • (2020) Build a simple cloud-native change data capture pipeline [YAML CONTENT] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — A developer tutorial illustrating how to compile a cloud-native Change Data Capture pipeline. It utilizes Strimzi (AMQ Streams) and Debezium on Kubernetes to propagate database updates instantly into reactive microservice topologies.

PostgreSQL

  • (2020) info.crunchydata.com: PostgreSQL Change Data Capture With Debezium [SQL CONTENT] [ADVANCED LEVEL] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — A deep technical dive into configuring log-based Change Data Capture (CDC) for PostgreSQL databases using Debezium. It details logical replication slots, pgoutput plugin optimizations, WAL management, and reliable target-stream syncs inside mission-critical setups.

Production Case Studies

  • (2020) debezium.io: Lessons Learned from Running Debezium with PostgreSQL on Amazon RDS [N/A CONTENT] [ADVANCED LEVEL] [CASE STUDY] [CASE STUDY] [COMMUNITY-TOOL] — This operational retrospective outlines key lessons from running Debezium with PostgreSQL databases on Amazon RDS. It addresses replication slot management, Write-Ahead Log (WAL) retention dynamics, network failover behaviors, and AWS-specific performance configurations under heavy write operations.

Cultural Shift

Real-Time Data

Data Lakehouse

Apache Iceberg

  • (2021) debezium.io: Using Debezium to Create a Data Lake with Apache Iceberg [N/A CONTENT] [ADVANCED LEVEL] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — This architectural guide illustrates how to combine Debezium CDC with Apache Iceberg to create a low-latency, ACID-compliant transactional data lake. It outlines how streaming database changes can be direct-written to open-table formats to support scalable and cost-effective analytical engines.

Data Pipelines

Cloud Architecture

History

  • (2021) thenewstack.io: Part 1: The Evolution of Data Pipeline Architecture [N/A CONTENT] [GUIDE] [GUIDE] [LEGACY] — An evolutionary study tracing the maturation of data pipelines from legacy batch-based ETL architectures to real-time event-streaming topologies. It provides key insights into how microservice patterns and cloud infrastructure have shifted corporate data strategy toward low-latency stream processing.

OpenShift

  • (2021) openshift.com: How to Orchestrate Data Pipelines with Applications Deployed on OpenShift [N/A CONTENT] [ADVANCED LEVEL] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — This guide reviews techniques for deploying and orchestrating resilient data pipelines within Red Hat OpenShift. It outlines utilizing Kubernetes-native orchestration patterns and operators to manage high-throughput ETL/ELT tasks alongside standard microservice applications.

Databases

Event Streaming

  • (2021) thenewstack.io: The Rise of the Event Streaming Database 🌟 [ADVANCED LEVEL] [COMMUNITY-TOOL] — This piece explores the architectural rise of specialized event streaming databases (such as ksqlDB or Materialize). It details how traditional read-centric DB engines struggle under continuous live streams, and contrasts them with stream-first engines designed for real-time continuous query materialization.

Event Streaming (1)

Apache Kafka

  • (2026) ==Apache Kafka== [JAVA CONTENT] [ADVANCED LEVEL] 🌟🌟🌟🌟🌟 [DE FACTO STANDARD] — Apache Kafka is the de facto industry-standard distributed event streaming platform. Operating on a partitioned, append-only log model, Kafka handles millions of messages per second with fault-tolerant durability, acting as the centralized real-time nervous system for microservices.

Architectural Patterns

  • (2021) davidxiang.com: Kafka As A Database? Yes Or No [N/A CONTENT] [COMMUNITY-TOOL] — An analytical exploration of whether Apache Kafka should be utilized as a primary database. It clarifies Kafka's persistence guarantees, limitations in ad-hoc indexing, and the architectural trade-offs of utilizing brokers as durable systems of record.

Case Study

Foundations (2)

  • (2021) Confluent.io: Intro to Apache Kafka: How Kafka Works 🌟 [N/A CONTENT] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — Confluent's foundational training manual detailing how Apache Kafka works under the hood. It explains partitions, replication, producers, consumer offsets, and transaction patterns, serving as the primer for event-driven systems.

How-To

  • (2022) thenewstack.io: How to Get Started with Data Streaming [COMMUNITY-TOOL] — A practical guide outlining how organizations can pivot from classic batch workflows to real-time event streaming systems. It highlights the deployment phases of streaming platforms and details data integration patterns.

Installation

  • (2020) tecmint: How to Install Apache Kafka in CentOS/RHEL 7 [SHELL CONTENT] [GUIDE] [GUIDE] [LEGACY] — A step-by-step systems administration guide for installing and configuring Zookeeper and Apache Kafka bare-metal nodes on CentOS/RHEL 7. It provides crucial configuration fundamentals for legacy VM deployments.

Kafka Connect SMT

  • (2021) Single Message Transformations - The Swiss Army Knife of Kafka Connect [JAVA CONTENT] [ADVANCED LEVEL] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — An in-depth guide covering Single Message Transformations (SMTs) in Apache Kafka Connect. It demonstrates how to apply lightweight, inline modifications such as masking, routing, or restructuring data directly on connector workers before payloads hit the brokers.

Kubernetes Operators (1)

  • (2021) containerjournal.com: Red Hat Platform Brings Kafka Closer to Kubernetes [YAML CONTENT] [ADVANCED LEVEL] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — This article highlights Red Hat AMQ Streams, based on the Strimzi project, and its approach to managing Kafka on OpenShift/Kubernetes. It details how GitOps and custom resource definitions (CRDs) streamline broker, topic, and user management.

Machine Learning

Meta-Resources

  • (2026) Awesome Kafka [N/A CONTENT] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — A comprehensive, community-curated list of tools, command-line utilities, clients, and GUI frameworks for Apache Kafka administration. It serves as an essential hub for engineers searching for proven ecosystem additions.

Multi-Cluster

Podcasts

Real-Time Data (1)

  • (2022) thenewstack.io: Streaming Data and the Modern Real-Time Data Stack [COMMUNITY-TOOL] — This technical comparison contrasts the offline batch processing of the Modern Data Stack with the low-latency Modern Real-Time Data Stack. It details the mechanics of utilizing Kafka, Pulsar, or Redpanda to feed continuous pipeline architectures.

Tutorials

  • (2026) kafka-tutorials.confluent.io 🌟 [JAVA CONTENT] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — An extensive hands-on tutorial catalog for implementing streaming patterns. It provides clear recipes for Kafka Streams, ksqlDB, and Kafka Connect, demonstrating stream-table joins, cryptographic masking, and real-time stateful aggregations.

UI Consoles

  • (2026) ==AKHQ (previously known as KafkaHQ) 🌟== ⭐ 3820 [JAVA CONTENT] 🌟🌟🌟🌟🌟 [DE FACTO STANDARD] — AKHQ (formerly KafkaHQ) is a comprehensive web interface for administering and browsing Apache Kafka resources. It provides granular visibility into topics, payloads, schema registries, and consumer group offsets without requiring complex CLI interactions.

Schema Registry

Apicurio

  • (2026) Apicurio Registry ⭐ 814 [JAVA CONTENT] [ADVANCED LEVEL] 🌟🌟🌟🌟 [ENTERPRISE-STABLE] — Apicurio Registry is an open-source, high-performance centralized schema registry. It manages API contracts, OpenAPI designs, AsyncAPI definitions, Avro, and Protobuf structures, enforcing real-time payload validations over high-throughput microservice pipelines while offering direct Kubernetes operator integrations.

Red Hat Integration

  • (2019) Red Hat Integration service registry [N/A CONTENT] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — An introductory guide to Red Hat's Service Registry, based on the Apicurio Registry upstream. It outlines configuration steps for maintaining schema formats (Avro, Protobuf, JSON) inside enterprise messaging pipelines, ensuring API contract governance in decoupled distributed architectures.

Stream Processing

Flink SQL

  • (2020) noti.st: Change Data Capture with Flink SQL and Debezium 🌟 [SQL CONTENT] [ADVANCED LEVEL] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — This reference presentation demonstrates how to unify Flink SQL with Debezium for continuous, stateful stream processing. By executing SQL syntax directly over streaming change logs, developers can bypass staging databases to run real-time aggregations and materialize low-latency analytical views.

Google Cloud Dataflow

  • (2020) cloudblog.withgoogle.com: Turn any Dataflow pipeline into a reusable template [JAVA CONTENT] [ADVANCED LEVEL] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — This tutorial shows how to convert Apache Beam stream-processing pipelines into reusable, parameterized Google Cloud Dataflow templates. It demonstrates how to decouple application logic from environment parameters to simplify pipeline delivery and scaling.

Meta-Resources (1)

  • (2026) Awesome Streaming [N/A CONTENT] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — A massive, community-maintained compilation of stream processing resources. It catalogues major ingestion engines, streaming databases, connector standards, and operational tools, serving as an exhaustive reference manual for data and cloud architects.

Quarkus

  • (2020) Build a data streaming pipeline using Kafka Streams and Quarkus [JAVA CONTENT] [ADVANCED LEVEL] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — A hands-on implementation guide for building stream-processing applications using Quarkus and the Kafka Streams API. By leveraging GraalVM native compilation, developers can achieve fast startup times and tiny footprints for event-driven microservices.

Data Platform

Data Pipelines (1)

Streaming Systems

Reference Material
  • (2018) O'Really: Streaming data [JAVA CONTENT] [ADVANCED LEVEL] [COMMUNITY-TOOL] — The definitive O'Reilly reference on stream processing architecture. It covers unified programming models (like the Apache Beam model) for out-of-order data processing. Focuses on temporal semantics, including windowing mechanics (fixed, sliding, session), watermarks, triggers, and state accumulation modes crucial for system design.

Machine Learning (1)

Open Data Hub

Architecture and Releases
  • (2020) Open Data Hub 0.6 brings component updates and Kubeflow architecture [YAML CONTENT] [ADVANCED LEVEL] [COMMUNITY-TOOL] — This article outlines the release of Open Data Hub 0.6, highlighting the alignment of its components with the Kubeflow architecture on OpenShift. It details operator-driven deployments of JupyterHub, Kubeflow Pipelines, and Apache Spark, establishing standardized declarative patterns for building cloud-native data science workspaces.
Core Platform
  • (2020) Open Data Hub [GO CONTENT] [ADVANCED LEVEL] [COMMUNITY-TOOL] — Open Data Hub (ODH) is an open-source, blueprint AI/ML platform built on OpenShift. It integrates projects like JupyterHub, Kubeflow, Apache Spark, and Prometheus. In 2026, ODH stands as the foundation of Red Hat OpenShift AI, demonstrating high enterprise stability for automating large-scale machine learning workflows, model serving, and data pipelines on Kubernetes.
Roadmap
  • (2020) A development roadmap for Open Data Hub [N/A CONTENT] [COMMUNITY-TOOL] — This roadmap article discusses the technical evolution of the Open Data Hub platform. It reviews integration strategies for OpenShift Serverless (Knative) for dynamic scaling, advanced Triton and Seldon Core model serving architectures, and metadata tracking systems, transforming monolithic pipelines into resilient microservices.

Enterprise Integration

Data Pipelines (2)

RudderStack

Customer Data Platform
  • (2021) rudderstack.com iPaaS [GO CONTENT] [COMMUNITY-TOOL] — RudderStack is a warehouse-first, developer-focused Customer Data Platform (CDP) and event-streaming pipeline engine. Architected as a secure, open-source alternative to Segment, it allows enterprises to route customer telemetry directly to cloud data warehouses without compromising privacy or incurring high third-party SaaS fees.

iPaaS

Architecture Concepts

  • (2020) quandarycg.com: Everything You Need To Know About System Integration (And IPaaS) 🌟 [N/A CONTENT] [COMMUNITY-TOOL] — This high-level architecture overview defines Integration Platform as a Service (iPaaS) principles and compares them to traditional Enterprise Service Bus (ESB) frameworks. It highlights modern data mapping, API management, and low-code integrations, discussing key tradeoffs in choosing centralized versus decentralized integration layers.

Market Review

  • (2021) blog.hubspot.com: The 22 Best iPaaS Vendors for Any Budget [N/A CONTENT] [COMMUNITY-TOOL] — An industry survey of 22 leading iPaaS platforms. It contrasts heavy enterprise offerings like MuleSoft and Workato with modern developer-centric alternatives. Evaluates features such as pre-built connectors, low-code interface flexibility, data translation capabilities, and target developer personas.

MuleSoft

Enterprise Integration Platform
  • (2022) Mulesoft [JAVA CONTENT] [ADVANCED LEVEL] [LEGACY] — MuleSoft Anypoint Platform remains an enterprise industry standard for API integration and microservice orchestration. By utilizing its DataWeave engine, hybrid deployment architectures (including Runtime Fabric on Kubernetes), and secure API gateway patterns, it connects legacy platforms with modern cloud-native systems.

Event-Driven Systems

Apache Kafka (1)

Architecture and KRaft

CLI Tools

Client Development

  • (2023) piotrminkowski.com: Concurrency with Kafka and Spring Boot [COMMUNITY-TOOL] — Examines advanced concurrency paradigms when developing high-throughput event consumers inside Spring Boot applications. Focuses on tuning consumer threads, partition assignments, off-loop processing patterns, and transactional commit strategies.

Cloud Infrastructure (1)

  • (2021) confluent.io: Making Apache Kafka Serverless: Lessons From Confluent Cloud [ADVANCED LEVEL] [COMMUNITY-TOOL] — Explores the complex software engineering effort behind transforming Apache Kafka into an elastic, multi-tenant serverless cloud platform within Confluent Cloud. Discusses decoupling storage and compute, dynamic resource balancing, and maintaining consistent latencies under spikes.

Disaster Recovery

  • (2021) tech.ebayinc.com: Resiliency and Disaster Recovery with Kafka [ADVANCED LEVEL] [CASE STUDY] [CASE STUDY] [COMMUNITY-TOOL] — A deep operational case study detailing how eBay manages disaster recovery and maintains multi-region high availability across global Kafka clusters. Highlights mirroring tools, replication offsets, network routing strategies, and automated failover validation tests.

Kubernetes and GitOps

  • (2021) confluent.io: DevOps for Apache Kafka with Kubernetes and GitOps 🌟 [ADVANCED LEVEL] [COMMUNITY-TOOL] — This architectural playbook details the convergence of Apache Kafka infrastructure automation and GitOps declarative workflows. It highlights the use of specialized Kubernetes Operators (e.g., Confluent Operator, Strimzi) alongside tools like ArgoCD or Flux to manage clusters, schemas, and ACLs from version-controlled configurations.

Kubernetes Deployment

  • (2023) thenewstack.io: Kafka on Kubernetes: Should You Adopt a Managed Solution? [COMMUNITY-TOOL] — An objective operational comparison evaluating self-hosting Apache Kafka on Kubernetes via operators (such as Strimzi) against adopting fully managed cloud platforms (e.g., Confluent Cloud). Discusses long-term maintenance costs, staff expertise requirements, and infrastructure overhead.
  • (2023) thelinuxnotes.com: How to deploy Kafka in Kubernetes with Helm chart + kafdrop [COMMUNITY-TOOL] [GUIDE] — A step-by-step tutorial showing how to deploy a local Kafka cluster within Kubernetes using public Helm charts and integrating it with Kafdrop, a popular open-source web UI, to facilitate real-time topic and offset troubleshooting.
  • (2022) learnk8s.io/kafka-ha-kubernetes: Designing and testing a highly available Kafka cluster on Kubernetes 🌟 [ADVANCED LEVEL] [COMMUNITY-TOOL] [GUIDE] — A high-fidelity guide and testing blueprint for configuring a highly available Apache Kafka cluster on Kubernetes. Covers pod anti-affinity patterns, multi-AZ PV attachments, node failure recovery, and automated resiliency testing under active chaos conditions.
  • (2022) linkedin.com: Kafka Cluster Setup on Kubernetes [COMMUNITY-TOOL] — Walks through the manual deployment and configuration of a production-ready Kafka cluster on Kubernetes. Focuses on setting up stateful sets, managing persistent volumes, and routing external client connections through secure ingress controllers.
  • (2021) thenewstack.io: Beyond the Quickstart: Running Apache Kafka as a Service on Kubernetes [ADVANCED LEVEL] [COMMUNITY-TOOL] — Goes beyond basic demo environments to dissect the operational hurdles of running Kafka as an internal platform service on Kubernetes. The guide discusses managing persistent stateful sets, configuring robust ingress/egress networking, and utilizing custom operators.
  • (2021) phoenixnap.com: How to Set Up and Run Kafka on Kubernetes 🌟 [COMMUNITY-TOOL] [GUIDE] — A step-by-step tutorial covering the baseline configuration files and setup sequences needed to orchestrate Apache Kafka inside a Kubernetes cluster. Walks through writing custom YAML manifests, deploying persistent stateful services, and testing inter-pod broker traffic.
  • (2021) itnext.io: Sending Messages to Kafka in Kubernetes [COMMUNITY-TOOL] — A configuration-focused guide showing how to reliably publish message event payloads from Kubernetes application workloads to external Kafka clusters. Details setup considerations for internal DNS, headless service mappings, and environment variables.
  • (2021) dev.to: Running Kafka on kubernetes for local development [COMMUNITY-TOOL] [GUIDE] — A practical walk-through explaining how to spin up a lightweight, local development Kafka deployment inside a desktop Kubernetes cluster (like Minikube or Kind) using pre-packaged Helm charts.

Kubernetes Operators (2)

  • (2021) strimzi.io: Kafka upgrade improvements [ADVANCED LEVEL] [COMMUNITY-TOOL] — Reviews design optimization improvements designed by the Strimzi community to orchestrate zero-downtime rolling upgrades of Kafka clusters inside Kubernetes. Discusses partition balance validations and automated protocol adjustments executed by the operator.

Learning Resources

  • (2022) conduktor.io/kafka: Learn Apache Kafka like never before [COMMUNITY-TOOL] — Conduktor's centralized, highly visual learning playground for mastering Apache Kafka. Covers core distributed architectural structures, partition routing, message durability guarantees, and schema setups through structured modules.
  • (2022) freecodecamp.org: The Apache Kafka Handbook – How to Get Started Using Kafka 🌟 [GUIDE] [COMMUNITY-TOOL] [GUIDE] — An extensive fundamental handbook detailing the core anatomy of Apache Kafka. Explains topics, partitions, replication models, offsets, producer/consumer client configurations, and cluster admin scripts with hands-on code examples.
  • (2021) developer.confluent.io 🌟🌟 [COMMUNITY-TOOL] — The premier developer learning portal designed and maintained by Confluent. Provides a repository of official tutorials, code patterns, and deep-dives explaining Kafka stream processing, client APIs, and administrative best practices.

Observability and UI

  • (2023) ==Kafdrop – Kafka Web UI 🌟== ⭐ 6138 [JAVA CONTENT] 🌟🌟🌟🌟🌟 [DE FACTO STANDARD] — Kafdrop is a popular, lightweight web UI for monitoring and managing Apache Kafka clusters. It renders real-time views of brokers, topic structures, partition offsets, consumer group lag, and permits active JSON/protobuf message payload inspection.
  • (2023) ==redpanda-data/kowl== [TYPESCRIPT CONTENT] 🌟🌟🌟🌟🌟 [DE FACTO STANDARD] — A high-performance web dashboard optimized for debugging and exploring event-streaming platforms. Developed originally as Kowl and later rebranded as Redpanda Console, it presents outstanding visualization of schema registries, active consumer state tracking, and rapid payload searches.
  • (2021) towardsdatascience.com: Overview of UI Tools for Monitoring and Management of Apache Kafka Clusters [COMMUNITY-TOOL] — A comparative overview of web-based UI management consoles for monitoring and administrating Apache Kafka clusters. Contrasts Kafdrop, AKHQ, CMAK, and other alternatives on criteria like schema registry integrations, user permissions, and deployment ease.
  • (2021) datadoghq.com: Monitoring Kafka performance metrics [COMMUNITY-TOOL] — An exhaustive guide detailing critical Apache Kafka performance metrics that platform operators and SREs should monitor. Highlights broker-level telemetry (e.g., under-replicated partitions, active controllers) alongside client consumer group lag.

Resiliency and Patterns

Scalability and Performance

  • (2021) blog.cloudera.com: Scalability of Kafka Messaging using Consumer Groups [COMMUNITY-TOOL] — Examines the horizontal scaling and performance mechanics of Kafka's consumer group model. It addresses critical production design details, such as partition count calculations, consumer group offset tracking, and the impacts of partition rebalancing protocols.

Schema Governance (1)

Security (1)

  • (2022) engineering.grab.com: Zero trust with Kafka [ADVANCED LEVEL] [CASE STUDY] [CASE STUDY] [COMMUNITY-TOOL] — Explores how transport provider Grab designed a Zero Trust security posture around their large-scale Kafka event bus. Details how mutual TLS (mTLS), fine-grained broker ACLs, and automated token rotation prevent inter-service data exfiltration.
  • (2021) itnext.io: Securely Decoupling Kubernetes-based Applications on Amazon EKS using Kafka with SASL/SCRAM [ADVANCED LEVEL] [COMMUNITY-TOOL] — Details secure-connectivity configurations for microservices running inside Amazon EKS communicating with Apache Kafka clusters. Focuses on setting up SASL/SCRAM authentication, certificate management, and Kubernetes namespace access bounds.

Stream Processing (1)

  • (2021) kafka-tutorials.confluent.io: How to count messages in a Kafka topic [COMMUNITY-TOOL] [GUIDE] — A hands-on technical guide detailing how to run stateful aggregations, specifically counting message events within high-throughput Kafka topics, using ksqlDB. It covers the underlying SQL-like syntax required to define event streams and continuous materialized tables.

Testing and Emulation

  • (2022) ==KLoadGen - Kafka + (Avro/Json Schema) Load Generator 🌟== ⭐ 218 [KOTLIN CONTENT] [ADVANCED LEVEL] 🌟🌟🌟🌟🌟 [DE FACTO STANDARD] — A purpose-built performance benchmarking CLI tool designed to simulate realistic cluster loads by generating synthetic schema-validated data. It easily ingests Avro or JSON schemas to produce representative records at controllable volume rates.
  • (2022) ==github.com/lensesio/fast-data-dev (Lenses Box)== ⭐ 2078 [SHELL CONTENT] 🌟🌟🌟🌟🌟 [DE FACTO STANDARD] — Fast-data-dev (Lenses Box) is a highly popular, all-in-one Docker environment integrating Kafka, ZooKeeper, Schema Registry, and REST Proxy components. It represents the industry standard for local developer mockups and continuous integration (CI) tests.

Topic Design

  • (2022) newrelic.com: Effective Strategies for Kafka Topic Partitioning 🌟 [COMMUNITY-TOOL] — A deep dive into strategies for sizing and partitioning Kafka topics to balance message distribution and throughput. Analyzes the runtime cost of partition limits on broker JVM overhead, partition key selection, and strategies to prevent hot broker hotspots.

Topology and Architecture

  • (2022) developers.redhat.com: Which is better: A single Kafka cluster to rule them all, or many? [ADVANCED LEVEL] [COMMUNITY-TOOL] — Explores the core architectural debate of running a unified, enterprise-wide Kafka cluster versus provisioning multiple, isolated, application-specific clusters. Evaluates resource isolation, operational support overhead, and data security boundaries.
  • (2022) kai-waehner.de: When NOT to use Apache Kafka? [COMMUNITY-TOOL] — Provides a critical, objective evaluation of systems architectures where Apache Kafka represents an anti-pattern. Discusses drawbacks of using Kafka as a long-term data storage lake, transactional ACID engine, or simple point-to-point RPC alternative.

Apache Kafka Connect

API and Orchestration

Security (2)

Case Studies (1)

Scale and Infrastructure

Concepts

Visual Learning

  • (2021) gentlydownthe.stream [COMMUNITY-TOOL] — An interactive, visually driven learning portal that uses storyboards to simplify core concepts of distributed message queues, logs, and stateful streams. Ideal for introducing incoming system architects to structural event-driven topologies.

Design Patterns

Transactional Outbox

Infrastructure

Cloud Native Integration

ActiveMQ Artemis

Networking
Persistence

Enterprise Messaging (1)

AMQ Streams
  • (2019) Understanding Red Hat AMQ Streams components for OpenShift and Kubernetes 🌟 [N/A CONTENT] 🌟🌟🌟 [COMMUNITY-TOOL] — Explains the underlying architectural parts of AMQ Streams (Red Hat's enterprise packaging of the Strimzi operator). It walks engineers through utilizing operator mechanisms to deploy highly-secure, production-ready Kafka instances inside OpenShift environments.
ActiveMQ Artemis (1)
  • (2026) Apache ActiveMQ Artemis broker [JAVA CONTENT] [ADVANCED LEVEL] 🌟🌟🌟🌟 [ENTERPRISE-STABLE] — Apache ActiveMQ Artemis is the next-generation messaging broker featuring a high-performance, asynchronous non-blocking execution model. Supporting AMQP, MQTT, STOMP, and JMS, it represents the primary engine under Red Hat AMQ deployments.
Red Hat AMQ
  • (2026) Red Hat AMQ [JAVA CONTENT] [ADVANCED LEVEL] 🌟🌟🌟🌟 [ENTERPRISE-STABLE] [LEGACY] — Red Hat AMQ is an enterprise message-brokering platform supporting traditional queue protocols (AMQP, JMS, MQTT) and high-throughput streaming patterns via integrated Kafka streams. It forms the core transactional backbone for legacy-to-modern hybrid cloud transformations.

Kubernetes Operators (3)

Koperator
  • (2024) Banzai Kafka Operator ⭐ 792 [GO CONTENT] [ADVANCED LEVEL] 🌟🌟🌟🌟 [ENTERPRISE-STABLE] — Originally engineered by Banzai Cloud, Koperator is a highly automated operator framework designed to manage Kafka on Kubernetes with Cruise Control integrations. While mostly superseded by Strimzi, its historical innovations in granular scaling and fine-grained rebalancing influenced modern stateful Kubernetes abstractions.
Strimzi (1)
  • (2026) ==strimzi.io== [JAVA CONTENT] [ADVANCED LEVEL] 🌟🌟🌟🌟🌟 [DE FACTO STANDARD] — Strimzi represents the premier CNCF project for deploying and managing Apache Kafka clusters natively inside Kubernetes. By leveraging the Operator pattern, Strimzi automates node scaling, security certificate provisioning, cluster balancing, and configuration drift-correction, making it the industry blueprint for stateful distributed streaming systems.

Strimzi (2)

CLI Tools (1)
  • (2026) pepy.tech/project/strimzi-kafka-cli 🌟 [PYTHON CONTENT] 🌟🌟🌟 [COMMUNITY-TOOL] — A developer-focused companion tool providing an interactive CLI wrapper around Strimzi resource administration on Kubernetes. By abstracting tedious kubectl YAML applications into simple command structures, it significantly reduces operational cycle time when modifying topics, users, or connections.
Configuration
  • (2021) strimzi/kafka-kubernetes-config-provider: Kubernetes Configuration Provider' for Apache Kafka ⭐ 30 [JAVA CONTENT] [ADVANCED LEVEL] 🌟🌟 [COMMUNITY-TOOL] — A specialized provider class allowing Kafka applications to read operational properties directly from Kubernetes Secrets and ConfigMaps. This architectural utility simplifies TLS certificate mount mappings and broker credential provisioning, eliminating redundant file sync code in application containers.
Introduction
Monitoring
  • (2021) strimzi/strimzi-canary ⭐ 42 [GO CONTENT] 🌟🌟 [COMMUNITY-TOOL] — A dedicated canary service designed to act as a diagnostic sentinel within Strimzi-managed environments. It continuously executes basic read-write loops inside dedicated topics to report real-time, end-to-end performance indicators like latency and partition availability.
Security (3)
Sidecar Patterns
  • (2021) strimzi.io: Using HTTP Bridge as a Kubernetes sidecar [YAML CONTENT] [ADVANCED LEVEL] 🌟🌟🌟 [COMMUNITY-TOOL] — Architectural breakdown of deploying the Strimzi HTTP Bridge as a sidecar alongside non-Java microservices. This pattern allows lightweight containers to interact with Kafka endpoints via standard HTTP REST APIs, avoiding massive native SDK dependencies.

Data Streaming

Architectural Patterns (1)

Comparisons
  • (2021) softkraft.co: WS Kinesis vs Kafka comparison: Which is right for you? 🌟 [N/A CONTENT] 🌟🌟🌟 [COMMUNITY-TOOL] — A structural trade-off comparison between AWS Kinesis and Apache Kafka. The evaluation measures cost dynamics, security compliance, payload constraints, and vendor lock-in vectors to steer technology selection in big data ingestion workloads.
  • (2021) dagster.io: Postgres: a better message queue than Kafka? [SQL CONTENT] 🌟🌟🌟 [COMMUNITY-TOOL] — A detailed, practical analysis investigating whether using Postgres with 'SKIP LOCKED' mechanisms is a more appropriate and less complex message-queue architecture than deploying heavy systems like Kafka. It provides explicit guidelines for making decisions based on data scale and operational overhead.
  • (2020) Pulsar vs Kafka – Comparison and Myths Explored [N/A CONTENT] [ADVANCED LEVEL] 🌟🌟🌟 [COMMUNITY-TOOL] — An unbiased evaluation of Apache Pulsar versus Apache Kafka. The piece analyzes standard misconceptions regarding storage efficiency, latency behaviors, queuing flexibility, and zoo-less metadata overhead in complex enterprise streaming networks.

Cloud Integration

Azure (1)
  • (2021) confluent.io: Confluent and Microsoft Announce Strategic Alliance [N/A CONTENT] 🌟🌟 [COMMUNITY-TOOL] — Highlights the strategic alliance bringing Confluent's fully managed streaming services directly into the Microsoft Azure marketplace. The integration addresses corporate security hurdles, provisioning friction, and unified billing requirements for cloud-native enterprise teams.

Enterprise Kafka

Confluent
  • (2026) ==confluent.io== [N/A CONTENT] 🌟🌟🌟🌟🌟 [DE FACTO STANDARD] — The corporate engine driving enterprise-grade Kafka. Confluent provides a comprehensive distribution containing cloud-managed Kafka clusters, an extensive library of managed source/sink connectors, Schema Registry, and advanced governance features required for complex multi-region hybrid topologies.

Integrations

MongoDB
  • (2021) mongodb.com: DaaS with MongoDB and Confluent [N/A CONTENT] [ADVANCED LEVEL] 🌟🌟🌟 [COMMUNITY-TOOL] — Details the construction of a low-latency Data-as-a-Service (DaaS) layer combining MongoDB's document-based storage engine with Confluent's real-time messaging pipeline. This architecture provides microservices with immediate, synchronized access to transactional and analytics database endpoints.

Kafka Tooling

CLI and TUI
  • (2023) ==github.com/sauljabin/kaskade== ⭐ 1015 [PYTHON CONTENT] 🌟🌟🌟🌟🌟 [DE FACTO STANDARD] — An interactive, terminal-based dashboard built using Python's Textual framework to easily inspect Kafka topics. Unlike bulky desktop clients, Kaskade runs directly in developer shells, permitting efficient topic navigation, dynamic JSON payload inspection, and rapid troubleshooting of Kafka message streams.
Enterprise GUIs
  • (2026) conduktor.io 🌟 [N/A CONTENT] 🌟🌟🌟🌟 [ENTERPRISE-STABLE] — Conduktor stands as the premier developer and enterprise GUI ecosystem for Kafka data governance and troubleshooting. Providing deep visual insight into consumer lag, topic state, schema registry configurations, and message payloads, it is critical for managing scale in event-driven systems.

Managed Services

Cloud Alternatives
  • (2026) AWS Kinesis [N/A CONTENT] 🌟🌟🌟🌟 [ENTERPRISE-STABLE] — AWS Kinesis is a fully-managed proprietary real-time streaming alternative to Apache Kafka, tightly integrated with the AWS serverless ecosystem. It abstracts partition management and storage architectures, serving as an attractive choice for engineering groups prioritizing low-overhead operations.

Monitoring (1)

Prometheus and Grafana

Next-Gen Event Brokers

Pulsar
  • (2026) Apache Pulsar [JAVA CONTENT] [ADVANCED LEVEL] 🌟🌟🌟🌟 [ENTERPRISE-STABLE] — Apache Pulsar is a highly scalable distributed messaging platform utilizing a multi-layered design that isolates broker-level computation from BookKeeper-backed storage nodes. This architecture enables independent cluster scaling, seamless multi-tenancy, and advanced geo-replication features out of the box.
Redpanda
  • (2026) ==Redpanda 🌟== [C++ CONTENT] [ADVANCED LEVEL] 🌟🌟🌟🌟🌟 [DE FACTO STANDARD] — A modern, high-performance streaming platform compatible with the Kafka API but engineered in C++ on a thread-per-core model. By eliminating JVM garbage collection issues and discarding ZooKeeper dependencies in favor of internal Raft consensus, Redpanda dramatically lowers latency and operational overhead.
  • (2021) softwareengineeringdaily.com: Redpanda: Kafka Alternative with Alexander Gallego 🌟 [N/A CONTENT] [ADVANCED LEVEL] 🌟🌟🌟 [COMMUNITY-TOOL] — An informative architect-to-architect discussion with the creator of Redpanda explaining the performance benefits of native execution over JVM virtualization. It discusses memory tiering, hardware-aware execution, and the integration of Raft consensus directly inside modern hardware layers.

Performance Tuning

Kafka Consumers
  • (2021) strimzi.io: Optimizing Kafka consumers 🌟 [N/A CONTENT] [ADVANCED LEVEL] [DOCUMENTATION] 🌟🌟🌟 [COMMUNITY-TOOL] — A comprehensive playbook for tuning Kafka consumers to prevent head-of-line blocking and partition rebalance storms in high-throughput clusters. It details proper session timeout windows, fetch size parameters, and threading behaviors crucial for maintaining consistent low-latency ingestion pipelines.
Kafka Producers
  • (2020) strimzi.io: Optimizing Kafka producers 🌟 [N/A CONTENT] [ADVANCED LEVEL] [DOCUMENTATION] 🌟🌟🌟 [COMMUNITY-TOOL] — An analytical guide focused on hardening Kafka message producers against data loss while maintaining performance levels. This resource covers client-side retry architectures, delivery timeouts, and buffer allocation metrics to ensure reliable transport in Kubernetes networks.

Stream Processing (2)

Architectural Patterns (2)
  • (2021) Kafka Streams and ksqlDB Compared – How to Choose [N/A CONTENT] [ADVANCED LEVEL] [DOCUMENTATION] 🌟🌟🌟 [COMMUNITY-TOOL] — A comparative guide contrasting the application patterns of using ksqlDB with writing custom Java code via the Kafka Streams library. It provides engineers with logical decision paths based on pipeline scale, deployment models, and development team specializations.
ksqlDB
  • (2026) ksqlDB [JAVA CONTENT] 🌟🌟🌟🌟 [ENTERPRISE-STABLE] — An event-streaming database engineered specifically to build stream-processing applications on top of Apache Kafka. By translating familiar SQL queries into stateful Kafka Streams topologies, ksqlDB enables microservices to construct real-time materialized views and joins with minimal code.

Enterprise Integration (1)

Apache Camel

  • (2023) Apache Camel [JAVA CONTENT] [ADVANCED LEVEL] [DOCUMENTATION] [COMMUNITY-TOOL] — The main technical page for Apache Camel, an integration framework built around Enterprise Integration Patterns (EIP). It simplifies system connectivity by offering hundreds of out-of-the-box protocol connectors and routing strategies.

Camel K

  • (2021) github.com/osa-ora/camel-k-samples [JAVA CONTENT] [COMMUNITY-TOOL] — A public repository containing community-driven Camel K sample deployment blueprints. It provides practical templates for routing, database pooling, and API integrations within modern Kubernetes clusters.

Camel Quarkus

Comparison

  • (2022) kai-waehner.de: When to use Apache Camel vs. Apache Kafka? 🌟 [ADVANCED LEVEL] [COMMUNITY-TOOL] — An expert analysis distinguishing the roles of Apache Camel (for enterprise application integration and routing) and Apache Kafka (for streaming data storage). It outlines integration patterns where both tools complement each other.

Kafka Connect (1)

IoT and Edge Messaging

Brokers

Mosquitto

Protocols (1)

MQTT
  • (2026) mqtt.org [N/A CONTENT] 🌟🌟🌟🌟 [ENTERPRISE-STABLE] — The home of MQTT, the industry-standard lightweight publish-subscribe transport protocol designed specifically for extreme remote locations and low-bandwidth channels. It constitutes the primary communication format for edge nodes and mobile endpoints bridging into central event-streaming backbones.

Kubernetes Native

Camel K (1)

  • (2023) Apache Camel K [GO CONTENT] [ADVANCED LEVEL] [DOCUMENTATION] [COMMUNITY-TOOL] — The homepage for Apache Camel K, a lightweight integration framework optimized for Kubernetes. Built on Knative, Camel K runs integration code natively, using custom operators to automate building and scaling processes.
  • (2021) thenewstack.io: Camel K Brings Apache Camel to Kubernetes for Event-Driven Architectures [COMMUNITY-TOOL] — This article documents the architectural impact of Camel K, explaining how it extends Kubernetes to support enterprise integration workflows. It highlights its runtime environment and integration with Knative and serverless architectures.
  • (2020) developers.redhat.com: Six reasons to love Camel K [COMMUNITY-TOOL] — This Red Hat article highlights six benefits of adopting Camel K. It details its low memory footprints, sub-second startup times, Serverless integration paths, and how it uses Kamelets to connect external APIs.

Kamelets

Message Brokers (1)

ActiveMQ

  • (2024) ==Apache Artemis JMeter== ⭐ 1024 [JAVA CONTENT] [ADVANCED LEVEL] 🌟🌟🌟🌟🌟 [DE FACTO STANDARD] — The official source repository for Apache ActiveMQ Artemis. Built with Netty, this broker delivers low-latency messaging, supports AMQP, MQTT, and STOMP, and provides an efficient data distribution engine for high-density architectures.
  • (2023) Apache ActiveMQ [JAVA CONTENT] [DOCUMENTATION] [COMMUNITY-TOOL] — The main technical reference for Apache ActiveMQ, a classic multi-protocol message broker. It supports standard messaging protocols such as AMQP, MQTT, and OpenWire, making it a reliable choice for enterprise JMS applications.
  • (2023) ActiveMQ 5.x "classic" [JAVA CONTENT] [DOCUMENTATION] [COMMUNITY-TOOL] — Reference page for the classic Apache ActiveMQ 5.x architecture. While stable and widely deployed across global enterprises, it is gradually being superseded by the non-blocking ActiveMQ Artemis engine.

Clustering

Comparison (1)

  • (2022) kubemq.io: Kafka VS KubeMQ 🌟 [ADVANCED LEVEL] [COMMUNITY-TOOL] — A technical comparison detailing the differences between Apache Kafka and KubeMQ. It contrasts KubeMQ's Kubernetes-native operator architecture and low-overhead design with Kafka's distributed streaming log structure.
  • (2022) kai-waehner.de: Comparison: JMS Message Queue vs. Apache Kafka [ADVANCED LEVEL] [COMMUNITY-TOOL] — A comprehensive comparison contrasting JMS message queues (like ActiveMQ or RabbitMQ) with event streaming networks (like Apache Kafka). It outlines the trade-offs between complex consumer-side routing and immutable stream logging.
  • (2020) developers.redhat.com: Choosing the right asynchronous-messaging infrastructure for the job [ADVANCED LEVEL] [COMMUNITY-TOOL] — This Red Hat article guides architects through selecting the appropriate messaging infrastructure. It contrasts traditional message brokers (like RabbitMQ and ActiveMQ) with distributed stream processing systems (like Kafka).

Docker

KubeMQ

  • (2024) ==github.com/kubemq-io/kubemq-community 🌟== ⭐ 667 [GO CONTENT] 🌟🌟🌟🌟🌟 [DE FACTO STANDARD] — The primary community codebase for KubeMQ. It showcases a lightweight, high-throughput message broker written in Go, specifically optimized for containerized microservice routing patterns inside Kubernetes.
  • (2023) KubeMQ.io: Kubernetes Native Message Queue Broker [GO CONTENT] [DOCUMENTATION] [COMMUNITY-TOOL] — The main page for KubeMQ, an enterprise-grade message broker built container-first for Kubernetes. KubeMQ provides queuing, pub/sub, and gRPC patterns with low CPU and memory footprints.

RabbitMQ

  • (2021) blog.rabbitmq.com: First Application With RabbitMQ Streams [ADVANCED LEVEL] [COMMUNITY-TOOL] — An introduction to RabbitMQ Streams, a protocol addition designed to bring high-performance append-only log capabilities directly to traditional RabbitMQ setups, enabling message replay and high throughput.

Messaging

Redis

  • (2023) Redis Pub/sub [C CONTENT] [DOCUMENTATION] [COMMUNITY-TOOL] — Documentation for the Redis Pub/Sub subsystem. It explains the fast, fire-and-forget messaging topology, highlighting its advantages for real-time notifications alongside limitations like lack of message persistence.

Stream Processing (3)

Flink

Kubernetes Deployment (1)
  • (2021) flink.apache.org: How to natively deploy Flink on Kubernetes with High-Availability (HA) [YAML CONTENT] [ADVANCED LEVEL] [DOCUMENTATION] 🌟🌟🌟🌟 [ENTERPRISE-STABLE] — A detailed technical guide explaining how to deploy stateful Flink jobs natively on Kubernetes with High Availability (HA). It details integration patterns using ZooKeeper or Kubernetes API endpoints to coordinate active leader election and prevent split-brain states.

In-Memory Compute

Hazelcast

Stateful Computations

Flink (1)
  • (2026) ==Apache Flink== [JAVA CONTENT] [ADVANCED LEVEL] 🌟🌟🌟🌟🌟 [DE FACTO STANDARD] — Apache Flink is the industry-standard distributed framework designed for stateful stream computations on real-time event logs. Offering sub-millisecond execution times and robust exactly-once state processing, Flink handles large-scale stream processing workloads with high efficiency.

Integration

Data Federation

Citizen Integration

  • (2020) Event streaming and data federation: A citizen integrator’s story [N/A CONTENT] [CASE STUDY] [CASE STUDY] [COMMUNITY-TOOL] — A narrative-style case study exploring how visual integration tools and event-streaming pipelines enable citizen integrators to aggregate disparate database models. It maps real-world patterns for democratization of data engineering and integration tasks across departments.

Enterprise Service Bus

Red Hat Fuse

  • (2026) Red Hat Fuse [JAVA CONTENT] [ADVANCED LEVEL] [LEGACY] — Historically a distributed integration platform based on Apache Camel, Red Hat Fuse has transitioned into the Red Hat Application Foundations suite. It provides enterprise-level connectivity for hybrid clouds, routing APIs, and legacy applications. Contemporary architectures deploy Camel Extensions for Quarkus to achieve high performance on Kubernetes.

Low-Code Integration

Syndesis

  • (2026) Syndesis open source integration platform [JAVA CONTENT] [LEGACY] — Syndesis was an open-source, cloud-native low-code integration platform built natively for Kubernetes. Though currently archived, it historically facilitated rapid microservice orchestration and API visual design with prebuilt connectors. Its architectural concepts paved the way for modern cloud-native iPaaS systems.

Tutorials (1)

  • (2020) developers.redhat.com: Low-code microservices orchestration with Syndesis [N/A CONTENT] [GUIDE] [COMMUNITY-TOOL] [GUIDE] — This architectural guide demonstrates how to construct and orchestrate low-code microservices integrations using the Syndesis platform on OpenShift. It highlights developer productivity pathways, showcasing visual data mapping and cloud-native connector deployments that bypass traditional integration boilerplate.

Microservices

Cloud Native

Event-Driven Architecture

  • (2023) ibm.com: Event-driven cloud-native applications (microservices) [DOCUMENTATION] [COMMUNITY-TOOL] — This IBM resource details how event-driven applications scale natively inside Kubernetes clusters. It focuses on isolating boundaries and implementing lightweight message-driven scaling paths for complex enterprise systems.

Decomposition

Event-Driven Architecture (1)

  • (2020) infoq.com: From Monolith to Event-Driven: Finding Seams in Your Future Architecture [ADVANCED LEVEL] [COMMUNITY-TOOL] — This article outlines methodologies for finding boundaries within tight-knit monolithic structures to facilitate migration. It contrasts synchronous runtime calls with asynchronous eventing boundaries, demonstrating how to isolate transactional domains using Domain-Driven Design (DDD) aggregates.

Distributed Transactions

Patterns

Domain-Driven Design

Patterns (1)

  • (2019) verraes.net: DDD and Messaging Architectures 🌟 [ADVANCED LEVEL] [COMMUNITY-TOOL] — This resource maps Domain-Driven Design (DDD) concepts onto messaging architectures. It explores how to structure messaging channels and aggregate roots to avoid distributed monolith structures and optimize data routing.

Enterprise Integration (2)

Event-Driven Architecture (2)

Event-Driven Architecture (3)

Industry Trends

  • (2021) thenewstack.io: The Rise of Event-Driven Architecture [COMMUNITY-TOOL] — This article documents the architectural factors that made event-driven integration standard in modern cloud-native enterprises. It explains how synchronous HTTP calls cause cascade failures and presents asynchronous patterns as the default design choice for complex topologies.

Kafka

  • (2021) confluent.io: Event-Driven Microservices Architecture (white paper) 🌟 [ADVANCED LEVEL] [CASE STUDY] [COMMUNITY-TOOL] — A comprehensive Confluent white paper establishing design principles for event-driven microservices. It highlights Apache Kafka as an immutable commit log, detailing exact execution models for Event Sourcing and Command Query Responsibility Segregation (CQRS).

Inter-Service Communication

Comparison (2)

  • (2021) particular.net: RPC vs. Messaging – which is faster? [ADVANCED LEVEL] [COMMUNITY-TOOL] — This performance analysis evaluates the trade-offs of RPC-style communication patterns against broker-mediated messaging. It details the impact of synchronous blocking calls on microservice performance and explains how message queues improve reliability.

Kubernetes (1)

CloudEvents

  • (2022) salaboy.com: Event-Driven applications with CloudEvents on Kubernetes [ADVANCED LEVEL] [COMMUNITY-TOOL] — This article explores deploying CloudEvents inside Kubernetes ecosystems to build standardized event schemas. It shows how the CloudEvents standard, combined with serverless tools like Knative, drives event-driven microservice integration.

Patterns (2)

Event Sourcing

  • (2021) codeopinion.com: Event Sourcing vs Event Driven Architecture [ADVANCED LEVEL] [COMMUNITY-TOOL] — This guide highlights the architectural differences between Event Sourcing (rebuilding state via a series of domain events) and Event-Driven Architecture (routing state transitions between services). It prevents common microservice anti-patterns.
  • (2020) blog.bitsrc.io: Why Microservices Should use Event Sourcing 🌟 [ADVANCED LEVEL] [COMMUNITY-TOOL] — An in-depth analysis advocating for Event Sourcing inside microservice frameworks. It details how recording every event state change enables historical auditability and decouples read queries from primary transaction engines via CQRS.

Web Development

Event-Driven Architecture (4)

Orchestration

Workflow Engines

Camunda

Zeebe
  • (2026) Zeebe workflow engine [JAVA CONTENT] [ADVANCED LEVEL] 🌟🌟🌟🌟 [ENTERPRISE-STABLE] — Zeebe is Camunda's highly available, horizontally scalable workflow orchestration engine designed specifically for microservices architectures. Relying on event-sourced execution loops, Zeebe manages complex BPMN process flows across thousands of servers with built-in partition tolerance.

Patterns (3)

Event-Driven Orchestration
  • (2019) infoq.com: Event Streams and Workflow Engines – Kafka and Zeebe 🌟 [N/A CONTENT] [ADVANCED LEVEL] 🌟🌟🌟 [COMMUNITY-TOOL] — An analytical study contrasting event-driven choreography with workflow orchestration. It shows how combining Kafka's decoupled event model with Zeebe's stateful execution engine resolves typical observability and error-handling bottlenecks in microservice topologies.

Workflows

Apache Airflow

Architecture (1)
  • (2020) towardsdatascience.com: Apache Airflow Architecture 🌟 [N/A CONTENT] 🌟🌟🌟 [COMMUNITY-TOOL] — An architectural breakdown exploring the foundational components of Airflow, including the metadata database, scheduler engine, and task executor options (Celery, Local, Kubernetes). Essential reading for understanding runtime orchestration.
Container Pipelines
  • (2020) towardsdatascience.com: Apache Airflow for containerized data-pipelines [PYTHON CONTENT] 🌟🌟🌟 [COMMUNITY-TOOL] — Explains how to design modern, isolated data ingestion pipelines inside Apache Airflow utilizing container environments. Isolating tasks inside dedicated containers prevents python library collisions, ensuring deterministic scheduling and robust operational execution.
DAG Management
  • (2022) airflow.apache.org: Add Owner Links to DAG [PYTHON CONTENT] [DOCUMENTATION] 🌟🌟🌟 [COMMUNITY-TOOL] — Explains how to add dynamic owner links inside Airflow's user interface to map custom DAGs back to responsible engineering teams, monitoring channels, or contact points. This is highly useful for organizing multi-tenant team systems.
Dynamic DAGs
  • (2026) docs.astronomer.io: Dynamically generating DAGs in Airflow [PYTHON CONTENT] [ADVANCED LEVEL] [DOCUMENTATION] 🌟🌟🌟🌟 [ENTERPRISE-STABLE] — A deep dive on building dynamically-generated DAGs in Airflow. This blueprint showcases how to dynamically compile hundreds of different workflows from external JSON or YAML configurations, dramatically reducing redundant code in large-scale platform teams.
Introduction (1)
  • (2021) dev.to: Get started with Apache Airflow [PYTHON CONTENT] 🌟🌟🌟 [COMMUNITY-TOOL] — An introductory guide covering the fundamental architecture of Apache Airflow. It helps developers write their first Python-based Directed Acyclic Graphs (DAGs) using basic Operators, sensors, and scheduling definitions.
Kubernetes Deployment (2)
  • (2026) ==Apache Airflow official helm chart 🌟== [YAML CONTENT] [ADVANCED LEVEL] 🌟🌟🌟🌟🌟 [DE FACTO STANDARD] — The official Helm chart for deploying Apache Airflow securely on Kubernetes. This package coordinates the complex interactions between scheduler, web server, worker nodes, and backend database deployments, offering extensive options for customizing pod parameters and cluster autoscaling.
  • (2021) youtube: Airflow Helm Chart : Quick Start For Beginners in 10mins [N/A CONTENT] 🌟🌟🌟 [COMMUNITY-TOOL] [GUIDE] — A beginner-friendly quickstart video highlighting how to set up the official Airflow Helm chart on a local development Kubernetes cluster in under ten minutes. The video covers basic value overrides, ingress setups, and initial worker deployment patterns.
Kubernetes Integration
  • (2026) ==airflow.apache.org: KubernetesPodOperator 🌟🌟🌟== [PYTHON CONTENT] [ADVANCED LEVEL] [DOCUMENTATION] 🌟🌟🌟🌟🌟 [DE FACTO STANDARD] — The KubernetesPodOperator allows Airflow tasks to execute dynamically inside isolated, single-use Kubernetes Pods. By isolating runtime dependencies, it lets developers execute pipeline tasks of any language or version without changing parent worker system environments.
Monitoring (2)
  • (2021) redhat.com: Monitoring Apache Airflow using Prometheus [YAML CONTENT] 🌟🌟🌟 [COMMUNITY-TOOL] — A practical walk-through detailing the integration of Apache Airflow metrics with Prometheus and Grafana dashboards. By leveraging StatsD exporters to capture worker runs and task duration logs, platform engineers can proactively identify bottlenecks in data ingestion pipelines.

Kubernetes SDKs

Couler
  • (2023) Couler ⭐ 944 [PYTHON CONTENT] [ADVANCED LEVEL] 🌟🌟🌟🌟 [ENTERPRISE-STABLE] — Couler is an open-source Python SDK built to simplify programming native Kubernetes workflow engines like Argo or Tekton. It allows machine learning and data engineering teams to construct complex workflows via intuitive Python code instead of hand-writing endless YAML sheets.

Software Engineering

Backend Development

Java Enterprise

MicroProfile

💡 Explore Related: Yaml | Databases | Crunchydata

Reference in New Issue View Git Blame Copy Permalink