Deploy the mongo-gui helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

Deploying a Helm chart on Google Kubernetes Engine (GKE) with Pulumi is a multi-step process. We first create a GKE cluster and then deploy the Helm chart to the cluster. We'll use the Pulumi GCP (`gcp`) and Kubernetes (`@pulumi/kubernetes`) packages.

Let's break this down into two main parts:

1. **Provisioning the GKE cluster**:
   - We'll use the `gcp.container.Cluster` class to create a new cluster.
   - Provide the necessary parameters like the zone, initial node count, and the machine type for nodes.

2. **Deploying the Helm chart**:
   - We'll use the `@pulumi/kubernetes` package to connect to the GKE cluster we've just provisioned.
   - We'll use the `helm.v3.Chart` class to deploy the MongoDB GUI chart, which will pull the Helm chart from a chart repository and deploy it to the cluster.

Now let's get to the program. The code below is structured to help you understand each section and what it does:

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

// Create a GKE cluster for our Helm chart.
const cluster = new gcp.container.Cluster("mongo-gui-cluster", {
  initialNodeCount: 2,
  nodeVersion: "latest",
  minMasterVersion: "latest",
  nodeConfig: {
    machineType: "n1-standard-1", // You can choose the machine type that works best for you.
    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;

// 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 (it's not just plain kubeconfig).
const kubeconfig = pulumi.
  all([cluster.name, cluster.endpoint, cluster.masterAuth]).
  apply(([name, endpoint, auth]) => {
    const context = `${gcp.config.project}_${gcp.config.zone}_${name}`;
    return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${auth.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 kubeConfigOutput = kubeconfig;

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

// Deploy the mongo-gui Helm chart using the new instance of the Kubernetes provider.
const chart = new k8s.helm.v3.Chart("mongo-gui", {
  chart: "mongo-gui",
  // This assumes that your Helm chart is available in the repository. Make sure to replace with the correct repository URL.
  fetchOpts:{
    repo: "https://charts.bitnami.com/bitnami",
  }
}, { provider: clusterProvider });

// Export the Helm chart name
export const chartName = chart.name;

```

Here's what each part of the code does:

- **Provision a GKE cluster**: We define a new cluster using the `gcp.container.Cluster` class. Adjust the `initialNodeCount` and `nodeConfig` parameters based on your performance and cost considerations.
  - The `kubeconfig` is generated to authenticate kubectl commands against the new GKE cluster. This is necessary because GKE requires specific OAuth2 authentication.
- **Deploy the Helm chart**: We use the `k8s.helm.v3.Chart` class to deploy the Helm chart.
  - The `chart` key specifies the name of the chart to deploy.
  - `fetchOpts.repo` should contain the URL of the Helm chart repository that contains the `mongo-gui` chart. Replace this with the appropriate URL for the Helm chart repository you're using.

After running this program with Pulumi, you will have a GKE cluster and the `mongo-gui` Helm chart deployed to it.