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

Question

Pulumi · Accepted Answer

To deploy a MongoDB ReplicaSet using the Helm chart on Google Kubernetes Engine (GKE), you will need to accomplish a few distinct steps:

1. **Set up a GKE cluster:** You'll first need to create a GKE cluster where your MongoDB ReplicaSet will be deployed.

2. **Install the Helm chart for MongoDB:** After setting up the GKE cluster, you'll need to install the Helm chart which contains the predefined Kubernetes resources necessary to run a MongoDB ReplicaSet.

Below is the step-by-step Pulumi program written in TypeScript to achieve this. Make sure you've got Pulumi and the respective cloud provider's CLI installed and configured before running this.

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

// Step 1: Create a GKE cluster
const cluster = new gcp.container.Cluster("mongo-cluster", {
    // Define the properties of the cluster
    initialNodeCount: 3, // Recommended to have at least 3 nodes for a ReplicaSet
    nodeVersion: "latest",
    minMasterVersion: "latest",
});

// Export the Cluster name and Kubeconfig
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: Install MongoDB Helm chart into the GKE cluster
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

const mongoChart = new k8s.helm.v3.Chart("mongo-replicaset", {
    chart: "mongodb-replicaset",
    version: "3.9.6", // Specify the version of the chart to be installed
    fetchOpts:{
        repo: "https://kubernetes-charts.storage.googleapis.com", // MongoDB Helm chart repository
    },
}, { provider: k8sProvider });

// Export the MongoDB ReplicaSet Helm chart resources
export const mongoReplicaSetResources = mongoChart.resources;
```

Here's what each part of the code is doing:

- First, you create a GKE cluster using the `gcp.container.Cluster` class. It's set to have a minimum of 3 nodes because MongoDB ReplicaSets typically require at least three nodes to work properly.

- Then, you export the cluster information, including the `kubeconfig`, which is necessary for Kubernetes tools (like `kubectl` and Pulumi) to communicate with your cluster.

- With the cluster set up, you create an instance of the `k8s.Provider` which understands how to communicate with the GKE cluster using the generated `kubeconfig`.

- Finally, you install the MongoDB ReplicaSet Helm chart by creating an instance of `k8s.helm.v3.Chart`. This Pulumi resource manages Helm chart installations. The chart details include its name (`mongodb-replicaset`) as well as the version and repository URL.

After this Pulumi program is executed, it will provision a GKE cluster and deploy a MongoDB ReplicaSet into it using Helm. You can modify the configuration of the GKE cluster and the Helm chart by changing the arguments passed to the resources.

Remember, before running this Pulumi program ensure that your Pulumi and GCP credentials are correctly set up and that you have permission to create resources in your GCP account.