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

Question

Pulumi · Accepted Answer

Deploying a Helm chart on Azure Kubernetes Service (AKS) using Pulumi involves several steps. I will guide you through a program that creates an AKS cluster and then deploys the Dashkiosk helm chart onto it.

First, we need to create an AKS cluster. To do that, we'll use the azure-native.containerservice.ManagedCluster Pulumi resource, which provisions a managed Kubernetes cluster on Azure.

Once we have the cluster, we'll use the kubernetes.helm.v3.Chart Pulumi resource to deploy a Helm chart onto that cluster. To manage resources on the Kubernetes cluster, we need to set up a provider that points to the newly created AKS cluster.

Here is a TypeScript program that demonstrates these steps:

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

// Create a resource group for AKS
const resourceGroup = new azure.resources.ResourceGroup("aksResourceGroup");

// Create a random password for the cluster
const password = new random.RandomPassword("password", {
    length: 20,
    special: true,
});

// Create the AKS cluster
const managedCluster = new azure.containerservice.ManagedCluster("aksCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 1,
        maxPods: 110,
        mode: "System",
        name: "agentpool",
        osDiskSizeGB: 30,
        osType: "Linux",
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: `${pulumi.getStack()}-kube`,
    linuxProfile: {
        adminUsername: "adminuser",
        ssh: {
            publicKeys: [{
                keyData: "<YOUR_SSH_PUBLIC_KEY>",
            }],
        },
    },
    servicePrincipalProfile: {
        clientId: "<YOUR_AZURE_CLIENT_ID>",
        secret: password.result,
    },
});

// Create a Kubernetes provider that uses the generated kubeconfig from the cluster
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: managedCluster.kubeConfigRaw,
});

// Deploy the Dashkiosk helm chart onto the AKS cluster
const dashkioskChart = new k8s.helm.v3.Chart("dashkiosk", {
    chart: "dashkiosk",
    version: "<CHART_VERSION>", // Replace with the desired chart version, e.g., "2.0.0"
    fetchOpts: {
        repo: "http://helm.example.com/", // Replace with the helm chart repository URL
    },
}, { provider: k8sProvider });

// Export the kubeconfig to access our cluster
export const kubeconfig = managedCluster.kubeConfigRaw;

Before running this program, you'll need to replace the placeholders with actual values:

<YOUR_SSH_PUBLIC_KEY>: Your SSH public key for securing access to the nodes within your AKS cluster.
<YOUR_AZURE_CLIENT_ID>: The client ID for the Azure service principal associated with your AKS cluster.
<CHART_VERSION>: The version of the Dashkiosk helm chart you want to deploy.
http://helm.example.com/: The repository URL where the Dashkiosk helm chart is stored.

You should also have your Azure credentials configured in your Pulumi environment. The credentials include your client ID, subscription ID, tenant ID and secret which you would typically have configured via the Azure CLI or environment variables.

To run this program, you would need to:

Install the required Pulumi packages.
Set up your Pulumi stack and Azure configuration.
Run pulumi up to deploy your stack.

This will create an AKS cluster and deploy the Dashkiosk helm chart onto it. The kubeconfig output provides you with a configuration file you can use with kubectl to interact with your AKS cluster and check the status of your helm deployment.