Deploy the mongodb-backup-aws helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To achieve the deployment of a Helm chart, specifically mongodb-backup-aws, on Azure Kubernetes Service (AKS), we'll be undertaking a multi-step process involving the following main tasks:

Provision an AKS cluster using the ProvisionedCluster resource from the azure-native/hybridcontainerservice package. We need an AKS cluster as the environment to deploy and run our Helm chart.
Once we have our AKS cluster, we can then proceed to deploy the Helm chart using Pulumi's Helm support. The Chart resource from the @pulumi/kubernetes/helm/v3 package will be used here to deploy mongodb-backup-aws. The Chart resource abstracts Helm operations in a way that Pulumi can manage the lifecycle of Helm charts as part of its infrastructure as code.

Below is a TypeScript program that uses Pulumi to perform these tasks:

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
import * as k8s from "@pulumi/kubernetes";

// STEP 1: Provision an AKS cluster
// You'd often want to customize these properties based on your specific needs,
// such as changing the location or node count. You would also use a configuration
// file or Pulumi config system to avoid hardcoding these values.

const resourceGroupName = new azure_native.resources.ResourceGroup("myResourceGroup", {
    location: "eastus",
});

const aksCluster = new azure_native.hybridcontainerservice.ProvisionedCluster("myCluster", {
    resourceGroupName: resourceGroupName.name,
    location: resourceGroupName.location,
    identity: {
        type: "SystemAssigned",
    },
    properties: {
        linuxProfile: {
            adminUsername: "adminuser",
            ssh: {
                publicKeys: [{
                    keyData: "<YOUR-SSH-PUBLIC-KEY>",
                }],
            },
        },
        controlPlane: {
            vmSize: "Standard_B2s", // You can select the appropriate VM size for your use case.
        },
        // Network config, node pools, and other settings would go here.
    },
});

// STEP 2: Deploy the Helm chart for mongodb-backup-aws on the AKS cluster
// Once the AKS cluster is provisioned, we will configure the Kubernetes provider
// to connect to the AKS cluster. Then we use that provider to install the Helm chart.

// Output the kubeconfig from the AKS cluster
const aksKubeconfig = pulumi.all([resourceGroupName.name, aksCluster.name]).apply(([rgName, clusterName]) =>
    azure_native.hybridcontainerservice.listProvisionedClusterUserCredentials({
        resourceName: clusterName,
        resourceGroupName: rgName,
    }).then(creds => {
        const kubeconfigEncoded = creds.kubeconfigs[0].value;
        return Buffer.from(kubeconfigEncoded, "base64").toString();
    })
);

// Use the kubeconfig to create a K8s provider
const k8sProvider = aksKubeconfig.apply(kc => new k8s.Provider("k8sProvider", {
    kubeconfig: kc,
}));

// Define the Helm chart resource for mongodb-backup-aws
const chart = new k8s.helm.v3.Chart("mongodb-backup-aws", {
    chart: "mongodb-backup-aws",
    version: "1.0.0", // Replace with the desired chart version
    fetchOpts: {
        repo: "https://example.com/charts", // Replace with the Helm repository URL
    },
    values: {
        // Add any values here that your chart requires
    },
}, { provider: k8sProvider });

// Export the cluster's kubeconfig and the chart's status as outputs
export const kubeconfig = aksKubeconfig;
export const chartStatus = chart.status;

// Note: Ensure to replace placeholders such as "<YOUR-SSH-PUBLIC-KEY>" and the Helm
// repository URL with actual values for your deployment. Additionally, the chart `version`
// and `values` may need to be adjusted based on the specific Helm chart you are deploying.

This program does the following:

Creates an Azure resource group to contain our AKS deployment.
Defines a new AKS cluster with a Linux profile and an SSH public key for administrator access.
Retrieves the kubeconfig output from the aksCluster, which is necessary to communicate with the AKS cluster.
Constructs a new Pulumi Kubernetes provider (k8sProvider) in TypeScript, using the kubeconfig of the provisioned AKS cluster.
Defines a Helm chart resource to deploy mongodb-backup-aws, referencing the Helm chart and the repository it's hosted on, as well as any configuration values that might be needed for the chart.
Exports the kubeconfig and the chart status, allowing us to interact with the AKS cluster using kubectl and view the deployment status.

Before running this program, you need to replace placeholders with actual values that apply to your deployment. This includes <YOUR-SSH-PUBLIC-KEY> for the SSH access to the nodes, as well as the Helm chart repository URL and any necessary configuration values (in the values object) that are required for mongodb-backup-aws.

After setting up and running this Pulumi program with pulumi up, you will have an AKS cluster running and ready, with the mongodb-backup-aws Helm chart deployed on it.

Make sure you have the Pulumi CLI installed, and you are logged in to both Pulumi and Azure. Once the program runs successfully, the AKS cluster and the Helm chart are deployed, and you will receive the kubeconfig required to interact with your AKS cluster.