Deploy the mod-tags helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

Deploying a Helm chart on Google Kubernetes Engine (GKE) involves several steps using Pulumi. First, you would need to create a GKE cluster, and then you would deploy the Helm chart to that cluster. Below I'll break down these steps and provide you with a TypeScript program that accomplishes this task.

### Step 1: Create a GKE Cluster

Before deploying any applications, you must have an existing Kubernetes cluster. With Pulumi, you can define your infrastructure as code, including GKE clusters.

The `google-native.container/v1beta1.Cluster` resource is used to create a GKE cluster. You will need to specify certain properties for your cluster, such as the zone or region where the cluster will be created, the number of nodes in the default node pool, the machine type for the nodes, etc.

### Step 2: Deploy the Helm Chart

Once the cluster is up and running, you can deploy applications using Helm charts. The `kubernetes.helm.sh/v3.Release` resource from Pulumi's Kubernetes provider facilitates deployment of Helm charts.

Here is a Pulumi TypeScript program that creates a GKE cluster and deploys the `mod-tags` Helm chart:

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("mod-tags-cluster", {
    initialNodeCount: 2,
    nodeConfig: {
        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"
        ],
        machineType: "n1-standard-1",
    },
});

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

// Export the Kubeconfig to access the 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: gcloud
`;
    });

// Create a Kubernetes Provider instance with the kubeconfig.
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig
});

// Deploy the 'mod-tags' Helm chart
const modTagsChart = new k8s.helm.v3.Chart("mod-tags", {
    chart: "mod-tags",
    // Assuming 'mod-tags' chart is available in the official repository
    fetchOpts: {
        repo: "https://charts.example.com/",
    },
    // Specify values for the Helm chart as needed
    // values: { /* ... */ },
}, { provider: k8sProvider });

// Export the Chart name
export const helmChartName = modTagsChart.id;
```

### Understanding the Program

- We start by importing the required Pulumi packages.
- Then, a GKE cluster is created with a `google-native.container/v1beta1.Cluster` resource specifying two nodes and the `n1-standard-1` machine type for the nodes.
- The kubeconfig needed to access the cluster is generated. It uses Pulumi's `apply` function to combine several outputs into a single kubeconfig string.
- A Pulumi Kubernetes provider is instantiated, which allows us to interact with the cluster using the generated kubeconfig.
- Finally, a `kubernetes.helm.sh/v3.Release` resource is declared that deploys the `mod-tags` Helm chart into the GKE cluster. The `fetchOpts` property is used to specify the remote Helm chart repository details, assuming your `mod-tags` chart is hosted there.
- The program exports the cluster name and Helm chart name so that they can be accessed from the CLI once the Pulumi program is run.

### How to Run the Program

To run this program, you would:
1. Ensure you have Pulumi and the GCP CLI installed and configured.
2. Save the TypeScript code in a file, e.g., `index.ts`.
3. Run `pulumi up` to preview and deploy the changes.
4. After the deployment, you can use the exported kubeconfig to access your GKE cluster and verify that the `mod-tags` Helm chart is deployed.