kubernetes-sigs/kubebuilder

Features

• Reconciliation Loops - Implements the core reconciliation loop pattern to continuously align the actual cluster state with the desired state.
• Custom Resource Definitions - Provides the core tooling to create Custom Resource Definitions (CRDs) that extend the Kubernetes API.
• Kubernetes Operators - Provides a comprehensive framework for building custom resources and controllers to extend Kubernetes functionality.
• State Reconciliation - Synchronizes the actual state of a cluster and external resources with the desired state defined in an object.
• Generators and Scaffolding - Provides the foundational boilerplate and directory structures specifically for Kubernetes API and controller development.
• RBAC Manifest Generation - Automatically generates Kubernetes role manifests from markers in the source code to enforce least-privilege access.
• Reconciliation Event Filtering - Evaluates field or label changes to determine if a resource event should trigger a reconciliation loop.
• Kubernetes Resource Validation - Enforces data constraints on custom resource values using markers to ensure only valid data is accepted.
• Finalizer Cleanup Hooks - Implements asynchronous cleanup logic via Kubernetes finalizers to ensure external resources are removed before object deletion.
• Project Initializers - Scaffolds a new project directory with a default structure based on a provided domain and repository.
• Project Scaffolding - Generates a standardized project directory structure and boilerplate code using a specified domain and repository.
• Project Scaffolding Templates - Generates a standardized project structure and boilerplate code required to build a set of controllers.
• Resource Mappings - Maintains a scheme mapping API kinds to Go types to ensure correct data serialization and deserialization.
• Container Image Packaging - Builds container images of the controller and pushes them to a registry for deployment.
• Controller Deployments - Packages the controller into a container image and deploys it as a running service within the cluster.
• Controller Managers - Orchestrates shared caches, leader election, and health probes to manage multiple controllers and webhooks.
• CRD Generators - Produces API schemas and manifests for extending the Kubernetes API with custom resource types.
• CRD Scaffolding - Generates boilerplate definitions to extend the cluster API with new resource types and associated schemas.
• Kubernetes API Generators - Creates resource definitions and associated controllers to extend cluster functionality with custom logic.
• Kubernetes Controllers - Generates the directory structure and reconciliation logic required to implement Kubernetes controllers.
• Manifest Generation - Produces YAML files for resource definitions, webhook configurations, and roles based on source code annotations.
• Resource Validators - Checks the validity of resource data during creation or updates to ensure business rules are met.
• Marker-Driven Resource Generation - Transforms type definitions and marker comments into resource definitions and role YAML.
• Manifest Generators - Produces the necessary YAML manifests and resource definitions required to deploy custom resources to a cluster.
• Kubernetes Resource Manifests - Automatically produces resource schemas and the corresponding YAML manifests and boilerplate for reconciliation logic.
• RBAC Manifest Generation - Automatically produces role and cluster role YAML manifests based on markers in the source code.
• RBAC Manifest Generation - Produces role YAML manifests to define required permissions based on markers in the controller code.
• Admission Webhooks - Generates configuration for mutating and validating admission webhooks to intercept and modify cluster resource requests.
• Webhook Generators - Scaffolds mutating and validating admission webhooks to enforce business rules and default values.
• Marker-Based Generators - Automatically generates Kubernetes manifests and boilerplate logic by parsing special marker comments in source code.
• RBAC Manifest Generation - Generates role and cluster role YAML manifests based on source code markers to enforce least privilege access.
• API Versioning Strategies - Implements a hub-and-spoke model to translate custom resource data between multiple API versions.
• Hub-and-Spoke Versioning - Manages the evolution of custom resource schemas across multiple versions to maintain client compatibility.
• Controller Lifecycle Management - Orchestrates controllers and webhooks through a central manager that handles shared caches and shutdown signals.
• Type-Safe API Schemas - Provides typed object definitions to ensure consistent data serialization and formal API interface specification for custom resources.
• Resource State Synchronization - Synchronizes actual cluster state with desired state by executing custom logic to manage resource lifecycles.
• Admission Request Modification - Intercepts object creation or update requests to apply default values or inject sidecar containers.
• Project Bootstrapping Tools - Initializes a directory structure and base configuration to start developing custom APIs and controllers.
• Request Validation - Implements admission webhooks to mutate or validate resources before the API server accepts them.
• Runtime Type Registrations - Adds resource definitions to the runtime scheme so the controller can recognize and operate on Kubernetes objects.
• Specification Validation Schemas - Generates formal validation schemas to enforce data constraints and required fields for custom resource definitions.
• Type Mapping Registries - Maintains a registry that maps Kubernetes API kinds to Go types for consistent data serialization.
• Resource Change Monitors - Triggers a reconciliation loop whenever resources are created, updated, or deleted to maintain desired state.
• Resource Ownership Monitoring - Monitors child resources and triggers reconciliation of the parent object when children are modified or deleted.
• Secondary Resource Management - Links resources via owner references and monitors secondary changes to trigger primary resource reconciliation.
• API Scaffolds - Generates directory structures and boilerplate code for new API groups, versions, and custom resource kinds.
• API Versioning - Transforms resource data between API versions using a hub-and-spoke model to maintain compatibility.
• CLI Extension Frameworks - Integrates external executables via standard I/O to customize project initialization and scaffolding.
• Boilerplate Generators - Generates required implementation files and runtime objects to minimize manual coding of repetitive structures.
• Feature Boilerplate Generators - Adds specialized boilerplate for recurring tasks such as deployment logic, dashboards, and chart generation.
• Local Control Plane Testing - Spawns a local API server to instantiate and execute controllers for validating behavior against real interactions.
• Local Execution Environments - Executes controller processes on a local machine against a target cluster for rapid development and testing.
• Project Migration Utilities - Automates the update of project files between versions using a three-way merge to preserve custom changes.
• Custom Scaffolding Logic - Integrates external tools or custom logic into the generation process to tailor the codebase structure.
• Git-Based Scaffold Upgrading - Updates a project to a newer version using a three-way Git merge to preserve custom code.
• Plugin-Based Scaffolding - Integrates additional plugins to add capabilities or maintain the project with the latest releases.
• Scaffold Migration - Updates the project structure to the latest version while preserving custom code and resolving conflicts.
• Three-Way Merge Updating - Upgrades the project structure to a newer version using a 3-way merge to preserve custom code changes.
• Scaffolding Engine Extensions - Integrates external tools and custom logic into the scaffolding engine to modify project structures.
• API Subresource Configurations - Defines specialized endpoints for status and scale to decouple desired state updates from observed state and autoscaling.
• API Subresource Implementations - Implements specialized endpoints for status and scaling to separate desired state from observed state.
• Container Deployment - Automates the deployment and management of container images using controllers and custom resources.
• Chart Generation - Creates distributable Helm charts from build output while preserving custom environment variables and labels.
• Chart Scaffolding - Generates a Helm chart in the distribution directory to package and distribute the project as a reusable unit.
• Leader Election - Implements distributed locking to ensure only one instance of a controller manager is active at a time.
• Finalizer-Based Lifecycle Controllers - Implements finalizers to ensure external dependencies are cleaned up before a resource is deleted from the cluster.
• Local Kubernetes Clusters - Provisions a local Kubernetes cluster with configurable node roles and image versions for development.
• Kustomize Scaffolding - Generates the necessary configuration files and manifests in a project directory to manage deployments via a base.
• Plugin Extensibility - Integrates custom plugins into the build process to extend support for new languages or templates.
• Resource Scope Definitions - Determines if a resource is isolated within a namespace or global to the cluster via configuration flags.
• Schema Installation Tools - Applies API schemas to the cluster so the system recognizes and stores new custom resource types.
• Webhook Deadlock Prevention - Excludes specific namespaces or objects from validation via selectors to ensure controller pods start without blocking.
• Runtime Compatibility Methods - Creates the necessary duplication and runtime methods for types to ensure compatibility with API machinery.
• Boilerplate Object Methods - Creates cloning method implementations to ensure types can be duplicated in memory as required by Kubernetes.
• Controller Scope Restriction - Determines which namespaces a manager watches using RBAC and cache settings to restrict operational scope.
• Webhook Certificate Rotation - Automates the creation and rotation of TLS certificates for admission webhooks to ensure secure communication.
• API Contract Definitions - Organizes API types into separate modules to allow external reuse without requiring controller dependencies.
• Scaffolding Customizers - Provides mechanisms to customize the default scaffolding process by modifying generated files.
• Schema Default Values - Sets initial field values for custom resources during creation or updates to ensure a consistent state.
• Scaffolding Plugins - Provides a plugin architecture to customize boilerplate file generation and add support for different languages.
• Plugin Integrations - Adds optional features or custom scaffolding logic by integrating external plugin executables.
• Plugin-Based Logic Extensions - Integrates optional feature modules into a project to add specialized capabilities.
• Kubernetes Resource Lifecycle Hooks - Implements asynchronous pre-delete hooks via finalizers to clean up external resources before object removal.
• Spec-Status Separation - Divides a custom resource into distinct spec and status endpoints to prevent conflicting updates.
• Three-Way Merge Strategies - Updates project scaffolding by merging new framework templates with existing user code and the original baseline.
• Controller Event Logging - Creates event objects during reconciliation to provide a traceable audit log of actions and status changes.
• Custom Metric Collectors - Registers application-specific collectors into the global registry to track custom business or operational logic.
• Metrics Exporters - Exports performance data to a global registry for monitoring via visualization dashboards.
• Metric and Performance Monitors - Integrates profiling and custom metrics to monitor the health and resource usage of controllers.
• Performance Metrics - Exposes a collection of controller performance metrics via a global registry for monitoring system health.
• Prometheus Exporters - Creates a monitor resource to enable a metrics operator to discover and scrape data from the controller.
• API Watch Optimization - Limits controllers to monitor resources within specific namespaces to improve security and performance.
• Test Environment Provisioning - Downloads and configures necessary binaries to run a local API server and database for controller testing.
• External Resource Controller Scaffolding - Scaffolds controllers for API types defined in external repositories without creating new local resource definitions.
• Source Code Injection - Identifies specific locations in files where new components can be inserted without overwriting user-written logic.

Star history