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

Question

Pulumi · Accepted Answer

Deploying a Helm chart on an Azure Kubernetes Service (AKS) cluster involves several steps:

1. **Set Up AKS Cluster**: First, you'll need an existing AKS cluster to which you can deploy your Helm chart. This cluster will be your deployment target.

2. **Install Helm**: Helm is a package manager for Kubernetes that simplifies deployment of applications. You'll need to have Helm installed on the machine where you're running the Pulumi code, or within a CI/CD pipeline environment if that's your use case.

3. **Deploy Helm Chart**: Once you have an AKS cluster and Helm installed, you can proceed to deploy the `de-elasticsearch` Helm chart.

For this scenario, we will assume you have already provisioned an AKS cluster. If not, you can do this using Pulumi with the `azure-native` package by creating a `ManagedCluster` resource, but we won't cover this part here.

Now, using Pulumi's `kubernetes` package, specifically the `helm.sh/v3` module, we can deploy a Helm chart. This `Chart` resource is a high-level component that simplifies deploying Helm charts. The following Pulumi program demonstrates the necessary code in TypeScript to achieve the deployment of the `de-elasticsearch` chart to your AKS cluster.

To understand the following program:

- The `Chart` class from the `@pulumi/kubernetes/helm` module is instantiated to deploy a Helm chart.
- You need to specify the Helm `repo` and `chart` name that you want to deploy.
- The `values` parameter can be provided to customize the Helm chart deployment, such as setting `clusterName`, `nodeCount`, or any other configurable option of the Helm chart.
- The `namespace` parameter specifies the Kubernetes namespace where your Helm chart will be deployed.
- Before deploying the Helm chart, make sure your AKS cluster's kubeconfig is set correctly so Pulumi can interact with your cluster.

Here's the Pulumi program written in TypeScript:

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

// This is the name of the Kubernetes namespace where the Helm chart will be deployed.
const namespaceName = "default";

// Create a new Kubernetes namespace
const ns = new k8s.core.v1.Namespace(namespaceName, {
    metadata: {
        name: namespaceName,
    },
});

// Deploy the `de-elasticsearch` Helm chart.
const elasticSearchChart = new k8s.helm.v3.Chart("de-elasticsearch", {
    // The repository where the Helm chart is stored.
    // Replace with the actual repository URL or name if it's an already added helm repository on your system.
    repo: "example-repo",
    chart: "de-elasticsearch",
    // You can specify values for the Helm chart here.
    // Usually, this would be based on the values you typically set using values.yaml file when deploying using the Helm CLI.
    // For example: { clusterName: "my-elastic-cluster", nodeCount: 3 }
    // Note: The keys and values here are chart-dependent, so make sure to adjust them based on the actual chart's requirements.
    values: {
        // Custom values for the Elasticsearch deployment
    },
    // We specify the namespace where the chart will be installed.
    namespace: ns.metadata.name,
}, { dependsOn: ns });

// Obtain the status URL
const statusUrl = elasticSearchChart.getResourceProperty("v1/Service", "de-elasticsearch-elasticsearch-master", "status");

// Export the URL to access the Elasticsearch cluster
export const elasticSearchUrl = statusUrl.apply(status => `http://${status.loadBalancer.ingress[0].ip}`);
```

In this code:

- A new Kubernetes namespace is created using Pulumi's Kubernetes provider.
- The `de-elasticsearch` Helm chart is deployed in the `default` namespace.
- We expect that the Helm chart creates a `Service` of type LoadBalancer (common for accessing Elasticsearch clusters).
- The external IP for accessing Elasticsearch's master service is exported.

You must replace `example-repo` with the actual repository name or URL where the `de-elasticsearch` Helm chart is stored. Also, you should customize the `values` field to match the configurations you want for your Elasticsearch cluster based on the chart's configurations.

Run this code with Pulumi in the same way as any Pulumi project:

1. Save this code in a file called `index.ts`.
2. Run `pulumi stack init` if you are setting up a new project.
3. Run `pulumi up`, and the Pulumi CLI will handle provisioning the resources as specified in the program.

This will set up your Elasticsearch on AKS using the specified Helm chart. Remember that you must be authenticated with AKS (with a valid `kubeconfig` file) for Pulumi to deploy resources into your cluster.