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

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Azure Kubernetes Service (AKS) using Pulumi, you'll need to follow these general steps:

1. **Set up an AKS cluster:** First, an Azure Kubernetes Service (AKS) cluster needs to be provisioned. This is where your Helm chart will be deployed.

2. **Deploy the Helm chart:** Using Pulumi's Kubernetes provider, you'll apply the Helm chart that defines the application you want to run on the AKS cluster.

Here's how you can accomplish this using Pulumi and TypeScript:

### Prerequisites
Before running the Pulumi program, ensure that you have:

- An Azure account with the necessary permissions to create resources.
- Azure CLI installed and authenticated to your Azure account.
- Pulumi CLI installed and set up.
- [Node.js](https://nodejs.org/) and [npm](https://www.npmjs.com/) (or [Yarn](https://yarnpkg.com/)) installed.

### Step-by-Step Pulumi Program

#### Import Required Pulumi Packages

First, you'll need to import the Pulumi packages for Azure and Kubernetes. You can install these using npm with the following commands:

```shell
npm install @pulumi/pulumi
npm install @pulumi/azure-native
npm install @pulumi/kubernetes
```

#### Define the Pulumi Program

Next, create a new Pulumi project and use the following TypeScript code:

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

// Define the AKS cluster
const resourceGroup = new azure.resources.ResourceGroup("my-aks-group");

const aksCluster = new azure.containerservice.ManagedCluster("my-aks-cluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [
        {
            count: 1,
            maxPods: 110,
            mode: "System",
            name: "agentpool",
            osDiskSizeGB: 30,
            osType: "Linux",
            type: "VirtualMachineScaleSets",
            vmSize: "Standard_DS2_v2",
        },
    ],
    dnsPrefix: "myakscluster",
    enableRBAC: true,
    kubernetesVersion: "1.18.14",
    linuxProfile: {
        adminUsername: "adminuser",
        ssh: {
            publicKeys: [{
                keyData: "ssh-rsa YOUR_SSH_PUBLIC_KEY",
            }],
        },
    },
    nodeResourceGroup: `MC_${resourceGroup.name}_my-aks-cluster_eastus`,
    servicePrincipalProfile: {
        clientId: "YOUR_AZURE_CLIENT_ID",
        secret: "YOUR_AZURE_CLIENT_SECRET",
    },
});

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

// Deploy the Helm chart
const websample = new k8s.helm.v3.Chart("websample", {
    chart: "websample",
    version: "1.0.0",
    fetchOpts: {
        repo: "http://charts.example.com/repos",
    },
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig: kubeconfig }) });

// Export the public IP to access the websample
const ingress = websample.getResource("v1/Service", "websample", "my-nginx-ingress-controller");
export const publicIP = ingress.status.apply(status => status.loadBalancer.ingress[0].ip);
```

#### Explanation of the Program

- The program begins by creating a resource group for our AKS cluster using `azure.resources.ResourceGroup`.
- It then defines the AKS cluster using `azure.containerservice.ManagedCluster`. You need to replace placeholders such as `YOUR_SSH_PUBLIC_KEY`, `YOUR_AZURE_CLIENT_ID`, and `YOUR_AZURE_CLIENT_SECRET` with your actual SSH public key and Azure credentials.
- The `kubeconfig` output is exported, which will allow you to interact with your AKS cluster using `kubectl` or any other Kubernetes tooling.
- A new instance of `k8s.helm.v3.Chart` represents the Helm chart deployment. The `chart` and `version` properties specify which chart to deploy and which version to use. The `fetchOpts.repo` should point to the repository where your Helm chart is hosted.
- We create a Kubernetes provider using the kubeconfig of the AKS cluster, which is used to handle the Helm deployment within the cluster.
- Finally, it exports the public IP of the ingress controller that is created by the Helm chart. This allows you to access your deployed application from the internet.

To run this program:

1. Save the code in a file named `index.ts`.
2. Run `pulumi up` to create the resources. It will also output the necessary configuration for `kubeconfig` and the public IP for accessing the deployed Helm chart.

Replace the placeholders with your actual values before executing the program. Additionally, you may need to adjust Helm chart details such as `chart` and `repo` to point to your specific chart's details.

This example demonstrates deploying a Helm chart for a sample application, but the same principles apply to deploying any Helm chart to AKS using Pulumi.