Deploy the wavefront-hpa-adapter helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the Wavefront Horizontal Pod Autoscaler (HPA) adapter on Google Kubernetes Engine (GKE) using Pulumi and TypeScript, you'll need to complete a few steps:

1. **Create a GKE Cluster**: Set up a Kubernetes cluster on GKE where the Wavefront HPA adapter will be deployed.
2. **Configure Kubeconfig**: Configure Pulumi to use the correct kubeconfig file so it can interact with your GKE cluster.
3. **Install the Helm Chart**: Use Pulumi's Helm support to deploy the Wavefront HPA adapter Helm chart to the GKE cluster.

I'll guide you through each of these steps with detailed explanations and a complete TypeScript program.

### 1. Creating a GKE Cluster

We'll first need a Kubernetes cluster running on GKE. With Pulumi, we can define our infrastructure using code. Here, we'll use the`google-native.container/v1beta1.Cluster` resource to create a new GKE cluster.

### 2. Configuring Kubeconfig

Once the GKE cluster is created, Pulumi can use the output of the cluster's endpoint and credentials to configure kubectl. This way, Pulumi will be able to manage resources within the Kubernetes cluster.

### 3. Installing the Helm Chart

With the cluster in place and `kubectl` configured by Pulumi, we can proceed to deploying the Helm chart. The `helm.v3.Chart` resource from Pulumi's Kubernetes provider allows us to deploy a chart from any Helm repository.

Below is a TypeScript program that puts these steps into action:

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("wavefront-hpa-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1",
    },
});

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

// Export the Kubeconfig to access the Cluster from kubectl
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 that uses our kubeconfig
const k8sProvider = new k8s.Provider("k8s", {
    kubeconfig: kubeconfig,
});

// Deploy the wavefront-hpa-adapter Helm chart
const wavefrontHpaAdapterChart = new k8s.helm.v3.Chart("wavefront-hpa-adapter", {
    chart: "wavefront-hpa-adapter",
    fetchOpts: {
        repo: "https://wavefronthq.github.io/helm/",
    },
}, { provider: k8sProvider });

// Export the Helm Chart status
export const helmChartStatus = wavefrontHpaAdapterChart.status;
```

This program will set up the cluster, create the kubeconfig, and deploy the Wavefront HPA adapter on GKE. To run this program, you'll need to have Pulumi CLI installed and configured for GCP access.

### Explanation

- We declare our GKE cluster with some default settings such as `initialNodeCount` and `machineType`. These can be customized as per your requirements.
- We create a kubeconfig that will allow us to interact with our GKE cluster via Pulumi.
- We then instantiate a new Kubernetes Provider with this kubeconfig.
- Finally, we deploy the Wavefront HPA adapter Helm chart to this cluster using the `helm.v3.Chart` resource which downloads the chart from the specified helm repository.

After deploying this program with Pulumi, you will have a GKE cluster running with the Wavefront HPA adapter Helm chart installed. You can see the outputs from the program, the `clusterName` and `helmChartStatus`, to confirm the deployment status.