Deploy the mongo helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the MongoDB Helm chart on Azure Kubernetes Service (AKS), you will need to perform a series of steps:

1. **Create an AKS Cluster**: This is the managed Kubernetes service provided by Azure where your MongoDB Helm chart will be deployed.

2. **Install Helm**: Helm is a package manager for Kubernetes, which simplifies deployment of applications and services.

3. **Add the Helm Chart Repository**: For deploying MongoDB, you will need to add the repository that contains the MongoDB Helm charts.

4. **Deploy the Helm Chart**: Use Helm to deploy the MongoDB chart to your AKS cluster.

For this task, we will write a Pulumi program in TypeScript to create an AKS cluster. After the cluster is created, you would generally use Helm CLI to deploy MongoDB chart into the cluster. However, Pulumi can also work with Helm charts directly!

Below is a Pulumi program that creates an AKS cluster and deploys MongoDB using Helm. Note that Pulumi manages the state and operations asynchronously, so cloud resource provisioning is handled efficiently.

### Detailed Explanation and Pulumi TypeScript Program

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

// Step 1 - Create a new Azure Resource Group
const resourceGroup = new azure.core.ResourceGroup("myResourceGroup");

// Step 2 - Create an Azure AD Application for the AKS cluster
const app = new azuread.Application("myApp");

// Step 3 - Create a Service Principal for the Application
const servicePrincipal = new azuread.ServicePrincipal("myServicePrincipal", {
    applicationId: app.applicationId,
});

// Step 4 - Create the Service Principal Password
const servicePrincipalPassword = new azuread.ServicePrincipalPassword("myServicePrincipalPassword", {
    servicePrincipalId: servicePrincipal.id,
});

// Step 5 - Create the AKS cluster
const cluster = new azure.containerservice.KubernetesCluster("myAksCluster", {
    resourceGroupName: resourceGroup.name,
    defaultNodePool: {
        name: "default",
        nodeCount: 2,
        vmSize: "Standard_DS2_v2",
    },
    dnsPrefix: "myakscluster",
    linuxProfile: {
        adminUsername: "adminuser",
        sshKey: {
            keyData: "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQD3b......", // replace with your public SSH key
        },
    },
    servicePrincipal: {
        clientId: app.applicationId,
        clientSecret: servicePrincipalPassword.value,
    },
});

// Step 6 - Deploy MongoDB using the Helm Chart
const mongoDb = new k8s.helm.v3.Chart("mongodb", {
    chart: "mongodb",
    version: "10.28.4", // specify the exact version to ensure the chart works correctly with Pulumi
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig: cluster.kubeConfigRaw }) });

// Export the kubeconfig for the AKS cluster
export const kubeConfig = cluster.kubeConfigRaw;

// Export the MongoDB service endpoint
export const mongoDbEndpoint = pulumi.interpolate `mongodb://${mongoDb.getResourceProperty("v1/Service", "mongodb", "metadata").apply(m => m.name)}.${resourceGroup.name}.svc.cluster.local`;
```

### Explanation:

- **Resource Group**: A resource group is a container that holds related resources for an Azure solution.

- **Azure AD Application**: AKS needs this to interact with Azure APIs.

- **Service Principal and Password**: This is an identity for the application; AKS uses it to access Azure resources.

- **AKS Cluster**: This is the managed Kubernetes cluster where we will deploy MongoDB.

- **Helm Chart for MongoDB**: We use the Bitnami Helm chart for MongoDB. The version provided here is an example and may need to be updated to the latest stable version available. The repository URL points to Bitnami's Helm chart repository where the MongoDB chart is hosted.

- **Kubeconfig**: The configuration file for accessing the AKS cluster with kubectl.

- **MongoDB Endpoint**: The endpoint through which you can connect to MongoDB. The actual endpoint will be available after deployment.

For this Pulumi program to run, you will need to replace the SSH key data with your own public SSH key. To get the SSH key into the variable, you would typically create and use an SSH key pair dedicated to this AKS cluster.

Lastly, after all resources have been declared, the program exports the `kubeConfig` and the `mongoDbEndpoint`. These outputs can be used to interact with the AKS cluster and the MongoDB service, respectively.

Please ensure you have Pulumi CLI installed and configured for Azure access. Once you have Pulumi set up, you can run the above program using the Pulumi CLI to create these resources on Azure and deploy MongoDB through Helm.