Deploy the tsorage helm chart on AWS EKS

Question

Pulumi · Accepted Answer

In order to deploy a Helm chart on AWS EKS, you need to follow these steps:

1. **Create an EKS cluster**: An Amazon EKS cluster is required to manage your workloads. When you create an EKS cluster, you launch an architecture that includes the necessary infrastructure to run Kubernetes control plane instances.

2. **Install and Configure Helm**: Helm is a package manager for Kubernetes. You use Helm to deploy applications that are packaged as Helm charts.

3. **Deploy the Helm chart**: Once you have the EKS cluster up and the Helm client configured, you can deploy the Helm chart to the EKS cluster.

In the following Pulumi TypeScript program, we use the `eks` package to create an EKS cluster, and the `kubernetes.helm.v3.Chart` resource to deploy the Helm chart. The name "tsorage" seems like a typo, and I assume you intended to say "storage". If "tsorage" is actually a specific Helm chart you wish to deploy, be sure to replace `"storage"` with the correct chart name.

Please ensure you have the AWS CLI and Pulumi CLI configured with appropriate credentials and have the `eks`, `kubernetes`, and `aws-iam` Pulumi packages installed.

Here's how you can accomplish this task using Pulumi:

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

// Step 1: Create an AWS EKS cluster.
const cluster = new eks.Cluster("my-cluster", {
    instanceType: "t2.medium",
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 2,
    storageClasses: "gp2",
    deployDashboard: false,
});

// Step 2: Use the EKS cluster's kubeconfig to interact with the cluster.
const provider = new kubernetes.Provider("k8s-provider", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Step 3: Deploy the Helm chart on the EKS cluster.
// Please replace "storage" with the actual Helm chart name you wish to deploy.
const storageChart = new kubernetes.helm.v3.Chart("storage-chart", {
    chart: "storage",  // Replace with the name of your Helm chart
    fetchOpts: {
        repo: "https://charts.exemplar.com",  // Replace with your Helm chart repository URL
    },
}, { provider }); // Specify the provider to ensure it uses the EKS cluster.

// Export the Kubeconfig and the cluster name
export const kubeconfig = cluster.kubeconfig;
export const clusterName = cluster.core.cluster.name;
```

**Explanation**:
- We start by importing the necessary Pulumi packages for EKS, Kubernetes, and AWS.
- Then, we create an EKS cluster with desired configurations using the `eks.Cluster` resource ([docs](https://www.pulumi.com/registry/packages/eks/api-docs/cluster/)). This includes specifications for instance types and the desired capacity for our nodes.
- Next, we create a Kubernetes provider configured with the kubeconfig from our EKS cluster. This allows Pulumi to apply changes to the cluster using Kubectl under the hood.
- After that, we use the `kubernetes.helm.v3.Chart` resource ([docs](https://www.pulumi.com/registry/packages/kubernetes/api-docs/helm.sh/v3/chart/)) to deploy a Helm chart named "storage" to our cluster. This part of the code requires the exact chart name and the repository URL where the Helm chart is located. Replace these placeholders with the correct values for your scenario.
- Finally, we export the kubeconfig and cluster name, so you can easily access and manage your EKS cluster using them.

Run this Pulumi program with:
```bash
pulumi up
```
This command will provision the resources as defined in the program.

In case you need to obtain the Helm chart from a specific repository, replace the `chart` and `fetchOpts.repo` parameters with the respective Helm chart name and repository URL you intend to use.