Deploy the quickwit helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the Quickwit Helm chart on an AWS EKS cluster using Pulumi, you will need to follow a few steps. First, you'll create the necessary resources for the EKS cluster itself. Then you will deploy the Quickwit Helm chart onto that cluster.

Let's break it down:

1. **Create an EKS Cluster**: This involves setting up the Kubernetes control plane, nodes, and the associated networking.
2. **Deploy the Quickwit Helm Chart**: Once the cluster is up and running, you can create a Helm Release to deploy Quickwit onto the cluster.

Below is the step-by-step Pulumi TypeScript program that accomplishes the above tasks:

### Step 1: Create an EKS Cluster

We will use the Pulumi EKS package to create an EKS cluster. You can customize your cluster by specifying various properties such as the number of nodes, node size, and Kubernetes version.

### Step 2: Deploy Quickwit Helm Chart

After the cluster is created, we will deploy the Quickwit Helm chart. This step involves using the `kubernetes.helm.v3.Chart` resource from Pulumi's Kubernetes provider.

Please note before you begin, ensure you have Pulumi installed and AWS credentials configured on your system.

Now, let's see the code in action:

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

// Step 1: Create an EKS Cluster
const cluster = new eks.Cluster("quickwit-cluster", {
    desiredCapacity: 2,  // Desired number of worker nodes
    minSize: 1,          // Minimum number of worker nodes
    maxSize: 3,          // Maximum number of worker nodes
    instanceType: "t2.medium", // Size of the worker nodes
    version: "1.21",     // Kubernetes version
    // Other customization can be applied here
});

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

// Step 2: Deploy Quickwit Helm Chart
const quickwitChart = new k8s.helm.v3.Chart("quickwit", {
    repo: "quickwit-helm-repo", // Replace with actual Helm repository
    chart: "quickwit",
    namespace: "default", // Specify the desired namespace (default if omitted)
    // You can specify additional Helm chart values here, if any.
}, { provider: cluster.provider });

// Export the Quickwit deployment status
export const quickwitStatus = quickwitChart.status;
```

The `eks.Cluster` resource creates and manages an EKS cluster, where `desiredCapacity`, `minSize`, `maxSize`, `instanceType`, and `version` are the configurable options for the worker nodes and Kubernetes version you want for your cluster.

The `kubeconfig` output variable gives you the kubeconfig file necessary to communicate with your cluster using `kubectl`.

The `k8s.helm.v3.Chart` resource is used to deploy the Quickwit Helm chart to the Kubernetes cluster. Make sure to replace `"quickwit-helm-repo"` with the actual Helm repository where the Quickwit chart is located.

In this program, we used very simple settings to create an EKS cluster and deploy a Helm chart. For production scenarios, you should take into account factors like IAM policies for worker node privileges, VPC configuration for the cluster, advanced Helm chart values for the Quickwit deployment, and properly managing your access credentials. Pulumi has comprehensive support for these advanced configurations as well.

After writing and saving your Pulumi program to a file (e.g., `index.ts`), you can deploy it by running the following commands:

```bash
pulumi up
```

This command creates the desired AWS EKS cluster and deploys the Quickwit Helm chart. You will be prompted to review the plan and confirm the deployment.

Remember to check the actual repository for the Quickwit Helm chart and specify any additional Helm chart values you need to deploy Quickwit according to your configurations/preferences.