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

Question

Pulumi · Accepted Answer

To deploy the `external-ingress` Helm chart on Azure Kubernetes Service (AKS), you will need to perform a few basic steps:

1. **Create an AKS Cluster**: We'll start by provisioning an AKS cluster using Pulumi's `azure-native` provider.
2. **Install the Helm Chart**: Once the AKS cluster is up and running, we'll use Pulumi's Kubernetes provider to deploy the `external-ingress` Helm chart to the cluster.

To achieve this, you'll need the following prerequisites:

- Pulumi CLI installed.
- Azure account and credentials configured for Pulumi to use.
- Helm chart information, for instance, the chart name (`external-ingress`) and repository URL.

Below is a detailed Pulumi program written in TypeScript that will create an AKS cluster and deploy the `external-ingress` Helm chart to it.

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

// Create a new Azure resource group for the AKS cluster
const resourceGroup = new azureNative.resources.ResourceGroup("aksResourceGroup");

// Create an AKS cluster
const aksCluster = new azureNative.containerservice.ManagedCluster("aksCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 3, // Number of nodes in the node pool
        vmSize: "Standard_DS2_v2", // VM size of the nodes
        mode: "System", // System mode for the node pool
        name: "agentpool", // Name of the node pool
    }],
    dnsPrefix: `${pulumi.getStack()}-kube`,
    enableRBAC: true, // Enable RBAC for the cluster
}, { dependsOn: resourceGroup });

// Retrieve the kubeconfig from the generated AKS cluster
export const kubeconfig = aksCluster.kubeConfigRaw;

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

// Use a random string to ensure the password changes when the secret is recreated.
const suffix = new random.RandomString("suffix", {
    upper: false,
    length: 8,
    special: false,
}).result;

// Deploy the external-ingress Helm chart using the Kubernetes provider
const ingressChart = new k8s.helm.v3.Chart("nginx-ingress", {
    chart: "nginx-ingress",
    version: "1.41.3", // Replace with the version of the chart you want to deploy
    namespace: "default", // Namespace where the chart should be deployed
    fetchOpts: {
        repo: "https://kubernetes-charts.storage.googleapis.com/", // The repository URL where the chart is located
    },
}, { provider: k8sProvider });

// Export the public IP of the ingress controller service
export const ingressIP = ingressChart.getResourceProperty("v1/Service", "nginx-ingress-controller", "status")
    .apply(status => status.loadBalancer.ingress[0].ip);

```

Let's go through the code step by step:

1. We start by importing the necessary Pulumi libraries and creating a resource group in Azure, which will contain all the resources we create.

2. We define an AKS cluster resource, specifying the node count, VM size, and enabling RBAC. We then export the kubeconfig which will allow us to communicate with the AKS cluster.

3. Using the kubeconfig, we create a new Pulumi Kubernetes provider. This provider is responsible for deploying resources to our AKS cluster.

4. We then define a random string, which is useful for generating unique values for resources.

5. Next, we deploy the `external-ingress` Helm chart (assumed to be named `nginx-ingress` in this code), specifying the chart name, version, and the namespace to which it should be deployed. We also specify the repository where the Helm chart is located. This step uses the Kubernetes provider we created earlier.

6. Finally, we export the public IP address of the ingress controller service, which can be used to access apps deployed within the AKS cluster.

After running this program using Pulumi CLI, you will have an AKS cluster running the `external-ingress` Helm chart. You can use the exported public IP to access your services.