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

Question

Pulumi · Accepted Answer

To deploy the simple-grafana Helm chart on Google Kubernetes Engine (GKE), we need to perform the following steps:

1. **Create a GKE Cluster:** First, we need to create a Kubernetes cluster in GKE where our Grafana instance will run.
2. **Install the Helm Chart:** Once the cluster is provisioned, we can use the Helm package manager to deploy the Grafana chart on it.

Pulumi provides resources for both creating GKE clusters and for deploying Helm charts. For creating a GKE cluster, we'll use the `google-native.container/v1.Cluster` resource, which is a representation of a GKE cluster. For deploying the Helm chart, we'll leverage the `kubernetes.helm.sh/v3.Release` resource that Pulumi provides, which allows us to manage Helm releases as part of our Pulumi infrastructure as code.

Let's see how you can use Pulumi with 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("my-gke-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    nodeConfig: {
        // This is the default machine type used by GKE
        machineType: "n1-standard-1",
        // Define the OAuth scopes for the node service accounts
        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",
        ],
    },
});

// Create a Kubernetes Provider pointing to the created GKE cluster
const k8sProvider = new k8s.Provider("my-k8s-provider", {
    kubeconfig: cluster.endpoint.apply(endpoint =>
        cluster.name.apply(name =>
            cluster.masterAuth.apply(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: gcloud
`
            })
        )
    ),
}, {dependsOn: cluster});

// Deploy the simple-grafana chart using the Helm Chart resource
const grafana = new k8s.helm.v3.Chart("simple-grafana", {
    chart: "grafana",
    fetchOpts: {repo: "https://grafana.github.io/helm-charts"},
    values: {
        // Define values for the Helm chart in this object
        // Refer to the chart's documentation for required values
    },
}, {provider: k8sProvider});

// Export the public IP address of the Grafana instance
const grafanaService = grafana.getResource("v1/Service", "simple-grafana-grafana");
export const grafanaIp = grafanaService.status.apply(s => s.loadBalancer.ingress[0].ip);
```

### Explanation

#### GKE Cluster Creation

Firstly, we create a Google Kubernetes Engine cluster by instantiating a `gcp.container.Cluster` resource. This cluster will automatically pick the latest Kubernetes version available on GKE, have 2 nodes in the default node pool (which you can adjust according to your needs), and use the `n1-standard-1` machine type, which should be sufficient for a basic Grafana deployment.

#### Kubernetes Provider Setup

After creating the cluster, we set up a Kubernetes provider by defining a `k8s.Provider` resource that references the newly created GKE cluster. We construct the Kubernetes configuration (`kubeconfig`) dynamically using the cluster's outputs like `endpoint`, `name`, and `masterAuth`, allowing Pulumi to communicate with the GKE cluster.

#### Deploying Grafana via Helm

Next, we deploy Grafana using the Helm chart resource. In this step, we specify the name of the chart (`grafana`) and the repository from where to fetch it. We also define a `values` object to configure the Grafana Helm chart according to your specific configuration parameters. For the simple Grafana deployment, you may not need to set any specific values. However, for a production setup, you will want to refer to the Grafana Helm chart's documentation for configurable parameters like persistence, admin password, service type, and others.

#### Exposing Grafana

Since Grafana would be accessible via a LoadBalancer service, we export the public IP address that gets assigned to the Grafana service. Once the deployment is complete, you can visit this IP address in your browser to access the Grafana dashboard.

Make sure you installed Pulumi, configured your GCP credentials, and set the desired GCP project and zone context using Pulumi CLI commands before running this program. With the provided program and explanation, you should be able to deploy Grafana on GKE using Pulumi.