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

Question

Pulumi · Accepted Answer

To deploy the Volcano Helm chart on an Azure Kubernetes Service (AKS) cluster using Pulumi, we will perform the following steps:

1. Create an AKS cluster using `azure-native.hybridcontainerservice.ProvisionedCluster`.
2. Deploy the Volcano Helm chart to the AKS cluster.

First, let's create the AKS cluster. We will need to define the necessary resources such as the resource group, the AKS cluster itself, and any additional configurations like the agent pool profile. After the AKS cluster is provisioned, we can proceed to install the Volcano Helm chart using the `kubernetes.helm.v3.Chart` resource from the Pulumi Kubernetes provider, which allows us to manage Helm charts.

Below is the TypeScript program to accomplish this:

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

// Create a new resource group for the AKS cluster
const resourceGroupName = `rg-volcano-aks-${pulumi.getStack()}`;
const resourceGroup = new azure.resources.ResourceGroup(resourceGroupName);

// Create the AKS cluster
const cluster = new azure.hybridcontainerservice.ProvisionedCluster("volcanoAksCluster", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    identity: {
        type: "SystemAssigned",
    },
    properties: {
        kubernetesVersion: "1.20.9", // Specify your desired Kubernetes version
        enableRbac: true,
        networkProfile: {
            networkPolicy: "calico", // Use Calico for network policy
        },
        agentPoolProfiles: [
            {
                count: 2, // Number of agent nodes
                vmSize: "Standard_DS2_v2", // Size of the virtual machines
                osType: "Linux",
                mode: "System",
            },
        ]
    },
});

// Get the kubeconfig of the AKS cluster
const creds = pulumi.all([cluster.name, resourceGroup.name]).apply(([name, rgName]) => {
    return azure.hybridcontainerservice.listClusterUserCredentials({
        resourceName: name,
        resourceGroupName: rgName,
    });
});
const kubeconfig = creds.apply(c => Buffer.from(c.kubeconfigs[0].value, 'base64').toString());

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

// Deploy the Volcano Helm chart using the k8s provider
const volcanoChart = new k8s.helm.v3.Chart("volcanoChart", {
    chart: "volcano",
    version: "1.2.0", // Specify the Volcano chart version you want to deploy
    fetchOpts: {
        repo: "https://volcano.sh/charts", // URL to the Helm repository where the Volcano chart is located
    },
}, { provider: k8sProvider });

// Export the kubeconfig and Volcano Helm release name
export const kubeconfigOutput = pulumi.secret(kubeconfig);
export const volcanoReleaseName = volcanoChart.getResourceName("v1/Deployment", "volcano-scheduler");
```

Here is the explanation of the Pulumi program:

- We define a resource group for organizational purposes.
- We create a new AKS cluster within the resource group. Values such as the Kubernetes version, VM size, and agent node count are specifications for the provisioned cluster, which you can adjust as needed. We enable RBAC and specify Calico as the network policy.
- We acquire the credentials for the created AKS cluster, decode the kubeconfig, and provide it to the Pulumi Kubernetes provider.
- We deploy the Volcano Helm chart to the AKS cluster using the Pulumi Kubernetes provider. For the `Chart` resource, specify the chart's name (`"volcano"`), the desired chart version, and the Helm repository URL where the Volcano chart is hosted.
- We export the kubeconfig (marked as a secret since it's sensitive information) to allow you to interact with your AKS cluster using `kubectl` and other tools.
- We also export the name of the Volcano chart deployment.

Before running this Pulumi program, ensure you have the Pulumi CLI installed and configured with Azure credentials. Then, you can use the standard Pulumi CLI commands `pulumi up` to create the resources, `pulumi stack output kubeconfig > kubeconfig.yaml` to save your kubeconfig to a file, and follow through with your Helm chart deployment.