Deploy the gardener-metrics-exporter helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `gardener-metrics-exporter` Helm chart on Google Kubernetes Engine (GKE), we need to complete the following steps:

1. **Create a GKE cluster**: This involves setting up a Kubernetes cluster on Google Cloud Platform (GCP) where our Helm chart will be deployed.
2. **Configure Kubectl**: Once the GKE cluster is ready, we need to configure `kubectl` to communicate with the newly created cluster.
3. **Initialize Helm**: Helm is a package manager for Kubernetes, and we need to ensure it is set up correctly to manage deployments.
4. **Deploy Helm Chart**: Lastly, we install the `gardener-metrics-exporter` Helm chart on the GKE cluster.

Below is a Pulumi program written in TypeScript that accomplishes these steps.

Please note that this program assumes the following:
- You have the Pulumi CLI installed and configured with your GCP credentials.
- You have set up the appropriate GCP project and have permissions to create GKE clusters.
- Helm is installed on your local machine.

Here is the TypeScript program:

```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
// We first create a GKE cluster with a small default node pool.
const cluster = new gcp.container.Cluster("my-gke-cluster", {
    initialNodeCount: 2,
});

// Export the Cluster name, Kubeconfig requires the cluster name and zone to communicate with the cluster.
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`;
});

// Step 2: Configure Kubectl
// The Kubeconfig is used to configure kubectl. We create a kubeconfig file from the output of our GKE cluster creation.
const k8sProvider = new k8s.Provider("gke-k8s", {
    kubeconfig: kubeConfig,
});

// Step 3: Initialize Helm
// We need a Helm Release resource to deploy our Helm chart onto our GKE cluster.
// This step might not be needed if you use Helm v3, as it no longer requires Tiller.

// Step 4: Deploy Helm Chart
// Finally, we deploy the `gardener-metrics-exporter` chart
const gardenerMetricsExporter = new k8s.helm.v3.Release("gardener-metrics-exporter", {
    chart: "gardener-metrics-exporter",
    // The repository option is used to specify the Helm chart repository.
    // Assuming "gardener-metrics-exporter" is in your configured chart repositories.
    // Otherwise, you have to add repository configuration with the `repo` option.
    namespace: "default",
}, { provider: k8sProvider });

// Export the Release name so we can easily find it in the Helm list later.
export const gardenerMetricsExporterName = gardenerMetricsExporter.name;
```

This program uses the following resources from the Pulumi library:
- `@pulumi/gcp`: To create and manage resources on GCP.
- `@pulumi/kubernetes`: To create and manage Kubernetes resources using Pulumi.
- `@pulumi/pulumi`: To work with outputs and other Pulumi-specific behaviors.

To use this program, save it into a file named `index.ts`, and then run `pulumi up` from the same directory. Pulumi will provision the GKE cluster and deploy the Helm chart automatically.

If you would like to customize the Helm chart's deployment, use the `values` property within the `k8s.helm.v3.Release` resource to provide your configuration. These are the equivalent of using `--set` or passing a values file in Helm's CLI.

Remember to follow any post-deployment steps required for `gardener-metrics-exporter`, such as configuring access policies or verifying that it is running properly within the cluster.