Deploy the sys-info-web-env-view-server helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Google Kubernetes Engine (GKE), you should first ensure that you have a Kubernetes cluster up and running on GKE. With Pulumi, you can create a GKE cluster using the `gcp.container.Cluster` resource. Once the cluster is up and ready, you will deploy the Helm chart using the `helm.v3.Chart` resource from Pulumi's Helm package.

Below are the steps and Pulumi code needed to accomplish this:

1. **Set up a GKE cluster**: Using Pulumi, we define a GKE cluster with the necessary configurations.

2. **Configure Kubeconfig**: Set up the Kubeconfig so that Pulumi can communicate with your GKE cluster to perform deployments.

3. **Deploy the Helm chart**: Using the Helm chart resource, we specify the name of the chart, the repository where it's hosted, and any configurations it requires.

Here's a complete program written in TypeScript:

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

const name = "sys-info-web-env-view-server";

// Step 1: Create a GKE cluster
const cluster = new gcp.container.Cluster(name, {
    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"
        ],
    },
});

// Step 2: Configure Kubeconfig
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 3: Deploy the Helm chart
const chart = new helm.Chart(name, {
    chart: "sys-info-web-env-view-server",
    // Assuming the Helm chart is in a Helm repository, specify the repository URL
    // For example, fetch from a stable Helm repository:
    //     fetchOpts: {
    //         repo: "https://kubernetes-charts.storage.googleapis.com/",
    //     },
    // If the chart is hosted on a specific URL or Git, you can specify `fetchOpts` accordingly
    values: {
        // Specify the values for the chart here.
        // For example, you might want to define the service type:
        //     service: {
        //         type: "LoadBalancer",
        //     },
    },
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig }) });

// Export the cluster's name and Kubeconfig
export const clusterName = cluster.name;
export const clusterKubeconfig = kubeconfig;

```

To deploy the above Pulumi program, follow these steps:

1. Save the code in a file named `Pulumi.yaml`.
2. Run `pulumi up` in your terminal from the same directory as the `Pulumi.yaml` file.
3. Pulumi CLI will show you a preview of the resources that will be created. If everything looks correct, proceed with the deployment by selecting `yes`.
4. Once the deployment is finished, Pulumi will output the name of the cluster and the Kubeconfig which you can use to interact with your Kubernetes cluster.

Remember to replace the placeholders in the `values` section with the actual settings required for your Helm chart. The example assumes that you have `gcloud` CLI installed and setup to authenticate with GCP, which Pulumi uses to generate a Kubeconfig file for accessing the GKE cluster.