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

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Google Kubernetes Engine (GKE) using Pulumi, you need to follow a sequence of steps:

1. **Provision a GKE Cluster**: You will first create a Google Kubernetes Engine cluster where the Helm chart will be deployed. This is the environment for your containerized applications.

2. **Install and Configure the Helm Client**: Once your Kubernetes cluster is up and running, you will need the Helm client to be installed and configured to communicate with your Kubernetes cluster. You can set up Helm as part of your deployment process or assume it is already installed in your environment.

3. **Deploy the Helm Chart**: With the cluster and Helm ready, you can proceed to deploy your Helm chart. In this case, you will deploy the `vcagent` chart.

Below is a Pulumi program written in TypeScript that demonstrates these steps. This program will:

- Create a GKE cluster.
- Use the Helm package to deploy a chart.

Before you run this program, make sure you've [installed Pulumi](https://www.pulumi.com/docs/get-started/install/) and set up [Google Cloud credentials](https://www.pulumi.com/docs/intro/cloud-providers/gcp/setup/).

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

// Create a GCP resource (GKE Cluster)
// The code assumes that default configuration values for the GCP project, region, and zone are set in Pulumi's configuration system or environment variables.
const cluster = new gcp.container.Cluster("my-gke-cluster", {
    initialNodeCount: 2,
});

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

// Export the Kubeconfig
export const kubeconfig = cluster.masterAuth.apply(masterAuth => {
    const context = `${gcp.config.project}_${gcp.config.zone}_${cluster.name}`;
    return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${masterAuth.clusterCaCertificate}
    server: https://${masterAuth.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
`;
});

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

// Deploy the Helm chart using the Helm provider instance.
const helmChart = new k8s.helm.v3.Chart("vcagent-chart", {
    chart: "vcagent",
    // You will typically want to specify the repository and version of the chart for reproducibility.
    // e.g. repo: "https://charts.example.com/", version: "1.2.3"
}, { provider: clusterProvider });

// Export the Helm chart name
export const helmChartName = helmChart.name;
```

This Pulumi program completes the following actions:

1. A new GKE cluster named 'my-gke-cluster' is defined and instantiated with 2 nodes using the `@pulumi/gcp` package.

2. It exports `clusterName`, which would be used in subsequent Pulumi commands or in your CI/CD system.

3. It constructs a kubeconfig which allows `kubectl` and Helm to communicate with your GKE cluster.

4. The `@pulumi/kubernetes` package is used to create a Kubernetes provider that uses the kubeconfig.

5. The `vcagent` Helm chart is deployed to the GKE cluster using Pulumi’s Helm support with the `@pulumi/kubernetes` package.

Remember to specify the actual chart repository and version if they are different from the defaults expected by the Helm client. After running `pulumi up`, the vcagent Helm chart will be deployed to your GKE cluster.