Deploy the ts-server helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `ts-server` Helm chart on an AWS EKS cluster, you need to follow a series of steps. I'll guide you through the process of setting up an EKS cluster, creating a role for the cluster, and then deploying the Helm chart using Pulumi. We'll be using the `aws`, `awsx`, and `kubernetes` packages from Pulumi to accomplish this. Below is a detailed explanation before I provide you with the Pulumi code.

1. **Set up an AWS EKS Cluster**: We will create an Amazon EKS cluster, which is a managed Kubernetes service that allows you to run Kubernetes on AWS without needing to install, operate, and maintain your own Kubernetes control plane.

2. **Define IAM Role for EKS**: We need to create an IAM role that the EKS service will assume to create AWS resources for Kubernetes clusters.

3. **Deploy the Helm chart**: Helm is a package manager for Kubernetes that allows you to deploy applications using pre-configured Kubernetes resources. We'll use Pulumi's Kubernetes provider to deploy the `ts-server` Helm chart onto the EKS cluster.

Now, let's begin with the TypeScript code to accomplish each step:

```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";

// Step 1: Create an EKS cluster
const vpc = new awsx.ec2.Vpc("my-vpc", {numberOfAvailabilityZones: 2});

const cluster = new awsx.eks.Cluster("my-cluster", {
    vpcId: vpc.id,
    subnetIds: vpc.publicSubnetIds,
    instanceType: "t2.medium",
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 3,
    deployDashboard: false,
});

// Step 2: Define IAM Role for EKS
const eksRole = new aws.iam.Role("eksRole", {
    assumeRolePolicy: aws.iam.assumeRolePolicyForPrincipal({
        Service: "eks.amazonaws.com",
    }),
});

new aws.iam.RolePolicyAttachment("eks-policy-attachment", {
    role: eksRole,
    policyArn: aws.iam.ManagedPolicy.AmazonEKSClusterPolicy,
});

// Step 3: Deploy the 'ts-server' Helm chart
// Assuming the Helm chart exists in a repository; if not, adjust it to your chart's location
const helmChart = new k8s.helm.v3.Chart("ts-server", {
    chart: "ts-server",
    version: "1.0.0", // specify the version of the chart
    fetchOpts: {
        repo: "http://example.com/helm-charts", // replace with the URL of your chart repository
    },
}, { provider: cluster.provider });

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

// Export the URL to access the 'ts-server' service if it creates an external endpoint
export const tsServerUrl = helmChart.getResourceProperty("v1/Service", "ts-server", "status")
    .apply(status => status.loadBalancer?.ingress[0]?.hostname || status.loadBalancer?.ingress[0]?.ip);
```

Here's what the above program does:

- We first create a VPC (Virtual Private Cloud) for our EKS cluster. The `awsx` package provides higher-level components that automatically create a VPC with public subnets across the specified number of availability zones.
  
- Next, we use `awsx` to create an EKS cluster within our VPC. We're launching a cluster with t2.medium instances, setting the desired count to 2 while allowing the autoscaling group to scale between 1 and 3 instances. We've also disabled the deployment of the Kubernetes Dashboard.

- We define an IAM Role `eksRole` that Amazon EKS will assume to create AWS resources, such as the VPC and EKS cluster. We attach the necessary policy to the role which grants it access to manage EKS clusters.

- We use the `kubernetes` package to define a Helm chart resource. You need to replace the `chart` and `fetchOpts` fields with the relevant information for the `ts-server` Helm chart. This block will tell Pulumi to install the Helm chart on your EKS cluster.

- Lastly, we export the kubeconfig of the cluster, which can be used to connect to the Kubernetes cluster with `kubectl`, and attempt to export the URL to access the deployed `ts-server` service, assuming it exposes an external endpoint through a LoadBalancer.

After you run this code with `pulumi up`, Pulumi will provision the infrastructure on AWS and deploy your Helm chart onto the EKS cluster. It might take a few minutes for all resources to be created and the `ts-server` to become accessible. Remember to replace the Helm chart repository details with the correct values for your use case.