Deploy the postgres-cluster helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `postgres-cluster` Helm chart on AWS Elastic Kubernetes Service (EKS), we need to create an EKS cluster and then deploy the Helm chart onto that cluster. We will use Pulumi to automate this process.

First, we'll create the EKS cluster with Pulumi's EKS component, which simplifies the process. Then, we'll use the Helm chart resource from Pulumi's Kubernetes provider to deploy the `postgres-cluster`.

Here's a step-by-step TypeScript program to accomplish this:

1. Create a new EKS cluster.
2. Deploy the Helm chart to the cluster.

Before running this Pulumi program, ensure you have [Pulumi installed](https://www.pulumi.com/docs/get-started/install/), [configured your AWS credentials](https://www.pulumi.com/docs/intro/cloud-providers/aws/setup/), and have [kubectl](https://kubernetes.io/docs/tasks/tools/) configured for the EKS cluster.

Now, let's write the 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';

// Step 1: Create an EKS cluster
const vpc = new aws.ec2.Vpc('vpc', {
  cidrBlock: '10.100.0.0/16',
});

const subnet1 = new aws.ec2.Subnet('subnet-1', {
  cidrBlock: '10.100.1.0/24',
  vpcId: vpc.id,
});

const subnet2 = new aws.ec2.Subnet('subnet-2', {
  cidrBlock: '10.100.2.0/24',
  vpcId: vpc.id,
});

const eksCluster = new eks.Cluster('eks-cluster', {
  vpcId: vpc.id,
  privateSubnetIds: [subnet1.id, subnet2.id],
  instanceType: 't2.medium',
  desiredCapacity: 2,
  minSize: 1,
  maxSize: 3,
  deployDashboard: false,
});

// Export the cluster's kubeconfig and name
export const kubeconfig = eksCluster.kubeconfig;
export const clusterName = eksCluster.eksCluster.name;

// Step 2: Deploy the postgres-cluster Helm chart to the EKS cluster
// We need to create a provider that uses the generated kubeconfig from our EKS cluster
const k8sProvider = new k8s.Provider('k8s-provider', {
  kubeconfig: eksCluster.kubeconfig.apply(JSON.stringify),
});

// Deploy the postgres-cluster Helm chart
const postgresClusterChart = new k8s.helm.v3.Chart('postgres-cluster', {
  chart: 'postgresql',
  version: '10.x.x', // Replace with the version of the chart you want to deploy
  namespace: 'default',
  fetchOpts: {
    repo: 'https://charts.bitnami.com/bitnami', // Assuming you are using the Bitnami PostgreSQL chart
  },
}, { provider: k8sProvider });

// Export the name of the chart 
export const chartName = postgresClusterChart.metadata.apply(m => m.name);
```

In this program, we:

- Define a new VPC and subnets that EKS will use, ensuring our cluster is isolated and secure within our AWS account.
- Create an EKS cluster with the `eks.Cluster` class, specifying the VPC, subnets, and the desired node configuration.
- Establish a Kubernetes provider with the `k8s.Provider` class, which will use our newly created EKS cluster's kubeconfig.
- Use the `k8s.helm.v3.Chart` class to deploy the `postgresql` Helm chart from the Bitnami repo (which is assumed to be what you refer to as `postgres-cluster`).

Keep in mind that you might need to adjust parameters such as chart version or repository URL depending on your specific use case. Also, you can customize the Helm chart values by providing a `values` argument to the Helm chart class.

To execute this program, save it into a file (e.g., `index.ts`), and run `pulumi up` in the same directory. Pulumi will perform the deployment, and you will see the infrastructure being created in your AWS account. Make sure to review the plan that Pulumi shows before you confirm the action.