Deploy the grafana-stakewise-dashboards helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy the `grafana-stakewise-dashboards` Helm chart on the Digital Ocean Kubernetes Service, we'll take the following steps using Pulumi with TypeScript:

1. **Create a Digital Ocean Kubernetes Cluster**: We'll use the `digitalocean.KubernetesCluster` resource from the Digital Ocean Pulumi provider to create a new Kubernetes cluster where the Grafana Helm chart will be deployed.

2. **Install the Helm Chart on the Kubernetes Cluster**: For this part, we'll utilize the `kubernetes.helm.v3.Chart` resource from the Kubernetes Pulumi provider. This resource serves to deploy Helm charts into a Kubernetes cluster.

Now, let's go through this process step-by-step in a Pulumi program.

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

// Step 1: Create a Digital Ocean Kubernetes cluster.
const cluster = new digitalocean.KubernetesCluster("do-cluster", {
    region: "nyc3", // You can change the region to your preferred DigitalOcean region.
    version: "latest", // This will use the latest version available for Kubernetes on DigitalOcean.
    nodePool: {
        name: "default-pool",
        size: "s-2vcpu-2gb", // This is the smallest size available, select what fits your needs.
        nodeCount: 2, // Specify the desired number of nodes in the node pool.
    },
});

// Once we have our Kubernetes cluster, we need to obtain the kubeconfig file so that Pulumi
// and tools like `kubectl` can communicate with the new Kubernetes cluster.
export const kubeconfig = cluster.kubeConfigs[0].rawConfig;

// Step 2: Install Grafana on the Kubernetes cluster created above using Helm.
const grafanaChart = new kubernetes.helm.v3.Chart("grafana-stakewise", {
    chart: "grafana",
    version: "6.1.17",  // Specify the version of the Grafana chart you would like to deploy.
    fetchOpts: {
        repo: "https://stakewise.github.io/helm-charts/", // The chart repository containing grafana-stakewise-dashboards.
    },
    namespace: "default", // Deploy the chart into the 'default' namespace; this can be changed as needed.
}, { provider: new kubernetes.Provider("do-k8s", { kubeconfig }) });

// Export the public endpoint to access Grafana.
export const grafanaEndpoint = pulumi.output(grafanaChart).status
    .apply(status => status?.loadBalancer?.ingress[0]?.ip || status?.loadBalancer?.ingress[0]?.hostname);
```

Here's what each part of the Pulumi program does:

- **Digital Ocean Kubernetes Cluster**: We define a new Kubernetes cluster in the specified region with a certain number of nodes of a specific machine size. Note that you can and should tailor the region, size, and node count to your particular workload and cost considerations.

- **Provider Setup**: We set up a Kubernetes provider with the kubeconfig we obtained from the newly created Digital Ocean Kubernetes cluster. This provider facilitates communication and deployment of resources onto the Kubernetes cluster.

- **Helm Chart Installation**: We install the `grafana` Helm chart from the `stakewise` repository. This is where you specify the specific Helm chart and repository to deploy. The `namespace` field denotes where the Helm chart should be deployed within the Kubernetes cluster.

The last part of the code exports the Grafana endpoint, assuming it is allocated by a LoadBalancer service. You would use this URL to access your Grafana service once it is up and running.

Finally, after writing this Pulumi program, you will run `pulumi up` to deploy your stack. Pulumi will show you a preview of the actions it is going to take and, upon your confirmation, it will carry out those actions to create resources in the Digital Ocean cloud.

Please ensure you have the appropriate Digital Ocean access token configured in your Pulumi stack and that you have installed the Pulumi CLI to run this program.