Deploy the weird helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy a Helm chart on a Digital Ocean Kubernetes Service (DOKS) using Pulumi, you'll need to follow these steps:

1. **Create a Kubernetes cluster** on Digital Ocean: You'll start by creating a DOKS cluster. This is where your applications will be hosted.

2. **Install the Helm chart** on the Kubernetes cluster: Once the cluster is up and running, you will deploy a Helm chart onto it. A Helm chart is a package that contains all the necessary resource definitions required to run an application or service inside a Kubernetes cluster.

The following Pulumi program written in TypeScript assumes that you already have a Helm chart that you refer to as the "weird helm chart". This program will not only create the DOKS cluster but also deploy your Helm chart to the cluster. Make sure you have Pulumi installed, and your Digital Ocean access token is set up as a Pulumi secret.

We'll use two Pulumi resources for this task:
- `digitalocean.KubernetesCluster` from the Digital Ocean package to create a managed Kubernetes cluster.
- `kubernetes.helm.v3.Chart` from the Kubernetes package to deploy the Helm chart to the cluster.

Here's your detailed program:

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

// Step 1: Create a Kubernetes cluster on Digital Ocean
const cluster = new digitalocean.KubernetesCluster("do-cluster", {
    region: "nyc3", // You can choose the region that is close to you or your users
    version: "1.21.5-do.0", // This is the Kubernetes version, make sure it's a valid version in DOKS
    nodePool: {
        size: "s-1vcpu-2gb", // Size of the Droplets (nodes).
        name: "default", // Name of the node pool.
        nodeCount: 2, // Number of nodes in the pool.
    },
});

// Step 2: Install the Helm chart on the Kubernetes cluster
const kubeconfig = cluster.kubeConfigs[0].rawConfig;

// Create a Kubernetes provider instance that uses the kubeconfig from the newly created cluster.
const k8sProvider = new kubernetes.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Define the chart and the repository where it is located
const chart = new kubernetes.helm.v3.Chart("weird-helm-chart", {
    chart: "weird-chart-name",  // Replace with your chart name
    version: "1.0.0",           // Replace with your desired chart version
    fetchOpts: { 
        repo: "http://charts.example.com/", // Replace with the chart's repository URL
    },
}, { provider: k8sProvider }); // Use the Kubernetes provider instance tied to our DOKS cluster

// Export the public IP to access your cluster
export const kubeClusterEndpoint = cluster.endpoint;
```

In this program:
- We create a new Kubernetes cluster in the Digital Ocean `nyc3` region with the Kubernetes version `1.21.5-do.0`.
- We specify the Droplet size and the number of nodes for our cluster.
- We retrieve the kubeconfig of our newly created DOKS cluster, which will be used by the Pulumi Kubernetes provider to interact with our cluster.
- We define the Helm chart for deployment, specifying its name, version, and repository where it's hosted.
- Finally, we export the cluster's endpoint, which can be used to access the Kubernetes API of our cluster.

Remember to replace placeholder values such as `weird-chart-name` and the repository URL with actual values applicable to your Helm chart.

You'd run your Pulumi program using the Pulumi CLI commands `pulumi up` to create and deploy or `pulumi destroy` to clean up resources. It's good to review Pulumi's stack outputs with `pulumi stack output` to check resources like the `kubeClusterEndpoint`.

To integrate these steps, ensure your Pulumi setup is configured for Digital Ocean with the appropriate access tokens and for Kubernetes with `kubectl` installed.