Deploy the konfigurator helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the Konfigurator Helm chart on Google Kubernetes Engine (GKE), you will need to follow these general steps:

Create a GKE cluster. To interact with Google Cloud services, including GKE, you'll use the gcp Pulumi provider. You'll define a cluster by creating an instance of the gcp.container.Cluster resource.
Configure kubectl to connect to the newly created GKE cluster.
Install the Helm chart. The kubernetes Pulumi provider allows you to manage Helm charts with the kubernetes.helm.v3.Chart resource. This Helm chart will be the Konfigurator itself.

Here is a TypeScript program that accomplishes these tasks:

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 gkeCluster = new gcp.container.Cluster("gke-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // Choosing a standard machine type. Adjust as necessary.
        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 kubectl to connect to the GKE cluster
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: gkeCluster.name.apply(name => {
        const cluster = gcp.container.getCluster({
            name: name,
            location: gkeCluster.location,
            project: gkeCluster.project,
        });
        const context = `${gcp.config.project}_${gcp.config.zone}_${name}`;
        return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${cluster.masterAuth.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:
        access-token: ${cluster.masterAuth.token}
        cmd-args: config config-helper --format=json
        cmd-path: gcloud
        expiry-key: '{.credential.token_expiry}'
        token-key: '{.credential.access_token}'
      name: gcp`;
    }),
});

// Step 3: Install the Konfigurator Helm chart
const konfiguratorChart = new k8s.helm.v3.Chart("konfigurator-chart", {
    chart: "konfigurator",
    // Replace `<repo>` with the actual Helm chart repository that hosts the Konfigurator chart
    // Example: version: "1.0.0", repositoryOpts: { repo: "https://charts.yourorg.com/" }
    version: "<chart-version>",
    fetchOpts: {
        repo: "<repo-url>",
    },
}, { provider: k8sProvider });

// Export the Kubeconfig as an output to access the cluster using kubectl
export const kubeConfig = k8sProvider.kubeconfig;

// Export the Konfigurator chart status
export const konfiguratorStatus = konfiguratorChart.status;

Explanation:

GKE Cluster: The program begins by declaring a GKE cluster resource. The gcp.container.Cluster type from the gcp provider is used to define the details of the cluster. In this case, we specify the initial node count and the versions for the master and node Kubernetes versions. We also provide the machine type and OAuth scopes necessary for the GKE nodes to interact with other Google Cloud services.
Kubectl Configuration: We set up a Kubernetes provider configured to connect to our GKE cluster. This requires generating a kubeconfig file dynamically using details from the GKE cluster we created. The kubeconfig is used by the Kubernetes provider to manage resources within the GKE cluster.
Helm Chart: Using the kubernetes.helm.v3.Chart resource, we deploy the Konfigurator Helm chart to the cluster. You need to specify the name and version of the chart you want to deploy, and its repository URL.

Please ensure you have the right Helm Chart details for Konfigurator, such as the version and the repository URL, which need to be provided in place of <chart-version> and <repo-url> placeholder values in the konfiguratorChart declaration. Additionally, replace <repo> with the actual Helm chart repository that hosts the Konfigurator chart, if applicable.

Exported Outputs: At the end of our program, we export the kubeconfig that can be used to manage the cluster with kubectl and the status of the Konfigurator Helm Chart deployment.

To execute this program:

Save the code to a file with the .ts extension, for example index.ts.
Run pulumi up to preview and deploy the changes.
Once applied, Pulumi will manage the GKE cluster and the Konfigurator Helm Chart according to this program.

Keep in mind that you need to have Pulumi installed and configured to use with your Google Cloud account. Additionally, replace any placeholder values used in the code with actual data from your environment.