Deploy the training-ns helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy a Helm chart on a Google Kubernetes Engine (GKE) cluster, you will need to perform a series of actions:

1. Create a GKE Cluster: Set up a Kubernetes cluster within GKE where your Helm chart will be deployed.
2. Install the Helm Chart: After the cluster is ready, use Pulumi to deploy a Helm chart into the GKE cluster.

I will guide you through these steps using Pulumi with TypeScript.

First, make sure you have the Pulumi CLI installed and you are logged in. Ensure that you have also set up the Google Cloud SDK and configured your credentials to interact with your GCP account.

Below is the complete Pulumi program in TypeScript that accomplishes these tasks:

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

// Step 1: Create a GKE Cluster.
// Here we define the configuration for the GKE cluster.
// For more options and detailed configuration, refer to the documentation:
// https://www.pulumi.com/registry/packages/gcp/api-docs/container/cluster/
const cluster = new gcp.container.Cluster("training-gke-cluster", {
    initialNodeCount: 2,
    nodeConfig: {
        machineType: "n1-standard-1", // Choose the machine type based on your needs
    },
});

// Export the Kubeconfig so we can interact with the cluster after it is created.
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: Deploy the Helm Chart to the GKE Cluster after the cluster becomes available.
// We use the kubernetes.Provider to interact with the GKE cluster using the generated kubeconfig.
const provider = new kubernetes.Provider("gke-k8s", {
    kubeconfig: kubeconfig,
});

// Now, we will deploy the helm chart 'training-ns' into the GKE cluster.
// You will need to specify the repository and chart name for your specific Helm chart.
// For more details, visit: https://www.pulumi.com/registry/packages/kubernetes/api-docs/helm/v3/chart/
const helmChart = new kubernetes.helm.v3.Chart("training-ns", {
    chart: "nginx", // Replace 'nginx' with the name of your chart
    version: "1.16.0", // Specify the version of the chart you want to deploy
    // Add the repository that hosts your Helm chart here. For example, for Bitnami charts: "https://charts.bitnami.com/bitnami"
    fetchOpts: { 
        repo: "https://example.com/helm-charts", // Replace with your Helm chart's repository
    },
}, { provider });

// Optionally, you can export the status and other properties of the deployed Helm chart.
export const helmChartStatus = helmChart.status;

```

This program consists of two parts:

- In the first part, we define a GKE cluster with an initial node count of 2 and a machine type of `n1-standard-1`. You can adjust the initialNodeCount and machineType based on your needs and the expected workload. After creating the cluster, we also export its kubeconfig to interact with the cluster.

- In the second part, we create a Kubernetes Provider configured with the kubeconfig of the GKE cluster. This allows Pulumi to deploy resources into the cluster. We then define a Helm Chart resource, which represents the Helm chart you want to deploy. In this example, I've used placeholders like `nginx` for the chart name and a made-up repository URL. You'll need to replace these with the actual name of your helm chart and its repository.

Remember to replace `"https://example.com/helm-charts"` with the actual URL to the Helm chart repository, and put the correct chart name and version according to your specific Helm Chart `training-ns`.

When you run this Pulumi program with `pulumi up`, Pulumi will handle provisioning the resources in the correct order, create the Kubernetes cluster, and deploy your Helm chart into it.