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

Question

Pulumi · Accepted Answer

To deploy the `grafana-storage` Helm chart on Google Kubernetes Engine (GKE) using Pulumi, you'll need to perform several steps:

1. Set up a GKE cluster where your Helm chart will be deployed.
2. Install and configure the Helm chart on your GKE cluster.

In the Pulumi program below, we will use the `@pulumi/gcp` package to create a GKE cluster, and the `@pulumi/kubernetes` package to deploy the Helm chart to that cluster.

Here's a step-by-step TypeScript program for deploying the `grafana-storage` Helm chart on GKE:

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

// Step 1: Create a GKE cluster
const cluster = new gcp.container.Cluster("my-gke-cluster", {
    initialNodeCount: 2,
    nodeConfig: {
        preemptible: true,
        machineType: "n1-standard-1",
        oauthScopes: [
            "https://www.googleapis.com/auth/compute",
            "https://www.googleapis.com/auth/devstorage.read_only",
            "https://www.googleapis.com/auth/logging.write",
            "https://www.googleapis.com/auth/monitoring"
        ],
    },
});

// Export the Cluster name
export const clusterName = cluster.name;

// Kubeconfig for the cluster
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
`;
    });

// Step 2: Deploy the Helm chart for grafana-storage
const grafanaStorageChart = new k8s.helm.v3.Chart("grafana-storage", {
    chart: "grafana",
    version: "6.1.17", // specify the version of the Helm chart
    fetchOpts:{
        repo: "https://grafana.github.io/helm-charts", // specify the Helm chart repository
    },
    values: {
        storage: {
            type: "pvc",
            size: "10Gi"
        },
        persistence: {
            enabled: true,
            size: "10Gi"
        },
        // specify more values as required
    },
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig }) });

// Export the Helm chart deployment name
export const grafanaReleaseName = grafanaStorageChart.name;
```

### Explanation:

In the program above:

- We import the `gcp`, `k8s`, and `pulumi` modules as these are required to create the GKE cluster and deploy the Helm chart.
- We create a GKE cluster with a given number of nodes and specific machine types using `gcp.container.Cluster`.
- We configure the `kubeconfig` needed to interact with the cluster. This configuration is built using the cluster details and is tailored to work with the GCP authentication mechanism.
- We declare a Helm chart release with `k8s.helm.v3.Chart`. In the `values` field, we specify the configuration for storage and persistence as would be necessary for Grafana.
- We use `fetchOpts` to specify the location of the Helm chart repository.
- We configure the `k8s.Provider` with the `kubeconfig` we created, which ensures that the Helm chart is deployed to the correct GKE cluster.
- We export the name of the GKE cluster and the Helm chart deployment, which can be useful for querying the cluster and viewing the Helm release details after deployment.

To apply this Pulumi program, save it to a `index.ts` file, and run the following commands in your terminal:

```shell
pulumi up
```

This will prompt Pulumi to perform an update, during which it will show you a preview of the resources that will be created. If you're happy with the changes, select `yes` when prompted to create the resources in your GCP project. After the update is completed, you'll see the outputs of the program, including the name of your GKE cluster and the Helm chart release name.