Deploy the twitter-app helm chart on AWS EKS

Question

Pulumi · Accepted Answer

Deploying a Helm chart on AWS Elastic Kubernetes Service (EKS) involves a few key steps: creating an EKS cluster, setting up the necessary roles and permissions, and using Pulumi to script the deployment of the Helm chart to the cluster. Below I'll break down each step and provide a Pulumi program in TypeScript that accomplishes this task.

First, we'll need to create an Amazon EKS cluster. We use the `aws.eks.Cluster` resource from the Pulumi AWS provider for this purpose. This will handle the creation of the Kubernetes cluster itself.

Next, we'll need to set up a Kubernetes provider that points to the newly created EKS cluster. This allows Pulumi to interact with our EKS cluster for deploying the Helm chart.

Lastly, we'll deploy the `twitter-app` Helm chart to the EKS cluster by using the `helm.v3.Chart` resource from Pulumi Kubernetes provider. We'll assume the Helm chart is available in a public or private chart repository that we can access.

Here's a TypeScript program that defines and creates these resources using Pulumi:

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

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

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

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

// Deploy the twitter-app Helm chart.
const twitterAppChart = new k8s.helm.v3.Chart('twitter-app', {
    chart: 'twitter-app',
    version: '1.0.0', // replace with the desired chart version
    fetchOpts: {
        repo: 'http://charts.example.com/', // replace with the actual chart repo URL
    },
}, { provider });

// Export the public endpoint for the twitter-app.
export const twitterAppEndpoint = pulumi.interpolate`http://${cluster.endpoint}`;
```

In this program:

- We're using `@pulumi/eks` to create an EKS cluster with `t2.medium` instances, desired capacity of 2 to ensure high availability, and using the `gp2` storage class.
- We're exporting the kubeconfig of the cluster which can be used to interact with the Kubernetes cluster via kubectl or any Kubernetes client.
- We set up a K8s provider that points to our EKS cluster.
- We deploy the `twitter-app` Helm chart using the `k8s.helm.v3.Chart` class. You'll need to replace `'http://charts.example.com/'` with the actual URL to your Helm chart's repository and `1.0.0` with the chart version you intend to deploy.
- We're exporting `twitterAppEndpoint`, which is an interpolated string to access the `twitter-app` service if it's exposed publicly.

Keep in mind to replace placeholders such as chart version and repo URL with actual values relevant to the `twitter-app` Helm chart.

To deploy this Pulumi program:

1. Make sure you have Pulumi and AWS CLI installed and configured.
2. Save this code to a file named `index.ts`.
3. Run `pulumi up` in the same directory as your `index.ts` file to create the EKS cluster and deploy the Helm chart.

Pulumi will provide detailed summary information before performing any actions, and you can confirm to proceed with the deployment. After the deployment, Pulumi will output the exported values such as `kubeconfig` and `twitterAppEndpoint`.