Deploy the mtls-proxy helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `mtls-proxy` Helm chart on Amazon EKS with Pulumi, you need to follow these steps:

1. **Set up an EKS Cluster**: You'll need an EKS cluster in AWS to deploy the Helm chart onto. With Pulumi, you can either create a new EKS cluster or use an existing one.

2. **Install the Helm Chart**: Once you have the cluster set up, you can use Pulumi's `helm.v3.Chart` resource to deploy your Helm chart to the EKS cluster.

Below you will find a Pulumi TypeScript program that:

- Creates an EKS Cluster.
- Deploys the `mtls-proxy` Helm chart onto the EKS Cluster.

First of all, make sure you have Pulumi installed and configured with the necessary AWS credentials. Next, create a new Pulumi project if you haven't already:

```shell
pulumi new typescript
```

Once you set up your project, you can define the resources in the `index.ts` file.

Here's the program, followed by a detailed explanation of each section:

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

// Create an EKS cluster with default settings.
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,
});

// Deploy the mtls-proxy helm chart
const mtlsProxyChart = new k8s.helm.v3.Chart("mtls-proxy", {
    chart: "mtls-proxy", // Replace with the correct chart name or path if it's a custom chart
    // You can specify the Helm chart version, values, namespace, and other settings here.
    // For instance:
    // version: "1.2.3",
    // values: {
    //   // Helm chart values
    // },
}, { provider });

// Export the Helm chart deployment status
export const mtlsProxyStatus = mtlsProxyChart.status;
```

Let's break it down:

- The `eks.Cluster` resource creates a new EKS cluster. The resource defaults are often a good start, but you can customize it with your configurations, such as VPC ID, subnet IDs, node size, etc.

- The `kubeconfig` is exported after the cluster is created, which you can use to interact with your cluster using `kubectl`.

- The `k8s.Provider` resource tells Pulumi how to communicate with the EKS cluster. It uses the `kubeconfig` output from our EKS cluster, which contains all the necessary information to authenticate to the cluster.

- The `k8s.helm.v3.Chart` resource is Pulumi's way of deploying a Helm chart onto a Kubernetes cluster. You specify the chart name and other chart configuration such as values or version similar to how you would with traditional Helm on the command line. Replace `"mtls-proxy"` with the name of the chart you want to deploy if it's hosted in a Helm repository. If the chart is stored locally, use the `path` property to specify the file path to the chart.

- Finally, the `mtlsProxyStatus` is exported, which allows you to see the status of the Helm release after deploying it.

Before running this program, ensure that you have the mtls-proxy Helm chart available in a Helm repository, or have the chart files locally with the correct path if applicable. Adjust the Helm chart properties as needed.

After completing your `index.ts`, you can preview and deploy your infrastructure using these Pulumi CLI commands:

```shell
pulumi up
```

This command will show you a preview of the resources that will be created and, upon confirmation, will provision those on AWS.

To remove the deployed Helm chart and EKS cluster later, you can run:

```shell
pulumi destroy
```

This command will delete all the resources created by this Pulumi program.