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

Question

Pulumi · Accepted Answer

In order to deploy the `elasticsearch-sed` Helm chart on Azure Kubernetes Service (AKS), we will perform the following steps:

1. Set up an AKS cluster within Azure using Pulumi's `azure-native` package. This will create a managed Kubernetes cluster that you can configure and scale as needed.
2. Install the `elasticsearch-sed` Helm chart on the AKS cluster using Pulumi's `kubernetes` package. Helm charts are collections of pre-configured Kubernetes resources that can be easily installed and managed within Kubernetes clusters.

Below is a complete TypeScript program that you can use to deploy an AKS cluster and then install the `elasticsearch-sed` Helm chart on it. Comments are included, explaining each key part of the program.

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

// Create a new resource group to contain the AKS cluster
const resourceGroup = new azure_native.resources.ResourceGroup("resourceGroup");

// Create the AKS cluster
const aksCluster = new azure_native.containerservice.ManagedCluster("aksCluster", {
    resourceGroupName: resourceGroup.name,
    // Using Kubernetes version based on Azure's supported list at the time of writing
    kubernetesVersion: '1.19.11',
    // Define the properties of the default node pool
    agentPoolProfiles: [{
        count: 2, // Number of nodes in the node pool
        vmSize: "Standard_DS2_v2",
        name: "default",
    }],
    // Generate SSH keys to use with nodes in the AKS cluster
    linuxProfile: {
        adminUsername: "azureuser",
        ssh: {
            publicKeys: [{
                keyData: "" // You should replace this with your SSH public key's text
            }],
        },
    },
    // Enable monitoring and logging using Azure services
    enableRBAC: true,
    dnsPrefix: pulumi.interpolate`${pulumi.getStack()}aks`, // DNS prefix for your AKS cluster
});

// Get the kubeconfig file for the AKS cluster
const creds = pulumi.all([resourceGroup.name, aksCluster.name]).apply(([resourceGroupName, clusterName]) =>
    azure_native.containerservice.listManagedClusterUserCredentials({
        resourceGroupName,
        resourceName: clusterName,
    })
);

// Extract and assign the kubeconfig
const kubeconfig = creds.kubeconfigs[0].value.apply(kc => Buffer.from(kc, 'base64').toString());

// Create a Kubernetes provider instance using the kubeconfig from AKS, which directs Pulumi to manage resources in that cluster
const provider = new k8s.Provider("aksK8s", {
    kubeconfig: kubeconfig,
});

// Install the `elasticsearch-sed` Helm chart into the AKS cluster using the Pulumi Kubernetes provider
const elasticsearchHelmChart = new k8s.helm.v3.Chart("elasticsearch-sed-chart", {
    // Set the name of the chart and repository details as required
    chart: "elasticsearch",
    version: "7.10.0", // At this point, you should use the version that matches your needs
    fetchOpts: {
        repo: "https://helm.elastic.co", // The repository URL where the chart can be found
    },
}, { provider: provider }); // Ensure that the Helm chart is installed in the AKS cluster provisioned by Pulumi

// Export the kubeconfig to be used outside the Pulumi program
export const kubeConfig = kubeconfig;
export const clusterName = aksCluster.name;

```

Place the above code in a file named `index.ts` within your Pulumi project directory.

Before running the code, ensure that the AKS cluster's `linuxProfile.ssh.publicKeys.keyData` field contains your SSH public key's text. This is important for security reasons to ensure only you have access to the nodes within the AKS cluster.

To run this program:

- Navigate to your Pulumi project directory in the terminal.
- Use `pulumi up` command to trigger the deployment. Pulumi CLI will show you a preview of the resources that will be created and ask for confirmation before proceeding.

When the deployment is successful, Pulumi will output the configured `kubeconfig` and `clusterName`. You can use this `kubeconfig` to interact with your AKS cluster using `kubectl` or any other Kubernetes tooling.

This program will set up a basic two-node AKS cluster, suitable for development or testing environments. For production use, consider a more robust configuration with additional node pools, increased node counts, and network configuration suitable for your specific needs.