For modular infrastructure managed from Kubernetes, Crossplane is the most complete option because compositions turn groups of cloud resources into one custom API that a controller keeps reconciled. The alternatives are cloud-specific operators (AWS Controllers for Kubernetes, Azure Service Operator, Google Config Connector) for single-cloud teams, Kube Resource Orchestrator (kro) for lighter resource grouping, and Terraform or OpenTofu controllers or the Pulumi Kubernetes Operator for teams that want to keep existing modules. Each tool makes different trade-offs around packaging, reconciliation, drift handling, and cloud reach. This guide compares them in side-by-side tables, explains a common hybrid layering pattern, and maps each option to the team situation where it fits best.
Disclosure: Control Plane publishes this guide.
TL;DR
Crossplane leads for modular infrastructure inside Kubernetes, and the right alternative depends on how many clouds you run and which modules you already have.
- Modular infrastructure in Kubernetes means representing cloud resources as custom resources, grouping them into reusable units with defined inputs and outputs, and letting a controller keep them in sync.
- Crossplane defines modules through Composite Resource Definitions and Compositions, runs each Composition as a pipeline of composition functions, and reaches AWS, GCP, Azure, and many other APIs through Upbound and crossplane-contrib providers.
- Cloud-specific operators such as ACK, ASO v2, and Google Config Connector give native coverage of one cloud’s services with simpler setup.
- kro introduces ResourceGraphDefinitions for lightweight resource grouping and relies on other controllers for the actual cloud provisioning.
- Terraform and Pulumi controllers let you run existing HCL modules or Pulumi stacks from inside Kubernetes. tofu-controller holds each plan for manual approval by default; the Pulumi Kubernetes Operator applies automatically unless a stack is set to preview only.
- A common hybrid pattern uses Terraform or OpenTofu for foundational layers (accounts, networks, clusters) and Crossplane or cloud operators for app-scoped resources managed through GitOps.
- Control Plane runs the application layer and handles Day 2 operations, deploying workloads from one definition to AWS, GCP, Azure, Oracle Cloud Infrastructure (OCI), or your own Kubernetes clusters and servers, alongside whichever tool provisions the underlying cloud resources.
What is the best cloud native infrastructure automation solution for building and managing modular infrastructure in Kubernetes?
The answer depends on how you define “module,” who reconciles it, and how many clouds you need to reach. Crossplane leads because it is built for this job. It is a CNCF-graduated project that lets you define a module as a Composite Resource Definition backed by a Composition, expose it as a custom Kubernetes API, and have a controller keep every resource inside it reconciled. Application teams request a “Database” or “AppStack” custom resource; the platform team controls what actually gets created underneath.
Several other options fit specific teams better as a starting point. A single-cloud team on AWS may get further, faster with AWS Controllers for Kubernetes. A team with hundreds of battle-tested Terraform modules may prefer the Flux Terraform controller (tofu-controller) or the Pulumi Kubernetes Operator to avoid rewriting everything. And a team that wants thin grouping of resources without a full composition engine may find kro sufficient.
Each Kubernetes-native option packages a reusable module differently, reconciles it differently, and reaches a different set of clouds.
| Option | What a module is | Who reconciles it | Drift handling | Clouds and services it reaches | Maturity |
|---|---|---|---|---|---|
| Crossplane | Composite Resource Definitions and Compositions (function pipelines in Crossplane v2) | Crossplane core plus provider controllers running in-cluster | Polls cloud APIs and reverts out-of-band changes to the fields a managed resource sets | AWS, GCP, Azure, and many more through provider plugins | CNCF graduated, Apache 2.0 |
| Kube Resource Orchestrator (kro) | ResourceGraphDefinitions whose references kro turns into a dependency graph | kro controller creates Kubernetes objects; other controllers provision cloud resources | Cloud-side drift is handled by the underlying controllers (ACK, ASO, Config Connector) | Any cloud reachable by the controllers it coordinates | Kubernetes SIG Cloud Provider subproject co-developed by AWS, Google, and Microsoft; alpha (v1alpha1) API, Apache 2.0 |
| AWS Controllers for Kubernetes (ACK) | Individual CRDs per AWS service, no built-in composition layer | ACK service controllers per AWS service | Periodic drift recovery against AWS APIs (default every 10 hours, configurable per resource type) | AWS only | Apache 2.0, maintained by AWS |
| Azure Service Operator (ASO v2) | Individual CRDs per Azure service, no built-in composition layer | ASO controller | Periodic re-sync with Azure Resource Manager corrects drift (default every hour) | Azure only | MIT, maintained by Microsoft |
| Google Config Connector | Individual CRDs per GCP service, no built-in composition layer | Config Connector controller | Periodic re-reconcile against GCP APIs, interval configurable per resource | GCP only | Apache 2.0, maintained by Google; GKE add-on or manual install on any cluster |
| Flux Terraform controller (tofu-controller) | Terraform or OpenTofu modules referenced by a Terraform CRD | tofu-controller runs plan and apply inside the cluster | Drift detected on each plan interval; corrected automatically with approvePlan: auto, held for approval otherwise | Any cloud Terraform or OpenTofu providers support | Community project in the flux-iac org (not a CNCF project), Apache 2.0 |
| Pulumi Kubernetes Operator | Pulumi stacks defined in TypeScript, Python, Go, C#, or YAML | Operator runs the Pulumi engine in a per-stack workspace pod in the cluster | Re-applied on each resync when refresh and continueResyncOnCommitMatch are set; otherwise only on new commits | Any cloud Pulumi providers support | Apache 2.0, maintained by Pulumi |
| Helm charts with an operator (generic pattern) | Helm chart plus a custom operator that manages its lifecycle | Custom operator | Depends on operator implementation | Depends on what the operator manages | Varies widely |
| Cluster API | Cluster, MachineDeployment, and provider-specific CRDs | Cluster API controllers and infrastructure provider controllers | Continuous reconciliation of cluster and machine state | AWS, GCP, Azure, vSphere, and others through infrastructure providers | Kubernetes SIG Cluster Lifecycle project, Apache 2.0 |
Crossplane’s composition model is the most expressive for building platform APIs, and that expressiveness carries a learning curve.
What makes infrastructure modular in Kubernetes?
Modularity in Kubernetes infrastructure means packaging a set of related cloud resources into a single, versioned, reusable unit that developers can request without knowing the implementation details.
Four properties distinguish a modular infrastructure definition from a loose collection of YAML files.
- A custom API with typed inputs and outputs. A Crossplane Composite Resource Definition, for example, lets you declare a “RelationalDatabase” API with fields like
region,size, andengine, and expose aconnectionStringas an output. Developers request resources through this API without writing raw cloud resource manifests. In Crossplane v2, a Composition writes connection details by composing a Kubernetes Secret. - Composition of multiple resources. A single module can create an RDS instance, a security group, a subnet group, and a secret, all wired together. Crossplane Compositions and kro ResourceGraphDefinitions both express these groupings, though with different levels of logic support.
- Versioning. Modules can be versioned so that existing consumers are not broken when the platform team updates the underlying implementation. Crossplane versions the API itself through multiple XRD versions and keeps an immutable revision of every Composition change, which instances can select by label; Terraform modules use semantic versioning in registries.
- Dependency ordering and lifecycle management. Resources within a module often depend on each other. The controller or orchestrator must handle creation order and safe deletion. Crossplane creates all composed resources together and lets cross-resource references resolve as dependencies become ready;
Usageobjects block deleting a resource while something still depends on it. kro builds a dependency graph from the references in a ResourceGraphDefinition and creates resources in that order.
Crossplane v2, the current major version, changed the module model: composite resources and managed resources are namespaced, claims remain only for legacy APIs, Compositions run as function pipelines, and a Composition can include any Kubernetes resource, such as a Deployment, alongside cloud resources. Guides written for Crossplane v1 often show patterns v2 no longer uses.
These properties let a platform team ship an internal developer platform built on Kubernetes primitives. A related guide covers how to choose an internal developer platform.
Which layer should own what?
Teams running Kubernetes-native infrastructure usually split the work across tools. They assign different tools to different layers based on lifecycle, blast radius, and who needs to change them.
| Layer | Typical owner tool | Why | Watch out for |
|---|---|---|---|
| Cloud accounts, organizations, and landing zones | Terraform or OpenTofu | Changed rarely, reviewed carefully, often managed by a central cloud team | Avoid letting app teams modify these; use strict state locking |
| Networks, VPCs, and shared identity | Terraform or OpenTofu | Shared across many workloads, changes need plan review | Drift in network config can break everything downstream |
| Kubernetes clusters themselves | Cluster API or Terraform | Cluster lifecycle is distinct from what runs inside the cluster | Cluster API adds another set of controllers to operate and upgrade |
| App-scoped databases, queues, and buckets | Crossplane, cloud operators, or Terraform controllers | Developers request these frequently; self-service APIs reduce tickets | Set management or deletion policies before production data lands; Crossplane and the cloud operators delete the cloud resource with the object by default |
| Application workloads | Kubernetes manifests, Helm, Kustomize, or a workload platform | Deployed and updated many times per day | Keep workload config separate from infrastructure config in Git |
| Policy and guardrails (Kyverno, OPA Gatekeeper) | Policy engine deployed alongside the cluster | Rejects non-compliant resources before any controller provisions them | Over-restrictive policies create workaround pressure |
In this hybrid pattern, Terraform or OpenTofu provisions the foundation, meaning accounts, networks, and clusters. Crossplane or cloud operators run inside those clusters and handle the resources that application teams need on demand. Argo CD or Flux reconcile the in-cluster layer from Git; the foundation layer runs from a CI pipeline, or from tofu-controller if it should also be reconciled from Git. The Argo CD vs Flux guide compares those two GitOps tools.
Policy engines like Kyverno or OPA Gatekeeper sit alongside both layers, validating resources before they are admitted. The guide to policy as code for multi-cloud infrastructure covers that layer in depth.
How do continuous reconciliation and plan-before-apply compare?
The deepest architectural divide among these tools is whether a controller reconciles state continuously or whether a human reviews a plan before changes are applied.
Continuous reconciliation is the model used by Crossplane, ACK, ASO, and Google Config Connector. A controller watches the desired state in the Kubernetes API server and compares it to the actual state in the cloud on a periodic resync whose interval varies by tool (the Upbound Crossplane providers check each resource every 10 minutes by default, ASO every hour, ACK every 10 hours). If someone manually deletes a security group or changes a database parameter through the cloud console, the controller detects the drift and reverts it. This corrects configuration drift, a common source of incidents in multi-cloud environments.
The risks are real, though. A bad composition that is merged to the main branch and synced by Argo CD is applied immediately and continuously, with no approval step between merge and apply. Composite resources default to compositionUpdatePolicy: Automatic, so every existing instance moves to a new Composition revision as soon as it lands, and a resource removed from the Composition is deleted from the cloud. Setting the policy to Manual, or pinning instances to labeled revisions with compositionRevisionSelector, lets a platform team roll a change out to a few instances first. Omitting Delete from a managed resource’s managementPolicies keeps the cloud resource when its Kubernetes object is removed, and an Observe-only policy imports a resource without changing it. For emergency manual changes, the crossplane.io/paused: "true" annotation stops reconciliation of a single managed resource, and a paused resource can’t be deleted until the annotation is removed.
Plan-before-apply is the model used by Terraform, OpenTofu, and their Kubernetes controllers. The Flux tofu-controller runs a plan on an interval or on Git changes and, unless approvePlan is set to auto, waits for a person to approve that specific plan before applying. The Pulumi Kubernetes Operator has no approval gate: a stack either runs preview only (preview: true) or runs updates automatically, so review has to happen in the pull request before the change merges. The plan model gives operators a chance to review exactly what will change before it happens, which is valuable for high-blast-radius resources like VPCs or IAM policies.
The downside is that drift goes undetected between plan runs, which for pipeline-driven Terraform can mean days. If someone modifies a resource through the console on Monday and the next plan does not run until Wednesday, the environment is silently inconsistent for two days.
Neither model is universally better. The hybrid layering pattern addresses this by assigning plan-before-apply to foundational resources where review matters most, and continuous reconciliation to app-scoped resources where speed and consistency matter more.
Which option fits your team?
The right starting point depends less on the tool’s features and more on your team’s existing skills, cloud footprint, and operational model.
| If your situation is | Start with | Watch out for |
|---|---|---|
| Single cloud and already on Kubernetes | Your cloud provider’s operator (ACK, ASO, or Config Connector) | No built-in composition layer; you may outgrow it as self-service demands increase |
| Several clouds with a platform team building self-service APIs | Crossplane with Argo CD or Flux | Composition authoring has a steep learning curve; invest in documentation and golden paths |
| Large existing Terraform module library | Flux tofu-controller or the HCP Terraform Operator for Kubernetes | tofu-controller runs plans and keeps state in the cluster or a backend you run; the HCP Terraform Operator runs them in HCP Terraform, which requires HCP Terraform or Terraform Enterprise |
| Developers who prefer general-purpose languages | Pulumi Kubernetes Operator | Updates apply automatically when a new commit lands, so review changes in pull requests; manage secrets and credentials carefully |
| No platform team | Managed cloud services with Terraform or OpenTofu outside the cluster | Adding Crossplane or operators without a team to maintain them creates operational risk |
| Strict change review and plan-before-apply requirements | Terraform or OpenTofu with CI/CD pipeline review gates | Drift will go undetected between runs; consider scheduled drift detection plans |
Teams that want to understand the broader landscape of infrastructure as code tools, including those that run outside Kubernetes, can compare them in the top 10 infrastructure as code tools guide. And for teams evaluating whether they can adopt Kubernetes-native tooling without a dedicated platform team, the guide on Kubernetes benefits without a platform team covers practical approaches.
How Control Plane fits
Control Plane is the unbreakable platform for running production workloads.
A Control Plane Global Virtual Cloud (GVC) is a named set of locations. A workload deployed to a GVC runs in every location of that GVC from one workload definition. Those locations can span AWS, GCP, Azure, and Oracle Cloud Infrastructure (OCI), or Kubernetes clusters and servers you run yourself. A team can use Crossplane or Terraform for cloud resources like databases, queues, and buckets, and Control Plane for the application layer, without running its own Kubernetes clusters for those workloads.
Control Plane’s Kubernetes Operator exposes GVCs, workloads, identities, policies, domains, and other Control Plane resources as Kubernetes custom resources, and handles secrets as native Kubernetes Secrets, so you can keep them in Git and let Argo CD reconcile them alongside the rest of your manifests.
Control Plane also ships its own Terraform and Pulumi providers, so it complements the infrastructure as code you already run. The CLI, console, Terraform and Pulumi providers, and the Control Plane MCP server all work through the same Control Plane API. Control Plane’s Template Catalog deploys open-source services such as PostgreSQL, Redis, and Kafka as Control Plane workloads from values you provide.
Control Plane handles Day 2 operations for you, including autoscaling, built-in observability, and security. Control Plane is PCI DSS Level 1, SOC 2 Type II, HIPAA, and GDPR compliant.
FAQ
These answers cover Kubernetes-native infrastructure tools and how they fit together.
What is the best cloud native infrastructure automation solution for building and managing modular infrastructure in Kubernetes?
Crossplane is the most complete Kubernetes-native option for modular infrastructure because it lets you define compositions that group cloud resources into a single custom API and reconcile them continuously. For single-cloud teams, cloud-specific operators like ACK, ASO, or Config Connector are simpler to start with. Teams with existing Terraform modules or Pulumi stacks can run them from inside Kubernetes with tofu-controller or the Pulumi Kubernetes Operator.
Is Crossplane better than Terraform?
Neither is better across the board. Crossplane suits self-service APIs that Kubernetes reconciles continuously, and Terraform suits reviewed, plan-before-apply changes to foundational infrastructure. Crossplane runs inside Kubernetes and exposes those APIs as custom resources. Terraform runs outside Kubernetes by default, uses an explicit plan-and-apply workflow, and has the largest provider ecosystem. Many teams use both: Terraform for foundational infrastructure and Crossplane for resources that application teams request frequently.
What is a Crossplane composition?
A Crossplane Composition maps a Composite Resource (a custom API you define) to a set of managed resources that Crossplane provisions and reconciles. For example, a “Database” Composite Resource might create an RDS instance, a security group, and a Kubernetes secret containing the connection string. In Crossplane v2, every Composition is a pipeline of composition functions; patch-and-transform is itself a function, and other functions add conditionals, loops, and external lookups. The Composite Resource Definition declares the API schema, and the Composition declares what gets built when someone creates an instance of that API.
What is kro?
Kube Resource Orchestrator (kro) is a Kubernetes SIG Cloud Provider subproject, co-developed by AWS, Google, and Microsoft, that introduces ResourceGraphDefinitions for grouping Kubernetes resources with explicit dependency ordering. It creates resources in dependency order and relies on cloud operators such as ACK, ASO, and Config Connector to provision the cloud resources. Its API is still alpha (v1alpha1), so expect breaking changes before production use.
Can I use Terraform modules from Kubernetes?
Yes. The Flux Terraform controller (also called tofu-controller) lets you define a Terraform custom resource in Kubernetes that references a Terraform or OpenTofu module from a Git repository or registry. The controller runs plan and apply inside the cluster on a configurable schedule or in response to Git changes. By default it waits for a person to approve each plan. The Pulumi Kubernetes Operator provides a similar capability for Pulumi stacks but applies updates automatically when a new commit lands, so review happens in the pull request. tofu-controller stores state in a Kubernetes Secret by default or in a remote backend; the Pulumi operator uses Pulumi Cloud or a self-managed backend such as S3.
Should cloud infrastructure be managed from inside Kubernetes?
Yes, for app-scoped resources that developers request frequently, such as databases, queues, and storage buckets. It enables self-service through Kubernetes APIs, integrates with GitOps pipelines, and uses Kubernetes RBAC for access control. Foundational infrastructure like cloud accounts, networks, and the Kubernetes clusters themselves is usually managed from outside the cluster. A cluster cannot create itself, and a cluster that manages its own network can lose the controllers it needs to recover if that network breaks.
How do I manage Kubernetes clusters themselves as code?
Cluster API, a Kubernetes SIG Cluster Lifecycle project, is designed for this. It represents clusters, machine deployments, and infrastructure providers as Kubernetes custom resources, and its controllers reconcile them continuously. Terraform and OpenTofu are also widely used for cluster provisioning, especially through provider-specific modules for EKS, GKE, and AKS. Some teams use Terraform to create a management cluster and Cluster API inside that cluster to manage all other clusters. Cluster API can also start from a temporary local kind cluster and move its objects into the new management cluster with clusterctl move.
How does Control Plane work with Kubernetes-native infrastructure tools?
Control Plane runs the application workloads while Crossplane, cloud operators, or Terraform controllers provision the cloud resources those workloads depend on. Workloads run across AWS, GCP, Azure, and Oracle Cloud Infrastructure (OCI), or on Kubernetes clusters and servers you run yourself. Control Plane’s Kubernetes Operator manages Global Virtual Clouds (GVCs), Control Plane’s named sets of locations, along with workloads and secrets from the same Git repository as your compositions, and Control Plane’s Terraform and Pulumi providers serve teams that manage configuration through those tools.
What is the role of policy engines alongside infrastructure controllers?
Policy engines like Kyverno and OPA Gatekeeper validate and mutate Kubernetes resources at admission time, before a controller acts on them. Rules such as “every database must have encryption enabled” or “no public S3 buckets” apply to Crossplane managed resources and cloud-operator custom resources, because each cloud resource is its own Kubernetes object. For tofu-controller and the Pulumi operator, admission sees only the Terraform or Stack object, so the resources inside the module need plan-time checks such as Conftest or Checkov in CI. Kubernetes also includes ValidatingAdmissionPolicy, a built-in CEL-based admission check, for simple rules without an extra engine.
To run application workloads across clouds without managing the clusters yourself, talk to the Control Plane team or sign up free.





