Deploy the victoria-metrics-k8s-stack helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

Great, I'll guide you through deploying the VictoriaMetrics Kubernetes stack using a Helm chart on the DigitalOcean Kubernetes service using Pulumi with TypeScript.

To accomplish this goal, we'll follow these general steps:

1. Provision a DigitalOcean Kubernetes (DOKS) cluster.
2. Deploy the VictoriaMetrics Helm chart to the DOKS cluster.

We'll use two Pulumi resources for this process:

- `digitalocean.KubernetesCluster`: This resource will manage the Kubernetes cluster on DigitalOcean.
- `kubernetes.helm.v3.Chart`: This resource from the Pulumi Kubernetes provider will deploy the Helm chart in the cluster we provisioned.

Here's what the Pulumi program will do:

1. It will create a new DigitalOcean Kubernetes cluster with the specified region, version, and node count.
2. It will install the Helm chart for VictoriaMetrics from the Helm repository. To do this, we'll utilise the Helm Chart resource from Pulumi's Kubernetes provider which abstracts the Helm CLI. We specify the chart name, version (optional), and any values we want to override in the Helm chart.

### Detailed Program Explanation and Code

The following TypeScript program will perform the steps mentioned above:

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

// Step 1: Provision the DigitalOcean Kubernetes Cluster
const cluster = new digitalocean.KubernetesCluster("vm-k8s-cluster", {
    region: "nyc1",
    version: "1.21.5-do.0", // Choose a valid Kubernetes version for DOKS
    nodePool: {
        name: "vm-workers",
        size: "s-1vcpu-2gb", // Choose the droplet size as per your requirement
        nodeCount: 1, // Specify the number of nodes in the node pool
    },
});

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

// Create a Provider to interact with the new Kubernetes cluster.
const k8sProvider = new kubernetes.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Step 2: Deploy VictoriaMetrics Helm Chart to the Kubernetes Cluster
const vmHelmChart = new kubernetes.helm.v3.Chart("vm-stack", {
    chart: "victoria-metrics-k8s-stack",
    version: "0.7.15", // Specify the version of the Helm chart, use a valid and stable version
    fetchOpts: {
        repo: "https://victoriametrics.github.io/helm-charts/", // The Helm repository for VictoriaMetrics
    },
}, { provider: k8sProvider });

// Export the Helm chart deployment status
export const helmDeploymentStatus = vmHelmChart.status;
```

This program is composed of the following parts:

- **DigitalOcean Kubernetes Cluster Resource**: This is where you define the specifics of your Kubernetes cluster on DigitalOcean, such as region, version, and node pool configuration. The `nodeCount` parameter dictates the number of Droplet instances to be provisioned as part of the node pool.

- **Kubernetes Provider**: This uses the kubeconfig of the newly created DigitalOcean Kubernetes cluster to interact with it.

- **Helm Chart Resource**: This deploys the VictoriaMetrics stack using the specified Helm chart from the defined repository.

Once this program is executed with Pulumi, it will output the kubeconfig for your new DigitalOcean Kubernetes cluster and the status of the Helm chart deployment. You can then use the kubeconfig to interact with your cluster using `kubectl` or other Kubernetes tooling.

You'll need to have Pulumi installed and setup with the appropriate credentials for DigitalOcean. Once that's in place, you can run this Pulumi program using the following commands:

```bash
pulumi stack init vm-stack-deployment
pulumi up
```

This will initialize a new Pulumi stack and deploy your resources according to the program defined above.