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

Question

Pulumi · Accepted Answer

To deploy the `jx-app-grafana` Helm chart on Google Kubernetes Engine (GKE) using Pulumi, you'd need to follow these general steps:

1. **Set up a GKE cluster**: You need a Kubernetes cluster to work with. For that, you will use the `google-native.container/v1beta1.Cluster` resource to create a new GKE cluster. This will provide a Kubernetes cluster where the Helm chart can be deployed.

2. **Install the Helm chart**: After setting up the GKE cluster, you would then deploy the `jx-app-grafana` Helm chart to your cluster. For this, you will utilize the `kubernetes.helm.v3.Chart` resource from the Pulumi Kubernetes provider, which allows you to deploy Helm charts.

Below you'll find a Pulumi program written in TypeScript that creates a GKE cluster and installs the `jx-app-grafana` Helm chart on this cluster. The program includes comments that explain what each section of the code does.

**Before running the Pulumi program**, make sure you have completed the following prerequisites:
- Install Pulumi CLI and set up your GCP credentials.
- Have the `@pulumi/google-native` and `@pulumi/kubernetes` packages installed in your project. You can install them using npm or yarn.

Now let's go through the code implementation:

```typescript
import * as pulumi from '@pulumi/pulumi';
import * as gcp from '@pulumi/gcp';
import * as gcpNative from '@pulumi/google-native';
import * as k8s from '@pulumi/kubernetes';

// Step 1: Create a GKE cluster for deploying the Helm chart.
const cluster = new gcpNative.container.v1beta1.Cluster("gke-cluster", {
    // Replace the following parameters with your desired settings.
    // The name of the GKE cluster
    name: "grafana-cluster",
    // The GCP project in which to create the cluster
    project: gcp.config.project,
    // The location of the cluster
    location: "us-central1",
    // Cluster configuration
    initialNodeCount: 1,
    nodeConfig: {
        machineType: "e2-medium", // Use a machine type appropriate for your workload
    },
});

// Export the cluster name and kubeconfig.
export const clusterName = cluster.name;

// Step 2: Create a provider for the created GKE cluster.
const k8sProvider = new k8s.Provider("gkeK8s", {
    kubeconfig: cluster.name.apply(name => {
        return gcp.container.getCluster({
            name: name,
            location: "us-central1",
        }).then(cluster => {
            const kubeconfig = {
                apiVersion: "v1",
                clusters: [{
                    cluster: {
                        "certificate-authority-data": cluster.masterAuth.clusterCaCertificate,
                        server: cluster.endpoint,
                    },
                    name: "k8s",
                }],
                contexts: [{
                    context: {
                        cluster: "k8s",
                        user: "admin",
                    },
                    name: "admin@k8s",
                }],
                "current-context": "admin@k8s",
                kind: "Config",
                users: [{
                    name: "admin",
                    user: {
                        "client-certificate-data": cluster.masterAuth.clientCertificate,
                        "client-key-data": cluster.masterAuth.clientKey,
                        "password": cluster.masterAuth.password,
                        username: cluster.masterAuth.username,
                    },
                }],
            };
            return JSON.stringify(kubeconfig);
        });
    }),
});

// Step 3: Install the `jx-app-grafana` Helm chart on the GKE cluster.
const grafanaChart = new k8s.helm.v3.Chart("jx-app-grafana", {
    chart: "grafana",
    fetchOpts: {
        // You will likely need to update the repo URL to the location where the chart is stored.
        repo: "https://grafana.github.io/helm-charts",
    },
    // Any custom values you want to pass
    values: {
        // Provide custom Grafana configuration here
    },
}, { provider: k8sProvider });

// Export the Grafana service URL
export const grafanaServiceUrl = grafanaChart.getResourceProperty("v1/Service", "grafana", "status").apply(status => {
    const ingress = status.loadBalancer.ingress[0];
    return ingress.ip || ingress.hostname;
});
```

In this program:
- We create a GKE cluster by instantiating `gcpNative.container.v1beta1.Cluster`. The essential properties like location and node configuration are specified.
  
- We export the cluster name and generate a kubeconfig file once the cluster is available. This kubeconfig is required to interact with the cluster using Kubernetes commands.

- After the cluster setup, a Pulumi Kubernetes provider is instantiated. This provider is configured to use the kubeconfig of the created GKE cluster.

- Using the `k8s.helm.v3.Chart` resource, we deploy the `grafana` Helm chart. Notice that we pass the `k8sProvider` which points to our GKE cluster.

- The `repo` property is where the Helm chart is located. Replace it with the appropriate Helm repository if you have a different source for the `jx-app-grafana` chart.

- Lastly, we export the Grafana service URL that can be used to access the Grafana dashboard once it's deployed and publicly accessible.

Run the Pulumi program with `pulumi up` to provision the resources, and after successful deployment, Pulumi will output the Grafana service URL.