Deploy the elastic-apm-server helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the `elastic-apm-server` Helm chart on Azure Kubernetes Service (AKS), you'll need to follow a few steps. I'll guide you through the process using Pulumi and TypeScript, which involves setting up an AKS cluster and then deploying the Helm chart to it.

Below is the detailed process and the program:

1. **Set up an Azure Kubernetes Service (AKS) cluster**: AKS is a managed Kubernetes service that can simplify the process of running a Kubernetes cluster in Azure. You create an AKS cluster by defining the `ProvisionedCluster` resource.

2. **Deploy the Helm chart**: Once the AKS cluster is up and running, you'll install the Helm chart for Elastic APM Server. To do this in Pulumi, you use the `helm.v3.Chart` resource from Pulumi's Kubernetes package.

Let's start with the TypeScript program that does this step-by-step.

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

// Step 1: Create an Azure Resource Group
const resourceGroup = new azure.core.ResourceGroup("myResourceGroup", {
    location: "WestUS", // You can choose a location that is close to you
});

// Step 2: Create an Azure AD application for AKS
const app = new azuread.Application("aks", {});

// Step 3: Create a service principal for the application
const servicePrincipal = new azuread.ServicePrincipal("aksSp", {
    applicationId: app.applicationId,
});

// Step 4: Create the AKS cluster
const cluster = new azure.containerservice.KubernetesCluster("aksCluster", {
    resourceGroupName: resourceGroup.name,
    defaultNodePool: {
        name: "aksagentpool",
        nodeCount: 2,
        vmSize: "Standard_DS2_v2", // You can choose a size that fits your needs
    },
    dnsPrefix: "aksk8s", // A unique DNS prefix for your cluster
    linuxProfile: {
        adminUsername: "adminuser",
        sshKey: {
            keyData: "ssh-rsa AAAAB3Nza...", // Replace with your real SSH public key
        },
    },
    servicePrincipal: {
        clientId: servicePrincipal.applicationId,
        clientSecret: servicePrincipal.id.apply(id => id.clientSecret),
    },
    kubernetesVersion: "1.20.5", // Specify your desired Kubernetes version
}, { dependsOn: [servicePrincipal] });

// Step 5: Deploy the elastic-apm-server Helm chart onto the AKS cluster
// Ensure that we have a K8s provider that uses the kubeconfig from the newly created AKS cluster
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: cluster.kubeConfigRaw,
});

const elasticApmChart = new k8s.helm.v3.Chart("elastic-apm-server", {
    repo: "elastic",
    chart: "apm-server",
    version: "7.12.0", // Use the version that you want to deploy
    // Add any custom values here that your chart requires
}, { provider: k8sProvider });

// Export the kubeconfig and cluster name
export const kubeconfig = cluster.kubeConfigRaw;
export const clusterName = cluster.name;
```

In this program, we first create an Azure Resource Group to house the services we are going to use. Then we create an Azure Active Directory application that is needed to define a service principal for authentication purposes with the AKS cluster.

We proceed to create the AKS cluster within the designated resource group, specifying the default node pool configuration, and providing SSH access information under the `linuxProfile`. Remember to replace `"ssh-rsa AAAAB3Nza..."` with your actual SSH public key.

Once the cluster is successfully created, we declare a Kubernetes provider configured to use the kubeconfig from the AKS cluster, which allows Pulumi to communicate with your cluster.

Finally, we deploy the `elastic-apm-server` Helm chart to the AKS cluster leveraging the chart's Helm registry. The version number of the chart is hard-coded in this example, but you could make it dynamic based on your requirements.

The outputs at the end of the program, `kubeconfig` and `clusterName`, will give you the necessary information to manage your Kubernetes cluster using `kubectl` or any other Kubernetes management tool.

Make sure to install the required packages if you haven't already:

```bash
npm install @pulumi/pulumi @pulumi/azure @pulumi/kubernetes @pulumi/azuread @pulumi/azure-native
```

After writing the code to a file (for instance `index.ts`), you can run it using:

```bash
pulumi up
```

This command will prompt you to confirm the deployment after showing you the plan. After confirmation, it will provision the resources as described in the code.