Deploy the vsbe-service helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

Deploying a Helm chart to a Digital Ocean Kubernetes cluster involves a few steps using Pulumi. First, we'll need to create a Kubernetes cluster on Digital Ocean using the `digitalocean.KubernetesCluster` resource. After the cluster is available, we will install the Helm chart onto it with the help of the `kubernetes.helm.v3.Chart` resource from the Pulumi Kubernetes provider.

To follow the process, you'll need to have the Pulumi CLI set up, along with the necessary cloud provider credentials (in this case, Digital Ocean).

We'll start by creating a new TypeScript program with Pulumi. First, make sure you have `@pulumi/pulumi`, `@pulumi/digitalocean`, and `@pulumi/kubernetes` packages installed.

Our program does two main things:

1. It creates a new Kubernetes cluster on Digital Ocean.
2. It deploys a Helm chart to the newly created cluster.

Below is the Pulumi program that achieves the above tasks:

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

// Create a Digital Ocean Kubernetes cluster.
const cluster = new digitalocean.KubernetesCluster("vsbe-cluster", {
    region: "nyc3",
    version: "latest",
    nodePool: {
        name: "default",
        size: "s-2vcpu-2gb",
        nodeCount: 2,
    },
});

// Once the cluster is provisioned, we can get its kubeconfig.
const kubeconfig = pulumi.all([cluster.name, cluster.kubeConfigs]).apply(([name, kubeConfigs]) => {
    if (kubeConfigs[0]) {
        return kubeConfigs[0].rawConfig;
    }

throw new Error(`Unable to fetch kubeconfig for cluster: ${name}`);
});

// Create a Kubernetes provider instance using the kubeconfig.
const k8sProvider = new k8s.Provider("do-k8s", { kubeconfig });

// Deploy the vsbe-service Helm chart using the Kubernetes provider.
const vsbeServiceChart = new k8s.helm.v3.Chart("vsbe-service", {
    chart: "vsbe-service", // The name of the chart. Replace with the actual chart name if different.
    version: "1.0.0", // The version of the chart. Replace with the desired chart version.
    // Additional configuration if needed for the Helm chart can be specified within values.
    values: {}, 
}, { provider: k8sProvider });

// Export the cluster's kubeconfig and the service's public endpoint if applicable.
export const kubeconfigOutput = kubeconfig;
export const serviceEndpoint = vsbeServiceChart.getResourceProperty("v1/Service", "vsbe-service", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

Now let's break down what the code does:

- A Kubernetes cluster is defined in Digital Ocean with a single node pool with `s-2vcpu-2gb` droplets (you can adjust the size and node count as needed).
- We capture the raw kubeconfig of the cluster to interact with the Kubernetes API.
- A Pulumi k8s Provider is instantiated to communicate with the deployed Kubernetes cluster using the kubeconfig.
- With the provider configured, we deploy the Helm chart named `vsbe-service`. You need to replace `"vsbe-service"` with the actual chart name and `"1.0.0"` with the version of the chart you want to deploy. The `values` object can be filled with any additional values you need to provide to the Helm chart.

Finally, we export the kubeconfig and the service endpoint if the Helm chart exposes a service with a public IP address. If the Helm chart does not expose a service or if you have other outputs, you would adjust the `export` lines accordingly.

To run the Pulumi program, navigate to the folder containing the program and run `pulumi up`. Pulumi will perform the deployment, giving you the status of resources it created or updated. Once the deployment is complete, you can take the kubeconfig output and use it to manage your cluster with `kubectl` or another Kubernetes tool.