Deploy the crossplane-exoscale-factory helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy the `crossplane-exoscale-factory` Helm chart on a DigitalOcean Kubernetes Service using Pulumi, you'll follow these general steps:

1. Create a Kubernetes cluster on DigitalOcean using the `digitalocean.KubernetesCluster` resource.
2. Use the `kubernetes.helm.v3.Chart` resource to deploy the `crossplane-exoscale-factory` Helm chart to the created Kubernetes cluster.

First, you need to set up a new Pulumi project if you have not done so. You can find the instructions on Pulumi's website to set up a new project. After setting up the project, you may proceed with the main TypeScript program below.

Here's a Pulumi program in TypeScript that accomplishes these steps:

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

const projectName = "crossplane-exoscale-factory-on-doks";

// Step 1: Create a DigitalOcean Kubernetes cluster
const cluster = new digitalocean.KubernetesCluster(projectName, {
    // Configure your Kubernetes cluster settings here
    region: "nyc1",
    version: "latest", // You can specify the exact version you want
    nodePool: {
        name: "worker-pool",
        size: "s-2vcpu-2gb", // This is the droplet type
        nodeCount: 2,        // Number of worker nodes
    },
});

// Once the cluster is created, we need to configure kubectl.
const kubeconfig = cluster.kubeConfigs[0].rawConfig;

// Step 2: Deploy the `crossplane-exoscale-factory` Helm chart
const chart = new k8s.helm.v3.Chart("exoscale-factory", {
    chart: "crossplane-exoscale-factory",
    // You may need to specify the Helm repository here if it's not included in your local Helm repos
    // In most cases, you would define the repository and version explicitly for clarity and control.
    // For example:
    // repositoryOpts: {
    //     repo: "https://charts.crossplane.io/stable",
    // },
    // version: "1.2.3", // specify the chart version you want to deploy
    fetchOpts: {
        // Helm fetch options go here
    },
    values: {
        // Set configuration values for the Helm chart here
    },
    // Specify the namespace to install the Helm chart into if needed
    namespace: "crossplane-system",
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig }) });

// Export the cluster's kubeconfig and the name of the Helm release.
export const kubeConfig = kubeconfig;
export const helmReleaseName = chart.name;
```

In this program, we do the following:
- Import the required Pulumi packages for DigitalOcean and Kubernetes.
- Create a DigitalOcean Kubernetes cluster by specifying the region, version, node count, and droplet size. Adjust these values based on your specific requirements.
- The `kubeConfigs` field of the cluster object will give us access to the cluster's kubeconfig, which we need to communicate with the cluster.
- Create a Helm chart resource using Pulumi's Kubernetes provider and specify the Helm chart's name (`crossplane-exoscale-factory`). You might need to adjust the `repositoryOpts` to point at the correct Helm repository that hosts the `crossplane-exoscale-factory` chart and specify the exact chart version you want to deploy.
- We then specify the Kubernetes provider instance for deploying the Helm chart with the kubeconfig from the DigitalOcean cluster.
- Finally, export the Kubernetes cluster's kubeconfig and the Helm release name for your reference.

Please ensure you have the Pulumi CLI installed and configured with access to your DigitalOcean account. You will run the Pulumi program typically by navigating to your project directory and executing `pulumi up`. This command will preview the deployment, and you can proceed to execute the changes by confirming the action.