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

Question

Pulumi · Accepted Answer

Sure, I can guide you through deploying a Helm Chart, particularly the `webapp-chart`, onto an Azure Kubernetes Service (AKS) cluster using Pulumi in TypeScript. Before we begin writing the code, let's understand the components we'll be using:

1. **Azure Kubernetes Service (AKS)**: This managed container orchestration service is based on Kubernetes and simplifies its deployment, management, and operations.

2. **Pulumi**: This is an Infrastructure as Code tool that allows you to define and deploy cloud infrastructure using general-purpose programming languages.

3. **Helm Chart**: Helm is a package manager for Kubernetes, which uses packages called charts. A chart is a collection of files that describe a related set of Kubernetes resources. In this case, `webapp-chart` is the name of the chart we'll be deploying.

First, we will need to create an AKS cluster. Then we'll deploy the Helm Chart to this cluster. Here's a program that performs both of these steps:

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

// Create an AKS cluster
const resourceGroup = new azure.core.ResourceGroup("resourceGroup", {
    location: "West US", // Set the location for your resource group
});

const aksCluster = new azure.containerservice.KubernetesCluster("aksCluster", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    defaultNodePool: {
        name: "aksagentpool",
        nodeCount: 2, // Define the number of nodes in the cluster
        vmSize: "Standard_DS2_v2", // Set the virtual machine size for the nodes
    },
    dnsPrefix: `${pulumi.getStack()}-kubernetes`,
    linuxProfile: {
        adminUsername: "adminuser",
        sshKey: {
            keyData: "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC...", // Replace with your real SSH public key
        },
    },
    servicePrincipal: {
        clientId: "YOUR_SP_APP_ID", // Set the service principal application ID
        clientSecret: "YOUR_SP_CLIENT_SECRET", // Set the service principal secret
    },
    kubernetesVersion: "1.18.14",
});

// Expose a K8s provider instance using our custom cluster instance.
const k8sProvider = new kubernetes.Provider("k8sProvider", {
    kubeconfig: aksCluster.kubeConfigRaw,
});

// Deploy the Helm chart for the web application
const webAppChart = new kubernetes.helm.v3.Chart("webapp-chart", {
    chart: "webapp-chart",
    version: "1.0.0", // Specify the version of the chart
    fetchOpts: {
        repo: "https://charts.example.com/", // Replace with the correct repository for the webapp-chart
    },
}, { provider: k8sProvider });

// Export the kubeconfig
export const kubeConfig = aksCluster.kubeConfigRaw;

```

This TypeScript program begins by importing the required Pulumi packages. It then creates a new resource group and an AKS cluster within that resource group. Note that you need to replace:

- The SSH public key where indicated with your own.
- The service principal credentials (`YOUR_SP_APP_ID` and `YOUR_SP_CLIENT_SECRET`) with valid Azure credentials that are authorized to create resources.

The program then creates a K8s Provider with the generated kubeconfig from the AKS cluster, which will be used to deploy the Helm Chart.

Lastly, we define a Helm chart resource, specifying the chart name, version, and the repository from where to fetch the chart. Since you want to deploy a `webapp-chart`, you would replace `https://charts.example.com/` with the actual chart repository URL that hosts your desired chart.

Make sure you have Pulumi installed and configured for Azure, and then you can run this program using the Pulumi CLI. After deploying, you can use the exported `kubeConfig` to interact with your AKS cluster through `kubectl`.