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

Question

Pulumi · Accepted Answer

To deploy the Linkerd Helm chart on Azure Kubernetes Service (AKS), you'll follow these high-level steps:

1. Create an AKS cluster by defining a `ProvisionedCluster` resource. This is where your applications, including Linkerd, will be running.
2. Configure the Helm chart for Linkerd using the `Chart` resource from the `kubernetes` package. This will set up Linkerd in your AKS cluster.
3. Outputs and dependencies are used to manage the order of resource creation and to fetch the necessary access information.

Below is the TypeScript program for Pulumi which will perform the steps mentioned. Ensure you have Pulumi installed and you’re logged in to Azure CLI on your machine with appropriate permissions before executing this code.

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

// Step 1: Creating an AKS Cluster
// The following code creates an AKS cluster in the resource group `myResourceGroup` in `EastUS` location.
// Please replace `myResourceGroup` and `myAKS` with your own names as needed.

const resourceGroup = new azure.resources.ResourceGroup("myResourceGroup", {
    location: "EastUS",
});

const aksCluster = new azure.containerservice.ManagedCluster("myAKS", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    agentPoolProfiles: [{
        count: 1,
        maxPods: 110,
        mode: "System",
        osDiskSizeGB: 30,
        osType: "Linux",
        vmSize: "Standard_DS2_v2",
        type: "VirtualMachineScaleSets"
    }],
    dnsPrefix: "myaksdns",
    enableRBAC: true,
    kubernetesVersion: "1.18.14",
    linuxProfile: {
        adminUsername: "adminuser",
        ssh: {
            publicKeys: [{
                keyData: "ssh-rsa ...", // replace `ssh-rsa ...` with your actual SSH public key
            }],
        },
    },
});

// Export the AKS cluster details
export const kubeconfig = aksCluster.kubeconfig;
export const clusterName = aksCluster.name;

// Step 2: Deploying Linkerd using Helm Chart
// Once the AKS cluster is up, we deploy Linkerd into it using a Helm Chart.

// Initialize a new K8s provider instance with the kubeconfig obtained from the created AKS cluster
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: kubeconfig,
});

// Deploy Linkerd Helm chart into the AKS cluster
const linkerdChart = new k8s.helm.v3.Chart("linkerdChart", {
    chart: "linkerd2",
    namespace: "linkerd", // Linkerd should be deployed in its own namespace
    fetchOpts: {
        repo: "https://helm.linkerd.io/stable", // Linkerd Helm chart repository
    },
    values: {
        // Specify your custom configuration here, if needed
    },
}, { providers: { kubernetes: k8sProvider } });

// Export the Linkerd dashboard URL for easy access
export const linkerdDashboard = pulumi.interpolate`http://${aksCluster.name}.${resourceGroup.location}.cloudapp.azure.com:8084`;

// Note: It's critical to manage dependencies in Pulumi. The `provider` property in the Chart resource ensures that
// Pulumi knows to only attempt deploy Linkerd after the provider has been configured with the correct kubeconfig.
```

In the above code:

- `azure.resources.ResourceGroup` creates a new Azure Resource Group.
- `azure.containerservice.ManagedCluster` sets up the AKS cluster.
- `@pulumi/kubernetes` is utilized to interact with Kubernetes. Within it, `helm.v3.Chart` is used to deploy Linkerd.
- `kubeconfig` is exported from the AKS resource, which allows Pulumi to communicate with your Kubernetes cluster.
- `linkerdChart` is the name of the Helm deployment for Linkerd. We've specified the Helm repository URL and the chart name.

The dashboard URL exported at the end formats the AKS cluster name and location to provide you with the correct URL to access the Linkerd dashboard once deployed.

Make sure to replace placeholder values with your actual configuration (like SSH key data, desired region, cluster name, etc.). After updating the code, run `pulumi up` to preview and deploy your infrastructure. Pulumi will handle the creation and management of the resources in the correct order based on dependencies.