Deploy the u4a-component helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Google Kubernetes Engine (GKE), we need to accomplish these key steps:

1. **Create a GKE Cluster**: This involves setting up a Kubernetes cluster on Google Cloud Platform, which serves as the environment where our Helm chart will be deployed.

2. **Install Helm**: Helm is a package manager for Kubernetes that allows you to manage applications through Helm charts. Helm must be installed within the cluster or in our CI/CD system to be able to deploy charts to the GKE cluster.

3. **Deploy Helm Chart**: Once Helm is set up, we can use it to deploy our specific Helm chart (`u4a-component` in this case) to the GKE cluster.

Below is the Pulumi program written in TypeScript that performs these steps. I'll explain each part of the code to make it understandable for you as a novice user.

```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("gke-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        machineType: "e2-medium",
        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;

// Export the Kubeconfig to access the GKE cluster
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 cluster from above.
const k8sProvider = new k8s.Provider("gke-k8s", {
    kubeconfig: kubeconfig,
});

// Deploy the Helm chart
const helmChart = new k8s.helm.v3.Chart("u4a-component", {
    chart: "u4a-component",
    version: "1.0.0",
    fetchOpts:{
        repo: "http://charts.yourcompany.com/", // Replace with your Helm chart repository
    },
}, { provider: k8sProvider });

// Export the Helm chart deployment status
export const helmChartStatus = helmChart.status;
```

Here's what each part does:

- We import the necessary Pulumi libraries for working with Google Cloud (`@pulumi/gcp`) and Kubernetes (`@pulumi/kubernetes`).
  
- We create a GKE cluster using the `gcp.container.Cluster` resource with an initial number of nodes and specifying its size and given OAuth scopes required for GKE.

- We export the `clusterName` and `kubeconfig` required to interact with the cluster. The `kubeconfig` contains credentials and endpoint information to connect to the GKE cluster's Kubernetes API.

- We set up the Pulumi Kubernetes provider configured with the `kubeconfig`. This allows Pulumi to communicate with our new GKE cluster.

- We deploy the `u4a-component` Helm chart using Pulumi's Helm support. In the `Chart` resource, you must specify the name of the chart and optionally the chart version and repository URL.

The provided program assumes you have the proper credentials set up to access Google Cloud, you have installed Pulumi, and you have chosen TypeScript as your language. When you run the program with `pulumi up`, Pulumi will create the GKE cluster, configure the Kubernetes provider to use that cluster, and deploy the Helm chart to it.

After running the code, Pulumi provides output which includes the `clusterName`, `kubeconfig`, and `helmChartStatus`. These can be used to verify your deployment and interact with your GKE cluster and the deployed Helm chart.