A Kubernetes-native platform for performance testing, chaos engineering,
and operational resilience auditing of Apache Kafka clusters.

---

Read the Kates Definitive Guide — a complete book covering performance theory, chaos engineering, security, deployment, and operations.

Contents — Why Kates · Features · Quick Start · Architecture · Helm Charts · CLI at a Glance · Building from Source · Documentation · Contributing · License

Why Kates

In modern cloud-native architectures, Apache Kafka lies at the critical path of data flow. Ensuring its reliability, low latency, security, and schema enforcement requires continuous, active testing — not passive monitoring. Kates provisions a production-parity environment, injects real faults, and measures the impact against your SLAs:

• Multi-AZ simulation on your laptop — a 3-node Kind cluster with brokers spread across virtual availability zones (alpha, sigma, gamma), zone-affinity storage, and rack-aware replica placement, so you can test real zone outages locally.
• Performance-chaos correlation — inject disruptions (broker kills, network latency, disk fill) while performance workloads run, and get an SLA grade (A–F) computed from throughput and latency degradation.
• Two deployment topologies — a single consolidated namespace for rapid prototyping, or isolated namespaces (kafka, kates, monitoring, litmus) for production parity.
• Safety guardrails built in — blast-radius validation before every fault, automatic rollback on SLA violation or timeout, and cleanup guardrails that strip finalizers and purge CRs so teardown never wedges.
• Full observability — OpenTelemetry auto-instrumentation flowing into Jaeger and Prometheus, with pre-provisioned Grafana dashboards and alert rules.

Features

Capability	Scope	Description
Performance Testing	8 test types	Supports Load, Stress, Spike, Endurance, Volume, Capacity, Round-Trip, and Integrity workloads, each configurable through MicroProfile Config with hierarchical defaults.
Chaos Engineering	13 disruption types	Provides fault injection with safety guardrails and automatic rollback, enabling controlled experiments against broker failures, network partitions, and resource exhaustion.
Observability	End-to-end telemetry	Integrates Prometheus, Grafana, and Jaeger with pre-built dashboards and alert rules, providing metrics, logs, and distributed traces across the entire test lifecycle.
Deployment	One-command provisioning	The kates deploy -i interactive wizard provisions the complete stack—including Kafka, monitoring, and chaos infrastructure—in a single operation.
Security Auditing	Multi-layer analysis	Performs TLS inspection, NetworkPolicy analysis, Kyverno compliance checks, and active penetration testing to validate the security posture of the target cluster.
CI/CD Integration	Pipeline-native	Exports results as JUnit XML, generates status badges, enforces quality gates with letter-grade thresholds, and delivers webhook notifications for automated pipelines.

Quick Start

Prerequisites: Docker (or OrbStack), Kind, kubectl, and Helm. macOS and Linux are supported; the Homebrew tap is macOS-only — Linux users install from the latest release binaries.

brew install bmscomp/tap/kates # Install the CLI
kates deploy -i # Interactive wizard — deploys everything
kates health # Verify the stack is healthy
kates test create --type LOAD # Run your first load test

Prefer make? make all provisions the same stack (Kind cluster, local registry, monitoring, Kafka, UI, schema registry, chaos) through a ten-step idempotent pipeline — see the Local Development Stack guide.

Access Points

Once the stack is provisioned, the following services are available via NodePort or port-forwarding (kates ports --all).

Service	URL	Credentials	Notes
Grafana	http://localhost:30080	admin / admin	Pre-loaded with Kafka dashboards and alert rules.
Kafka UI	http://localhost:30081	—	Read-only by default; write access requires KAFKA_UI_AUTH configuration.
Apicurio Registry	http://localhost:30082	—	Schema compatibility rules are enforced per-subject.
Kates API	http://localhost:30083	—	Protected by API key in production; disabled in dev/test profiles.
Jaeger UI	http://localhost:30086	—	Displays distributed traces for REST, Kafka, and JDBC operations.
Prometheus	http://localhost:30090	—	Exposes /api/v1/query for ad-hoc PromQL queries.
Litmus UI	make chaos-ui then http://localhost:9091	admin / litmus	Requires an explicit port-forward; not exposed by default.

Teardown

kates clean --force

Architecture

graph TD
classDef cli fill:#1f6feb,stroke:#58a6ff,stroke-width:2px,color:#fff;
classDef core fill:#238636,stroke:#3fb950,stroke-width:2px,color:#fff;
classDef spi fill:#8957e5,stroke:#a371f7,stroke-width:2px,color:#fff;
classDef ext fill:#d29922,stroke:#f0883e,stroke-width:2px,color:#fff;
subgraph "User Space"
CLI["Kates CLI Client"]:::cli
TUI["Interactive TUI Dashboard"]:::cli
end
subgraph "Kates Backend Engine (Quarkus App)"
API["JAX-RS REST Resource Layer"]:::core
GRPC["gRPC Telemetry Service"]:::core
Orch["Test & Disruption Orchestrators"]:::core
Intel["Kafka Intelligence Service"]:::core
Panache[("PostgreSQL / Panache DB")]:::core
MPConfig["MicroProfile Config Engine"]:::core
end
subgraph "Service Provider Interfaces"
BENCH_SPI{"BenchmarkBackend SPI"}:::spi
CHAOS_SPI{"ChaosProvider SPI"}:::spi
end
subgraph "Concrete Execution Backends"
NativeEng["Native Loom Workload Engine"]:::spi
TrogClient["Trogdor Coordinator Adapter"]:::spi
LitmusEng["LitmusChaos CRD Provider"]:::spi
DirectK8s["Direct Kubernetes API Provider"]:::spi
end
subgraph "Infrastructure"
Kafka["Strimzi Apache Kafka Cluster"]:::ext
Prom["Prometheus Metrics Server"]:::ext
Litmus["Litmus Operator"]:::ext
end
CLI -->|HTTP/JSON REST| API
TUI -->|gRPC Bidirectional Stream| GRPC
API --> Orch
GRPC --> Orch
Orch --> Intel
Orch --> Panache
Orch --> MPConfig
Orch --> BENCH_SPI
Orch --> CHAOS_SPI
BENCH_SPI --> NativeEng
BENCH_SPI --> TrogClient
CHAOS_SPI --> LitmusEng
CHAOS_SPI --> DirectK8s
NativeEng -->|Producer/Consumer clients| Kafka
TrogClient -->|REST Client requests| Kafka
LitmusEng -->|Custom Resources| Litmus
DirectK8s -->|Fabric8 API Restarts| Kafka
Intel -->|AdminClient Metadata| Kafka

Loading

The core backend (/kates) is a reactive, containerized Java microservice built on Quarkus 3.15 and Java 21:

• Virtual Threads (Project Loom) — workload engines spawn hundreds of independent producer/consumer loops on lightweight virtual threads for massive throughput simulation.
• Reactive REST & gRPC dual stack — CRUD via JAX-RS, real-time telemetry via gRPC bidirectional streams.
• Extensible SPIs — swap workload engines (NativeKafkaBackend, TrogdorBackend) and fault-injection providers (LitmusChaosProvider, KubernetesChaosProvider, HybridChaosProvider) without touching the orchestrators.
• Persistent telemetry — PostgreSQL via Hibernate ORM (Panache) with Flyway migrations.

For the disruption pipeline, data-flow diagrams, and component deep-dives, see the Architecture chapter of the Definitive Guide.

Helm Charts

Kates ships its platform as independently versioned Helm charts, composable via the kates-platform umbrella chart. Run make readme-check to verify this table against the chart sources.

Chart	Version	App Version	Description
apicurio-registry	0.4.0	3.3.0	Apicurio Registry (KafkaSQL) backed by the in-repo kafka-cluster chart
connect-cluster	1.3.1	3.6.0	A Helm chart for deploying Strimzi Kafka Connect clusters
headlamp	0.2.0	0.40.1	Headlamp — Kubernetes Dashboard for cluster visualization and management
kafka-cluster	0.3.0	4.3.0	Strimzi-based Kafka cluster deployment with KRaft, zone-aware broker pools, and full observability
kafka-ui	0.3.0	v1.5.0	A Helm chart for deploying Kafka UI (Kafbat) with Strimzi SCRAM-SHA-512 authentication
kates-chaos	2.0.0	3.28.0	Kates Chaos Engineering — wraps the LitmusChaos execution plane (operator, exporter, CRDs) with Kafka-specific RBAC, experiment/engine templating, and monitoring
kates-platform	0.4.0	1.0.0	Umbrella chart for the full Kates platform — Kafka, Kates, and supporting infrastructure
kates	0.6.0	1.21.0	Kates — Kafka Advanced Testing & Engineering Suite
minio	17.0.22	2025.7.23	MinIO(R) is an object storage server, compatible with Amazon S3 cloud
mirror-maker2	0.1.0	4.3.0	Strimzi KafkaMirrorMaker2 — cross-cluster replication / DR / migration
monitoring	1.1.0	82.4.3	Kates Monitoring — wraps kube-prometheus-stack with Kates-specific dashboards and configuration
strimzi-operator	0.1.0	1.1.0	The Strimzi Kafka Operator — wraps the upstream chart with pinned kates defaults, an owned CRD-upgrade hook, and a strict values schema
velero	11.3.3	1.17.1	A Helm chart for velero

CLI at a Glance

The kates CLI spans deployment, testing, chaos, security, and cluster administration. A few emblematic commands:

kates deploy -i # Interactive deployment wizard
kates health # Stack health and connectivity
kates kafka tui # Full-screen interactive Kafka explorer
kates test create --type LOAD --records 100000 # Run a load test
kates benchmark # Full battery with an A–F scorecard
kates resilience --experiment pod-kill --duration 60s # Chaos-performance correlation
kates report show <id># Full report with SLA verdict
kates gate -f scenario.yaml --min-grade B # CI quality gate (non-zero exit below B)
kates security audit # Security posture scan with A–F grade
kates dashboard # Live full-screen monitoring dashboard

Contexts point the CLI at an environment: kates ctx set local --url http://localhost:30083 && kates ctx use local.

The complete command reference — all twelve command domains with every flag — lives in the CLI Reference chapter of the Definitive Guide, with hands-on walkthroughs in the tutorials.

Building from Source

Prerequisites: Go 1.25+ (CLI), Java SDK 21 and Maven 3.9+ or ./mvnw (backend), Docker, and optionally GraalVM for native binaries.

# CLIcd cli && go build -ldflags="-s -w" -o kates .&& mv kates /usr/local/bin/
# Backendcd kates
./mvnw quarkus:dev # Dev mode with hot-reload
./mvnw package -DskipTests # JVM package
./mvnw package -Dnative -DskipTests # Native binary (GraalVM)# Container images
docker build -f kates/Dockerfile -t kates:latest .# JVM image
docker build -f kates/Dockerfile.native -t kates:latest kates/ # Native image# Testscd cli && go test ./... # CLI testscd kates && ./mvnw test# Backend tests

Documentation

Resource	Description
The Definitive Guide	A complete book covering performance testing theory, CLI usage, REST API integration, deployment topologies, security hardening, and operational procedures.
Tutorials	Progressive, step-by-step tutorials that guide practitioners from running a first load test through building fully automated CI/CD quality gates.
Local Development Stack	The make provisioning pipeline, image management via images.env, and corporate proxy configuration.
REST API Reference	Complete API specification including JSON request/response schemas, gRPC service definitions, and REST resource documentation.
Disruption Catalog	Reference documentation for all supported disruption types, including configuration models, blast radius parameters, and safety constraints.
Export Formats	Specification of all supported export formats: CSV for data analysis, JUnit XML for CI integration, latency heatmaps for visualization, and metrics diffs for regression detection.
Deployment Guide	Deployment procedures for local Kind clusters, managed Kubernetes services (EKS, GKE, AKS), and bare-metal installations.

Contributing

We welcome contributions from the community to improve the resilience engineering ecosystem!

• Guidelines: Please read the Contribution Guide before opening pull requests.
• Conduct: We adhere to a professional community standard. See the Code of Conduct for details.

License

Kates is licensed under the Apache License 2.0.

---

_{Built with ❤️ for the Kafka community}