Deploy the grafana-dashboards-rancher helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `grafana-dashboards-rancher` Helm chart on Google Kubernetes Engine (GKE), we'll need to perform a few steps. Below is a high-level outline of the process:

1. **Set up a GKE Cluster**: We will create a new GKE cluster where our Grafana dashboard will live.
2. **Install the Helm Chart**: Once we have a cluster, we can install the Helm chart for Grafana within the Kubernetes cluster.

We will be using the `@pulumi/gcp` package to create the GKE cluster and `@pulumi/kubernetes` to deploy the Helm chart to the GKE cluster.

Here's a detailed explanation of each step in the code:

**1. Create a GKE Cluster:**
   - Import `@pulumi/gcp` package to manage resources on Google Cloud.
   - Use `gcp.container.Cluster` class to create a new GKE cluster.
   - Define configuration details for the cluster, such as the machine type and the number of nodes.

**2. Deploy the Helm Chart:**
   - Import `@pulumi/kubernetes` package to interact with Kubernetes clusters.
   - Configure the Pulumi program to use the newly created GKE cluster's kubeconfig as the context.
   - Use the `kubernetes.helm.v3.Chart` class to deploy the `grafana-dashboards-rancher` Helm chart to the GKE cluster.
   - Provide necessary configurations such as chart version or any custom values you may wish to override in the chart.

Now let's create the Pulumi program in TypeScript to perform these tasks.

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("cluster", {
  initialNodeCount: 2,
  nodeVersion: "latest",
  minMasterVersion: "latest",
  nodeConfig: {
    machineType: "n1-standard-1", // The type of machine to use for nodes.
  },
});

// Export the Kubernetes cluster name and kubeconfig
export const clusterName = cluster.name;
export const kubeconfig = pulumi.
  all([ cluster.name, cluster.endpoint, cluster.masterAuth ]).
  apply(([ name, endpoint, masterAuth ]) => {
    const context = `${gcp.config.project}_${gcp.config.zone}_${name}`;
    return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${masterAuth.clusterCaCertificate}
    server: https://${endpoint}
  name: ${context}
contexts:
- context:
    cluster: ${context}
    user: ${context}
  name: ${context}
current-context: ${context}
kind: Config
preferences: {}
users:
- name: ${context}
  user:
    auth-provider:
      config:
        cmd-args: config config-helper --format=json
        cmd-path: gcloud
        expiry-key: '{.credential.token_expiry}'
        token-key: '{.credential.access_token}'
      name: gcp
`;
  });

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

// Deploy Grafana dashboard using helm chart
const grafana = new k8s.helm.v3.Chart("grafana", {
  chart: "grafana-dashboards-rancher",
  fetchOpts: {
    repo: "https://helm.rancher.io",
  },
}, { provider: k8sProvider });

// Export the Grafana service URL
export const grafanaUrl = grafana.getResourceProperty("v1/Service", "grafana", "status").apply(status => `http://${status.loadBalancer.ingress[0].ip}`);

```

Let me explain the code in detail:

- The `gcp.container.Cluster` class is responsible for provisioning a new GKE cluster on Google Cloud. We're setting `initialNodeCount` to `2`, which means we'll have two nodes in our cluster, and we're using standard machine types `n1-standard-1`.

- After the cluster is created, we construct a kubeconfig using `pulumi.all([...]).apply`, which allows us to combine multiple output properties into a single object. The resulting kubeconfig is outputted from the program so it can be used by external tools if necessary.

- We then create a Pulumi Kubernetes provider using this kubeconfig. This provider allows us to deploy Kubernetes resources to our GKE cluster.

- The `k8s.helm.v3.Chart` class deploys the `grafana-dashboards-rancher` Helm chart from the `https://helm.rancher.io` repository to our cluster. The Grafana service is exposed through a LoadBalancer, and we export its IP address.

Once you set up your Pulumi stack and authenticate with Google Cloud, you can deploy this program using Pulumi CLI commands:

```bash
pulumi up
```

This command creates all the resources defined in your Pulumi program and the output will show you the endpoints to access your Grafana dashboards. To interact with your Grafana instance, you typically use the Grafana URL provided in the outputs of your Pulumi program.