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

Question

Pulumi · Accepted Answer

To deploy the "robot" Helm chart on Azure Kubernetes Service (AKS) using Pulumi, you'll need to follow several steps:

1. **Create an AKS Cluster**: First, you need to have an AKS cluster running in your Azure subscription.
2. **Install a Helm Chart**: Once you have your Kubernetes cluster, you can deploy applications using Helm charts.

Below is a Pulumi program in TypeScript that demonstrates how to achieve this. The program is divided into two parts:

- The first part creates an AKS cluster.
- The second part deploys the "robot" Helm chart to the AKS cluster.

Before you begin, make sure you have Pulumi installed and configured with the appropriate Azure credentials. Also, ensure that you have Node.js installed to run the TypeScript program.

Let's walk through the code step-by-step.

### Step 1: Create an AKS Cluster

First, we import the necessary Pulumi and Azure Native packages and create a new AKS cluster. The `ProvisionedCluster` resource from `azure-native/hybridcontainerservice` is used to create the AKS cluster.

### Step 2: Deploy the Helm Chart

After the cluster is up and running, we use the `Chart` resource from the `kubernetes` package to deploy the Helm chart. The Helm chart named "robot" will be fetched from the specified Helm repository (if you have a specific Helm repository, replace `"my-repo"` with the correct one and `"robot"` with the chart name you require).

To establish a connection to the AKS cluster, we use the `KubeConfig` output from the AKS cluster resource, which is required by the Helm chart resource to communicate with the Kubernetes API.

Here's the Pulumi TypeScript code:

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

// Create an AKS cluster
const resourceGroup = new azure_native.resources.ResourceGroup("myResourceGroup");

const cluster = new azure_native.containerservice.ManagedCluster("myAksCluster", {
    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.21.2",
    linuxProfile: {
        adminUsername: "adminuser",
        ssh: {
            publicKeys: [{
                keyData: "ssh-rsa ...",
            }],
        },
    },
    nodeResourceGroup: "myaksnodegroup",
    resourceGroupName: resourceGroup.name,
});

// Export the cluster's kubeconfig.
export const kubeconfig = cluster.kubeConfigRaw;

// Use the kubeconfig from the generated AKS cluster to interact with the K8s cluster
const k8sProvider = new k8s.Provider("myK8sProvider", {
    kubeconfig: kubeconfig,
});

// Deploy the "robot" Helm chart into the AKS cluster
const robotChart = new k8s.helm.v3.Chart("robot", {
    repo: "my-repo", // replace with your Helm chart's repository
    chart: "robot",
    version: "1.0.0", // replace with your desired chart version
    // If the Helm chart requires additional values, fill in the `values` object.
    // values: {
    //     key1: "value1",
    //     key2: "value2",
    // },
}, { provider: k8sProvider });

// Optionally, you can export the status of the Helm release
export const robotChartStatus = robotChart.status;
```

### Explanation of the Code

- We first create a resource group that will contain our AKS cluster.
- Then we declare the AKS cluster, setting up an agent pool, enabling RBAC, configuring SSH access, and selecting the VM size and Kubernetes version.
- We export the Kubernetes configuration needed to interact with the cluster (`kubeconfig`).
- A `k8s.Provider` is defined, which uses the kubeconfig of the AKS cluster we created.
- Finally, we deploy the "robot" Helm chart to the AKS cluster using the previously defined Kubernetes provider.

After you run this Pulumi program, it will provision an AKS cluster and deploy the Helm chart, resulting in a running instance of the "robot" application on AKS.