Deploy the ibm-ucdr-prod helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

Deploying a Helm chart on a Kubernetes cluster involves several steps:

1. Setting up the Kubernetes cluster.
2. Installing and configuring the Helm CLI tool.
3. Adding the repository containing the Helm chart (if it's not a part of the standard Helm chart repositories).
4. Deploying the Helm chart to the Kubernetes cluster.

Using Pulumi, we can automate the creation and configuration of the Google Kubernetes Engine (GKE) cluster. After the cluster is set up, we'd typically use the Helm CLI to deploy the IBM UC Deploy chart directly. However, Pulumi also provides a way to manage Helm releases as resources in your Pulumi program.

Below is a Pulumi program written in TypeScript that creates a GKE cluster and deploys the "ibm-ucdr-prod" Helm chart to it.

Let's walk through the code step by step:

1. **Import Necessary Modules**:
   We import Pulumi's GKE and Helm resources, as well as the `@pulumi/kubernetes` to interact with Kubernetes resources.

2. **Create a GKE Cluster**:
   We use `gcp.container.Cluster` to create a new cluster. Here, we define the necessary parameters for our GKE cluster such as the name, location, and node configuration.

3. **Install Helm Chart**:
   Once the cluster is created, we use `kubernetes.helm.v3.Chart` to deploy the IBM UC Deploy Helm chart. Note that in a real-world scenario, you will need to specify the correct repository that holds the "ibm-ucdr-prod" chart and ensure that chart's values are configured according to your requirements.

4. **Export the Kubeconfig**:
   To interact with your cluster using kubectl or similar tools, you will need a kubeconfig file. We configure the Pulumi program to export this file.

Please replace `'INSERT_HELM_REPO_URL_HERE'` with the actual URL of the Helm repository that contains "ibm-ucdr-prod," and adjust the `version` and `values` as necessary for the chart.

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("my-gke-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1",
    },
});

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

// Manufacture a GKE-style Kubeconfig. Note that this is slightly "different"
// because of the way GKE requires gcloud to be in the picture for cluster
// authentication (rather than using the client cert/key directly).
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
`;
    });

// Export the Kubeconfig
export const kubeConfig = kubeconfig;

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

// Deploy the IBM UC Deploy Helm chart
const ibm_ucdr_prod = new k8s.helm.v3.Chart("ibm-ucdr-prod", {
    chart: "ibm-ucdr-prod",
    version: "1.0.0", // specify the exact chart version
    fetchOpts:{
        repo: "INSERT_HELM_REPO_URL_HERE",
    },
}, { provider: provider });

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

This program will:
- Provision a new GKE cluster (with the desired configuration)
- Deploy the specified Helm chart onto the new cluster
- Provide you with a kubeconfig file so you can interact with your GKE cluster using kubectl or other Kubernetes tools

Remember that some settings, such as the Helm repo URL (`'INSERT_HELM_REPO_URL_HERE'`) and `version`, need to be adjusted to match the correct details for the Helm chart you wish to deploy.