Deploy the mongodb-backup-aws helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `mongodb-backup-aws` Helm chart on a Google Kubernetes Engine (GKE) cluster, you'll first need to ensure you have a running GKE cluster. Then you can utilize Pulumi's Helm chart support to deploy the chart to your GKE cluster.

In the following TypeScript program, we perform the following steps:

1. Import necessary Pulumi packages for working with GKE and Helm charts.
2. Create a Kubernetes service provider specific to GKE, which establishes the context we deploy resources into.
3. Deploy a Helm chart from a repository where `mongodb-backup-aws` is located, using the GKE provider created in step 2.

Here is a full example that demonstrates how to perform these steps:

```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("mongo-backup-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1",
        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 Kubeconfig.
export const kubeconfig = pulumi.
    all([cluster.name, cluster.endpoint, cluster.masterAuth]).
    apply(([name, endpoint, masterAuth]) => {
        const kubeconfig = {
            "apiVersion": "v1",
            "clusters": [{
                "cluster": {
                    "server": `https://${endpoint}`,
                    "certificate-authority-data": masterAuth.clusterCaCertificate,
                },
                "name": "gke_cluster",
            }],
            "contexts": [{
                "context": {
                    "cluster": "gke_cluster",
                    "user": "gke_cluster",
                },
                "name": "gke_cluster",
            }],
            "current-context": "gke_cluster",
            "kind": "Config",
            "users": [{
                "name": "gke_cluster",
                "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",
                    },
                },
            }],
        };
        return JSON.stringify(kubeconfig);
    });

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

// Deploy the mongodb-backup-aws Helm chart.
const chart = new k8s.helm.v3.Chart("mongodb-backup-aws", {
    chart: "mongodb-backup-aws",
    version: "1.0.0", // replace with the desired chart version
    fetchOpts:{
        repo: "https://charts.bitnami.com/bitnami", // replace with the Helm repository URL containing the chart
    },
}, { provider: k8sProvider });

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

Before you run this program, make sure you've completed the following steps:

- Install and configure the Pulumi CLI with your GCP credentials. See the [Pulumi installation guide](https://www.pulumi.com/docs/get-started/install/) for details.
- Have `gcloud` CLI installed and authenticated with GCP.
- Install Node.js and the npm package manager to run the TypeScript program.
- Ensure the Helm chart `mongodb-backup-aws` exists in the Helm repository you're referencing. Replace the version and repository URL in the `Chart` resource with appropriate values.

After you've completed these prerequisites, run the program by executing these commands within the directory:

```
pulumi stack init mongo-backup
pulumi up
```

This code above initializes a new Pulumi stack called `mongo-backup` and then creates the resources with `pulumi up`. When prompted, confirm the deployment by selecting `yes`.

This program will set up the GKE cluster and then deploy the specified Helm chart to the cluster. It also exports the name of the chart and the kubeconfig needed to interact with the cluster, which could be useful for additional configuration or for access with `kubectl`.