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

Question

Pulumi · Accepted Answer

To deploy a Helm chart for the MongoDB Operator on a Google Kubernetes Engine (GKE) cluster using Pulumi, you'll need to follow these steps:

1. Set up a new GKE cluster or ensure you have access to an existing cluster.
2. Deploy the MongoDB Operator Helm chart to the GKE cluster.

We'll use the Pulumi `google-native` provider to create a GKE cluster. Once the cluster is available, we'll configure Pulumi to use the Kubernetes provider, which allows us to deploy Helm charts to a Kubernetes cluster.

First, ensure you have already set up your Pulumi environment with appropriate credentials to interact with Google Cloud, and you have the `pulumi` CLI installed.

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

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("mongo-cluster", {
    initialNodeCount: 3,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        // Specify the amount of memory and CPU each node will have
        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 Cluster name
export const clusterName = cluster.name;

// Export the Cluster kubeconfig
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
`;
});

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

// Deploy MongoDB Operator Helm chart using the new K8s provider
const mongoDbOperator = new k8s.helm.v3.Chart(
    "mongodb-operator",
    {
        chart: "mongodb-operator",
        version: "0.2.0",
        fetchOpts:{
            // Replace with the repository where your desired Helm chart is located.
            repo: "https://mongodb.github.io/helm-charts",
        },
    },
    { provider: k8sProvider }
);

// Export the MongoDB Operator Helm chart deployment status
export const mongoDbOperatorStatus = mongoDbOperator.status;
```

This program performs the following actions:

1. It imports the necessary Pulumi modules for Google Cloud (`gcp`), Kubernetes (`k8s`), and the base Pulumi module (`pulumi`).
2. It configures and creates a new GKE cluster with 3 nodes using the `n1-standard-1` machine type. The nodes have the required OAuth scopes to interact with Google Cloud services.
3. It exports the GKE cluster's name and generates a kubeconfig file that will be used to interact with the Kubernetes cluster.
4. It creates a Kubernetes provider that is configured to use the kubeconfig from the GKE cluster we created.
5. It deploys the MongoDB Operator Helm chart to the GKE cluster using the `k8s.helm.v3.Chart` resource of the Kubernetes provider we set up.
6. It exports the MongoDB Operator Helm chart's deployment status.

To run this program:
- Place the code in a file with a `.ts` extension, for example `index.ts`.
- Run `pulumi up` from your command line in the directory where you've saved the file to create the resources.

Make sure you have `gcloud` CLI installed and configured as the code uses `gcloud` to fetch credentials for kubeconfig generation.