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

Question

Pulumi · Accepted Answer

To deploy the `ebpf-exporter` Helm chart on Azure Kubernetes Service (AKS), you'll first need to provision an AKS cluster. Post that, you'll deploy the Helm chart onto the cluster. Pulumi provides resource classes for both AKS and Helm charts that can be used together to achieve this.

Here's what you need to know to understand the program we'll create:

1. **Provision the AKS Cluster:** We will use the `azure-native` package to create an AKS cluster. Unlike the `azure` package, `azure-native` is auto-generated from Azure Resource Manager API descriptions and provides complete coverage of Azure resources.
   
2. **Deploy Helm Chart:** Once the cluster is provisioned, we will use the `kubernetes` package to install a Helm chart. Pulumi's Kubernetes provider can manage Helm charts among other resources.

Below is a Pulumi program written in TypeScript that demonstrates these steps:

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

// Step 1: Create an Azure Resource Group
const resourceGroupName = new azure_native.resources.ResourceGroup("resourceGroup", {
    location: "West Europe", // You can change the location as needed.
});

// Step 2: Create an AKS cluster in the resource group
const aksCluster = new azure_native.containerservice.ManagedCluster("aksCluster", {
    // Ensure you choose a proper name for the AKS cluster
    resourceGroupName: resourceGroupName.name,
    location: resourceGroupName.location,
    // An Azure AD service principal or a managed identity must be provided for the AKS cluster
    identity: {
        type: "SystemAssigned",
    },
    agentPoolProfiles: [{
        // At least one agent pool profile is needed, defining the size of the VMs and the number of VMs in the pool
        count: 1,
        maxPods: 110,
        mode: "System",
        name: "agentpool",
        vmSize: "Standard_DS2_v2",
        osType: "Linux",
    }],
    dnsPrefix: "aksk8s", // Replace with a DNS prefix of your choice
});

// Step 3: Get the kubeconfig file for the AKS cluster after it's created
const creds = pulumi.all([resourceGroupName.name, aksCluster.name]).apply(([rgName, clusterName]) =>
    azure_native.containerservice.listManagedClusterUserCredentials({
        resourceGroupName: rgName,
        resourceName: clusterName,
    })
);

const kubeconfig = creds.apply(creds => {
    // Extract the kubeconfig from the list of credentials
    const encoded = creds.kubeconfigs[0].value;
    if (encoded === undefined) {
        throw new Error("Kubeconfig was not found");
    }
    return Buffer.from(encoded, "base64").toString();
});

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

// Step 4: Deploy the ebpf-exporter Helm chart onto the AKS cluster using the Kubernetes provider
const ebpfExporterChart = new k8s.helm.v3.Chart("ebpf-exporter-chart", {
    chart: "ebpf-exporter",
    // Specify the version of the chart you wish to deploy.
    version: "1.0.0", // Replace with the version of the ebpf-exporter Helm chart
    // You can specify the repository if the chart is not in the official Helm repo
    // repositoryOpts: {
    //     repo: "https://my-helm-chart-repo.com/charts",
    // },
    // Optionally, you can configure the chart values here
    // values: { /* Chart Values Here */ },
}, { provider: k8sProvider });

// Optional: Export the cluster's kubeconfig and endpoint to access it when needed
export const kubeconfigOutput = kubeconfig;
export const clusterEndpoint = aksCluster.fqdn;

```

This program completes the following actions:

1. Creates a new Azure resource group.
2. Provisions an AKS cluster within this resource group. An agent pool is defined where the actual Kubernetes nodes will run. Be sure to replace `agentpool`, `aksk8s`, and other values with ones that suit your needs.
3. Once the AKS cluster is provisioned, it retrieves the kubeconfig file needed to interact with the Kubernetes cluster.
4. Initializes the Pulumi Kubernetes provider with the obtained kubeconfig.
5. Deploys the `ebpf-exporter` Helm chart to the AKS cluster using Pulumi's Helm chart resource.

Please remember to specify Helm chart details such as the `version` and `repositoryOpts` as applicable for your `ebpf-exporter` chart.

To use this program:

1. Save the code to a file with a `.ts` extension, for example, `deployEbpfExporter.ts`.
2. Install the necessary Pulumi packages if you haven't already:
   ```bash
   npm install @pulumi/pulumi
   npm install @pulumi/azure-native
   npm install @pulumi/kubernetes
   ```
3. Run `pulumi up` to preview and deploy the changes; Pulumi CLI will take care of the rest.

Remember that you need to have Pulumi installed and configured along with the necessary Azure credentials configured on your local machine to use this program directly.