Deploy the forms-catalogue helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

Deploying a Helm chart to an Azure Kubernetes Service (AKS) cluster involves several steps. We will need to create the AKS cluster and then deploy the Helm chart to it.

In this Pulumi program, we will be using the following resources:

- `azure-native.hybridcontainerservice.ProvisionedCluster`: To create an AKS cluster.
- `kubernetes.helm.sh/v3.Chart`: To deploy the Helm chart onto the AKS cluster.

Below is the Pulumi TypeScript program that achieves this:

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

// Create an Azure Resource Group
const resourceGroup = new azureNative.resources.ResourceGroup("resourceGroup", {
    // You can set your resource group name and location here
    resourceName: "myResourceGroup",
    location: "WestUS",
});

// Create an AKS cluster
const cluster = new azureNative.hybridcontainerservice.ProvisionedCluster("myAKSCluster", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    // Define the required properties for your AKS cluster
    properties: {
        kubernetesVersion: "1.18.14", // Specify the desired Kubernetes version
        dnsPrefix: "myakscluster",    // Replace with your DNS prefix
        agentPoolProfiles: [{
            count: 2,                  // Number of agent nodes
            vmSize: "Standard_DS2_v2", // VM size for the nodes
            osType: "Linux",           // Operating System
            mode: "System",            // AgentPoolMode
        }],
        linuxProfile: {
            adminUsername: "azureuser",
            ssh: {
                publicKeys: [{
                    keyData: "ssh-rsa AAAAB3N...", // Replace with your SSH public key
                }],
            },
        },
        servicePrincipalProfile: {
            clientId: "xxxxxxx",     // Replace with your client/service principal ID
            secret: "xxxxxxx",       // Replace with your service principal secret
        },
    },
});

// Get AKS credentials
const aksCreds = pulumi.all({resourceGroupName: resourceGroup.name, resourceName: cluster.name}).apply(name =>
    azureNative.hybridcontainerservice.listManagedClusterUserCredentials({
        resourceGroupName: name.resourceGroupName,
        resourceName: name.resourceName,
    }),
);

// Extract the Kubeconfig from the response
const kubeconfig = aksCreds.kubeconfigs[0].value.apply(c => Buffer.from(c, "base64").toString());

// Create a Kubernetes provider instance using the kubeconfig
const k8sProvider = new k8s.Provider("k8s", {
    kubeconfig: kubeconfig,
});

// Deploy the "forms-catalogue" Helm chart into the AKS cluster
const formsCatalogue = new k8s.helm.sh.v3.Chart("forms-catalogue", {
    chart: "forms-catalogue", // Replace with the correct chart name if different
    version: "1.0.0",         // Specify the chart version you want to deploy
    // Specify any custom values for your chart
    values: {
        // Example values - change them to suit your application's needs
        service: {
            type: "LoadBalancer",
        },
    },
}, { provider: k8sProvider });

// Export the Kubernetes cluster name and the Kubeconfig
export const kubeconfigOut = pulumi.secret(kubeconfig); // Masked for security
export const clusterName = cluster.name;
```

### Explanation:

1. We start by importing the necessary Pulumi and Azure SDKs.
2. A Resource Group is created where all the Azure resources will reside.
3. We then proceed to declare an AKS cluster with the desired properties, such as the Kubernetes version, node size, and count.
4. We retrieve the AKS cluster credentials using the `listManagedClusterUserCredentials` function.
5. The credentials obtained are used to create an instance of the Kubernetes provider, which establishes the connection to your AKS cluster.
6. We create a new Helm Chart resource specifying the chart we want to deploy.
7. Finally, we export some outputs, such as the cluster name and the generated Kubeconfig, which allows you to interact with your AKS cluster with tools like `kubectl`.

This program will create an Azure Kubernetes Service (AKS) cluster and deploy the specified Helm chart onto that cluster. Replace the placeholders with your details, such as the SSH key, service principal credentials, the Helm chart name, and any other Helm values specific to your deployment.

Please ensure your Pulumi stack is correctly configured for your Azure account and that you've installed the Pulumi CLI and initialized your project. After you set this up, you can run `pulumi up` to execute this program with Pulumi.