Deploy the k8s-configmap helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

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

1. Set up a new GKE cluster or use an existing one.
2. Install and configure the Helm and Kubernetes providers in Pulumi.
3. Deploy the Helm chart to your GKE cluster using Pulumi's Helm support.

Below you'll find a Pulumi program written in TypeScript that will set up a new GKE cluster and deploy a Helm chart representing a Kubernetes `ConfigMap`. This example assumes that you have the `k8s-configmap` Helm chart available and that you've set up your Pulumi and GCP credentials.

### Detailed Explanation:

The program will:

- Use the `@pulumi/gcp` package to create a new GKE cluster.
- Use the `@pulumi/kubernetes` package to interact with the Kubernetes cluster and deploy the Helm chart.
- A `ConfigMap` doesn't typically have a standalone Helm chart because it's a basic Kubernetes resource. However, for the purpose of this example, we'll assume that such a Helm chart exists. If you are using a pre-existing Helm chart like `stable/k8s-configmap`, please replace `"k8s-configmap"` with the correct chart identifier.

Here's the Pulumi program:

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

// Create a GCP project and zone to deploy the GKE cluster in.
const project = gcp.config.project || "your-gcp-project";
const zone = gcp.config.zone || "us-central1-a";

// Create a GKE cluster
const cluster = new gcp.container.Cluster("my-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    nodeConfig: {
        preemptible: true,
        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",
        ],
    },
    project: project,
    location: zone,
});

// Export the Cluster name
export const clusterName = cluster.name;

// Export the Kubeconfig to interact with the cluster
export const kubeconfig = pulumi.
    all([cluster.name, cluster.endpoint, cluster.masterAuth]).
    apply(([name, endpoint, auth]) => {
        const context = `${gcp.config.project}_${gcp.config.zone}_${name}`;
        return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${auth.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
`;
    });

// Set up Kubernetes provider to use the generated kubeconfig.
const k8sProvider = new k8s.Provider("gkeK8s", {
    kubeconfig: kubeconfig,
});

// Deploy the Helm chart for the Kubernetes ConfigMap
const configMapChart = new k8s.helm.v3.Chart("k8s-configmap", {
    chart: "k8s-configmap",
    version: "1.0.0",
    fetchOpts: {
        repo: "http://charts.example.com/", // Replace with the actual URL of the chart repository.
    },
}, { provider: k8sProvider });

// Export the ConfigMap name deployed by Helm
export const configMapName = configMapChart.getResourceProperty("v1/ConfigMap", "my-configmap", "metadata").apply(m => m.name);
```

### Instructions to Run the Program:

1. Make sure you have Pulumi and Google Cloud SDK (`gcloud`) installed and configured on your machine.
2. Copy the program into a new directory and ensure you install the required NPM modules with `npm install @pulumi/pulumi @pulumi/gcp @pulumi/kubernetes`.
3. Replace `"your-gcp-project"` and `"http://charts.example.com/"` with the actual values for your Google Cloud project and Helm chart repository.
4. Run `pulumi up` to provision the resources. You will be prompted to confirm the action before any infrastructure is provisioned.
5. Once the deployment is complete, the outputs, including the cluster name and ConfigMap name, will be displayed.
6. To clean up the resources, run `pulumi destroy`.

This program is just a starting point. You might need to adjust settings such as the GCP project, GKE cluster configurations, or Helm chart details according to your specific requirements. Moreover, since the `ConfigMap` resource is a simple one, it's not common to have a Helm chart for such a resource exclusively. This example is for demonstration and learning purposes. For real-world scenarios, you'd deploy Helm charts containing actual applications or complex configurations.