Deploy the nginx-files-server helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the `nginx-files-server` Helm chart on Azure Kubernetes Service (AKS), you'll be taking the following steps through Pulumi:

1. **Create an AKS cluster**: You'll use the Azure Native Pulumi provider to provision an AKS cluster. This is where your Helm chart will be deployed.
   
2. **Install the Helm Chart**: Pulumi supports Helm charts as a resource type via the `Chart` class, allowing you to deploy existing Helm charts.

Here's a step-by-step Pulumi TypeScript program for deploying a Helm chart to an AKS cluster:

### Pre-requisites
Before running the Pulumi program, ensure you have the following prerequisites met:
- Pulumi CLI installed.
- Azure CLI installed and configured with the necessary permissions to create resources.
- Appropriate Pulumi program set-up (new project, stack, and config).

### The Pulumi Program

We begin by importing the necessary packages for both creating the AKS cluster and deploying the Helm chart.

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

// The Pulumi program's main function.
async function main() {
    // [Kubernetes Cluster Creation] - Step 1: Declare the resource group where the AKS cluster will be deployed.
    const resourceGroup = new azure.resources.ResourceGroup("resourceGroup");
    
    // [Kubernetes Cluster Creation] - Step 2: Define the AKS cluster itself with some basic configurations
    const aksCluster = new azure.containerservice.ManagedCluster("aksCluster", {
        resourceGroupName: resourceGroup.name,
        agentPoolProfiles: [{
            count: 2, // Define the number of nodes (VMs) in the Kubernetes cluster
            maxPods: 110,
            mode: "System",
            name: "agentpool",
            osDiskSizeGB: 30,
            osType: "Linux",
            vmSize: "Standard_DS2_v2",
        }],
        dnsPrefix: `${pulumi.getStack()}-kube`,
        enableRBAC: true,
        kubernetesVersion: "1.18.14",
    });

// [Kubernetes Configuration] - Step 3: Retrieve the kubeconfig output from the AKS cluster to configure the Kubernetes provider
    const creds = pulumi.all([resourceGroup.name, aksCluster.name]).apply(([rgName, clusterName]) => {
        return azure.containerservice.listManagedClusterUserCredentials({
            resourceGroupName: rgName,
            resourceName: clusterName,
        });
    });
    const kubeconfig = creds.kubeconfigs[0].value.apply(v => Buffer.from(v, "base64").toString());

// [Helm Chart Deployment] - Step 4: Use the kubeconfig to create a Kubernetes provider instance
    const k8sProvider = new k8s.Provider("k8sProvider", {
        kubeconfig: kubeconfig,
    });

// [Helm Chart Deployment] - Step 5: Deploy the nginx-files-server Helm chart using the Kubernetes provider
    const nginxFilesServerChart = new k8s.helm.v3.Chart("nginx-files-server", {
        chart: "nginx-files-server",
        version: "1.0.1", // Replace with the desired version of the Helm chart
        namespace: "default", // Deploy to the default namespace, or any namespace of your preference
    }, { provider: k8sProvider });

// Export the public IP for the nginx service
    const frontend = nginxFilesServerChart.getResourceProperty("v1/Service", "nginx-files-server", "status");
    export const frontendIp = frontend.apply(status => status.loadBalancer.ingress[0].ip);
}

// Start the Pulumi program
main();
```

Please, replace the `"nginx-files-server"` with the correct Helm chart name you intend to deploy and adjust the `version` with the desired chart version.

### Running the Program

Now, let’s run the Pulumi program by executing the following commands in the terminal in the same directory as our Pulumi program:

1. Install the dependencies by running: `npm install`
2. Create all declared resources by running: `pulumi up`

Upon successful completion of the `pulumi up` command, you will have an AKS cluster running with the `nginx-files-server` deployed.

### Explanation

Here's what each part of the program is doing:

- **Resource Group**: A logical container for your Azure resources. In this case, it's where the AKS cluster will live.
- **AKS Cluster**: An instance of Azure Kubernetes Service. You configure the node count, the size of OS disks, the VM size, and optionally the version of Kubernetes.
- **Kubernetes Provider**: This bridges the communication between Pulumi and Kubernetes, in this case using the kubeconfig of your AKS cluster to manage resources.
- **Helm Chart**: The actual deployment of your `nginx-files-server`. This will install the Helm chart in your AKS cluster within the default namespace.

Regarding the exported value `frontendIp`, once the `nginx-files-server` service is successfully deployed and assigned an IP by the AKS load balancer, this IP is exported by Pulumi. You can use this IP to access your `nginx-files-server` from your browser or API.

Remember to manage the resources created by pulumi responsibly. Use `pulumi destroy` when necessary to clean up all resources to avoid incurring any unnecessary costs.