Crossplane as Cloud-Native IaC

Crossplane is K8s-native IaC.

Idea

Crossplane is an IaC tool that uses Kubernetes as the control plane for cloud infrastructure. Cloud resources (databases, storage, network) are represented as Kubernetes resources; kubectl applies them; the cloud provider's API is called by Crossplane controllers. The pattern unifies application and infrastructure deployment.

What the idea looks like:

• IaC as K8s resources.: Cloud infrastructure (S3 buckets, RDS databases, VPCs) is defined as Kubernetes Custom Resources. The same kubectl tooling that manages applications manages infrastructure.
• kubectl applies cloud resources.: The team's deployment workflow is unified. kubectl apply creates infrastructure or applications; the same approach covers both.
• Unifies app and infra deployment.: The team's GitOps tools (ArgoCD, Flux) deploy both applications and infrastructure. The same review, the same audit trail, the same operational tooling apply to both.
• Provider-based architecture.: Crossplane's Provider concept maps to cloud providers (AWS, GCP, Azure). Each provider implements the cloud-specific resources; the team installs the providers they need.
• Composition for abstraction.: Crossplane's Composition feature lets teams define abstractions that combine multiple cloud resources. A "database" Composition might create the RDS instance, IAM roles, parameter store entries, and CloudWatch alarms together.

The idea is powerful. Whether it fits the team depends on the team's overall approach.

When

Crossplane fits Kubernetes-centric organizations. Teams already using GitOps for applications can extend the pattern to infrastructure; the integration is natural.

• K8s-centric orgs.: Organizations whose primary platform is Kubernetes benefit most. Crossplane extends Kubernetes to cover infrastructure; the cognitive overhead is bounded.
• Already using GitOps.: Teams using ArgoCD or Flux for applications can apply the same tools to infrastructure. The infrastructure changes flow through the same pipeline; the consistency is real.
• Tightens the integration.: Application and infrastructure are deployed together. Application that needs a database has the database in the same manifest set; the deployment is atomic; the operational story is simpler.
• Self-service patterns.: Crossplane's abstractions enable team-level self-service. The platform team defines the abstractions; application teams consume them; the platform-team scaling is real.
• Standard tooling.: kubectl, kubeconfig, RBAC all apply to Crossplane resources. The team's existing Kubernetes expertise extends; the learning curve is bounded.

Crossplane is the right choice for Kubernetes-centric teams. The unified approach pays off when the rest of the platform is Kubernetes-aligned.

Limits

Crossplane has real limitations. Provider coverage is smaller than Terraform; some cloud features are unavailable; the approach has costs as well as benefits.

• Provider coverage smaller than Terraform.: Terraform has providers for almost everything. Crossplane's provider catalog is growing but smaller. Some cloud services may not be available as Crossplane resources.
• Some cloud features unavailable.: Even when a provider exists, not every feature of the underlying cloud service may be exposed. The team may need to fall back to other tools for unsupported features.
• Younger ecosystem.: The community is smaller than Terraform's. Documentation, examples, and integrations are less abundant; the team may need to build more themselves.
• Operational complexity.: Crossplane is more components running in the cluster. The team operates these; the operational burden is real; the cost is part of the calculation.
• Multi-provider patterns require more work.: Some patterns that are cleaner in Terraform require more work in Crossplane. The team's specific patterns determine whether this matters.

Crossplane as IaC is one of those infrastructure choices that fits some teams well. Nova AI Ops integrates with infrastructure tooling across approaches, surfaces deployment patterns, and helps teams understand whether their tool choice matches their actual needs.