Deploy the standard-application helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy a Helm chart onto a Google Kubernetes Engine (GKE) cluster using Pulumi, we will follow these steps:

1. **Setup a GKE Cluster**: First, we'll need a GKE cluster where we can deploy our Helm chart.
2. **Install Helm Chart**: Once a cluster is available, we will use Pulumi's Helm Release resource to deploy the standard-application chart.

We are going to use the `@pulumi/kubernetes` package to create the Helm Release, and the `@pulumi/gcp` package to set up the GKE cluster. Here's what you need to do step-by-step:

### Step 1: Create a GKE Cluster

A GKE cluster is a managed set of Compute Engine instances that run containerized applications using Google's Kubernetes Engine.

1. `Cluster`: This is the main resource for GKE in Pulumi. A cluster consists of at least one cluster master machine and multiple worker machines called nodes. Nodes are Compute Engine VMs that run the Kubernetes processes necessary to make them part of the cluster.

### Step 2: Deploy a Helm Release to the GKE cluster

Helm is a tool for managing Kubernetes packages called charts. Helm allows you to define, install, and upgrade even the most complex Kubernetes applications. Charts are easy to create, version, share, and publish. Pulumi interacts with Helm via the Helm Release resource.

1. `Release`: This is a resource provided by Pulumi’s Kubernetes provider which represents a Helm chart release. The Release resource installs a chart into a Kubernetes cluster.

Below is a TypeScript program that performs both steps. Make sure you have Pulumi installed and configured with access to Google Cloud, and set your project and region as required.

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("my-gke-cluster", {
    // You can adjust these settings for your requirements
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1",
        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 and Kubeconfig
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
`;
    });

// Create a Kubernetes provider instance that uses our cluster from above.
const k8sProvider = new k8s.Provider("gkeK8s", {
    kubeconfig: kubeconfig,
});

// Deploy the Helm chart
const chart = new k8s.helm.v3.Chart("nginx-chart", {
    chart: "nginx",
    version: "1.16.1",
    // This assumes your Helm chart has these values available.
    values: {
        // Use your actual values that you want to pass to the Helm chart here
        service: { 
            type: "LoadBalancer"
        },
    },
}, { provider: k8sProvider });

// Export the public LoadBalancer IP for the deployed service
export const frontendIp = chart
    .getResourceProperty("v1/Service", "nginx-chart", "status")
    .apply(status => status.loadBalancer.ingress[0].ip);

```
This program will create a GKE cluster and then use a Helm Release to deploy an NGINX chart, which is a stand-in for the "standard-application" chart mentioned. If you have a specific chart you want to deploy, replace `"nginx"` with your chart name and update the `values` if your chart requires any specific configuration.

Keep in mind that the program assumes that you have the `gcloud` CLI installed and you are authenticated with Google Cloud. Also, Helm charts typically have a set of configurable values, which you'll need to specify depending on the specific chart you are deploying.