operator-framework/operator-sdk

Features

• Operator Bundles - Packages operators into standardized container images containing manifests and metadata for distribution via OLM.
• Control Loops - Implements the fundamental Kubernetes-style reconciliation pattern to maintain desired system states.
• Custom Resource Definitions - Defines new data types and schemas that extend the cluster API to manage domain-specific application lifecycles.
• Kubernetes Operators - Provides a comprehensive framework for developing custom controllers that extend the Kubernetes API to automate complex application management.
• Operator Lifecycle Installations - Deploys operator instances using the Operator Lifecycle Manager to automate installation and version updates.
• Command Line Interfaces - Provides a comprehensive command-line tool suite to scaffold, build, and manage the lifecycle of operators.
• Bundle Orchestration Updates - Automates the orchestration of updating bundles by updating catalog sources and replacing pods.
• Project Scaffolding - Bootstraps new operator projects with standardized file structures and initial configurations.
• Operator Extension Scaffolding - Generates the initial project structure, API definitions, and webhooks required for an operator.
• CLI Installation Managers - Provides a CLI tool for scaffolding, building, and managing the lifecycle of Kubernetes operators from a local environment.
• Project Initializers - Bootstraps new operator project directories with essential configuration files and dependency structures.
• Ansible Playbooks - Enables the use of Ansible playbooks to automate infrastructure setup and resource configuration.
• Chart-to-Resource Mappings - Links custom resource types to corresponding Helm charts to automate deployment and reconciliation.
• Cluster State Reconciliation - Continuously aligns the actual state of the cluster with a desired configuration using automation.
• Automation Role Mappings - Connects specific automation roles to custom resources via mapping files to trigger updates.
• Operator-Based Lifecycles - Uses a lifecycle manager to automate the installation, updates, and dependency handling of operators.
• Ansible-Based Operators - Provides the framework to build operators that execute Ansible playbooks for application lifecycle management.
• Direct Cluster Deployment - Provides the full workflow to build, push, and install operator images and resource definitions into a cluster.
• Helm Chart Management - Provides a framework for building operators that automate the installation and lifecycle of applications using Helm charts.
• Kubernetes Operations Automation - Automates the full lifecycle of stateful applications, including installation, scaling, and upgrades, using the Operator pattern.
• Kubernetes API Generators - Generates boilerplate code for custom resource definitions and their corresponding controller reconciliation logic.
• Cluster Resource Management - Performs create, update, and delete operations on Kubernetes cluster resources to synchronize state.
• Dynamic Resource Watching - Allows controllers to register and track resource types at runtime to trigger automated updates.
• Resource Event Triggers - Maps resource events to reconciliation triggers to automate updates when primary or owned objects change.
• Kubernetes Controllers - Implements a framework for managing cluster state through declarative reconciliation loops and API server interactions.
• Kubernetes Deployments - Implements the core capability of deploying controllers and their associated resources into Kubernetes clusters.
• Manifest Generation - Automatically creates Kubernetes YAML deployment and permission manifests from source code markers.
• Scaffolding Tools - Provides automated scaffolding to generate the boilerplate code and tooling required to build custom Kubernetes controllers.
• Operator Bundle Packaging - Packages manifests and metadata into standardized bundles for distribution through compliant container registries.
• Operator Deployment Modes - Allows running the operator as a local program, a Kubernetes deployment, or as a managed bundle.
• Admission Webhooks - Implements admission webhooks to intercept and validate or mutate API resource creation requests.
• Operator Permission Restrictions - Implements granular RBAC constraints to limit an operator's access to secrets and custom resources.
• RBAC Manifest Generation - Automatically generates Kubernetes RBAC role and cluster role manifests from source code markers.
• Reconciliation Implementations - Provides the logic used to automate application state management across code, playbooks, or charts.
• Custom Schema Definitions - Defines structural schemas for custom resources to validate and reject malformed API requests.
• Dependency Tracking - Automatically identifies and tracks data dependencies to trigger reconciliation when child resources change.
• Automation Integration - Translates resource specifications into variables for Ansible playbooks or Helm charts to ensure consistent state application.
• Project Bootstrapping Tools - Generates the initial project structure and access rules required to bootstrap a new operator.
• Request Validation - Intercepts API server requests to validate or mutate resource configurations before they are persisted.
• Boilerplate Scaffolders - Generates standard boilerplate files and project structures to accelerate the development of operators using various toolsets.
• Application Lifecycle Management - Automates the full deployment, configuration, and cleanup lifecycle of stateful applications on a cluster.
• Secondary Resource Management - Manages resources linked via owner references to trigger reconciliation of the primary resource.
• Custom Resource APIs - Generates resource definitions and controllers to extend the system with new data types and custom behaviors.
• Operational Self-Healing - Provides autonomous capabilities for monitoring system health and applying corrective redeployments.
• Operator Auto-Updates - Regenerates operator manifests to incorporate new API types and configuration changes while preserving metadata.
• Request Validation - Enforces schema constraints to ensure data integrity of incoming API requests before processing.
• Reconciliation Loops - Implements continuous control loops that converge system state toward a target state with configurable timing.
• Reconciliation Event Filtering - Implements logic to evaluate incoming resource events and filter those that should not trigger a reconciliation loop.
• Kubernetes Resource Validation - Defines validation rules in manifests to reject invalid properties during resource creation or updates.
• Finalizer Cleanup Hooks - Executes asynchronous cleanup logic via Kubernetes finalizers before a resource is permanently deleted.
• Operator Bundle Validation - Checks the content and format of bundle images to ensure they conform to OLM specifications.
• Cluster State Validations - Validates that the actual cluster state matches the desired configuration defined in manifests.
• Cross-Architecture Binary Compilation - Compiles executable binaries targeting different CPU architectures to ensure compatibility across various hardware platforms.
• Multi-Architecture Builds - Produces executable binaries targeting multiple hardware architectures to ensure operator compatibility across diverse environments.
• Operator Bundle Deployments - Enables the deployment and upgrading of operator bundles in a cluster using secure authentication.
• Ephemeral Bundle Testing - Verifies operator behavior by ephemerally deploying bundle images to a cluster using subscriptions.
• Local Controller Execution - Starts a controller in a local or remote environment to facilitate rapid testing and development.
• Out-of-Cluster Controller Execution - Executes the controller outside of a cluster for debugging while maintaining a connection to a remote API.
• OLM Manifest Generation - Creates the configuration files and container images necessary for OLM-based operator deployment.
• Kubernetes Manifest Generators - Produces the necessary YAML configuration files to deploy operators and their resources into a cluster.
• Kubernetes Operator Catalogs - Packages operator bundles into catalog index images for distribution via an operator registry.
• Admission Webhooks - Modifies or validates resources via callbacks to enforce business logic or apply default values before storage.
• Playbook Variable Injection - Injects resource specifications and system metadata into playbooks as variables during reconciliation.
• Application Provisioning - Provides automated deployment of software stacks and services via custom resource definitions.
• Application Version Updates - Automates the upgrade of workloads and schema migrations for applications managed by previous controller versions.
• Manifest Validation - Validates the on-disk representation of bundle manifests to ensure they are statically correct for installation.
• Cluster Lifecycle Managers - Installs and manages the Operator Lifecycle Manager within a cluster to coordinate operator updates.
• Cluster Resource Pruning - Automatically removes redundant Kubernetes resources from the cluster when they are no longer defined in the desired state.
• Multi-Architecture Images - Builds and bundles container images that support multiple CPU architectures through manifest lists.
• Operator - Verifies that operator manifests and metadata meet the required specifications for distribution via catalog registries.
• Multi-Platform Builds - Supports creating container images for multiple CPU architectures using manifest lists for diverse hardware environments.
• Custom Resource Status Management - Updates the status subresource of custom resources using execution output or key-value pairs to report application state.
• Deployment Lifecycle Managers - Installs and verifies the status of the lifecycle manager to prepare the cluster for operator deployment.
• Deployment Managers - Runs operators in various environments and manages the cleanup of deployed resources after execution.
• Finalizer-Based Resource Cleanup - Injects owner references into resources to enable automatic garbage collection by the Kubernetes cluster.
• Automated Chart Upgrades - Triggers a Helm chart upgrade using the force option when changes are detected on a managed resource.
• Chart Scaffolding - Generates the initial project structure and configuration files needed to build an operator that manages Helm charts.
• Helm Chart Deployment - Customizes applications by setting override values and environment variables during the deployment of Helm charts.
• Leader Election - Implements distributed locking and leader election to ensure only one instance handles reconciliation.
• Tag-to-Digest Resolution - Allows the use of immutable image digests instead of mutable tags to ensure deployment consistency and reproducibility.
• Annotation-Driven Control - Enables modification of the reconciliation process behavior via metadata annotations on custom resources.
• Local Resource Caches - Implements local resource caches with selectors to reduce memory consumption in large clusters.
• PromQL-Based Alerting Rules - Creates and reconciles rule objects, using PromQL, to trigger notifications based on specific cluster state conditions.
• Deployment Validations - Mimics production rollouts by creating a registry from manifests and verifying that resources reach an installed status.
• Multi-Architecture Deployments - Checks deployment specifications to ensure compliance with multi-architecture support best practices.
• Kubernetes Resource Status Management - Provides specialized writers to modify the status subresource of objects for reporting the current state of managed resources.
• Kustomize Scaffolding - Generates the base and overlay directory structures required for Kustomize-based operator deployments.
• Bundle Integrity Validation - Checks the integrity and correctness of a portable operator package before it is deployed.
• Operator Lifecycle Manager Tooling - Provides commands to install, uninstall, and monitor the status of the Operator Lifecycle Manager.
• Resource Scope Definitions - Determines whether a resource is cluster-scoped or namespace-scoped to control visibility and access.
• Resource-to-Automation Mappings - Links custom resource types to specific roles or playbooks to trigger automated reconciliation when resources change.
• Server Load Management - Optimizes API server load by routing read requests through local caches and directing writes to the server.
• RBAC Manifest Generation - Automatically produces RBAC and deployment manifests based on markers embedded in the source code.
• Operator Package Manifests - Creates versioned directories containing metadata that defines how an operator is packaged and distributed.
• Concurrency Tuning - Provides configuration settings to tune the number of concurrent reconciliation workers based on CPU capacity.
• Version Upgrades - Updates software versions and manages schema migrations for controllers and managed applications.
• API Resource Version Conversions - Handles API resource versioning through semantic versioning and conversion webhooks to support legacy resource instances.
• Service Account Provisioning - Automates the creation and configuration of multiple service accounts during the operator bundle generation process.
• Concurrency Scaling Strategies - Implements concurrency scaling strategies to process multiple resources simultaneously and ensure timely updates.
• Webhook Generators - Scaffolds the necessary boilerplate for mutating and validating admission webhooks.
• Traffic Routing Policies - Creates fine-grained traffic routing policies that restrict communication to authorized components.
• Controller Scope Restriction - Configures controllers to either manage resources cluster-wide or restrict their operations to specific namespaces.
• Encrypted Secret Management - Integrates with external vaulting tools to decrypt sensitive keys during the reconciliation process.
• Cluster Resource Isolation - Enables the architecture of operators that support multiple users on a single cluster with strict resource separation.
• Network Security Policies - Configures network security policies to restrict traffic for metrics and webhooks within a cluster.
• Service Account Management - Manages non-human identities and programmatic access tokens by assigning different service accounts to components.
• ClusterServiceVersion Metadata - Automatically populates resource definition details in CSV version files using markers in the source code.
• Package Manifest to Bundle Conversion - Transforms package manifest directories into bundle images with custom base tags and build commands.
• Resource Lifecycle Management - Guarantees the correct acquisition and release of resources using finalizers and scopes.
• Alert Runbooks - Defines operational alerts paired with runbooks to guide administrators through failure remediation.
• Global Metric Registries - Exposes internal performance counters via a global registry for integration with external monitoring tools.
• Health Metrics Exposure - Exposes internal component health and performance metrics for consumption by external monitoring tools.
• Alert-Dashboard Integration - Automatically generates rules and dashboards to track operator performance and alert on operational symptoms.
• Monitoring and Observability - Provides comprehensive telemetry collection to gain visibility into operator performance and health.
• Health Monitoring Endpoints - Instruments the controller with standardized endpoints to provide health indicators for monitoring platforms.
• HTTP Health Probes - Configures liveness, readiness, and startup probes to maintain application availability.
• Reconciliation Performance Metrics - Exposes histogram metrics to track the frequency and duration of reconciliation loops.
• Status Condition Event Emissions - Generates Kubernetes-native resource status events to provide operational observability into the reconciliation process.
• Local Test Execution - Provides a workflow to run operator test suites and build images in a temporary local cluster.
• Bundle Scorecards - Launches test pods to collect and analyze results for validating operator software bundles.
• Compliance Verifiers - Executes automated tests within a cluster to ensure the operator conforms to required functional and integration standards.
• State Assertions - Uses automated tests to assert that the resulting cluster state aligns with the desired configuration.
• Cluster Integration Testing - Validates component behavior using a local API server environment to simulate cluster interactions.
• Isolated Functionality Testing - Verifies basic application behavior by running automated test blocks in temporary, isolated environments.
• Operator Scorecards - Executes scorecard validations to ensure operators meet defined quality and functional standards.
• Lifecycle Testing - Verifies the behavior of operators during their installation and operational phases via a lifecycle manager.
• End-to-End Testing - Verifies system-wide functional correctness by simulating complete user workflows across the application stack.
• Quality Assurance Frameworks - Inspects container images and manifests to ensure they meet defined technical and functional quality standards.
• Renderer Reconciler Abstractions - Implements the reconciler pattern to compute and apply changes to the cluster state.

Star history