Deploy the stakater-buildah helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `stakater-buildah` Helm chart on Google Kubernetes Engine (GKE), you'll need to perform several steps:

1. **Create a GKE cluster**: We will use the `google-native.container/v1beta1.Cluster` resource to provision a new GKE cluster. This resource allows you to specify the parameters for your Kubernetes cluster, such as the node size, the number of nodes, and the location.

2. **Install the Helm chart**: To install a Helm chart on the Kubernetes cluster, we will utilize the `kubernetes.helm.sh/v3.Release` resource. This resource represents a Helm release in a Kubernetes cluster and enables you to specify the Helm chart to be deployed, including its version, any custom values, and the namespace where it should be installed.

Here is a complete Pulumi program in TypeScript that performs these tasks. This program creates a GKE cluster and then deploys the `stakater-buildah` Helm chart:

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

// Step 1: Create a GKE cluster
const cluster = new gcp.container.Cluster("gke-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest", // Use the latest version of GKE
    nodeConfig: {
        machineType: "n1-standard-1", // This is a standard machine type with 1 vCPU and 3.75GB memory.
        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;

// Obtain the Kubeconfig for the GKE cluster
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: Installing the Helm chart
// A Kubernetes provider is required to install the Helm chart onto the GKE cluster
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Deploy the stakater-buildah Helm chart
const buildahChart = new k8s.helm.v3.Chart("stakater-buildah", {
    chart: "buildah",
    version: "0.1.0", // Specify the chart version you want to deploy
    fetchOpts: {
        repo: "https://stakater.github.io/stakater-charts", // The repository containing the helm chart
    },
}, { provider: k8sProvider });

// Export the Helm chart status
export const buildahChartStatus = buildahChart.status;

```

Explanation:

- We create a GKE cluster with `gcp.container.Cluster`, specifying the initial number of nodes, master version, machine types, and OAuth scopes. Scopes allow the cluster nodes to interact with other Google Cloud services.
  
- Next, we construct a Kubeconfig file which is required by the Kubernetes provider to deploy resources onto the GKE cluster.

- We use the `k8s.Provider` resource to create a Kubernetes provider instance with the Kubeconfig from the GKE cluster.

- Finally, we use the `k8s.helm.v3.Chart` resource to deploy the `stakater-buildah` Helm chart to the cluster, specifying the chart version and the repository URL.

This program deploys the specified Helm chart to the newly created GKE cluster. You must ensure that you have:

- Installed and configured Pulumi
- Configured GCP credentials for Pulumi to use
- Installed the Pulumi GCP and Kubernetes plugins

Once you have this setup, you can run the program using the `pulumi up` command.

Remember to replace the `version` with the version of stakater-buildah Helm chart you wish to use and ensure the `repo` URL is correct and reachable. The chart name must also match the name of the chart in the specified Helm chart repository.