Deploy the burger-app helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

Deploying a Helm chart on Google Kubernetes Engine (GKE) involves several steps:

1. **Provision a GKE Cluster**: First, you need to create a GKE cluster, which is a managed Kubernetes service that simplifies the deployment and management of a Kubernetes cluster in Google Cloud.

2. **Install and Configure `kubectl`**: After the cluster is provisioned, you need to configure `kubectl` to interact with it. This typically involves obtaining credentials for the cluster, so `kubectl` can access it.

3. **Deploy the Helm Chart**: Helm helps manage Kubernetes applications through Helm charts, which are packages of pre-configured Kubernetes resources. To deploy an application, you apply the Helm chart to your cluster.

The following TypeScript program using Pulumi performs these steps. Make sure you have Pulumi and `gcloud` CLI installe, and you are authenticated with Google Cloud with necessary privileges to create and manage GKE clusters.

```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("burger-app-cluster", {
    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
export const clusterName = cluster.name;

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

// Deploy the burger-app Helm chart to the GKE cluster.
const burgerAppChart = new k8s.helm.v3.Release("burger-app-chart", {
    chart: "burger-app",
    version: "1.0.0", // replace with the actual chart version
    namespace: "default", 
    // Set to the namespace where you want to deploy the chart. 
    // Helm will create the namespace if it doesn't exist.
}, { provider: k8sProvider });

// Export the burger-app's service endpoint.
export const burgerAppServiceEndpoint = burgerAppChart.status.apply(status => status);

```

### Explanation:

- **GKE Cluster**: This block creates a GKE cluster using the `Cluster` class from the `@pulumi/gcp` package. Here we define the initial number of nodes (`initialNodeCount`) and machine type for each node.

- **Kubeconfig**: This configuration is critical for `kubectl` and Pulumi's Kubernetes provider to interact with your GKE cluster. It contains the necessary cluster access information.

- **Kubernetes Provider**: The `k8s.Provider` class is from the `@pulumi/kubernetes` package. It represents the Kubernetes provider for Pulumi and is configured to use the exported `kubeconfig`.

- **Helm Chart**: `k8s.helm.v3.Release` represents a Helm chart. In this case, it is the `burger-app` Helm chart. You will need to replace `"1.0.0"` with the actual version of your Helm chart.

- **Service Endpoint**: This line exports the Helm release status, which may include information on service endpoints after deployment.

### To run this Pulumi program:

1. Ensure Pulumi is installed and configured with your Google Cloud credentials.
2. Save this script to a file with a `.ts` extension.
3. Run `pulumi up` in the command line within the directory of your script.

This program will provision a new GKE cluster, configure the Kubernetes provider to use the cluster, and deploy the Helm chart. After the deployment, you will see the service endpoint as part of the outputs.