Deploy the backup-maker-controller helm chart on AWS EKS

Question

Pulumi · Accepted Answer

In order to deploy the `backup-maker-controller` Helm chart on an AWS EKS cluster, you will need to follow these high-level steps:

1. Create an Amazon EKS cluster using `aws.eks.Cluster` resource.
2. Deploy the Helm chart using the `kubernetes.helm.sh/v3.Chart` resource, which relies on the existence of a Kubernetes cluster and applicable `kubeconfig` file to interact with it.

The following Pulumi program in TypeScript will guide you through setting up an AWS EKS cluster and deploying the `backup-maker-controller` Helm chart into that cluster:

First, we'll set up the EKS cluster. This is done by creating a new instance of `eks.Cluster`, which will provision the cluster on AWS. This involves setting up the required VPC and IAM roles as well, but for simplicity, we'll assume default roles and VPC are sufficient.

After the cluster is ready, we'll deploy the `backup-maker-controller` Helm chart. This involves using the `helm.sh/v3.Chart` resource, which will manage the Helm release for us from within our Pulumi 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";

// Create an EKS cluster with the default configuration.
const cluster = new eks.Cluster("backup-maker-cluster", {});

// Export the cluster kubeconfig and name to be used outside the Pulumi stack.
export const kubeconfig = cluster.kubeconfig;
export const clusterName = cluster.eksCluster.name;

// Define the Helm chart for deployment.
const backupMakerChart = new k8s.helm.v3.Chart("backup-maker-controller", {
    fetchOpts: {
        // Replace `repoUrl` with the actual Helm chart repository URL.
        // This is where your Helm chart is hosted.
        repo: "https://charts.yourcompany.com/",
    },
    chart: "backup-maker-controller",
    version: "1.0.0", // Replace with the desired chart version
    namespace: "default", // Replace with the namespace where you want to deploy your chart
}, { provider: cluster.provider });

// Export the Helm chart deployment name.
export const chartName = backupMakerChart.releaseName;
```

In this program:

- We first import the required modules from Pulumi to manage AWS resources, EKS clusters, and Kubernetes resources.
- We create a new EKS cluster using the `eks.Cluster` class. This cluster is provisioned with all the necessary components such as an IAM role for EKS and a VPC. For this specific example, we are using the default configurations provided by Pulumi.
- We export the `kubeconfig` which provides the necessary credentials to access the cluster. This output can be used to interact with the cluster via `kubectl` or any Kubernetes SDK.
- We define the `backupMakerChart` using the `k8s.helm.v3.Chart` class. You'll need to replace `repoUrl` with the URL of your Helm chart's repository and choose the correct chart version.
- The `chartName` is exported, which can be helpful if you need to reference the deployed Helm chart from other parts of your Pulumi program or in the Pulumi stack outputs.
- We pass `cluster.provider` to the Helm chart to ensure it deploys to the EKS cluster we created.

Remember to replace the placeholder values such as `https://charts.yourcompany.com/` and `1.0.0` with the actual repository URL and version of your Helm chart.

To run this, you would typically check this code into a Pulumi project and use the Pulumi CLI to execute it. Make sure you have the AWS and Kubernetes configurations set up correctly for Pulumi to access both your AWS account and the Kubernetes cluster.

Once the Pulumi program is executed, it will create the AWS EKS cluster and deploy the `backup-maker-controller` Helm chart onto it, without any manual intervention required for Helm commands or `kubectl`.