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

Question

Pulumi · Accepted Answer

To deploy a Helm chart onto an Azure Kubernetes Service (AKS) cluster using Pulumi, you'll need to orchestrate several steps: create the AKS cluster, install the necessary dependencies for Helm, and finally deploy the chart itself.

Here's how you can do that with Pulumi using TypeScript.

1. **Define your AKS Cluster:**
   You'll start by authoring a Pulumi program to provision your AKS cluster. For this scenario, I'll use the `azure-native` provider as it directly interacts with Azure resources.
   
2. **Install the Helm Chart:**
   Once your AKS cluster is set up, you'll want to install a Helm chart into it. For that, you'll use the `kubernetes` provider to interact with Kubernetes.

3. **Deploy the Helm Chart:**
   Finally, you'll define the `Chart` resource that represents your "weird" Helm chart. Pulumi can pull Helm charts from any chart repository, or from a local path if your chart is hosted there.

I will now show you the code on how to do this. Each step will have comments to guide you through the process.

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

// Step 1: Define the AKS cluster.
const resourceName = "myAKSCluster"; // Change with your desired resource name
const resourceGroupName = new azure.resources.ResourceGroup(resourceName);

const cluster = new azure.containerservice.ManagedCluster(resourceName, {
    resourceGroupName: resourceGroupName.name,
    agentPoolProfiles: [{
        count: 1,
        maxPods: 110,
        mode: "System",
        name: "agentpool",
        osDiskSizeGB: 30,
        osType: "Linux",
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: resourceName,
    enableRBAC: true,
    kubernetesVersion: "1.19.11",
    linuxProfile: {
        adminUsername: "adminuser",
        ssh: {
            publicKeys: [{
                keyData: "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCe /....== Generated by Azure", // replace with your public SSH key
            }],
        },
    },
    nodeResourceGroup: `MC_${resourceName}`,
});

// Export the kubeconfig - this allows us to interact with the cluster programmatically
export const kubeconfig = pulumi.
    all([cluster.name, resourceGroupName.name]).
    apply(([clusterName, rgName]) => {
        let creds = azure.containerservice.listManagedClusterUserCredentials({
            resourceGroupName: rgName,
            resourceName: clusterName,
        });
        return creds.kubeconfigs[0].value.apply(enc => Buffer.from(enc, 'base64').toString());
    });

// Step 2: Configure the Kubernetes provider using the kubeconfig from the AKS cluster created above.
const k8sProvider = new k8s.Provider(resourceName, {
    kubeconfig: kubeconfig,
});

// Step 3: Deploy the Helm chart into AKS.
const chart = new k8s.helm.v3.Chart("myWeirdChart", {
    chart: "weirdChartName", // Replace with the real chart name
    version: "1.0.0", // Specify the chart version
    fetchOpts: {
        repo: "http://myhelmrepo.com/" // Replace this with your Helm chart's repository URL
    },
}, { provider: k8sProvider });

// Export the resulting base URL this will be the URL to access deployed services
export const baseUrl = chart.getResourceProperty("v1/Service", "myWeirdChart-svc", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

In this code, the `ManagedCluster` resource from the `azure-native` provider creates an AKS cluster. We configure the Kubernetes provider using the `kubeconfig` obtained from the AKS cluster to interact with our Kubernetes resources.

Next, we define a `Chart` resource, which tells Pulumi to deploy the specified Helm chart `weirdChartName` into the AKS cluster we just created. Replace `weirdChartName` with the name of your chart, and the `repo` URL with the location of your Helm repository.

The last line of code exports a `baseUrl`, which assumes your Helm chart provisions a service of type LoadBalancer with an external IP; this will be the IP to access your deployed services.

To apply this Pulumi program:

1. Save this code in a file such as `index.ts`.
2. Ensure you've installed Pulumi and logged in to your account.
3. Set up your Azure credentials.
4. Run the following commands:

```sh
pulumi stack init dev
pulumi up
```

When the `pulumi up` command completes, you'll have an AKS cluster with your Helm chart deployed to it. Pulumi provides outputs after the deployment, including the `baseUrl` if applicable to your Helm chart.