Deploy the squash-api helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

Deploying a Helm chart on the Digital Ocean Kubernetes Service using Pulumi involves several steps which I'll outline below. As we progress through each of these steps, I'll provide explanations for the important parts of the code to help you understand what each part is doing.

### Step 1: Create a Digital Ocean Kubernetes Cluster
Firstly, you need a Kubernetes cluster on Digital Ocean. Pulumi provides a resource for this called `digitalocean.KubernetesCluster`. This resource allows you to declare and manage a Kubernetes cluster in your Pulumi program.

### Step 2: Deploy the Helm Chart
After the cluster is available, you would deploy the Helm chart using the `kubernetes.helm.v3.Chart` resource. This resource from Pulumi's Kubernetes provider will manage the lifecycle of the Helm chart in your cluster, making sure it is deployed as specified.

Here's how you can accomplish these steps with Pulumi in TypeScript:

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

// The name for your Digital Ocean Kubernetes cluster and the region where you want to deploy it.
const clusterName = "do-k8s-cluster";
const region = "nyc3";

// Create a Digital Ocean Kubernetes cluster.
const cluster = new digitalocean.KubernetesCluster(clusterName, {
    region: region,
    version: "latest", // This would deploy the latest available version of Kubernetes.
    nodePool: {
        name: "default",
        size: "s-1vcpu-2gb", // This is the smallest droplet size. Scale accordingly.
        nodeCount: 2,
    },
});

// Get the kubeconfig from the created Digital Ocean Kubernetes cluster.
const kubeconfig = cluster.kubeConfigs[0].rawConfig.apply((c) => c);

// Use the kubeconfig with Pulumi's Kubernetes provider.
const k8sProvider = new kubernetes.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Deploy the squash-api Helm chart to the Kubernetes cluster.
const squashApiChart = new kubernetes.helm.v3.Chart("squash-api", {
    chart: "squash-api",
    // Ensure you have the correct repository URL for the Helm chart.
    // If the chart is within a repo, for example in the "stable" repository,
    // you'll need to add a `repo: "https://charts.helm.sh/stable"` field here.
    version: "1.2.3", // Use the desired chart version.
    namespace: "default", // Specify the namespace where you want the chart to be deployed.
},{
    provider: k8sProvider, // Associate with the Kubernetes provider.
});

// Export the cluster's kubeconfig.
export const kubeconfigOutput = kubeconfig;
```

Explanation:
- `digitalocean.KubernetesCluster` creates a new Kubernetes cluster in the specified Digital Ocean region.
- We extract the kubeconfig of the created cluster, which is necessary to interact with the cluster, using Pulumi's `apply` method.
- The `kubernetes.Provider` resource is used to pass this kubeconfig to the Kubernetes provider, enabling Pulumi to interact with your cluster.
- `kubernetes.helm.v3.Chart` represents the deployment of the Helm chart within your Kubernetes cluster. You specify the chart name, version, and namespace.
- Lastly, the kubeconfig is exported as a stack output so that you can use it to access your cluster via `kubectl` or other tools.

The above program assumes that the Digital Ocean and Kubernetes providers have been set up correctly with the respective credentials. You can place this code in a file, say `index.ts`, within your Pulumi project. To deploy this infrastructure, you would run `pulumi up` in your shell, which will provision the resources in the order specified by the dependencies between them.

Remember to replace `"squash-api"` with the actual name of the Helm chart you want to deploy and fill in the actual repository URL if it's not a locally available chart. You also need to adjust the Digital Ocean node size (`s-1vcpu-2gb`) and the node count (`2`) if different specifications are desired.