Deploy the multus-cni helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the Multus CNI Helm chart on Azure Kubernetes Service (AKS), we will take the following approach:

1. **Set Up AKS Cluster**: We will create an AKS cluster that will be the environment for our Helm chart deployment.
2. **Install Helm Chart**: Once the AKS cluster is set up, we will use Pulumi's `helm.sh/v3.Chart` resource to install the Multus CNI Helm chart into the AKS cluster. Multus CNI is a container network interface (CNI) plugin for Kubernetes that enables attaching multiple network interfaces to pods, which can be particularly useful for workloads that require high-performance networking.

First, we will write a Pulumi program in TypeScript. This program will include two main parts:
- Creating the AKS cluster using the `azure-native:containerservice:ManagedCluster` resource.
- Using the `kubernetes.helm.v3.Chart` resource to deploy Multus CNI Helm chart onto the newly created AKS cluster.

The program assumes you have already authenticated to Azure and have the required permissions to create resources in your Azure subscription. Pulumi will use your Azure CLI credentials by default.

Below is the TypeScript program that performs the above actions:

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

// Create a new Azure Resource Group
const resourceGroup = new azure.resources.ResourceGroup("myResourceGroup");

// Create an AKS cluster
const managedCluster = new azure.containerservice.ManagedCluster("myAksCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 3,
        maxPods: 110,
        mode: "System",
        name: "agentpool",
        osDiskSizeGB: 30,
        osType: "Linux",
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: `${pulumi.getStack()}-kube`,
    enableRBAC: true,
    kubernetesVersion: "1.18.14",
    linuxProfile: {
        adminUsername: "adminuser",
        ssh: {
            publicKeys: [{
                keyData: "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC..." // your SSH public key
            }],
        },
    },
    nodeResourceGroup: `MC_${resourceGroup.name}_myAksCluster_${pulumi.getStack()}`,
    resourceGroupName: resourceGroup.name,
});

// Export the cluster's kubeconfig
export const kubeconfig = pulumi.
    all([managedCluster.name, resourceGroup.name]).
    apply(([clusterName, rgName]) => {
        return azure.containerservice.listManagedClusterUserCredentials({
            resourceGroupName: rgName,
            resourceName: clusterName,
        });
    }).apply(creds => {
        const encoded = creds.kubeconfigs[0].value;
        return Buffer.from(encoded, 'base64').toString();
    });

// Create a Kubernetes provider instance that uses our cluster from above.
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: kubeconfig,
});

// Now we have the AKS cluster running and have the provider ready,
// we can deploy Multus CNI using the Helm chart.

// The name of the Helm chart we want to deploy
const multusChartName = "multus";

// Deploy a Helm chart using the Kubernetes provider
const multusCniChart = new k8s.helm.v3.Chart(multusChartName, {
    chart: "multus",
    version: "3.7.1", // specify the exact chart version
    namespace: "kube-system", // deploying chart under 'kube-system' namespace
    fetchOpts: { 
        repo: "https://k8snetworkplumbingwg.github.io/multus-cni/", // Multus CNI Helm repo URL
    },
}, { provider: k8sProvider });

// Export the name of the chart
export const multusChart = multusCniChart.ready.map(_ => `${multusChartName} helm chart is deployed`);
```

In this program:
- We begin by creating a new Azure Resource Group to hold all of our resources.
- We then create a Managed AKS cluster with a designated agent pool, enable RBAC, and configure SSH access (replace the public key with your own).
- We extract the kubeconfig needed to interact with the AKS cluster via the Kubernetes provider.
- We then initialize the Kubernetes provider with our AKS kubeconfig.
- We deploy the Multus CNI Helm chart by declaring a `kubernetes.helm.v3.Chart` resource, passing it the chart name, version, namespace, and the repository URL where the chart can be found.
- Lastly, we export the kubeconfig and the deployment status for easy access to the cluster and verification of the deployment.

To run this program, save it as `index.ts`, and ensure you have Pulumi installed and configured to interact with your Azure account. Then you can execute the Pulumi CLI commands to create the resources defined in your program:

```bash
pulumi stack init multus-deployment
pulumi up
```

Please read through the comments to understand each step of the deployment and adjust any values to match your requirements, such as the SSH public key and AKS version. Remember to replace the public key placeholder with your actual SSH public key to ensure secure access to your nodes.