Deploy the ingress-helm-chart helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `ingress-helm-chart` on an AWS EKS cluster using Pulumi, you'll need to take the following steps:

1. **Set up an EKS cluster**: You need a Kubernetes environment to deploy the Helm chart. AWS EKS is a managed Kubernetes service which makes it easy to run Kubernetes clusters without having to manage the infrastructure.

2. **Install and Configure Helm**: Helm is a package manager for Kubernetes, and it allows you to define, install, and upgrade even the most complex Kubernetes applications in the form of charts.

3. **Deploy the Ingress Helm Chart**: Once Helm is installed, you can deploy the ingress helm chart. There are multiple Ingress controllers available, such as nginx, traefik, etc. You'll need to specify which one you want to deploy through Helm.

Here’s how you can implement this in a Pulumi program using TypeScript:

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

// Create an EKS cluster.
const cluster = new eks.Cluster("my-cluster", {});

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

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

// Deploy the ingress-nginx Helm chart to the cluster.
const ingressController = new k8s.helm.v3.Chart("nginx-ingress", {
  chart: "ingress-nginx",
  version: "3.7.1", // Use the appropriate version
  namespace: "default",
  fetchOpts: {
    repo: "https://kubernetes.github.io/ingress-nginx", // Use the appropriate Helm repo
  },
}, { provider });

// Export the address of the ingress controller.
export const ingressEndpoint = ingressController
  .getResourceProperty("v1/Service", "default", "nginx-ingress-controller", "status")
  .apply(status => status.loadBalancer.ingress[0].hostname ?? status.loadBalancer.ingress[0].ip);
```

**Explanation of the Program:**

- We import necessary modules for Pulumi, AWS EKS, and Kubernetes.
- We create an EKS cluster with default settings using `eks.Cluster`. This encapsulates the creation of all resources necessary for the cluster (like VPC, IAM roles, etc.).
- We export the `kubeconfig` of the newly created EKS cluster so you can interact with it using `kubectl`.
- We set up a `kubernetes.Provider` configured to our EKS cluster’s Kubernetes.
- We deploy the nginx ingress controller using the `k8s.helm.v3.Chart` class. The chart is sourced from its Helm repository, and we specify a chart `version`. For other types of ingress controllers, you would change the `chart` and `fetchOpts.repo` accordingly.
- We then export the ingress controller's endpoint as `ingressEndpoint`, which will be the address to access the controller and by extension the services that it manages.

**Next Steps:**

- Run `pulumi up` to deploy your Pulumi program.
- After deployment, you can use the exported `kubeconfig` to manage your Kubernetes cluster with `kubectl` commands.
- Use the `ingressEndpoint` to access your applications served by the ingress controller.

**Important Points:**

- You need to replace `"3.7.1"` with the `version` of the ingress-nginx you want to use. Always try to use a stable Helm chart version.
- The example uses the nginx ingress controller, but if you are using a different Ingress controller, update the chart details accordingly.
- Ensure you have the required AWS credentials and Pulumi CLI configured on your machine where you intend to run this code.
- Be aware of AWS charges for the resources created as part of the EKS cluster.