Deploy the kanister-elasticsearch helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `kanister-elasticsearch` Helm chart on AWS EKS, we will follow a multi-step process using Pulumi's TypeScript language support. The steps to achieve this are as follows:

1. **Create an EKS Cluster**: We'll need an Amazon EKS cluster where our Elasticsearch will be deployed. Pulumi's AWS EKS package helps us create and configure a cluster with ease.

2. **Configure Kubeconfig**: We will set up kubeconfig to enable communication with the EKS cluster using Pulumi's Kubernetes provider.

3. **Deploy Helm Chart**: After setting up the EKS cluster, we will deploy the `kanister-elasticsearch` Helm chart onto the cluster. Pulumi provides a Helm Chart resource in its Kubernetes package that can manage Helm chart deployment.

Let's break these down and write a Pulumi program that will set up your infrastructure and deploy the `kanister-elasticsearch` Helm chart.

First, you'll need to import several packages:

- `@pulumi/pulumi` for general Pulumi infrastructure as code functionality.
- `@pulumi/aws` for AWS resources including EKS.
- `@pulumi/awsx` for creating an EKS cluster using AWS' Crosswalk for AWS abstraction library.
- `@pulumi/kubernetes` for interacting with Kubernetes clusters and deploying helm charts.

Now, let's write the program to deploy the `kanister-elasticsearch` Helm chart on AWS EKS.

```typescript
import * as pulumi from '@pulumi/pulumi';
import * as aws from '@pulumi/aws';
import * as awsx from '@pulumi/awsx';
import * as k8s from '@pulumi/kubernetes';

// Create an EKS cluster
const cluster = new awsx.eks.Cluster('kanister-eks-cluster', {
  // Specify the desired size and type of the EKS cluster, you can make these configurations as per your needs.
  desiredCapacity: 2,
  minSize: 1,
  maxSize: 2,
  instanceType: 't2.medium', // Choose an appropriate instance type.
});

// Export the clusters' kubeconfig
export const kubeconfig = cluster.kubeconfig;

// Create a Kubernetes provider instance that uses the cluster's kubeconfig
const k8sProvider = new k8s.Provider('k8s-provider', {
  kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Deploy the kanister-elasticsearch helm chart using the Kubernetes provider
const elasticsearchChart = new k8s.helm.v3.Chart('kanister-elasticsearch', {
  chart: 'kanister-elasticsearch',
  version: 'x.y.z', // Replace with the appropriate chart version
  fetchOpts: {
    repo: 'https://charts.kanister.io/', // Official Kanister helm chart repository
  },
}, { provider: k8sProvider });

// Optionally, you can export endpoints or other resources that were created by the Helm chart
// For instance, to export the Elasticsearch service endpoint:
const elasticsearchService = elasticsearchChart.getResource('v1/Service', 'kanister-elasticsearch-client');
export const elasticsearchEndpoint = elasticsearchService.status.loadBalancer.ingress[0].hostname;

```

Here's what the code is doing step by step:

1. Create an EKS cluster with `awsx.eks.Cluster`, which will set up the necessary AWS resources and credentials.

2. Export the kubeconfig of our newly created EKS. This kubeconfig allows us to interact with the EKS cluster with any Kubernetes tooling.

3. Instantiate the `k8s.Provider` using the above `kubeconfig`. This provider is responsible for deploying and managing Kubernetes resources.

4. Deploy the `kanister-elasticsearch` Helm chart by instantiating `k8s.helm.v3.Chart`. This class accepts the chart name, version, and repository among other configurations.

5. Optionally, export any resource details such as a service endpoint from the deployed Helm chart. This enables easy access to the resource outside Pulumi.

Remember that before running `pulumi up` to apply this code, you should ensure that your AWS credentials are configured correctly, either through the AWS CLI or by setting the appropriate environment variables.

Upon running `pulumi up`, Pulumi will provision the resources in the correct order, setting up a new EKS cluster and deploying the `kanister-elasticsearch` Helm chart in the process. You will then be able to interact with your Elasticsearch deployment via the exported endpoint.