Deploy the helm-demo 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. You'll need to set up an AKS cluster, configure your Kubernetes provider to connect to the cluster, and then deploy the Helm chart to the cluster.

Here is a high-level overview of the steps we will take in the program:

1. Provision an AKS cluster using Pulumi's `azure-native` provider.
2. Set up a Kubernetes provider instance that knows how to communicate with the created AKS cluster.
3. Use the Helm chart resource from Pulumi's `kubernetes` provider to deploy the `helm-demo` chart to the AKS cluster.

Let's go through each of these steps in code:

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

// Step 1: Create an Azure Kubernetes Service (AKS) cluster
const resourceGroupName = new azure.resources.ResourceGroup("resourceGroup", {
  location: "East US", // You can choose the appropriate Azure region
});

const aksCluster = new azure.containerservice.ManagedCluster("aksCluster", {
  resourceGroupName: resourceGroupName.name,
  location: resourceGroupName.location,
  agentPoolProfiles: [{
    count: 1,
    maxPods: 110,
    mode: "System",
    name: "agentpool",
    osType: "Linux",
    vmSize: "Standard_DS2_v2",
  }],
  dnsPrefix: pulumi.interpolate`${resourceGroupName.name}-kube`,
});

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

// Step 2: Set up the Kubernetes provider pointing to the AKS cluster's kubeconfig
const k8sProvider = new k8s.Provider("k8sProvider", {
  kubeconfig: kubeconfig,
});

// Step 3: Deploy the `helm-demo` helm chart
const helmDemoChart = new k8s.helm.v3.Chart("helm-demo", {
  chart: "helm-demo",
  // Ensure you point to the correct repository or local path of the chart
  // If the chart is in a repository, you have to add the `repo` attribute here
  version: "1.0.0", // Substitute with the correct version of your chart
  // Add any custom values for the Helm chart here if necessary
  values: {
    service: {
      type: "LoadBalancer",
    },
  },
}, { provider: k8sProvider });

// After running `pulumi up`, the `helm-demo` chart will be installed on the AKS cluster.
```

Let's break down the code:

- We start by creating a new resource group for holding our AKS cluster.
- An AKS cluster is defined with a name, resource group, and specifications, including the number of nodes, node size, and operating system.
- We then export the kubeconfig, which allows us to interact with the AKS cluster using kubectl or any Kubernetes client. Pulumi programmatically retrieves the kubeconfig.
- We create a Pulumi Kubernetes provider and feed it with the kubeconfig from the previous step. This provider will be used to manage resources in our AKS cluster.
- Finally, we define a Helm chart resource. We select a chart named `helm-demo`, specify the version, and provide any value overrides required for the chart. The Kubernetes provider we set up earlier is passed to let Pulumi know where to deploy the chart.

To run this program, save the code in a file named `index.ts`, and run `pulumi up` in your terminal. This command will start provisioning the resources defined in the code on Azure.

Make sure you have the Pulumi CLI installed and configured with your Azure account credentials. You'll also need to have Node.js installed to execute the TypeScript program.

This program creates an AKS cluster and deploys the Helm chart named `helm-demo`. You will need to have access to the Helm chart you want to deploy and specify the correct repository or local path if it is not a chart commonly available in the public Helm repositories. Additionally, adjust the `version` and `values` fields to match the Helm chart's requirements.