Deploy the gce-ingress helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Google Kubernetes Engine (GKE), you will need to perform the following high-level steps:

Create a GKE cluster.
Deploy the Helm chart to the GKE cluster.

In this example, we'll use Pulumi with the GCP and Kubernetes providers. The GCP provider is used to provision a GKE cluster, and the Kubernetes provider is used to deploy the Helm chart on that cluster.

Below is a Pulumi program written in TypeScript that demonstrates how to accomplish these tasks. The program assumes you have already set up the Pulumi CLI and have authenticated with GCP.

First, we import the necessary Pulumi packages for GCP and Kubernetes. Then, we define a GKE cluster and deploy the gce-ingress Helm chart to it.

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

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

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

// Export the Kubeconfig so that the Kubernetes provider can use it to deploy Helm charts.
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
`;
    });

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

// Deploy the 'gce-ingress' Helm chart on the GKE cluster.
const gceIngressChart = new k8s.helm.v3.Chart("gce-ingress", {
    chart: "gce-ingress",
    // You need to specify the repository that contains the 'gce-ingress' Helm chart.
    // For example, if your chart is hosted in Helm Hub or any other Helm chart repository,
    // you will need to provide the 'repo' option here.
    repositoryOpts: {
        repo: "<Helm chart repository URL>",
    },
    values: {
        // You should specify the configuration values for your 'gce-ingress' chart here.
        // Check the 'values.yaml' file of the 'gce-ingress' chart for the configuration options.
    },
}, { provider: k8sProvider });

// Export the status of the Helm release.
export const gceIngressStatus = gceIngressChart.status;

In the program above:

We create a GKE cluster (gcp.container.Cluster) with the specified machine type and OAuth scopes necessary for this example to work. You may need to adjust the machine type and OAuth scopes based on your specific needs.
The kubeconfig is a formatted string allowing the Kubernetes provider to interact with our newly created GKE cluster.
We then instantiate a Kubernetes provider (k8s.Provider) configured with our kubeconfig to interact with the GKE cluster.
Finally, we deploy the gce-ingress Helm chart to the GKE cluster using the Helm Chart resource from the Pulumi Kubernetes provider.

Replace <Helm chart repository URL> with the actual URL to the Helm chart repository that hosts the gce-ingress chart. This information can be found in the documentation of the Helm chart you are using or in a Helm repository's listings.

To find the specific values for the gce-ingress Helm chart you want to configure, you need to examine the Helm chart's values.yaml file found in the Helm chart source or documentation.

Please note that the values provided in the values property of the Chart resource should match the exact structure expected by the Helm chart.

After deploying the chart, the gceIngressStatus export will provide information about the release status of the Helm chart.