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

Question

Pulumi · Accepted Answer

To accomplish the deployment of a Helm chart on Azure Kubernetes Service (AKS) using Pulumi, you would typically follow a series of steps. First, you'd create an AKS cluster, and then deploy a Helm chart within that cluster. For the Helm chart deployment, the `kubernetes.helm.v3.Chart` resource is commonly used; this resource allows you to define a Helm chart deployment similarly to how you would use `helm` CLI commands, but with the added benefits of Pulumi's infrastructure as code approach.

Here is a TypeScript program that demonstrates how to create an AKS cluster and deploy a stable Helm chart to it:

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

// Create an AKS cluster.
const aksCluster = new azure.containerservice.KubernetesCluster("my-aks-cluster", {
    defaultNodePool: {
        name: "aksagentpool",
        nodeCount: 2,
        vmSize: "Standard_D2_v2",
    },
    dnsPrefix: "my-kube-dns",
    resourceGroupName: "my-resource-group",
});

// Export the kubeconfig for the AKS cluster.
const kubeconfig = aksCluster.kubeConfigRaw;
export const kubeconfigOutput = pulumi.secret(kubeconfig);

// Create a provider for the AKS cluster using the exported kubeconfig.
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Deploy a stable Helm chart into the AKS cluster.
const helmChart = new kubernetes.helm.v3.Chart("my-helm-chart", {
    chart: "nginx", // Replace with your desired Helm chart
    version: "1.16.0", // Specify the chart version. Adjust as needed.
    namespace: "default", // Specify the Kubernetes namespace.
    fetchOpts: {
        repo: "https://charts.helm.sh/stable", // Specify the chart repository.
    },
}, { provider: k8sProvider });

// You could expose any output from the Helm chart that you may need.
// export const frontendServiceIP = helmChart.getResourceProperty(
//     "v1/Service", "my-helm-chart-nginx", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

Let's break down the program:

1. We import the necessary Pulumi packages: `@pulumi/pulumi`, `@pulumi/azure`, `@pulumi/kubernetes`, and the actual Kubernetes package with helm charts `@pulumi/kubernetes`.

2. We create an AKS cluster by using the `KubernetesCluster` resource from the `@pulumi/azure` package. Here, you define the node pool, DNS prefix, and the resource group where the cluster resides.

3. The `kubeConfigRaw` output from the AKS cluster is then exported as a secret. This kubeconfig will later allow you to interact with your Kubernetes cluster.

4. Using that kubeconfig, we instantiate a Pulumi Kubernetes provider. This provider is required to deploy Kubernetes resources onto the created AKS cluster.

5. Deploy the specified Helm chart using the `kubernetes.helm.v3.Chart` resource. This resource needs details about the Helm chart and the repository where the chart is hosted. The `provider` option ensures that the Helm chart is deployed into our AKS cluster.

6. Optionally, you could export additional outputs, such as the external IP of a front-end service deployed by your Helm chart.

Please adjust the parameters such as the Helm chart to be deployed (`nginx` in the example), the chart version, and the repository URL (`https://charts.helm.sh/stable`) according to your needs. The namespace is set to `default`, but if your chart should be deployed to a different namespace, you'll need to change that as well.