Deploy the mongodb-backup-aws helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the MongoDB backup Helm chart on AWS EKS using Pulumi, we will perform the following steps:

1. Create an EKS Cluster, which will serve as the environment where our Kubernetes resources will run.
2. Deploy a Helm chart that sets up MongoDB and presumably its backup solution onto the EKS cluster.

We will use the following Pulumi resources:
- `eks.Cluster` from the `@pulumi/eks` package, which simplifies creating and configuring an EKS cluster.
- `Chart` from the `@pulumi/kubernetes/helm/v3` package to deploy the Helm chart onto our Kubernetes cluster.

Let's go through the Pulumi TypeScript program.

First, you need to install the required npm packages by running:

```bash
npm install @pulumi/pulumi @pulumi/awsx @pulumi/eks @pulumi/kubernetes
```

Then, you can create a new TypeScript file `index.ts` where you will define the Pulumi program:

```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 an EKS cluster.
const cluster = new eks.Cluster("my-mongo-cluster", {
  desiredCapacity: 2,     // The number of worker nodes for the EKS cluster.
  minSize: 1,             // The minimum number of worker nodes for the EKS cluster.
  maxSize: 3,             // The maximum number of worker nodes for the EKS cluster.
  storageClasses: "gp2",  // The default storage class will use the AWS gp2 volume type.
  deployDashboard: false, // Skip deployment of the Kubernetes dashboard.
});

// Step 2: Deploy the MongoDB Helm chart onto the EKS cluster.
const mongoDbChart = new k8s.helm.v3.Chart("mongodb-backup", {
  chart: "mongodb-backup",
  version: "1.0.0", // Replace this with the version of the chart you wish to deploy.
  fetchOpts: {
    // Specify the repository where your Helm chart is located.
    repo: "https://charts.example.com/", // Replace this with the actual Helm chart repository URL.
  },
}, { provider: cluster.provider });

// Export the Kubernetes cluster name and kubeconfig.
export const kubeConfig = cluster.kubeconfig;
export const clusterName = cluster.eksCluster.name;

// Export a kubeconfig that does not require authentication for testing purposes.
export const kubeconfigNoAuth = pulumi.
  all([cluster.eksCluster.name, cluster.eksCluster.endpoint, cluster.eksCluster.certificateAuthority]).
  apply(([name, endpoint, ca]) => {
    return `apiVersion: v1
clusters:
- cluster:
    server: ${endpoint}
    certificate-authority-data: ${ca.data}
  name: ${name}
contexts:
- context:
    cluster: ${name}
    user: ${name}
  name: ${name}
current-context: ${name}
kind: Config
preferences: {}
users:
- name: ${name}
  user:
    client-certificate-data: ${ca.data}
    client-key-data: ${ca.data}
    `;
});
```

In the code above:

- A new EKS cluster is provisioned using the `eks.Cluster` class. The cluster's node group configuration is designed to be changeable, with node counts ranging from 1 to 3.
  
- We deploy a Kubernetes Helm chart named `mongodb-backup` using Pulumi's Helm support. The `k8s.helm.v3.Chart` resource is used to deploy the MongoDB Helm chart to our cluster. Make sure that the `repo` URL and `version` match with where your actual Helm chart is located and what version you wish to deploy.

- The `kubeConfig` and `clusterName` are exported. These can then be used to interface with your EKS cluster using `kubectl` and other Kubernetes tools.

- The `kubeconfigNoAuth` is for testing purposes to easily connect to your cluster without setting up an IAM authenticator, but this should **never be done in a production environment**.

To run this Pulumi program, you need to set up your AWS credentials and have Pulumi CLI installed. When these prerequisites are satisfied, you can execute the program using the `pulumi up` command, which will deploy the resources defined in the program to your AWS account.