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

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Azure Kubernetes Service (AKS) using Pulumi, you will need to perform a series of steps. The deployment will involve creating an AKS cluster and then deploying the `test-helm` Helm chart onto that cluster.

Here is a systematic approach to what needs to be done:

1. **Set up an AKS Cluster**: This involves creating a new AKS cluster in your Azure environment using the `azure-native.hybridcontainerservice.ProvisionedCluster` resource. This cluster will be the foundation where your Kubernetes applications and workloads will run.

2. **Deploy Helm Chart**: The next step is to deploy your Helm chart onto the AKS cluster. For this, you'll use the `kubernetes.helm.v3.Chart` resource from the Kubernetes provider for Pulumi. The Helm provider will manage the release of the Helm chart on your cluster.

Below is a TypeScript program that uses Pulumi to create an AKS cluster and deploy the `test-helm` Helm chart to it. Make sure you have `@pulumi/azure-native` and `@pulumi/kubernetes` packages installed in your Node.js project and you've configured your Pulumi for Azure. Also, ensure you have access to the Helm chart you want to deploy (`test-helm` in this case).

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

// Create an AKS cluster.
const resourceGroupName = new azure.resources.ResourceGroup("myResourceGroup");
const aksCluster = new azure.containerservice.ManagedCluster("myAKSCluster", {
    resourceGroupName: resourceGroupName.name,
    agentPoolProfiles: [{
        count: 1,
        maxPods: 110,
        mode: "System",
        name: "agentpool",
        osDiskSizeGB: 30,
        osType: "Linux",
        type: "VirtualMachineScaleSets",
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: "myakscluster",
    enableRBAC: true,
    kubernetesVersion: "1.18.14",
    linuxProfile: {
        adminUsername: "adminuser",
        ssh: {
            publicKeys: [{
                keyData: "ssh-rsa ...",  // replace with your SSH public key
            }],
        },
    },
});

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

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

// Deploy the `test-helm` Helm chart onto the AKS cluster.
const testHelmChart = new k8s.helm.v3.Chart("testHelmChart", {
    chart: "test-helm",
    version: "0.1.0", // replace with the desired chart version
    fetchOpts: {
        repo: "http://charts.example.com/", // replace with the URL of your Helm chart repository
    },
}, { provider: k8sProvider });

// Export the public IP to access the Helm chart application
export const publicIP = testHelmChart.getResourceProperty("v1/Service", "test-helm", "status")
    .apply(status => status.loadBalancer.ingress[0].ip);
```

### Explanation:

- A resource group is created to organize the resources in Azure.
- An AKS cluster is instantiated with a specified version and a minimal configuration. You should customize the SSH key, node size, and Kubernetes version to suit your scenario.
- We obtain the kubeconfig for the newly created AKS cluster, which allows us to interact with the cluster using the Kubernetes API.
- A Kubernetes provider is then created, configured to use the fetched kubeconfig. This provider ensures that Pulumi knows how to deploy resources to our AKS cluster.
- Finally, we deploy a Helm chart using the `test-helm` name. You must replace the `chart` and `version` fields with the details of the Helm chart you want to deploy, as well as the `repo` parameter with the URL of your Helm chart repository.

The `publicIP` exported at the end will display the ingress IP address which you can use to access your deployed Helm chart application if it is a web service or similar.

To apply these changes with Pulumi, save the above code in a file named `index.ts`, and then run the following CLI commands:

```bash
pulumi up
```

These will prompt you to create a new stack (if you haven't created one already), display a preview of the changes, and execute the deployment if confirmed. The resources will be created in the order specified in the program, with Pulumi understanding and taking care of dependencies between resources.