Deploy the alb-controller helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `alb-controller` Helm chart on AWS EKS, you'll need to complete a few steps:

1. Set up an EKS cluster.
2. Install the `alb-controller` Helm chart into your EKS cluster.

We will be using a combination of Pulumi resources from the AWS, AWSX, EKS, and Kubernetes packages:

- `aws.eks.Cluster` from the `aws` provider to create an EKS cluster.
- `kubernetes.helm.v3.Chart` from the `kubernetes` provider to deploy Helm charts on Kubernetes.

Below is a detailed TypeScript program using Pulumi which accomplishes these steps.

Before running the Pulumi program, ensure you have the following prerequisites:

- Pulumi CLI installed and AWS credentials configured.
- `kubectl` command-line tool installed to interact with the Kubernetes cluster.
- AWS IAM Authenticator for Kubernetes or update your AWS CLI to a version that includes the `aws eks update-kubeconfig` command.

Now, let's dive into the program:

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

// Step 1: Create an EKS cluster
const cluster = new eks.Cluster("my-cluster", {
    // Define the EKS cluster with the desired settings; refer to the Pulumi API docs for detailed options.
    instanceType: "t2.medium",
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 3,
});

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

// Step 2: Deploy the alb-controller Helm chart onto the EKS cluster
const albControllerChart = new k8s.helm.v3.Chart("aws-load-balancer-controller", {
    chart: "aws-load-balancer-controller",
    version: "1.3.5", // specify the chart version you want to deploy
    namespace: "kube-system", // the namespace where the chart will be installed
    fetchOpts: {
        repo: "https://aws.github.io/eks-charts", // the repository where the Helm chart is located
    },
    values: {
        // define necessary values for the alb-controller, refer to its Helm chart documentation for more options
        clusterName: cluster.eksCluster.name, // pass the EKS cluster name for the controller to know which cluster it manages
    },
}, { provider: cluster.provider });

// Export the Helm chart status
export const albControllerChartStatus = albControllerChart.status;

```

This Pulumi program begins by importing the necessary modules. It then creates an EKS cluster with a desired configuration, including the instance type and scaling options. Once the cluster is up and running, it exports the `kubeconfig`, which can be used to interact with the cluster using `kubectl`.

The second part of the program deploys the `aws-load-balancer-controller` Helm chart. The chart is specified by its name and version and is fetched from its repository. We pass the EKS cluster name through the `values` property, so that the ALB Ingress Controller knows which EKS cluster it should manage.

After you run this Pulumi program with `pulumi up`, it deploys the EKS cluster and the `alb-controller`. You can check the resources created in your AWS account and interact with your Kubernetes cluster using `kubectl` with the provided kubeconfig.

To verify the deployment of the ALB Ingress Controller, run `kubectl get pods -n kube-system` and look for the `aws-load-balancer-controller` pods.

Please note that you might need additional IAM permissions and configurations depending on your specific use case and AWS setup. You would also need to configure the AWS Load Balancer Controller with proper IAM roles. For a production setup, make sure you follow the AWS best practices for security and reliability.