Deploy the heartbeat helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

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

1. Ensure you have a DigitalOcean Kubernetes cluster running. For this purpose, we'll define and create one using Pulumi's DigitalOcean provider.

2. Install the Heartbeat Helm chart onto your DOKS cluster using Pulumi's Kubernetes provider. Heartbeat is a lightweight daemon that checks the status of your services and forwards that information on to Elasticsearch.

Below is the TypeScript program that performs these tasks using Pulumi:

### Prerequisites

Ensure you have the following set up and configured before running the Pulumi program:
- Pulumi CLI and an account: Follow the instructions on the [Pulumi website](https://www.pulumi.com/docs/get-started/) to install the CLI and set up an account.
- DigitalOcean account: You should have a DigitalOcean account with a personal access token generated. Set this token as an environment variable `DIGITALOCEAN_TOKEN`.
- Kubernetes configuration: Once the DigitalOcean Kubernetes cluster is created by Pulumi, you'll need to obtain the kubeconfig.

### The Pulumi Program

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

// Set the desired properties for the DigitalOcean Kubernetes cluster.
const clusterName = "heartbeat-cluster";
const nodeSize = "s-1vcpu-2gb"; // You can choose an appropriate Droplet size.
const region = "nyc1"; // Choose the region closest to you or your users.

// Create a new DigitalOcean Kubernetes cluster.
const cluster = new digitalocean.KubernetesCluster(clusterName, {
    region,
    version: digitalocean.getKubernetesVersions({}).then(p => p.latestVersion), // Latest stable version.
    nodePool: {
        name: "default",
        size: nodeSize,
        nodeCount: 1,
    },
});

// Once the cluster is provisioned, the kubeconfig content will be outputted by the cluster.
// You can also fetch kubeconfig files via `doctl` or the DigitalOcean dashboard.

// Export the cluster kubeconfig.
export const kubeconfig = cluster.kubeConfigs[0].rawConfig;

// Create a Kubernetes provider instance using the kubeconfig from our DOKS cluster.
const k8sProvider = new kubernetes.Provider(clusterName, {
    kubeconfig: kubeconfig,
});

// Define Helm Chart options for Heartbeat.
const heartbeatHelmChart = {
    chart: "heartbeat",
    version: "7.10.0", // Replace with your desired chart version.
    namespace: "monitoring",
    fetchOpts:{
        repo: "https://helm.elastic.co",
    },
    // You can add chart values here as needed.
    values: {
        // Configuration options go here.
    },
};

// Deploy heartbeat Helm chart using the Kubernetes provider for our DOKS cluster.
const heartbeatChart = new kubernetes.helm.v3.Chart("heartbeat", heartbeatHelmChart, { provider: k8sProvider });

// Export the heartbeat Helm release name.
export const heartbeatReleaseName = heartbeatChart.getResourceProperty("v1/Service", "heartbeat-heartbeat", "metadata").apply(m => m.name);
```

### Explanation

1. We import the necessary Pulumi packages.
2. We create a DigitalOcean Kubernetes cluster with a single node pool.

The `digitalocean.KubernetesCluster` resource is used to provision the cluster. Documentation for this resource is available [here](https://www.pulumi.com/registry/packages/digitalocean/api-docs/kubernetescluster/).

3. We then create a Pulumi Kubernetes provider, which allows us to interact with the cluster using its kubeconfig.
4. We define a Helm chart resource for Heartbeat, specifying the chart name, version, and any configuration values we require.

The `kubernetes.helm.v3.Chart` resource is a Pulumi resource that allows you to deploy Helm charts. More information on this resource can be found [here](https://www.pulumi.com/registry/packages/kubernetes/api-docs/helm/v3/chart/).

5. We deploy the Heartbeat Helm chart to our DOKS cluster using the Pulumi Kubernetes provider we set up earlier.
6. We export the release name of the Heartbeat deployment and the kubeconfig needed to interact with the Kubernetes cluster.

### Conclusion

After executing the above program with `pulumi up`, Pulumi will perform the following actions:
- Provision a new DigitalOcean Kubernetes cluster.
- Deploy the Heartbeat Helm chart to the cluster.

When the process is completed, you will receive output indicating the name of the Heartbeat release. You can use this information to check on your Heartbeat deployment, including using `kubectl` with the exported kubeconfig to interact with your DOKS cluster.