Deploy the quickstart-python helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `quickstart-python` Helm chart on Google Kubernetes Engine (GKE), we'll need to perform a few steps:

1. **Create a GKE Cluster**: We will begin by provisioning a GKE cluster using Pulumi's GCP provider.
2. **Install the Helm Chart**: After the cluster is up and running, we will install the `quickstart-python` Helm chart into our GKE cluster.

I'll guide you through a Pulumi TypeScript program that accomplishes these steps. Note that you will need to have Pulumi CLI installed, and appropriate GCP credentials configured.

Let's start by defining the GKE cluster:

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("my-gke-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    nodeConfig: {
        preemptible: true,
        machineType: "n1-standard-1",
        oauthScopes: [
            "https://www.googleapis.com/auth/cloud-platform",
        ],
    },
});

// 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
`;
    });
```

This code snippet does the following:
- Imports the necessary Pulumi libraries for GCP and Kubernetes.
- Creates a GKE cluster with two nodes using the `n1-standard-1` machine type, which are preemptible VMs. This can help reduce costs, but they may be terminated and replaced by the cloud provider at any time.
- Exports the cluster name and the generated Kubeconfig. The Kubeconfig is essential to interact with the cluster using `kubectl` or any Kubernetes client libraries.

Next, we need to set up the Helm chart deployment. This requires Pulumi's Kubernetes provider to install the Helm chart.

```typescript
// The following code assumes the Pulumi program has already been provided
// above, including the creation of a GKE cluster named `my-gke-cluster`.

// Create a Kubernetes provider instance that uses our cluster from above.
const k8sProvider = new k8s.Provider("my-k8s-provider", {
    kubeconfig: kubeconfig,
});

// Deploy the `quickstart-python` Helm chart into the `my-gke-cluster`.
const chart = new k8s.helm.v3.Chart("quickstart-python", {
    chart: "quickstart-python",
    version: "1.0.0", // specify the exact chart version
    fetchOpts: {
        repo: "https://charts.example.com/", // specify the correct Helm chart repository
    },
}, { provider: k8sProvider });

// Export the Chart name
export const chartName = chart.name;
```

This code snippet accomplishes the following:
- Uses the Kubernetes provider configured with the Kubeconfig obtained from our GKE cluster, allowing us to interact with the cluster.
- Installs the `quickstart-python` Helm chart in our GKE cluster. Since Helm charts are usually versioned and stored in repositories, you need to specify the repository URL and the version you want to deploy.
- Exports the name of the deployed Helm chart for reference.

Ensure to replace `"https://charts.example.com/"` with the actual URL of the Helm chart repository that hosts the `quickstart-python` chart and specify the correct version.

Combining these two code snippets into a single Pulumi program will create a GKE cluster and deploy the `quickstart-python` Helm chart onto it.