kube-burner

kube-burner
Name	kube-burner
Developer	Red Hat
Released	2019
Programming language	Go
Platform	Linux
License	Apache License 2.0

kube-burner

kube-burner is an open-source performance and scalability testing tool for Kubernetes clusters developed initially by Red Hat engineers and contributors from the Cloud Native Computing Foundation. It orchestrates synthetic workloads, resource templates, and continuous load patterns to validate cluster behavior under stress, integrating with observability stacks and CI/CD pipelines used by teams at organizations such as Google and Amazon Web Services. The project is used in conjunction with common cloud and on-prem platforms including OpenShift, Azure, Google Cloud Platform, and Amazon EKS.

Overview

kube-burner provides declarative, template-driven scenarios that create, update, and delete Kubernetes objects to simulate production-scale conditions for projects like KubeCon performance studies and platform validations performed by teams from IBM, Microsoft, VMware, and Canonical. It targets performance engineering workflows similar to those practiced in Netflix's resilience testing and standards established by the Linux Foundation and Cloud Native Computing Foundation's Working Groups. The tool emphasizes repeatability, reproducibility, and integration with observability suites used by enterprises such as New Relic, Datadog, Splunk, and Prometheus-based stacks.

Architecture and Components

kube-burner is implemented in Go (programming language) and relies on a control-plane binary that interacts with the Kubernetes API to apply templated manifests, manage job lifecycles, and harvest metrics, integrating with collectors like Prometheus, Grafana, and OpenTelemetry. Core components include a scenario engine, template renderer, workload executor, and reporter, analogous to architectures in projects such as Locust and JMeter but specialized for Kubernetes object churn similar to patterns described by The CNCF. It can drive object types handled by controllers from apps/v1, batch/v1, and custom resources implemented by platforms like OpenShift Operators and Helm charts created by teams at Bitnami.

Installation and Configuration

Installation typically follows standard practices for cloud-native tooling used by operators from Red Hat and platform teams at Google Cloud Platform: compile the binary using Go (programming language) toolchains or deploy via container images built with Docker and orchestrated by Kubernetes manifests or Helm charts. Configuration uses YAML scenario files, parameterized templates, and environment variables compatible with CI systems such as Jenkins, GitLab CI, GitHub Actions, and Tekton. Integrations with service accounts and role bindings follow patterns recommended in guidance from CNCF and cloud providers like Amazon Web Services IAM and Azure Active Directory.

Workloads and Test Scenarios

Workloads are expressed through templates and scenario files that create a mix of Deployment, StatefulSet, DaemonSet, Job, and custom resource objects to exercise control plane components similar to testing approaches used by Kubernetes SIG-Testing and performance investigations from Google's internal SRE teams. Scenarios can emulate high object creation rates, pod churn, node scaling events, and API server saturation, useful for validating autoscaling behaviors akin to those implemented by Cluster Autoscaler and tools from Kubeflow or Istio traffic scenarios. Test suites can include multi-namespace tenancy, quota exhaustion, and operator lifecycle events like those studied during OpenShift performance benchmarks.

Metrics, Monitoring, and Reporting

kube-burner exports metrics compatible with Prometheus exposition format and integrates with dashboards in Grafana for visualizing resource consumption, API server latencies, and scheduler throughput—similar to observability patterns advocated by Prometheus maintainers and SIGs at Kubernetes. Built-in reporters produce time-series data, percentile latency distributions, and event traces consumable by OpenTelemetry collectors and APM systems from Datadog and New Relic. The tool supports correlation with control-plane logs from components like kube-apiserver, kube-scheduler, and kube-controller-manager and can feed outputs into analytics pipelines using Elasticsearch and Fluentd.

Use Cases and Best Practices

Common use cases include capacity planning for clusters managed by platform engineering groups at organizations like Netflix, Airbnb, and Salesforce, pre-upgrade validation for Kubernetes distributions such as Red Hat OpenShift and Rancher, and CI-based regression testing in GitHub-hosted workflows. Best practices recommend isolating performance clusters, versioning scenario templates in repositories overseen by SRE teams, and combining kube-burner runs with chaos engineering tools used by practitioners familiar with Chaos Mesh and ChaosMonkey experiments. Teams often pair it with policy and compliance checks from Open Policy Agent for reproducible validation.

Security and Limitations

Security considerations reflect standard controls used by platform operators at Red Hat and cloud providers: use least-privilege Kubernetes RBAC roles, audit logs collected by solutions like Stackdriver or AWS CloudTrail, and limit network exposure consistent with CNCF security recommendations. Limitations include dependency on cluster API scalability (affected by etcd performance), potential interference with production workloads, and the need for careful resource governance when testing multi-tenant environments as highlighted by best practices from Kubernetes SIG-Architecture and incident postmortems from major cloud operators. Users should combine kube-burner with staging environments and observability practices used by enterprise platform teams from Google, Amazon, and Microsoft.

Category:Kubernetes tools