Deploy the simplified-ob-pattern-2 helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Google Kubernetes Engine (GKE) using Pulumi, you'll need to perform the following steps:

1. **Set up a GKE cluster**: This is the environment where your Helm chart will be deployed.
2. **Install the Helm chart on the cluster**: Helm charts are packages that contain all of the resource definitions necessary to run an application, tool, or service inside of a Kubernetes cluster.

For the first step, you will use the `gcp.container.Cluster` resource, which lets you create and manage a GKE cluster. This is a fundamental requirement for deploying any workload on GKE. Then, for the second step, you will use the `kubernetes.helm.sh/v3.Release` resource from Pulumi's Kubernetes provider to deploy the Helm chart to the cluster you have created.

### Detailed Explanation and TypeScript Program

Below is a TypeScript program written for Pulumi that sets up a GKE cluster and deploys a hypothetical Helm chart named `simplified-ob-pattern-2` to it. Make sure to install the required npm packages by running `npm install @pulumi/gcp @pulumi/kubernetes` in your project directory.

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

// Create a GKE cluster.
const cluster = new gcp.container.Cluster("my-gke-cluster", {
    initialNodeCount: 2,
    nodeConfig: {
        preemptible: true, // This creates lower-cost, preemptible nodes.
        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
export const kubeconfig = cluster.name.apply(name => {
    const cluster = gcp.container.getCluster({
        name: name,
        location: cluster.location,
    });
    const context = `${gcp.config.project}_${cluster.location}_${cluster.name}`;
    return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${cluster.masterAuth[0].clusterCaCertificate}
    server: https://${cluster.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("my-k8s-provider", {
    kubeconfig: kubeconfig,
});

// Deploy the Helm chart.
const helmChart = new k8s.helm.sh.v3.Release("simplified-ob-pattern-2-release", {
    chart: "simplified-ob-pattern-2",
    // Assuming the chart is in a Helm repo that has been added to your Helm repository list.
    repositoryOpts: {
        repo: "http://example.com/helm-charts", // Replace with the actual Helm chart repository URL.
    },
}, { provider: k8sProvider });

// Export the Helm release's status
export const helmChartStatus = helmChart.status;
```

This program does the following:

- **Declare a GKE cluster**: We set up a GKE cluster with a specified number of nodes of a certain machine type. The `initialNodeCount`, `machineType`, and `oauthScopes` are customizable to your workload's needs. We also flag our node as "preemptible" to reduce costs, though preemptible nodes may be terminated by GCP if it requires access to those resources.
  
- **Generate kubeconfig**: This configuration is used to communicate with the Kubernetes cluster. We export the kubeconfig to make it easier to run `kubectl` commands against the cluster outside of Pulumi if needed.

- **Create a Kubernetes provider**: Pulumi uses a Kubernetes provider to interact with the GKE cluster. The provider needs a kubeconfig file to authenticate with the cluster.

- **Deploy a Helm chart**: We create a Helm `Release` resource for the `simplified-ob-pattern-2` Helm chart. Before deploying the chart, make sure the chart is accessible from the specified Helm repository.

- **Export output**: The program exports the cluster name and Helm chart status, which can be queried with the Pulumi CLI.

To use this code, you would replace the placeholder strings (like the Helm repo URL) with actual values from your environment. Then, running this code with Pulumi CLI will set up the infrastructure and deploy the chart to your GKE cluster. Remember that the `simplified-ob-pattern-2` chart must exist in your Helm repository for this to work. If it's a local chart or from a private repository, you'll need to adjust the `repositoryOpts` accordingly.