kubernetes-sigs/kro

Features

• Dependency Graph Orchestrators - Uses a dependency graph orchestrator to determine the optimal creation and deletion order of resources based on data flow.
• Interdependent Resource Management - Creates a set of interdependent resources as a single unit based on a resource graph.
• Kubernetes API Generators - Provides a framework for generating simplified API surfaces that include both resource schemas and controller logic.
• Resource - Builds a directed acyclic graph of resource dependencies to determine creation order and detect circular references.
• DAG-Based Orchestration - Deploys resources as a directed acyclic graph to ensure all dependencies are met in the correct order.
• Dependency Mapping - Creates automatic ordering dependencies by referencing resource identifiers within expressions for task orchestration.
• Resource Manifest Templating - Creates manifests using expressions to dynamically inject configuration while maintaining YAML structure.
• API Definition Validation - Performs static analysis on resource definitions to catch type errors and circular dependencies.
• Infrastructure API Definitions - Provides a framework for defining custom infrastructure APIs that bundle multiple interdependent Kubernetes resources into abstract models.
• Resource Grouping - Groups interdependent Kubernetes resources into reusable components to simplify the deployment of complex applications.
• Cluster State Reconciliation - Continuously monitors managed resources for drift and automatically updates them to match the desired configuration.
• Conditional Resource Provisioning - Implements boolean expressions to conditionally include or exclude resources during the reconciliation process.
• Custom API Surfaces - Implements custom API surfaces that map user inputs to resource templates for automated creation of complex objects.
• Custom Resource Definitions - Defines the identity, scope, and validation rules for custom resources using the Kubernetes API.
• CRD Generators - Automatically generates custom resource definitions and controllers from resource graph specifications without manual Go code.
• Custom Resource Controllers - Automatically generates Kubernetes controllers and CRDs from specifications to eliminate manual Go code.
• Dependency Orchestrators - Coordinates the creation and deletion of resources using a directed acyclic graph based on data flow.
• Dynamic Configuration Expressions - Provides a common language for evaluating dynamic expressions to reference data and define runtime conditions.
• Configuration Engines - Provides an expression-based engine for dynamic value computation and conditional resource deployment.
• List-Based Resource Expansion - Creates a set of resources based on an array of values and syncs as the list changes.
• Resource Data Mapping - Wires values between resources using expressions to pass outputs from one component as inputs to another.
• Composite Resource Interfaces - Aggregates multiple interdependent Kubernetes resources into a single manageable composite model.
• Resource Orchestrators - Simplifies the deployment of complex applications by grouping interdependent Kubernetes resources into single manageable units.
• Topological Resource Lifecycle - Coordinates the creation and deletion of dependent resources based on the topological order of data flow.
• Type Validation - Checks configuration expressions against schemas to ensure field paths exist and output types are correct.
• Infrastructure Composition - Bundles multiple Kubernetes resources into reusable templates to ensure consistent delivery across environments.
• Resource Lifecycle Management - Translates resource instances and parameters into underlying components to automate deployment and maintain operational state.
• Infrastructure State Synchronization - Watches managed resources for drift and automatically restores them to the defined configuration.
• Static Type Checking - Verifies that expressions are type-safe by comparing inferred output types against expected schemas.
• Infrastructure Manifest Expansion - Evaluates dynamic expressions and logic to transform high-level schemas into multiple concrete resource manifests.
• API Stability Frameworks - Detects and blocks breaking schema changes to ensure existing resource instances remain valid.
• Complex Data Structure Transformation - Reshapes lists and maps using comprehension macros to filter entries or rebuild pairs.
• Map Data Structure Manipulation - Merges maps and performs index-based mutations on lists to manage complex resource configurations.
• Dynamic Configuration Resolution - Substitutes values from configuration or status into templates and requeues until values are available.
• Resource Dependency Inference - Infers execution order by analyzing references to ensure dependencies are resolved before dependent resources deploy.
• Specification Snapshoting - Creates numbered snapshots of specifications to provide a history of changes and their compilation results.
• Automated Resource Naming - Automatically derives resource names from namespaces and labels to ensure consistent naming conventions across the cluster.
• Collection Readiness Verifications - Blocks dependent resources until every item in a generated set satisfies status conditions.
• Conditional Resource Deployment - Includes or excludes specific resources based on the evaluation of logical expressions during the deployment process.
• Dynamic Resource Watching - Registers new resource watches dynamically to track external dependencies without requiring a controller restart.
• External Resource Referencing - Reads data from existing resources without managing their lifecycle to use as input.
• Dynamic Resource Watching - Registers new resource watches at runtime to track external dependencies without requiring a controller restart.
• Cartesian Product Generation - Generates resources for every possible combination of multiple input lists to cover all permutations.
• Conditional Provisioning - Includes supporting resources within a group only when specific capabilities are enabled via expressions.
• Manifest Field Manipulation - Enables the removal of specific fields from rendered objects to distinguish between absent and null values.
• Readiness Condition Validation - Ensures that expressions controlling resource readiness are type-safe and return boolean values.
• Resource Abstraction Layers - Creates simplified interfaces over native Kubernetes resources to hide complexity and enforce stable contracts.
• Tenant Provisioning - Deploys isolated environments using hierarchical resource definitions to manage multi-tenancy at scale.
• Collection Transformations - Uses comprehensions and macros to flatten, sort, or deduplicate lists and maps during configuration expansion.
• Conditional Field Omissions - Returns a sentinel value that excludes a specific field from the rendered resource output based on a condition.
• Immutable Version Snapshots - Maintains immutable snapshots of specifications to separate the validation phase from the compilation phase.
• Schema-Driven Validations - Performs static analysis and type checking of expressions against OpenAPI schemas to ensure API stability.
• Reverse-Order Teardown Protocols - Removes dependent resources in reverse topological order to ensure clean teardown.
• Template Integrity Validators - Validates resource templates against OpenAPI schemas to ensure field names and structures are valid.
• Status Type Inference - Determines the OpenAPI schema for status fields by analyzing the output types of the associated expressions.
• Instance Health Monitors - Tracks the operational state of a resource group using a hierarchical status system.
• Service Readiness Coordination - Defines boolean conditions that a resource must satisfy before dependent resources can be created.
• Resource Ownership Monitoring - Applies labels to managed resources to identify their parent and maintain an ownership graph.
• Status Propagation - Exposes status fields from child resources to a parent to surface aggregated health details.
• Topological Status Propagation - Aggregates and surfaces operational health data from child resources up to a parent resource status.
• Schema Validation - Checks syntax and type-checks expressions against OpenAPI schemas during definition.

Star history