Crossplane on Dev & Platform Engineering Hub

Kratix Ep 3: Kratix GitOps vs Crossplane GitOps

Sun, 09 Aug 2026 20:30:00 +0000

Crossplane uses GitOps to provision AWS infrastructure. Kratix uses GitOps to orchestrate Promises. This frequently leads to severe architectural confusion for teams adopting Platform Engineering. In this episode, we define the exact boundary between the two tools and learn how they complement each other in a Production IDP.

Crossplane Ep 15: Building an IDP with Backstage

Sun, 09 Aug 2026 19:40:00 +0000

We have built the APIs, the translation engine, the GitOps pipeline, and the security webhooks. But developers still have to write YAML to request a database. In this final episode, we integrate Crossplane with Backstage to create the ultimate Internal Developer Portal (IDP).

Crossplane Ep 14: Custom Composition Webhooks

Sun, 09 Aug 2026 19:30:00 +0000

OpenAPI schema validation (like type: integer) is too basic for enterprise security. What if you need to enforce that a database’s storage size is an even number, or that the requested environment matches a specific regex? In this episode, we write a Kubernetes Validating Webhook in Go to intercept and inspect Crossplane Claims.

Crossplane Ep 13: Provider Families and Performance

Sun, 09 Aug 2026 19:20:00 +0000

If you install the monolithic provider-aws package into a small EKS cluster, your Kubernetes API server might crash. AWS has over 1,000 resources, meaning Crossplane will inject 1,000 CRDs and run a massive Go controller in memory. In this episode, we learn how to architect high-performance Crossplane clusters using Provider Families.

Crossplane Ep 12: GitOps with ArgoCD and Crossplane

Sun, 09 Aug 2026 19:10:00 +0000

If you are running kubectl apply -f my-database.yaml from your laptop, you are doing it wrong. In modern Platform Engineering, no human should ever talk directly to the Kubernetes API. In this episode, we configure ArgoCD to automatically deploy Crossplane XRs directly from a GitHub repository.

Crossplane Ep 11: Writing Composition Functions in Go

Sun, 09 Aug 2026 19:00:00 +0000

In Episode 10, we learned that Composition Functions allow us to escape the limitations of YAML. In this episode, we will write a custom Go program that dynamically generates an array of AWS Subnets based on a single integer provided by the Application Developer.

Crossplane Ep 10: Introduction to Composition Functions

Sun, 09 Aug 2026 18:40:00 +0000

YAML is excellent for configuration, but terrible for programming. As your Platform scales, you will inevitably need for loops, complex if/else logic, and external API calls. In this final intermediate episode, we introduce Composition Functions—the architecture that allows you to write Crossplane logic in Turing-complete languages.

Crossplane Ep 9: Troubleshooting Sync Errors

Sun, 09 Aug 2026 18:30:00 +0000

When you run terraform apply, you get immediate red text in your console if an AWS API call fails. Because Crossplane is an asynchronous control loop, kubectl apply always succeeds immediately. When a database fails to boot 10 minutes later, how do you find the error? In this episode, we learn the Crossplane troubleshooting cascade.

Crossplane Ep 8: Managing Dependencies Between Resources

Sun, 09 Aug 2026 18:20:00 +0000

If a Composition provisions both an AWS VPC and a Subnet, the Subnet physically cannot be created until the VPC exists and returns an ID. In Terraform, you use implicit dependency mapping (e.g., vpc_id = aws_vpc.main.id). In Crossplane, we manage this using Cross-Resource References and Selector matching.

Crossplane Ep 7: Environment Configs

Sun, 09 Aug 2026 18:10:00 +0000

If your company has three clusters (Development, Staging, and Production), you do not want to write three different Compositions for the same RDS database. In this episode, we learn how to use Crossplane EnvironmentConfigs to inject global context (like AWS Account IDs, VPC IDs, and Regions) dynamically into your Compositions.

Crossplane Ep 6: Patching and Transforms

Sun, 09 Aug 2026 18:00:00 +0000

In Episode 5, we hardcoded our RDS instance size to 20GB. If a developer asked for 50GB in their Claim, Crossplane ignored it. In this episode, we explore the Patcher, learning how to dynamically route data from the Composite Resource (XR) into the physical Managed Resources (MRs).

Crossplane Ep 5: Compositions

Sun, 09 Aug 2026 17:50:00 +0000

In Episode 4, we built an API (XRD) but it didn’t actually create any AWS infrastructure. In this final fundamental episode, we write a Composition. This is the ’translation engine’ that instructs Crossplane exactly which physical Managed Resources to create when a developer requests our custom API.

Crossplane Ep 4: Composite Resources (XR)

Sun, 09 Aug 2026 17:40:00 +0000

Managed Resources (MRs) are too low-level for application developers. In this episode, we learn how to define a Composite Resource Definition (XRD). This allows Platform Engineers to design a brand new, highly abstracted Custom Kubernetes API tailored exactly to their company’s needs.

Crossplane Ep 3: Managed Resources (MR)

Sun, 09 Aug 2026 17:30:00 +0000

A Managed Resource (MR) is the foundational building block of Crossplane. It is a 1-to-1 representation of a physical cloud object (like an S3 Bucket or an RDS Instance) stored as a Custom Resource in Kubernetes. In this episode, we provision our first AWS resource directly via kubectl.

Crossplane Ep 2: Providers and Credentials

Sun, 09 Aug 2026 17:20:00 +0000

Crossplane is useless on its own. To orchestrate AWS, Azure, or GCP, we must install Providers. In this episode, we install the official Upbound AWS Provider, configure Kubernetes Secrets to store our IAM credentials, and bind them to a ProviderConfig.

Crossplane Ep 1: The Kubernetes Native Control Plane

Sun, 09 Aug 2026 17:10:00 +0000

To understand Crossplane, you must first understand the Kubernetes Control Loop. In this episode, we explore the theoretical difference between CLI-driven IaC (Terraform) and Control Plane IaC (Crossplane). We will then install Crossplane into a local cluster using Helm.