Deploy the mongodb-cluster helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

Deploying a MongoDB cluster using Helm on Azure Red Hat OpenShift (ARO) involves several steps. First, you will need to provision an OpenShift cluster. For this, we will use the `azure-native.redhatopenshift.OpenShiftCluster` resource. Once the OpenShift cluster is up and running, you can deploy a MongoDB cluster Helm chart using the `kubernetes.helm.sh/v3.Chart` resource.

A `Chart` resource represents a Helm chart in a Kubernetes cluster which, in this case, we will use to deploy MongoDB. Below is a Pulumi program in TypeScript that demonstrates how to carry out these tasks:

- It sets up an ARO cluster.
- Then, it configures the Kubernetes provider to point to the created ARO cluster.
- Finally, it deploys the MongoDB Helm chart to that ARO cluster.

Let's take a look at the code:

```typescript
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
import * as k8s from "@pulumi/kubernetes";
import * as openshift from "@pulumi/azure-native/redhatopenshift";

// Create an Azure Resource Group
const resourceGroup = new azure_native.resources.ResourceGroup("rg", {
    location: "EastUS", // Change the location if needed
});

// Create an Azure Red Hat OpenShift Cluster
const openshiftCluster = new openshift.OpenShiftCluster("openshiftCluster", {
    resourceGroupName: resourceGroup.name,
    resourceName: "myAROCluster", // Change the cluster name if needed
    location: resourceGroup.location,
    masterProfile: {
        vmSize: "Standard_D8s_v3",
        // Specify the subnetId if you have an existing Virtual Network or Subnet you wish to use
    },
    // ... other necessary configurations for the ARO cluster
});

// Once the Openshift cluster is ready, we will use its kubeconfig to deploy the MongoDB chart.
// Register the Openshift cluster kubeconfig as a new Kubernetes provider instance.
const openshiftProvider = new k8s.Provider("openshiftK8s", {
    kubeconfig: openshiftCluster.kubeconfig,
});

// Deploy the MongoDB Helm chart using the Helm provider.
const mongodbChart = new k8s.helm.v3.Chart("mongodb", {
    chart: "mongodb",
    version: "10.23.13", // Specify the chart version you want to deploy
    fetchOpts:{
        repo: "https://charts.bitnami.com/bitnami",
    },
}, { provider: openshiftProvider });

// Export the URL to access the MongoDB Helm Chart deployment
export const mongodbUrl = pulumi.interpolate`mongodb://${mongodbChart.getResourceProperty("v1/Service", "mongodb", "status").apply(status => status.loadBalancer.ingress[0].ip)}`;
```

This program performs the following actions:

1. Imports the required Pulumi modules for working with resources and providers.
2. Creates a new Azure Resource Group to contain our ARO cluster resources.
3. Provisions a new ARO cluster within the defined Resource Group using the `OpenShiftCluster` resource.
   - Sets the location of the Resource Group (and by extension, the ARO cluster).
   - Sets a name for the OpenShift Cluster.
   - Specifies the VM size for the master nodes of the OpenShift cluster.
   - (Additional configurations may be required depending on your specific requirements for networking, authentication, etc.)
4. Once the OpenShift Cluster is created, it captures the `kubeconfig`, which is used by Pulumi to configure a Kubernetes provider corresponding to the ARO cluster.
5. Deploys the MongoDB Helm chart into the ARO cluster using the Kubernetes provider.
   - Specifies the chart name ("mongodb") and the version.
   - Specifies the repository where the MongoDB chart is located.
   - Associates this Helm chart deployment with the Kubernetes provider that points to our ARO cluster.
6. Exports a URL that can be used to access the deployed MongoDB cluster services once it's up and running.

Remember, before running this code, ensure that you've set up:

- Pulumi CLI and the relevant Pulumi account.
- Azure credentials configured for Pulumi to access your Azure subscription.
- The Azure-native Pulumi provider to create Azure-based resources.

Please install the required dependencies for the TypeScript program using npm:

```bash
npm install @pulumi/pulumi @pulumi/azure-native @pulumi/kubernetes
```

Once you've installed your dependencies and set up your cloud environment, you can run `pulumi up` to deploy this infrastructure and the MongoDB cluster. Make sure to review the details provided by the command and confirm the deployment when prompted.

After successful deployment, `pulumi` will output the `mongodbUrl`, which you can use to access the MongoDB cluster. Keep in mind that the actual MongoDB connection string will depend on your MongoDB setup details such as authentication credentials and database names, which are beyond the scope of this infrastructure code.