Presenters

Source

Level Up Your Self-Service Game: Crossplane + Backstage = Infrastructure Nirvana! 🚀

Ever feel like managing infrastructure is a bit like wrestling a hydra? You fix one thing, and two more pop up. Or maybe you’re a developer yearning for the power to spin up exactly what you need, when you need it, without waiting for a ticket to be processed? Well, get ready to have your mind blown, because the brilliant minds behind the latest tech trends are showing us how to make infrastructure programmable and consumable, all thanks to a dynamic duo: Crossplane and Backstage! ✨

This isn’t just another tech talk; it’s a roadmap to a self-service utopia where developers get autonomy and platform engineers keep control. Let’s dive into how this powerful synergy is transforming the game.

What’s the Big Deal with Crossplane? 🤔

Imagine being able to manage all your infrastructure – cloud resources, Kubernetes clusters, databases, you name it – using the familiar language of Kubernetes APIs. That’s the magic of Crossplane! 🛠️

  • Declarative Infrastructure, Simplified: Crossplane lets you define your infrastructure needs in simple YAML files, just like you define your application deployments. No more writing complex scripts for every cloud provider or service.
  • Kubernetes Control Plane for Everything: It essentially turns Kubernetes into a universal control plane for your entire infrastructure. This means you get the power of reconciliation – Crossplane ensures your desired state always matches the actual state.
  • Providers: The Universal Translators: How does Crossplane talk to AWS, Azure, GCP, or your on-prem databases? Through providers! These are like plugins that translate Kubernetes API calls into the specific API calls of your infrastructure services. And guess what? You can even leverage existing Terraform providers for a smooth transition.
  • XRDs & Compositions: Your Custom Infrastructure Blueprints:
    • Composite Resource Definitions (XRDs) are like OpenAPI v3 schemas for your custom infrastructure APIs. They define what you can request (e.g., a PostgreSQL database with a specific size and version).
    • Compositions are the actual blueprints that tell Crossplane how to build it. They define the sequence of resource creation and can incorporate logic using languages like Go, KCL, or Python. This means a single YAML request for a database can intelligently orchestrate the creation of VPCs, networks, routing rules, and the database instance itself!
  • CNCF Graduation: A major win! Crossplane has recently graduated as a Cloud Native Computing Foundation (CNCF) project, signifying its maturity, widespread adoption, and strong community support. 🌐

Backstage: The User-Friendly Gateway to Your Platform 🚪

While Crossplane is a powerhouse for defining and managing infrastructure, it can sometimes feel a bit abstract for developers accustomed to a more visual experience. This is where Backstage swoops in to save the day! 🦸‍♀️

  • The Missing GUI for Crossplane: Let’s be honest, sometimes a “clicky-clicky” interface is just what the doctor ordered. Backstage provides a much-needed graphical user interface, making it easier for users to discover, provision, and manage Crossplane resources without diving deep into YAML.
  • Bridging the Kubernetes Discovery Gap: Backstage’s Kubernetes plugin is a great starting point, but discovering and managing the sheer volume of Custom Resource Definitions (CRDs) introduced by operators like Crossplane can be a significant undertaking. Backstage helps to tame this complexity.
  • Seamless Schema Compatibility: Developers love consistency! Backstage’s software templates use JSON schema, which plays nicely with Crossplane’s OpenAPI schema. This compatibility ensures that the forms developers interact with accurately reflect the underlying infrastructure APIs.
  • Backstage as the Portal, Crossplane as the API: Think of Backstage as the polished storefront and Crossplane as the robust, programmable backend API. Together, they create an intuitive and powerful self-service experience.

The Power Couple: Key Integration Wins 🤝

When Crossplane and Backstage join forces, the results are nothing short of spectacular. Here’s how they elevate the self-service experience:

  1. Automated Software Templates from XRDS: This is a game-changer! By automatically generating software templates directly from Crossplane’s XRDS, the system ensures that the user interface (the template form) is always in sync with the backend infrastructure API. This eliminates frustrating breaking changes and inconsistencies.
  2. Effortless Ingestion of Crossplane Resources: High-level infrastructure constructs defined by Crossplane (like your “DB as a Service” offering) are automatically pulled into the Backstage software catalog. Say goodbye to manual YAML creation and hello to instant discoverability! 💡
  3. Visualize Your Infrastructure’s DNA: Backstage offers a clear, hierarchical view of Crossplane resources. Developers can easily see the “tree” of dependencies for their deployed infrastructure, making debugging complex deployments a breeze. 🌳
  4. Streamlined Day-Two Operations: Managing and updating your infrastructure shouldn’t be a chore. The integration empowers users to perform these crucial “day-two” tasks directly through Backstage, simplifying ongoing operations.

A Glimpse into the Future: GitOps, AI, and More! 🤖

The demonstration showcased a platform built with a formidable stack: Backstage, Argo CD, Crossplane, and Kyverno. Here’s what makes it so compelling:

  • User-Friendly Creation, GitOps Enforcement: Users can create complex resources, like web applications, through a simple form generated from the XRD schema. But here’s the kicker: this action automatically triggers a pull request to your GitOps repository! This ensures all changes are version-controlled, auditable, and applied through robust GitOps pipelines. The UI enhances consumption without compromising best practices. 🔒
  • Instant API Availability: Need to offer a new “DB as a Service”? Define it with Crossplane, and it’s instantly discoverable and consumable within Backstage. The agility is incredible!
  • AI-Powered Insights: The integration with AI tools via Backstage’s MCP (Meta-Control Plane) integration is mind-blowing. Imagine querying for information about Crossplane resources connected to your components or identifying policy violations directly from your IDE! This is the future of developer productivity. 🧠

Key Takeaways to Remember 🎯

  • Crossplane: Makes infrastructure programmable through declarative definitions.
  • Backstage: Makes infrastructure consumable with a user-friendly interface.
  • The Synergy: Creates a powerful self-service experience, bridging developer autonomy and platform engineer control.
  • GitOps First: The integration enforces GitOps best practices for robust and auditable infrastructure management.
  • Policy Enforcement: Seamless integration with tools like Kyverno ensures security and compliance.

Tackling Brownfield and Staying Ahead 🚀

A crucial question arose during the Q&A: How do we handle updating brownfield applications? The answer is a testament to thoughtful platform design:

  • Guided Updates: Kyverno policies can provide feedback on deprecated versions and guide developers toward updating their resources through the Backstage scaffolder.
  • Proactive Communication: The analogy of public clouds forcing upgrades after a support window highlights the importance of clear communication and ample time for users to adapt.

Ultimately, the goal is to strike a delicate balance: empowering developers with autonomy while maintaining platform stability and control. This powerful combination of Crossplane and Backstage is paving the way for a more efficient, secure, and developer-friendly infrastructure landscape. Get ready to embrace the future of self-service! ✨

Appendix