Deploy the gcpdisk-csi-driver helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `gcpdisk-csi-driver` Helm chart on Google Kubernetes Engine (GKE), we'll need to take the following steps:

1. **Create a GKE Cluster**: Provision a new Kubernetes cluster on Google Cloud Platform (GCP) using Pulumi's GKE resource.
2. **Install the Helm Chart**: Use Pulumi's Helm package to deploy the `gcpdisk-csi-driver` chart to your GKE cluster.

Here's a program that accomplishes these tasks using Pulumi with TypeScript:

### Prerequisites
Make sure you have the following before running the Pulumi program:
- Pulumi CLI installed and configured for GCP.
- `gcloud` CLI installed and configured for GCP.
- Access to a GCP account with permissions to create GKE clusters and deploy Helm charts.

### Program Explanation

1. **GKE Cluster Resource**: This uses the `gcp.container.Cluster` class to create a new GKE cluster on GCP. You can adjust cluster settings such as machine type, node count, etc., as needed for your use case.

2. **Helm Release Resource**: After the GKE cluster is created, the program defines a `helm.v3.Release` resource. This resource specifies the Helm chart to be installed on our GKE cluster. In this case, it's the `gcpdisk-csi-driver` chart.

Here's the Pulumi program to accomplish this:

```typescript
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 cluster = new gcp.container.Cluster("gke-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // You can choose an appropriate machine type
        oauthScopes: [
            "https://www.googleapis.com/auth/cloud-platform"
        ],
    },
});

// Export the Cluster name and Kubeconfig for the cluster
export const clusterName = cluster.name;
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
`;
    });

// Step 2: Deploy the `gcpdisk-csi-driver` Helm chart to the GKE cluster
const gcpDiskCsiDriverRelease = new k8s.helm.v3.Release("gcpdisk-csi-driver", {
    chart: "gcpdisk-csi-driver",
    version: "0.1.0", // Specify the version of the chart you wish to deploy
    namespace: "default", // Chart namespace
    repositoryOpts: {
        repo: "https://kubernetes-sigs.github.io/gcp-compute-persistent-disk-csi-driver", // Helm chart repository
    },
}, { provider: new k8s.Provider("gke-k8s", { kubeconfig }) });

// Export the Helm chart release name
export const releaseName = gcpDiskCsiDriverRelease.status.name;

```

In the program:
- We define `initialNodeCount` for the number of nodes in the cluster, `minMasterVersion` and `nodeVersion` to specify the Kubernetes version. Make sure to use versions compatible with your CSI driver chart.
- OAuth scopes enable the nodes to interact with Google Cloud APIs.
- The `kubeconfig` is assembled with cluster access details for the Kubernetes provider to interact with the GKE cluster.
- A `k8s.Provider` instance, specific to the GKE cluster created, is used to tell the Helm chart where to deploy.

### Running the Program

To run the program, follow these steps:

1. Save the aforementioned program in a file named `index.ts`.
2. Run `pulumi up` to preview and deploy the changes.

After running `pulumi up`, you'll receive a detailed preview of the resources that Pulumi will create. If everything looks correct, proceed with the deployment.

Once the deployment is successful, the `gcpdisk-csi-driver` should be installed on your GKE cluster, and you can start using Google Compute Engine persistent disks as storage within your Kubernetes cluster.