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

Question

Pulumi · Accepted Answer

Deploying a Helm chart on an Azure Kubernetes Service (AKS) cluster requires several steps:

1. **Provisioning an AKS Cluster**: We need to create an AKS cluster to deploy the Helm chart to. With Pulumi, we utilize the AKS-related resources in the `azure-native` package for that.

2. **Installing Helm and Tiller**: Helm is the package manager for Kubernetes, which streamlines installing and managing Kubernetes applications. Tiller is the server-side component of Helm; however, since Helm v3, Tiller is not required.

3. **Deploying the Helm Chart**: After setting up the Kubernetes cluster and Helm, we can deploy your Helm chart. Pulumi has a resource type called `Chart` from the `kubernetes` package that represents a Helm chart for easy deployment.

Now, let's see a Pulumi program that performs these steps using TypeScript.

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

// Step 1: Create an AKS cluster using Pulumi's azure-native package
const aksCluster = new azure.containerservice.ManagedCluster("kixAksCluster", {
    // Change these values to the appropriate values for your environment.
    resourceGroupName: "myResourceGroup",
    location: "East US",
    agentPoolProfiles: [{
        name: "agentpool",
        count: 1,
        vmSize: azure.containerservice.VMSizeTypes.Standard_D2_v2,
    }],
    dnsPrefix: "kixAksCluster",
});

// Export the kubeconfig for the AKS cluster
export const kubeconfig = aksCluster.kubeConfigRaw;

// Step 2: Helm and Tiller are not required to be installed separately for Helm v3

// Step 3: Deploy the Helm chart to the AKS cluster
const kixHelmChart = new k8s.helm.v3.Chart("kixChart", {
    // You need to specify the repo and chart names where your Helm chart is located.
    // For illustration, we're going to use a generic repository and chart name, but you'll need to change these to match your own.
    repo: "myhelmrepo", // Replace with your Helm repository name
    chart: "kix", // Replace with your Helm chart name
    // Add any required values for your Helm chart here
    values: {
        serviceType: "LoadBalancer",
        // Additional values as needed
    },
}, { provider: k8sProvider });

// Creating a provider with the kubeconfig from the generated AKS cluster
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: aksCluster.kubeConfigRaw,
});

// Optional: Export a URL or other output properties from a resource within the Helm chart
export const myAppUrl = kixHelmChart.getResourceProperty("v1/Service", "my-app-service", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

In the code above:

- We create an AKS cluster with a single node pool using the `azure-native.containerservice.ManagedCluster` resource.

- We omit the explicit installation of Helm v3 and Tiller since it's not required (from Helm 3 onwards, Tiller isn't used anymore).

- We deploy a generic Helm chart, here named "kix", to AKS using the `k8s.helm.v3.Chart` resource. You will need to replace `"myhelmrepo"` and `"kix"` with your Helm repository and chart name.

- We define a `k8s.Provider` which takes the kubeconfig from the AKS cluster we provisioned earlier. This provider is then used to create the Helm chart in the AKS cluster context.

- At the end of the program, we export the kubeconfig necessary to interact with the Kubernetes cluster, and optionally, a public IP address or DNS name for an application service defined in the Helm chart, if available.

Make sure that you replace placeholders with actual values suitable for your situation (e.g., the resource group name `myResourceGroup`, Helm chart repository `myhelmrepo`, etc.).

Please ensure you have the [Pulumi CLI installed](https://www.pulumi.com/docs/get-started/install/) and configured with Azure credentials. Once ready, you can save this TypeScript code to a file (e.g., `index.ts`), run `pulumi up` to preview and deploy the resources. Pulumi will handle creating the AKS cluster and deploying the specified Helm chart.