Deploy the sts helm chart on AWS EKS

Question

Pulumi · Accepted Answer

In order to deploy the STS Helm chart on AWS Elastic Kubernetes Service (EKS), we'll need to create an EKS cluster and configure it for Helm chart deployments.

Pulumi provides us with a high-level package `eks` that simplifies the creation of an EKS cluster. The `kubernetes` package contains resources for deploying Helm charts on a Kubernetes cluster.

Here's how our process will look:
1. We'll create an EKS cluster.
2. Once the EKS cluster is up and running, we'll configure Kubeconfig to interact with the cluster.
3. We'll deploy the STS Helm chart to our EKS cluster using the `Chart` resource from the `kubernetes` package.

Now, I'll guide you through the process step by step in the Pulumi TypeScript program below:

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

// Step 1: Create an EKS cluster
const cluster = new eks.Cluster("my-cluster", {
    minSize: 2, // Minimum size of the cluster
    maxSize: 3, // Maximum size of the cluster
    desiredCapacity: 2, // Desired capacity of the cluster
    instanceType: "t2.medium", // The instance type to use for the cluster's nodes
});

// Step 2: Configure Kubeconfig
// The kubeconfig is needed to communicate with the cluster. It is a JSON object that defines clusters, users, and contexts.
// The EKS module will automatically provision a kubeconfig for us.
const kubeconfig = cluster.kubeconfig.apply(JSON.stringify);

// Step 3: Deploy the STS Helm chart using the `Chart` resource from the `kubernetes` package
// We need to set up a provider to use the generated kubeconfig from our EKS cluster so the Helm chart knows where to install.
const provider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Here we deploy the STS Helm chart. `chart` references the name of the chart.
// Replace `chart-repo` with the name of the Helm chart repository containing the STS chart,
// and ensure `chart-version` matches the version you wish to deploy.
const chart = new k8s.helm.v3.Chart("sts-chart", {
    chart: "sts",
    version: "chart-version",
    fetchOpts: {
        repo: "https://charts.example.com/", // Replace with the actual repo URL
    },
}, { provider });

// Export the cluster's kubeconfig and the public endpoint to access services deployed in the cluster.
export const kubeConfigOutput = kubeconfig;
export const clusterEndpoint = cluster.endpoint;

```

Let's break down what this program does:

- We begin by importing the necessary Pulumi packages (`pulumi`, `aws`, `eks`, and `kubernetes`).
- We create an EKS cluster with the `eks.Cluster` resource. Here, we specify the size and instance type for the nodes in the cluster. You can adjust the `minSize`, `maxSize`, `desiredCapacity`, and `instanceType` parameters based on your requirements.
- The `kubeconfig` for the cluster is extracted, which will be used to interact with the cluster through `kubectl` or any Kubernetes client.
- We then set up a Kubernetes provider utilizing this `kubeconfig`. The provider ensures that the Helm chart is deployed to the correct EKS cluster.
- The `k8s.helm.v3.Chart` resource deploys the actual STS Helm chart. You need to specify the `repo` where the STS Helm chart is located and the desired `version`.
- Lastly, we export the kubeconfig and the cluster endpoint as outputs, which you can use to interact with your EKS cluster and deployed services.

Make sure to replace placeholder values like `chart-version` and `https://charts.example.com/` with actual values corresponding to your STS Helm chart and its repository.

To run this program, save the code to a file named `index.ts`, ensure your Pulumi stack is properly configured with AWS credentials, and then use the Pulumi CLI to deploy:

```bash
pulumi up
```

This command will provision the resources as defined. After the command completes successfully, you will be able to see the outputs, which include the kubeconfig and the cluster endpoint.