Deploy the postgresql-backup-to-minio helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `postgresql-backup-to-minio` Helm chart to an AWS EKS cluster, we will follow these steps:

1. **Set up an EKS cluster:** We'll create an EKS cluster using the `aws.eks.Cluster` resource. This will set up the necessary infrastructure on AWS for running a Kubernetes cluster.
2. **Install Helm chart:** Once the cluster is set up, we'll use the `kubernetes.helm.v3.Chart` resource to deploy the `postgresql-backup-to-minio` Helm chart to the cluster.

Firstly, let's make sure you have Pulumi installed and set up with the correct AWS credentials. You should have the Pulumi CLI installed, and your AWS CLI configured with access to your account.

Here's a Pulumi program in TypeScript that accomplishes these tasks:

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

// First, create an EKS cluster.
const cluster = new eks.Cluster("my-cluster", {
    instanceType: "t2.medium",
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 2,
});

// Expose the Kubeconfig for the EKS cluster.
export const kubeconfig = cluster.kubeconfig;

// With the EKS cluster available, we deploy the postgresql-backup-to-minio Helm chart.
// Note that you need to provide the correct chart version and repository URL that contains the postgresql-backup-to-minio chart.

// Use the cluster's kubeconfig to create a provider.
const provider = new k8s.Provider("k8s-provider", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

const chart = new k8s.helm.v3.Chart("postgresql-backup-to-minio", {
    chart: "postgresql-backup-to-minio",
    version: "your_chart_version", // replace with the chart version you want to deploy
    fetchOpts: {
        repo: "your_chart_repository_url", // replace with Helm chart repository URL
    },
    values: {
        // Define any values here that the helm chart accepts.
    },
}, { provider });

// Export the name of the bucket that MinIO will use for backups.
export const bucketName = chart.getResource("v1/Service", "postgresql-backup-to-minio").metadata.name;
```

Explanation:

1. We create an Amazon EKS cluster named `"my-cluster"` using `eks.Cluster`. We configure the cluster with an instance type `t2.medium`, which is a good default choice for general-purpose workloads, and set the desired number of instances to 2 with a minimum of 1 and a maximum of 2.
2. We then output the `kubeconfig` for the EKS cluster using `export`, which will allow us to interact with the cluster with tools like `kubectl`.
3. We define the Kubernetes provider using the `kubeconfig` of the newly created EKS cluster. This provider will be used when deploying resources to the EKS cluster.
4. Then, we deploy the `postgresql-backup-to-minio` Helm chart using Pulumi's Helm `v3.Chart` resource. We pass the chart name and optionally the version number and the repository URL. You'll need to replace `"your_chart_version"` and `"your_chart_repository_url"` with the appropriate values for the chart you want to deploy.
5. Lastly, we export the bucket name, which will hold the backups created by this chart. This will be provided by the specific Helm chart used for deploying PostgreSQL with MinIO backup.

Before running `pulumi up`, ensure to replace `"your_chart_version"` and `"your_chart_repository_url"` with actual values provided for your Helm chart.

Keep in mind that the default values used in the `values` object inside the `Chart` resource may not be appropriate for your use case, and you might need to configure them based on your requirements and the configuration options provided by the `postgresql-backup-to-minio` chart.