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

Question

Pulumi · Accepted Answer

To deploy a UI Helm chart on an Azure Kubernetes Service (AKS) cluster with Pulumi, you'll need to go through several steps. First, you'll set up an AKS cluster. Then, you'll deploy the UI Helm chart to your AKS cluster. Below, I'll explain each step and provide you with the corresponding Pulumi TypeScript code.

1. **Creating an AKS Cluster**: You will begin by creating an AKS cluster using the `ProvisionedCluster` resource from the `azure-native` provider. This will be your Kubernetes environment where your Helm chart will be deployed.

2. **Deploying a Helm Chart**: After the AKS cluster is set up, you will then deploy the Helm chart using the `Chart` resource from the Kubernetes provider, which is capable of deploying Helm charts on a Kubernetes cluster.

Here is the TypeScript program that accomplishes both of these steps:

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

const main = async () => {
    // Step 1: Create an AKS cluster
    const resourceGroup = new azureNative.resources.ResourceGroup("myResourceGroup");

const cluster = new azureNative.containerService.ManagedCluster("myAKSCluster", {
        resourceGroupName: resourceGroup.name,
        agentPoolProfiles: [{
            count: 2,
            maxPods: 110,
            mode: "System",
            osType: "Linux",
            vmSize: "Standard_DS2_v2",
            name: "agentpool",
        }],
        dnsPrefix: "myakscluster",
        kubernetesVersion: "1.20.9",
        linuxProfile: {
            adminUsername: "adminuser",
            ssh: {
                publicKeys: [{
                    keyData: "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQD1b...", // Replace with your SSH public key
                }],
            },
        },
    });

// Export the kubeconfig
    const creds = pulumi.all([cluster.name, resourceGroup.name]).apply(([clusterName, rgName]) =>
        azureNative.containerService.listManagedClusterUserCredentials({
            resourceName: clusterName,
            resourceGroupName: rgName,
        }));

const kubeconfig = creds.apply(creds => Buffer.from(creds.kubeconfigs[0].value, 'base64').toString());

// Step 2: Deploy a Helm chart
    const k8sProvider = new kubernetes.Provider("k8sProvider", {
        kubeconfig: kubeconfig,
    });

const uiChart = new kubernetes.helm.v3.Chart("ui-chart", {
        chart: "nginx", // Replace with your actual Helm chart name
        version: "1.16.0", // Specify the chart version
        fetchOpts: {
            repo: "https://charts.bitnami.com/bitnami", // Replace with the chart's repository URL
        }
    }, { provider: k8sProvider });

// Export the public endpoint of the UI service
    const service = uiChart.getResource("v1/Service", "my-ui-service");
    export const uiServiceIp = service.status.apply(s => s.loadBalancer.ingress[0].ip);
};

main();
```

In the code above, you will need to replace placeholders (like the SSH public key and Helm chart details) with your own values.

- The `ManagedCluster` resource creates an AKS cluster within the provided resource group. Adjust the `agentPoolProfiles` to match the size and number of nodes you need.
- The `listManagedClusterUserCredentials` function retrieves the credentials needed to interact with your AKS cluster, which are then used to configure the Kubernetes provider.
- The `Chart` class from the `pulumi/kubernetes` package is used to deploy the Helm chart. We specify the chart name and version, and provide the repository URL where the chart is hosted.
- We use `getResource` to access the Kubernetes `Service` deployed by the Helm chart and export its public IP address.

Please make sure that you have Pulumi CLI installed and configured for Azure before running this program. You might also want to install `kubectl` to interact with your cluster directly. Once you have Pulumi installed, you can use the Pulumi CLI to create a new stack and then run `pulumi up` to create the resources in Azure.