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

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.

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.

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

kates clean --force

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

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.

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.

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.

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

# CLI
cd cli && go build -ldflags="-s -w" -o kates . && mv kates /usr/local/bin/

# Backend
cd 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

# Tests
cd cli && go test ./...                      # CLI tests
cd kates && ./mvnw test                      # Backend tests

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.

Kates is licensed under the Apache License 2.0.