Deploy the crossplane-types helm chart on Rancher

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Rancher using Crossplane, you'll need to perform a set of actions:

1. Set up a Kubernetes Cluster within Rancher where Crossplane will be deployed.
2. Install Crossplane to manage Helm chart deployments within your Kubernetes cluster.
3. Configure the necessary providers and resources for Crossplane to deploy a Helm chart.
4. Finally, deploy the `crossplane-types` Helm chart using a `Release` resource.

Here's a Pulumi program written in TypeScript that demonstrates how you could set up and deploy a Helm chart on Rancher by leveraging the relevant resources from the `crossplane` provider:

```typescript
import * as k8s from "@pulumi/kubernetes";
import * as rancher2 from "@pulumi/rancher2";
import * as crossplane from "@crossplane/crossplane";

// Step 1: Set up Rancher Kubernetes cluster
// For example purposes, we're defining a minimal cluster configuration.
// Refer: https://www.pulumi.com/registry/packages/rancher2/api-docs/cluster/
const cluster = new rancher2.Cluster("crossplane-cluster", {
    name: "crossplane-cluster",
    // Provide additional configurations such as node pools, driver details here as per your Cloud provider.
});

// Step 2: Deploy the Crossplane system to your cluster.
// This could be done through either a Helm chart or directly through manifests.
// The Crossplane Kubernetes provider needs to be installed as well, which can interact with your cluster.
// Note: Ensure that your local kubeconfig is correctly configured to allow Pulumi to interact with the cluster.

const crossplaneChart = new k8s.helm.v3.Chart("crossplane", {
    chart: "crossplane",
    version: "1.3.0", // specify the desired Crossplane chart version
    namespace: "crossplane-system", // ensure the namespace exists or set up to create if not
    fetchOpts:{
        repo: "https://charts.crossplane.io/stable",
    },
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig: cluster.kubeConfigRaw }) });

// Step 3: Install the providers and configuration required for Crossplane.
// These would provide Crossplane the ability to deploy and manage Helm charts.

const providerConfig = new crossplane.ProviderConfig("provider-config", {
    metadata: {
        name: "my-provider",
    },
    spec: {
        credentials: {
            source: "InjectedIdentity", // This example uses the default service account Crossplane uses
        },
    },
});

// You might also need Crossplane provider for the specific Kubernetes provider (e.g., AWS, GCP, Azure, etc)
// Example:
// const kubernetesProvider = new crossplane.Provider("kubernetes-provider", {
//     metadata: {namespace: crossplaneChart.metadata.namespace},
//     spec: {
//         providerConfigRef: {name: providerConfig.metadata.name},
//         // ...additional provider-specific configurations
//     },
// });

// Step 4: Deploy the crossplane-types Helm chart using Crossplane's `Release` resource.
// This resource enables Crossplane to manage Helm releases in the Kubernetes cluster.
// Refer: https://crossplane.io/docs/latest/concepts/managed-resources.html

const helmRelease = new crossplane.helm.v1beta1.Release("crossplane-types-release", {
    metadata: {
        namespace: "crossplane-system", // the namespace where you want to deploy the helm chart
    },
    spec: {
        forProvider: {
            chart: {
                name: "crossplane-types",
                repository: "http://charts.crossplane.io/stable", // specify the repository url
            },
            values: {}, // pass any chart values here
        },
        providerConfigRef: {
            name: providerConfig.metadata.name,
        },
        // Set the reclaim policy to Delete to automatically clean up the release when the resource is deleted.
        // You can adjust this based on your retention needs.
        reclaimPolicy: "Delete",
    },
});

// Outputs
export const clusterName = cluster.name;
export const crossplaneReleaseStatus = helmRelease.status;
```

In this program, we go through the following process:

1. Define a cluster using the Rancher2 Cluster resource. The configuration details for this cluster should match your cloud provider's requirements.

2. Deploy Crossplane to the Kubernetes cluster, set up through Rancher. We install it using its Helm chart, specifying the version and namespace. Make sure that the `crossplane-system` namespace is created if it does not exist.

3. Define a ProviderConfig resource pointing to your specific provider configuration. This is necessary for Crossplane to manage resources on your behalf. In this program, `InjectedIdentity` means that Crossplane will use the permissions of the service account it was installed with.

4. Define the Helm `Release` resource, which Crossplane will use to manage the life cycle of the `crossplane-types` Helm chart. Specify the chart name and chart repository URL, along with any chart values in the `spec.forProvider.values` property.

Lastly, we export some useful outputs that you can use to check on the state of your resources or use in other parts of your Pulumi program.