Deploy the helm-mongodb-operator helm chart on Oracle Kubernetes Engine (OKE)

Question

Pulumi · Accepted Answer

To deploy the `helm-mongodb-operator` Helm chart on Oracle Kubernetes Engine (OKE), you’ll first need to define a Kubernetes cluster using OCI's Container Engine for Kubernetes. Once the cluster is provisioned, you can then use the `kubernetes` package to deploy the Helm chart.

Here's a step-by-step guide on how to do this with Pulumi:

1. **Define an OCI Kubernetes Cluster**: You’ll begin by defining an OKE cluster. The `oci.ContainerEngine.Cluster` resource allows you to create and manage a Kubernetes cluster in OCI.

2. **Interact with Kubernetes**: Once you have an OKE cluster, you can use the `kubernetes.helm.v3.Chart` resource from the `kubernetes` package to deploy charts.

3. **Deploy the Helm Chart**: With the `Chart` resource, you will specify the MongoDB operator chart. Usually, a Helm chart requires a repository and chart name, along with any configuration parameters as values.

Below is a `TypeScript` program that demonstrates these steps. Please ensure that you have configured your Pulumi environment with the appropriate OCI credentials before proceeding.

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

// Step 1: Define an OCI Kubernetes Cluster
const cluster = new oci.containerengine.Cluster("mongo-cluster", {
    // Specify the necessary properties for the OKE cluster.
    // This includes details like compartment ID, VCN configuration, node pool setup, etc.
    // The specific values will depend on your OCI environment and requirements.
});

// Assuming you have an existing VCN and subnet, you might need to configure the node pool as follows:
const nodePool = new oci.core.NodePool("mongo-node-pool", {
    clusterId: cluster.id,
    // Other properties like node shape, node source details, subnet IDs go here...
    // These would typically be provided as per your specific OCI configuration.
});

// After creating the cluster, we need to obtain the Kubeconfig file to interact with it.
// For simplicity, assume that an Output containing the kubeconfig is provided.
// In practice, you would retrieve it from the OCI API or console.
const kubeconfig = cluster.kubeconfig; // This is a simplification. Replace with actual retrieval.

// Configure the Pulumi Kubernetes Provider with kubeconfig from the OCI Kubernetes Cluster
const provider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Step 2: Deploy the Helm Chart
const mongoChart = new k8s.helm.v3.Chart("mongodb-operator", {
    chart: "mongodb-operator",
    version: "x.y.z", // replace with the chart version you're targeting
    repositoryOpts: {
        repo: "https://xyz.com/helm-charts", // replace with the actual Helm chart repository URL
    },
    // If the chart requires any custom values, specify them here.
    // values: {
    //     customValue: "custom",
    // },
}, { provider });

// The `mongoChart` resource will now deploy the MongoDB operator helm chart to your OKE cluster.

// Exports are useful for displaying information about the resources created.
export const clusterId = cluster.id;
export const nodePoolId = nodePool.id;
export const mongoOperatorChart = mongoChart.status;

```

Here's what the program does:

- It establishes an OKE cluster, which will serve as the environment where the MongoDB Operator is deployed.
- It sets up a NodePool, which is a group of worker nodes within the Kubernetes cluster. Each node in the OKE cluster is an OCI compute instance.
- It defines the necessary Kubernetes provider to interact with the newly created OKE cluster using the generated kubeconfig.
- It then defines a Helm chart resource, which represents the MongoDB Operator you want to install into your cluster. I've used placeholders for the chart version and repository URL, which you'll need to replace with actual values.
- Finally, it exports some of the key identifiers of the resources which can be used to reference them later.

Make a note that this code assumes that you have already set up the necessary network resources like VCN and subnets for your OKE cluster. You will need to fill in the details such as compartment ID, VCN configuration, and node pool setup, which are specific to your OCI environment.

This is a high-level overview to help you get started with provisioning an OKE cluster and deploying a Helm chart. However, for a complete setup, you'll need to consider additional factors such as securing your cluster, managing access permissions, and setting up monitoring and logging.