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

Question

Pulumi · Accepted Answer

To deploy the `kanister-elasticsearch` Helm chart on an Azure Kubernetes Service (AKS) cluster using Pulumi, you follow these general steps:

1. **Create an AKS cluster**: Before deploying any applications, you need a Kubernetes cluster. In Azure, this service is provided by AKS.
   
2. **Deploy the Helm chart**: Once the cluster is available, you can deploy applications into this cluster. Helm is a package manager for Kubernetes that allows you to deploy applications defined in charts, which package all the required resources into a single, deployable unit.

We'll use the `azure-native` package to create the AKS cluster and the `kubernetes` package to deploy the Helm chart. Here's how you can do this in Pulumi using TypeScript:

Before you begin, ensure you have the following prerequisites:

- The Pulumi CLI installed and configured with Azure credentials.
- Node.js and npm installed to run the TypeScript program.
- Access to the Azure container registry if your Helm chart needs to pull images from a private registry.

### Detailed Explanation of the Program

The program consists of two main parts:

1. The first part will configure the AKS cluster, specifying the necessary parameters like node count, VM size, and Kubernetes version.
   
2. The second part will install the Helm chart into the AKS cluster. We'll be installing the `kanister-elasticsearch` chart, which will set up Elasticsearch with support for Kanister for backup and restore capabilities.

Now let's look at the TypeScript code. You will need to run `npm install @pulumi/azure-native @pulumi/kubernetes` to bring in the required Pulumi packages:

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

// Step 1: Create an AKS cluster
// We define the AKS cluster resource.
const aksCluster = new azure.containerservice.ManagedCluster("my-aks-cluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 2, // This is the number of nodes for the cluster.
        maxPods: 110,
        mode: "System",
        name: "agentpool",
        osType: "Linux",
        vmSize: "Standard_DS2_v2", // You can choose the VM size that fits your needs.
    }],
    dnsPrefix: "myakscluster",
    enableRBAC: true,
    kubernetesVersion: "1.18.14",
    linuxProfile: {
        adminUsername: "adminuser",
        ssh: {
            publicKeys: [{
                keyData: "ssh-rsa YOUR_SSH_PUBLIC_KEY",
            }],
        },
    },
    nodeResourceGroup: "my-aks-node-resource-group",
});

// Step 2: Deploy the kanister-elasticsearch Helm chart
// We define a Kubernetes provider instance that uses the kubeconfig from the AZK cluster.
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: aksCluster.kubeConfigRaw,
});

// The settings, repo, and version for the Helm chart can be set or changed here as needed.
const elasticsearchChart = new k8s.helm.v3.Chart("kanister-elasticsearch", {
    chart: "elasticsearch",
    version: "7.6.0", // Specify the version of the chart.
    fetchOpts: {
        repo: "https://charts.kanister.io/", // Helm repository URL
    },
}, { provider: k8sProvider });

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

```

In the code above, replace `YOUR_SSH_PUBLIC_KEY` with your actual SSH public key to enable SSH access to the AKS cluster nodes.

Upon running this Pulumi program, it will perform the following actions:
- Provision an AKS cluster with the given settings.
- Configure the `k8s.Provider` to communicate with the AKS cluster using its `kubeconfig`.
- Deploy the `kanister-elasticsearch` Helm chart to the AKS cluster using the specified version and repository.

### Running the Program

Run the following commands in your terminal:

1. Create a new Pulumi project: `pulumi new azure-typescript`.
2. Replace the generated `index.ts` with the code provided above.
3. Install the necessary dependencies: `npm install`.
4. Deploy the stack with `pulumi up`.

After you confirm the deployment, Pulumi will provision the resources, and once the deployment is complete, you'll have an AKS cluster with the `kanister-elasticsearch` helm chart deployed.

### Further Considerations

Make sure to manage the Kubernetes resources cleanly with Pulumi's stack management. Updating, replacing, or deleting infrastructure can be done through the Pulumi CLI commands, tracking all changes to your infrastructure over time.

To remove the resources, you can run `pulumi destroy`, which will delete the resources in the reverse order they were created.

Remember to comply with Azure's naming constraints and select a suitable region when you create the `ManagedCluster`. Adjust the VM size and node count to match your workload requirements and budget constraints.