Deploy the nfs-provisioner helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `nfs-provisioner` Helm chart on Google Kubernetes Engine (GKE), we'll go through a multi-step process:

1. **Setup the GKE Cluster**: We will create a GKE cluster where the Helm chart will be deployed. GKE is a managed environment for running Kubernetes clusters designed by Google Cloud, making it convenient to run Kubernetes without handling the underlying infrastructure.

2. **Install the Helm Chart**: Once the GKE cluster is ready, we will use the `kubernetes.helm.sh/v3.Release` resource from Pulumi's Kubernetes provider to deploy the `nfs-provisioner` chart. Helm charts are packages of pre-configured Kubernetes resources that you can deploy as a single unit.

Here's a detailed Pulumi program written in TypeScript that performs the above steps:

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

// Step 1: Configure the GKE cluster
const cluster = new gcp.container.Cluster("nfs-provisioner-cluster", {
  initialNodeCount: 1,
  nodeVersion: "latest",
  minMasterVersion: "latest",
  nodeConfig: {
    machineType: "n1-standard-1", // Choose the machine type based on your needs
    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;

// Obtain the KubeConfig from the GKE cluster
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
`;
  });

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

// Step 2: Install the nfs-provisioner Helm chart
const nfsProvisionerChart = new k8s.helm.v3.Chart("nfs-provisioner", {
  chart: "nfs-provisioner",
  version: "1.0.0", // Specify the version of the chart you want to deploy
  fetchOpts:{
    repo: "https://kubernetes-sigs.github.io/nfs-subdir-external-provisioner/", // Repository URL of nfs-subdir-external-provisioner Helm chart
  },
}, { provider: clusterProvider });

// Export the Helm chart resources
export const helmChartName = nfsProvisionerChart.chart;

```

#### Explanation:

- **GKE Cluster Configuration**: We start by defining a new GKE cluster (`gcp.container.Cluster`) with a specific node count and machine type. It's important to grant the necessary OAuth scopes to the nodes for them to interact with other Google Cloud services. The `minMasterVersion` and `nodeVersion` fields ensure that the cluster gets created with the latest available versions.

- **Kubernetes Provider**: We create a Kubernetes provider that is bound to the kubeconfig of the GKE cluster. This provider is responsible for provisioning and managing Kubernetes resources in the given GKE cluster.

- **Helm Chart Installation**: We create a new Helm chart resource using `k8s.helm.v3.Chart`. Here, we specify the `nfs-provisioner` chart along with its version and the repository where the chart is hosted. That will install the NFS Provisioner into our GKE cluster.

After running this program with Pulumi (assuming you have the Pulumi CLI and GCP configured), it will output the cluster name and the Helm chart name.