Deploy the aws-node-termination-handler-2 helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Azure Kubernetes Service (AKS), you will first need to set up an AKS cluster. AKS is a managed container orchestration service provided by Azure that simplifies the deployment, management, and operations of Kubernetes.

Once the AKS cluster is up and running, we'll use Pulumi's Kubernetes provider to deploy the "aws-node-termination-handler-2" Helm chart onto our Azure Kubernetes cluster. Please note that the Helm chart you're asking to deploy seems to be AWS specific, and it's uncommon to deploy an AWS-associated Helm chart on an Azure cluster. However, assuming that the Helm chart is compatible with AKS regardless of its AWS-specific naming, the process below should generally apply to any Helm chart.

Here is a step-by-step guide of the process:

1. **Create AKS Cluster**: We will declare the infrastructure for an AKS cluster using Pulumi's `azure-native` provider, which interacts with the resources on Azure platform natively.

2. **Install Helm Chart**: Once the AKS cluster is provisioned and configured, we'll use the `@pulumi/kubernetes` package to interact with the cluster to install the aws-node-termination-handler-2 Helm chart.

Below is a program written in TypeScript that demonstrates these steps:

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

// Step 1: Creating AKS Cluster
// Define the AKS-managed cluster resource
const aksCluster = new azure.containerservice.ManagedCluster("myAksCluster", {
    // Replace with your preferred settings
    resourceGroupName: "myResourceGroup",
    kubernetesVersion: "1.18.14",
    agentPoolProfiles: [{
        name: "agentpool",
        count: 2,
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: "myakscluster",
});

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

// Step 2: Install Helm Chart
// Define a Kubernetes provider instance using the AKS cluster's kubeconfig
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: aksCluster.kubeConfigRaw,
});

// Deploy the aws-node-termination-handler-2 Helm chart on your AKS cluster
const awsNodeTerminationHandlerChart = new k8s.helm.v3.Chart("aws-node-termination-handler", {
    chart: "aws-node-termination-handler",
    repositoryOpts: {
        repo: "https://aws.github.io/eks-charts",
    },
    version: "2.x.x", // specify the version you wish to install
    // values for the Helm chart should be set based on the respective chart's documentation
}, { provider: k8sProvider });

// Export the resources
export const aksClusterName = aksCluster.name;
export const helmChartName = awsNodeTerminationHandlerChart.metadata.apply(m => m.name);
```

This program will create a new AKS cluster and install the specified Helm chart using Pulumi.

Here are the main components:

- The creation of an AKS cluster is done by defining `azure.containerservice.ManagedCluster`. Here, you can specify the properties for your cluster, such as node size (`vmSize`), number of nodes (`count`), DNS prefix, and the Kubernetes version.

- After the AKS cluster resource is declared, we use `aksCluster.kubeConfigRaw` to get the raw kubeconfig from the generated AKS cluster, which is necessary for configuring the Kubernetes provider.

- We then set up a Pulumi Kubernetes provider with this kubeconfig. This provider will be responsible for deploying Kubernetes resources on the AKS cluster.

- Finally, we install the Helm chart named "aws-node-termination-handler" by declaring `k8s.helm.v3.Chart`. We specify the chart version and any configurations that match the respective chart's documentation.

Remember, when applying this program, Pulumi needs to be [configured with Azure](https://www.pulumi.com/registry/packages/azure-native/installation-configuration/) and [Azure Container Service (AKS)](https://www.pulumi.com/registry/packages/azure-native/api-docs/containerservice/managedcluster/) specifically.

You can simply place this code in a file named `index.ts` and run `pulumi up` to deploy the infrastructure. Pulumi will perform the deployment and display the changes to be made before confirming to proceed.

Please ensure that you've already installed Pulumi, set up the Azure CLI, and logged in into both Pulumi and Azure before executing this program. If you have any further questions or need clarification on the above code, feel free to ask!