Deploy the forward helm chart on AWS EKS

Question

Pulumi · Accepted Answer

In order to deploy the Forward Helm chart on AWS EKS, we will proceed by breaking down the task into a series of steps, which we will then translate into a Pulumi program in TypeScript.

1. **Create an AWS EKS Cluster**: Before we can deploy any applications on EKS, we need to create an EKS cluster. Here we will use the `aws.eks.Cluster` resource to create a new cluster on AWS.

2. **Define the EKS Node Group**: To run our Helm chart, we need a group of worker nodes. These are EC2 instances that run the pods in our cluster. Typically, you define a node group using the `aws-native.eks.Nodegroup` resource.

3. **Deploy the Forward Helm Chart**: Once we have the EKS cluster and node group in place, we can deploy applications to it using Helm charts. The `kubernetes.helm.v3.Chart` resource can be used to deploy a Helm chart to the cluster.

Let’s start writing the Pulumi program in TypeScript:

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

// Create an EKS Cluster
const cluster = new eks.Cluster("my-cluster", {
    // Specify the version of Kubernetes you want to run on the cluster.
    version: "1.21",
    // Define the size and properties of the node group, which dictates the EC2 instances that run the Kubernetes worker nodes.
    nodeGroup: {
        instanceType: "t2.medium",
        desiredCapacity: 2,
        minSize: 1,
        maxSize: 2,
        // ... Other configuration like AMI, keypair, etc.
    },
    // ... Additional options for VPC, subnets, IAM roles, etc.
    deployDashboard: false, // Kubernetes dashboard is optional and up to your preference
});

// Deploy the Forward Helm chart into the EKS cluster.
// Ensure you have the correct Helm chart name and repository URL.
const forwardHelmChart = new k8s.helm.v3.Chart("forward", {
    chart: "forward",
    version: "1.2.3", // Replace with the Helm chart version you intend to deploy
    fetchOpts: {
        // Define the Helm chart repository here, if it's not part of the stable repository
        repo: "https://example.com/charts",
    },
}, { provider: cluster.provider });

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

This program performs the following actions:

- Defines an EKS cluster, with a set number of EC2 instances as node groups.
- Deploys a Helm chart named "forward" using the specified version number and repository URL (in this example, `https://example.com/charts` is a placeholder; replace it with the correct repository URL).

Please ensure that you replace `version` (of EKS Cluster and Helm chart) and Helm `repo` with the suitable values matching the Forward Helm chart you have.

You also need to be logged into your AWS account and have the AWS access set up, as Pulumi will use your AWS credentials to create the resources. Make sure your AWS user has the necessary permissions to create EKS clusters and manage EC2 instances.

After you have written this program into a `index.ts` file within your Pulumi project, you can deploy the resources with the following Pulumi CLI commands:

```bash
# Login to the Pulumi service
pulumi login

# To preview the deployment without making any changes
pulumi preview

# To deploy the infrastructure to AWS
pulumi up

# Check the output of the EKS kubeconfig after the deployment
pulumi stack output kubeconfig
```

This kubeconfig output can be used to interact with your Kubernetes cluster using the usual `kubectl` commands or any other compatible Kubernetes management tool.

Remember that Pulumi manages your infrastructure via state files. The initial command `pulumi login` might ask you to log in or sign up for the Pulumi service where your infrastructure state will be stored securely. Alternatively, you can store your state using a [self-managed backend](https://www.pulumi.com/docs/intro/concepts/state/#backends) such as an S3 bucket.