Deploy the mongo helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy the MongoDB Helm chart on DigitalOcean Kubernetes Service using Pulumi, you'll need to follow these steps:

1. **Set up a DigitalOcean Kubernetes Cluster**: You need to have a Kubernetes cluster up and running in DigitalOcean before you can deploy applications on it. We'll use the `digitalocean.KubernetesCluster` resource to create one.
2. **Install the Helm Chart for MongoDB**: Once the cluster is set up, you can use the `kubernetes.helm.v3.Chart` resource to deploy MongoDB via Helm. Helm charts abstract the complexity of deploying software on Kubernetes and provide configurable parameters.

Below is the TypeScript program using Pulumi that performs these steps:

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

// Step 1: Provision a DigitalOcean Kubernetes Cluster.
const cluster = new digitalocean.KubernetesCluster("mongo-cluster", {
    region: "nyc3",
    version: "latest", // Use the latest available version of Kubernetes
    nodePool: {
        name: "default",
        size: "s-2vcpu-2gb",
        nodeCount: 2,
    },
});

// Step 2: Deploy MongoDB Helm chart onto the cluster.
// First, we'll need to set up a Kubernetes provider instance to interact with the newly created cluster.
const k8sProvider = new kubernetes.Provider("do-k8s-provider", {
    kubeconfig: cluster.kubeConfigs[0].rawConfig,
});

// Now deploy the MongoDB chart using the kubernetes.helm.v3.Chart class.
const mongoChart = new kubernetes.helm.v3.Chart("mongo-chart", {
    chart: "mongodb",
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
    // Provide any custom values to the Helm chart.
    // For all available chart values: https://artifacthub.io/packages/helm/bitnami/mongodb
    values: {
        // Example: custom MongoDB root password and replica set configuration
        auth: {
            rootPassword: "my-mongo-root-password",
            replicaSet: {
                enabled: true,
                name: "rs0",
            },
        },
    },
}, { provider: k8sProvider });

// Export the cluster kubeconfig and MongoDB service endpoint.
export const kubeconfig = cluster.kubeConfigs[0].rawConfig;
export const mongoServiceEndpoint = pulumi.interpolate`mongodb://${mongoChart.getResourceProperty("v1/Service", "mongo-chart-mongodb", "status").apply(status => status.loadBalancer.ingress[0].ip)}:27017`;
```

Here's an explanation of what each part of the code does:

- **DigitalOcean Kubernetes Cluster**: The `digitalocean.KubernetesCluster` class is used to create a Kubernetes cluster. We specify the region where the cluster will reside (`nyc3` in this case), the Kubernetes version (`latest` to use the latest stable version), and the node pool configuration (2 nodes with the `s-2vcpu-2gb` plan).

- **Kubernetes Provider**: When interfacing with Kubernetes, Pulumi uses providers to manage the lifecycle of resources. The `kubernetes.Provider` is configured with the kubeconfig from the DigitalOcean cluster, allowing Pulumi to communicate with the cluster.

- **MongoDB Helm Chart**: The `kubernetes.helm.v3.Chart` class is what Pulumi uses to deploy Helm charts. In this case, we specify the `mongodb` chart from Bitnami's Helm repository. We also provide custom values for MongoDB authentication and replication.

Lastly, the code exports two important pieces of information. The `kubeconfig` allows you to interface with the Kubernetes cluster using `kubectl` or any compatible tool, while the `mongoServiceEndpoint` provides the address you can use to connect to MongoDB once the deployment is complete.

To run this Pulumi program:

1. Install Pulumi CLI on your machine and set up the DigitalOcean access token.
2. Run `pulumi new typescript` to create a new Pulumi project.
3. Replace the content of `index.ts` with the code above.
4. Run `npm install` to get the required Pulumi packages.
5. Run `pulumi up` to deploy the resources to DigitalOcean.

Once the deployment is complete, you will receive the kubeconfig and MongoDB service endpoint as part of your stack's outputs.