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

Question

Pulumi · Accepted Answer

To deploy the Elasticsearch umbrella helm chart on Azure Kubernetes Service (AKS), we will go through a series of steps to create an AKS cluster and then install a Helm chart on it. Specifically, we will:

1. Create an instance of AKS using the `azure-native` provider.
2. Install the Elasticsearch umbrella Helm chart to the AKS cluster using the `kubernetes` provider and the Helm resource.

Below is a TypeScript program for Pulumi that accomplishes this task. The program uses the `azure-native` provider to first create a resource group and AKS cluster. Then, using the `kubernetes` provider, it installs the Elasticsearch Helm chart. Comments are included in the code to guide you through the process.

Before executing this Pulumi program, ensure that you have:

- Installed the Pulumi CLI and logged in.
- Configured the Azure provider with appropriate credentials.
- Installed Node.js and npm to run the TypeScript program.
- Initialized a new Pulumi project with `pulumi new azure-typescript`.

Here's the TypeScript program:

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

// Create a new resource group to hold our AKS cluster resources.
const resourceGroupName = new azure_native.resources.ResourceGroup("rg");

// Create a new AKS cluster.
const aksClusterName = new random.RandomString("aksClusterName", {
    length: 12,
    special: false,
    upper: false,
}).result;

const aksCluster = new azure_native.containerservice.ManagedCluster("aksCluster", {
    resourceGroupName: resourceGroupName.name,
    resourceName: aksClusterName,
    identity: {
        type: "SystemAssigned",
    },
    agentPoolProfiles: [{
        count: 1,
        maxPods: 110,
        mode: "System",
        name: "agentpool",
        osDiskSizeGB: 30,
        osType: "Linux",
        type: "VirtualMachineScaleSets",
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: aksClusterName,
    enableRBAC: true,
    kubernetesVersion: "1.21.1",
});

// Export the kubeconfig to access the created AKS cluster.
export const kubeConfig = aksCluster.kubeConfig;

// Create a provider for the AKS cluster.
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: kubeConfig,
});

// Deploy the elasticsearch-umbrella helm chart to the AKS cluster.
const elasticsearchHelmChart = new k8s.helm.v3.Chart("elasticsearch", {
    chart: "elasticsearch",
    version: "7.14.0", // specify the version of Elasticsearch you want to deploy
    fetchOpts: {
        repo: "https://helm.elastic.co",
    },
}, { provider: k8sProvider });

// Alternatively, if the chart is an umbrella chart and uses a different name,
// specify the correct chart name and repository here.

// Export the status URL of the deployed Elasticsearch service.
export const elasticsearchStatusURL = pulumi.interpolate`http://${aksCluster.name}.${resourceGroupName.name}.cloudapp.azure.com`;
```

This program will do the following:

- Create a new resource group in Azure to hold the AKS resources.
- Provision a new AKS cluster with a single node pool.
- Export the AKS cluster's `kubeConfig` for further access (you can use this to connect via `kubectl`).
- Create a Kubernetes provider instance that uses the `kubeConfig` of the AKS cluster.
- Deploy the Elasticsearch Helm chart to the AKS cluster.

Remember to replace the helm chart version with the version you wish to deploy. The `version` field in the `elasticsearchHelmChart` resource should reflect the chart version compatible with your requirements.

To deploy this program with Pulumi:

1. Save the code to a `index.ts` file in your Pulumi project directory.
2. Run `pulumi up` in the command line from the project directory to create the resources.

Ensure that you review the planned changes before confirming the deployment. After the deployment completes, the Kubernetes resources will be available, and Pulumi will export the `kubeConfig` and `elasticsearchStatusURL` for your use. Use `kubectl` with the exported `kubeConfig` to manage your Kubernetes cluster and deployed applications.