Deploy the taikun-lma helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

Deploying a Helm chart on a Google Kubernetes Engine (GKE) cluster involves several steps:

Create a GKE Cluster: Before you can deploy your Helm chart, you need a running Kubernetes cluster. The following program demonstrates how to create a GKE cluster using the Pulumi Google Native provider.
Install Helm and Add the chart repository: Helm is a package manager for Kubernetes, which allows you to define, install, and upgrade even the most complex Kubernetes applications. You'll need to install the Helm CLI on your local machine and add the repository that contains the taikun-lma chart.
Deploy the Helm Chart: After you've configured Helm and your Kubernetes cluster is up and running, you can deploy the taikun-lma Helm chart to your GKE cluster.

Detailed Program Explanation

Before running the following program, make sure you have the Pulumi CLI installed and authenticated with your GCP account, and the Google Cloud SDK installed and configured.

This Pulumi program will guide you through:

Creating a new GKE cluster.
Defining a Helm Release resource to deploy the taikun-lma Helm chart on that GKE cluster.

Comments are included within the code to provide additional context.

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

// Initialize a new Pulumi project with GCP as the provider.
const name = "taikun-lma-cluster";
const project = gcp.config.project;
const location = gcp.config.region;

// Define the GKE cluster configuration.
const cluster = new gcp.container.Cluster(name, {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    location: location,
    nodeConfig: {
        machineType: "n1-standard-1", // Use an appropriate machine type
        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"
        ],
    },
});

// Once the cluster is created, we can obtain the Kubeconfig needed to manage the cluster
const kubeconfig = pulumi.all([cluster.name, cluster.endpoint, cluster.masterAuth]).apply(([name, endpoint, masterAuth]) => {
    const context = `${project}_${location}_${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
`;
});

// Create a Kubernetes Provider instance with the kubeconfig.
const k8sProvider = new k8s.Provider(name, {
    kubeconfig: kubeconfig,
});

// Define the Helm Release for the `taikun-lma` chart.
const taikunLmaChart = new k8s.helm.v3.Release("taikun-lma", {
    chart: "taikun-lma",
    version: "1.0.0", // Use the correct version
    repositoryOpts: {
        repo: "https://<repo-url>", // Use the correct Helm repository URL
    },
    namespace: "default", // Specify the namespace if needed
}, { provider: k8sProvider });

// Export the kubeconfig so that the Kubernetes cluster can be easily accessed.
export const kubeconfigOutput = kubeconfig;

// Export the public endpoint of the GKE cluster.
export const clusterEndpoint = cluster.endpoint;

Running the Program

Save the code above into a file named index.ts within your Pulumi project. Next, perform the following steps:

Deploy the GKE cluster and the Helm chart:
- Navigate to the folder containing your Pulumi program.
- Run pulumi up to preview and deploy the changes. You'll be prompted to confirm the deployment by selecting yes.
Access the cluster:
- Use the exported kubeconfig to configure kubectl or to access the Kubernetes cluster dashboard.
- Utilize the GKE cluster's endpoint which is also exported from the program.
Verify the deployment:
- Make sure Helm is properly installed and configured on your local system.
- Use Helm to list the deployed charts by running helm list, and verify that the taikun-lma chart is deployed.

Remember to replace <repo-url> with the actual repository URL where your taikun-lma Helm chart is located, and set the correct chart version in the taikunLmaChart resource. Additionally, ensure that your GKE cluster's node pool has the necessary resources and permissions to deploy and run your Helm chart as desired.