Kubernetes operators

This project provides a framework for building Kubernetes operators and custom controllers. It offers a set of libraries designed to manage the lifecycle of cluster resources, enabling developers to synchronize the actual state of a cluster with a desired configuration through event-driven reconciliation loops. The framework distinguishes itself by providing a manager-orchestrated environment that coordinates multiple controllers and webhooks within a single process. It includes built-in support for optimistic concurrency control to prevent update conflicts and utilizes in-memory informer cac

The Operator SDK is a framework for building, packaging, and managing custom controllers that extend the Kubernetes API. It serves as a toolset for defining new API types and implementing reconcile loops to automate the lifecycles of complex applications. The project provides specialized support for creating operators based on Helm charts or Ansible playbooks, allowing users to maintain a desired cluster state using existing automation tools. It includes a dedicated system for packaging controllers into standardized container image bundles for distribution via the Operator Lifecycle Manager.

Kubebuilder is a framework and set of scaffolding tools used to build Kubernetes APIs and controllers. It functions as an operator framework that provides generators for custom resource definitions, admission webhooks, and RBAC manifests to extend cluster functionality. The project distinguishes itself through marker-based code generation, which parses source code comments to automatically produce Kubernetes manifests and boilerplate logic. It employs a hub-and-spoke versioning model to translate data between multiple API versions and uses a three-way merge strategy to automate project migrat

The quarkus-operator-sdk is a Java extension and framework for building custom Kubernetes operators and controllers. It provides an operator framework that generates boilerplate classes, registers reconcilers, and automatically produces custom resource definitions, role-based access control rules, deployment manifests, and Helm charts directly from application code metadata. The framework supports compile-time configuration validation to catch errors before deployment, standard dependency injection wiring for clients and controllers, and static native image compilation for generating self-con

Sample Controller is a reference implementation and developer toolkit for building custom controllers and operators to extend cluster capabilities with domain-specific resource types and reconciliation loops. It provides a foundational framework for defining, registering, and validating custom resource definitions and their instances to store domain-specific data within a cluster. The framework observes remote API servers for resource mutations, queueing discovered instances for asynchronous processing while listening for creation, update, and deletion events to trigger reconciliation logic.

Shell-operator is a tool for running event-driven scripts in a Kubernetes cluster

Kube-rs is a Rust client library and runtime for interacting with the Kubernetes API server. It provides a type-safe interface for managing cluster resources and state, including a toolkit for defining custom resource definitions and a framework for building admission webhooks to validate or mutate API requests. The project distinguishes itself through a dedicated controller runtime that implements event-driven reconciliation loops to align actual cluster state with desired configurations. It utilizes a streaming system to monitor resource changes and synchronize remote states into a local qu

The Prometheus Operator is a Kubernetes monitoring orchestrator and controller that manages Prometheus clusters and observability components through declarative custom resources. It functions as a custom resource controller that translates high-level Kubernetes resource definitions into the configuration files required by the underlying monitoring software. The project automates the deployment, scaling, and lifecycle of an observability stack, including the integration of components like Thanos and Alertmanager. It distinguishes itself by syncing monitoring targets, alerting rules, and scrape

Sealed Secrets is a Kubernetes secret encryption tool and controller designed for GitOps security. It provides a mechanism to encrypt sensitive data into specialized resources that can be safely stored in public version control systems and decrypted only within a cluster. The system uses an asymmetric encryption manager to seal secrets with a public key, ensuring that only the corresponding private key held within the cluster can unseal them. It includes utilities for security key rotation, secret re-encryption, and offline private key recovery to maintain data access during disaster recovery

Strimzi is a Kubernetes operator that automates the deployment, management, and lifecycle of Apache Kafka clusters on Kubernetes or OpenShift. It uses custom resource definitions and declarative YAML configuration to define Kafka cluster topology, broker placement, and security settings, with operator-based controllers that reconcile the desired state with the actual cluster state. The operator handles rolling updates during cluster upgrades or configuration changes to maintain availability and data integrity, and supports rack-aware broker scheduling across Kubernetes nodes and availability

The etcd-operator is a custom resource controller designed to automate the deployment, scaling, backup, and recovery of distributed key-value storage clusters on container orchestration platforms. By extending container orchestration APIs with custom resource definitions, the system manages multi-node database instances through declarative configuration files and a continuous controller reconciliation loop that drives cluster provisioning, scaling, and maintenance. The operator provides automated cluster member recovery, detecting unresponsive nodes and executing membership replacements to pr

The logging operator is a Kubernetes-native controller designed to automate the deployment, configuration, and lifecycle management of log collection and routing infrastructure. By utilizing custom resource definitions, it provides a declarative framework for standardizing how container logs are captured, processed, and forwarded across distributed cluster environments. The project distinguishes itself through its support for multi-tenant logging architectures, allowing administrators to enforce namespace-scoped isolation for log collection and routing configurations. It employs a sidecar inj