Crossplane Intro and Deep Dive

Being a CNCF project, Crossplane had an “Intro and Deep Dive” talk at the recent KubeCon in Paris. The room was packed, and many more people were queuing outside but didn’t manage to get in, unfortunately. But don’t worry, the talk was recorded, and in this article, we will go through a few highlights.

The format

“Intro and Deep Dive” is a strange format; presenters must carefully balance the topics to appeal to new and experienced users of the project at the same time. Thus, it needs to provide enough context to allow newcomers to understand the project’s goals, but also showcase new or upcoming features to offer valuable insights for people who have already adopted it.

We already covered what Crossplane is and why you should care about it at length in a few previous blog posts:

• What is Crossplane?
• Why Choose Crossplane?
• 8 Reasons Why Crossplane is the Ideal Engine for Internal Developer Platforms

So, we will focus more on the “Deep Dive” part here.

Crossplane Deep Dive

In the second half of the talk, we went through the improvements from 1.15, which you can read more about in the dedicated article, but with a few insightful demos and references that we will try to summarize below.

Developer experience

One of the main focuses for Crossplane 1.15 was to improve the developer experience around writing Compositions, enriching the `crossplane` CLI with many new subcommands to help develop and debug Compositions, first locally and then in a live cluster:

• init: to scaffold new Crossplane projects
• render: to test Compositions locally
• validate: to validate resources against their schemas
• trace: to visualize and debug complicated compositions and packages
• top: to get more information about Crossplane resources
• convert: to help migrate older resources to new versions

Jared Watts, Crossplane steering committee member, walked us through a terrific demo clearly demonstrating how much of an improvement the new flow built on top of Composition Functions and all the latest tooling is while working with Crossplane from Composition development to debugging in production. You can find the repository he used here, but we highly recommend watching him walk through it live.

Composition Functions

Composition Functions were fully revamped and promoted to Beta in 1.14. In 1.15 we further improved them by:

• providing a Python SDK.
• exposing from Crossplane a few more metrics related to Functions, such as call/response counts and execution times.
• allowing functions to request extra resources directly from Crossplane.

Since then, we saw the Composition Function ecosystem thriving since then, so we took the chance to showcase a few interesting existing functions, such as:

• function-kcl: allowing to define your whole composition logic in KCL.
• function-cue: allowing to define your whole composition logic in Cue.
• function-cel-filter: a function meant to be used downstream of other functions, to conditionally filter out generated resources based on CEL expressions.
• function-switcher: similarly allowing to filter out resources created by upstream functions, but based on annotations on the Composite resource this time.
• function-sequencer: allowing to define sequencing rules delaying the creation of resources until other resources are ready.
• function-environment-configs: reimplementing almost fully the in-tree Composition Environments as a function, more on this later.
• function-extra-resources [NEW]: a more general purpose version of function-environment-configs, allowing functions to request any cluster-scoped resource.

We highly recommend going through each one of them, but even more building the next great Composition Function yourself if none of them satisfies your use case! Have a look at the available guides to write Composition Functions in Go and Python.

Composition Environment

We then highlighted the current direction for the Alpha Composition Environments, as explained in detail in this one-pager, and, as you might have guessed, it is all about Composition Functions!

We took the opportunity to demonstrate how to transition from the old in-tree implementation to function-environment-configs; you can find the code used in the repository. As you can see, it’s just a matter of pushing down the exact same configuration previously defined at the Composition level to the new function, with the added benefit of easier testability using the tooling mentioned above.

Final Thoughts

Demos worked, and the room was packed, so we can call it a success, but the best part was meeting with so many contributors and new or old users in person afterward! So again, we highly suggest watching the recording, but even more, joining the talk in person at the next KubeCons and come say hi!

If you want to dive deeper before the next few KubeCons to see the full Crossplane picture, take a look at Viktor Farcic’s book, “Crossplane: The Cloud Native Control Plane”. He’s a dev advocate here at Upbound but also a DevOps expert.