Kubernetes MongoDB as a Backend for AI Dashboards

Question

Pulumi · Accepted Answer

To deploy a MongoDB instance on a Kubernetes cluster that can be used as a backend for AI Dashboards, we need to:

1. Set up a Kubernetes cluster (for the sake of this guide, we'll assume you have one set up and configured for use with Pulumi).
2. Create a dedicated namespace for MongoDB, to keep our deployment organized.
3. Use a `Deployment` to manage a MongoDB pod.
4. Use a `Service` to expose the MongoDB deployment within the cluster.
5. Optionally, you can set up a `PersistentVolume` and a `PersistentVolumeClaim` to provide durable storage for MongoDB, ensuring the data remains intact even if the MongoDB pod gets restarted.

We use Kubernetes resources from Pulumi's Kubernetes SDK in the example code. First, ensure you have the Pulumi CLI installed and configured for access to your Kubernetes cluster.

Here's a simple program to create a MongoDB deployment on Kubernetes:

```python
import pulumi
import pulumi_kubernetes as k8s

# Create a Kubernetes Namespace for MongoDB
mongo_ns = k8s.core.v1.Namespace("mongo-namespace",
    metadata={"name": "mongodb"})

# Define the MongoDB Deployment
mongo_deployment = k8s.apps.v1.Deployment("mongo-deployment",
    metadata={
        "namespace": mongo_ns.metadata["name"]
    },
    spec={
        "selector": {
            "matchLabels": {
                "app": "mongodb"
            }
        },
        "replicas": 1,
        "template": {
            "metadata": {
                "labels": {
                    "app": "mongodb"
                }
            },
            "spec": {
                "containers": [{
                    "name": "mongo",
                    "image": "mongo:4.4",
                    "ports": [{
                        "containerPort": 27017,
                        "name": "mongo"
                    }],
                    "env": [{
                        "name": "MONGO_INITDB_ROOT_USERNAME",
                        "value": "mongo_user"
                    }, {
                        "name": "MONGO_INITDB_ROOT_PASSWORD",
                        "value": "mongo_password"
                    }]
                }]
            }
        }
    })

# Expose MongoDB using a Service
mongo_service = k8s.core.v1.Service("mongo-service",
    metadata={
        "namespace": mongo_ns.metadata["name"],
        "name": "mongodb-service"
    },
    spec={
        "type": "ClusterIP",
        "ports": [{
            "port": 27017,
            "targetPort": 27017
        }],
        "selector": {
            "app": "mongodb"
        }
    })

# Export the MongoDB service name and cluster IP for access within the cluster
pulumi.export("mongo_service_name", mongo_service.metadata["name"])
pulumi.export("mongo_service_cluster_ip", mongo_service.spec["cluster_ip"])

```

In this program:

- We first create a namespace for MongoDB using `k8s.core.v1.Namespace`.
- Next, we define the MongoDB deployment with a single replica, this is done using `k8s.apps.v1.Deployment`.
- We specify the container image to be `mongo:4.4`. This image is pulled from Docker Hub and contains MongoDB server.
- The ports list contains configuration for accessing MongoDB on its default port `27017`.
- Environment variables are used to set the MongoDB root user's credentials with `MONGO_INITDB_ROOT_USERNAME` and `MONGO_INITDB_ROOT_PASSWORD`. This is not a recommended practice for production and special measures like Kubernetes Secrets should be used for managing sensitive data.
- Then, we define a `Service` of type `ClusterIP` to expose MongoDB within the cluster. Other types can be `NodePort` or `LoadBalancer`, but `ClusterIP` is usually sufficient for internal access.
- Lastly, we `export` the MongoDB service name and cluster IP that can be used to connect to the MongoDB instance from other services within the same Kubernetes cluster.

To apply this Pulumi program, save it to a file (e.g., `mongo-deploy.py`), and execute `pulumi up` in the command line, assuming your Pulumi project and stack are already configured. This will provision the resources on your Kubernetes cluster as per the configuration specified in the code.

Remember, this code sets root credentials in plain text, which is not secure for a production environment. For a production setup, consider using Kubernetes Secrets or another secure way of managing sensitive information.