Deploy the k8s-aws-ebs-tagger helm chart on AWS EKS

Question

Pulumi · Accepted Answer

Deploying a Helm chart to an Amazon EKS (Elastic Kubernetes Service) cluster involves several steps with Pulumi, including setting up an EKS cluster, configuring Kubernetes provider, and finally deploying the Helm chart. Below, I'll walk you through the entire process.

### Prerequisites

Before you proceed, make sure you have the following prerequisites in place:

1. AWS CLI is installed and configured with the necessary access rights.
2. Pulumi CLI is installed.
3. Helm is installed if you need to download or configure the Helm charts locally.
4. Node.js and npm/yarn installed to run the Pulumi program.

### Step-by-step Guide

#### Step 1: Create an EKS Cluster

First, we will create an Amazon EKS cluster using Pulumi's EKS package, which simplifies cluster creation.

#### Step 2: Configuring the Kubernetes Provider

Once the EKS cluster is up and running, we will set up the Kubernetes provider to interact with the cluster.

#### Step 3: Deploy the Helm Chart

Finally, we will deploy the `k8s-aws-ebs-tagger` Helm chart into our EKS cluster using Pulumi's `helm.v3.Chart` resource.

#### Pulumi TypeScript Program

Here is the complete TypeScript program which carries out the tasks mentioned above:

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

// Step 1: Create and configure a new EKS cluster.
// The EKS cluster itself, including IAM roles and networking infrastructure.
const cluster = new eks.Cluster("eks-cluster", {
    desiredCapacity: 2,     // Desired number of worker nodes.
    minSize: 1,             // Minimum number of worker nodes.
    maxSize: 3,             // Maximum number of worker nodes.
    storageClasses: "gp2",  // Default storage class for EBS (Elastic Block Store).
    deployDashboard: false  // Do not deploy the Kubernetes dashboard.
});

// Export the cluster's kubeconfig and its EKS endpoint to easily access the cluster with `kubectl`.
export const kubeconfig = cluster.kubeconfig;
export const clusterEndpoint = cluster.core.endpoint;

// Step 2: Set up the Kubernetes provider pointing to the EKS cluster kubeconfig.
// This provider is used to interact with the cluster's Kubernetes API Server.
const k8sProvider = new k8s.Provider("eks-k8s", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Step 3: Deploy the k8s-aws-ebs-tagger Helm chart into the EKS cluster.
const helmChart = new k8s.helm.v3.Chart("k8s-aws-ebs-tagger", {
    chart: "k8s-aws-ebs-tagger",
    // Depending on the source of your Helm chart, version and repository might also need to be specified.
    // For example, if your chart is in a Helm repo, you'd specify `version` and `fetchOpts: { repo: "<url>" }`.
    values: {
        // Provide any specific configuration for the chart here.
        // If the chart requires customized values, you replace the following with your content.
        // For example:
        // serviceType: "LoadBalancer"
    },
}, { provider: k8sProvider });

// Optional: Export any resources or values that you might want to access later or use in other stacks.
export const helmChartName = helmChart.getResourceName();
```

When you run this program with Pulumi, it will perform the following actions:

1. Provision a new EKS cluster with a default node group using the specified instance types and desired capacity.
2. Set up the Kubernetes provider that Pulumi needs for deploying resources to the EKS cluster.
3. Deploy the `k8s-aws-ebs-tagger` Helm chart. You might need to update the chart and value configuration details according to the actual chart you are using.

Remember to replace the placeholder values in the `values` block with the actual configuration required by your Helm chart. Helm chart configurations vary, so consult your chart documentation for specific settings.

After writing this Pulumi code, run the following commands in the terminal:

```sh
pulumi stack init dev
pulumi up
```

This initializes a new Pulumi stack called `dev` and deploys the resources described in the code. The `pulumi up` command shows a preview of the changes and prompts for confirmation before making any changes to your cloud resources.

I hope this guide helps you understand the process of deploying a Helm chart on EKS using Pulumi. If you've got specific configurations or requirements for the Helm chart, you may need to modify the 'values' section to fit your use case.