Deploy the grafaml helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy the Grafana Helm chart on Digital Ocean Kubernetes Service using Pulumi, we will follow these steps:

1. Initialize DigitalOcean Kubernetes Cluster using the `digitalocean.KubernetesCluster` resource.
2. Deploy Grafana using the `kubernetes.helm.sh/v3.Chart` resource.

Firstly, you need to have Pulumi installed and configured for use with your DigitalOcean account. Pulumi uses the credentials from your DigitalOcean account that you've set up with `doctl` CLI or stored in environment variables.

Below is the program in TypeScript to deploy the Grafana Helm chart on a Digital Ocean Kubernetes cluster:

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

// Step 1: Create a new DigitalOcean Kubernetes cluster.
const cluster = new digitalocean.KubernetesCluster("do-cluster", {
    region: "nyc3",
    version: "1.23.4-do.0",
    nodePool: {
        name: "worker-pool",
        size: "s-2vcpu-2gb",
        nodeCount: 1,
    },
});

// Step 2: Create a provider to interact with the new cluster.
const k8sProvider = new kubernetes.Provider("do-k8s-provider", {
    kubeconfig: cluster.kubeConfigs[0].rawConfig,
});

// Step 3: Deploy Grafana using the Helm chart.
const grafana = new kubernetes.helm.v3.Chart("grafana", {
    chart: "grafana",
    version: "6.13.9", // specify the version of Grafana chart you want to deploy
    fetchOpts: { repo: "https://grafana.github.io/helm-charts" },
    namespace: "monitoring", // assuming you have a "monitoring" namespace or you can create one.
}, { provider: k8sProvider });

// Step 4: Export relevant endpoints.
export const kubeconfig = cluster.kubeConfigs[0].rawConfig;
export const grafanaEndpoint = grafana.getResource("v1/Service", "monitoring", "grafana-grafana").status.loadBalancer.ingress[0].ip;

```

Here's a breakdown of what the above Pulumi program does:

- First, we import the necessary Pulumi modules for DigitalOcean and Kubernetes.
- We then create a DigitalOcean Kubernetes cluster with a single node pool. You can adjust the region, version, and node pool size based on your requirements.
- Once the DigitalOcean Kubernetes cluster is initialized, we set up a Kubernetes provider that refers to the new cluster's kubeconfig. This provider enables us to interact with the cluster and deploy Kubernetes resources, including the Helm charts.
- We deploy the Grafana Helm chart to the "monitoring" namespace in the Kubernetes cluster. Don't forget to create the namespace if it doesn't exist already. The `chart` parameter specifies the name of the Helm chart, while `version` is the chart version you wish to use. The `fetchOpts` provides the Helm repository information.
- Finally, we export the kubeconfig and the IP address of the Grafana service for access. This IP can be used to access the Grafana dashboard through the web browser.

To apply this Pulumi program:

1. Save the code to a file named `index.ts`.
2. Run `pulumi up` from the command line to create the resources.
3. Follow the on-screen prompts by Pulumi to confirm the deployment.
4. After the deployment is successful, you will receive the kubeconfig and Grafana endpoint.

Remember, Helm charts have a lot of configurable values, and you can customize Grafana by setting these values in the Pulumi program using the `values` property inside `kubernetes.helm.v3.Chart`.