Deploy the postgres-with-operator helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `postgres-with-operator` Helm chart on an AWS EKS cluster using Pulumi, you will need to follow these steps:

1. **Create an EKS Cluster**: Use the `eks.Cluster` resource to create an Amazon EKS cluster. This cluster will be the Kubernetes environment where your PostgreSQL will run.

2. **Deploy the PostgreSQL Helm Chart**: Use the `helm.v3.Chart` resource to deploy the `postgres-with-operator` chart to your EKS cluster.

Below, I'll provide you with a Pulumi program in TypeScript that accomplishes these tasks. The program assumes you have Pulumi installed, AWS CLI configured with the necessary privileges to create EKS clusters, and Helm charts.

Here is the detailed Pulumi TypeScript program that will create an EKS cluster and deploy a PostgreSQL Helm chart on it:

```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
// Creating a new EKS cluster
const cluster = new eks.Cluster("my-cluster", {
    // Specify the version of Kubernetes
    version: "1.21",
    // Specify the desired capacity for the default node group
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 3,
    // Indicate that the worker nodes should be accessible via SSH
    deployDashboard: false,
});

export const kubeconfig = cluster.kubeconfig;

// Step 2: Deploy the PostgreSQL Helm Chart to EKS

// Create a provider for the newly created EKS cluster
const provider = new k8s.Provider("eks-provider", {
    kubeconfig: cluster.kubeconfig,
});

// Deploy a PostgreSQL Helm chart with the necessary configuration
// Using the Helm Chart resource from the Pulumi Kubernetes provider
const postgresChart = new k8s.helm.v3.Chart(
    "postgres-operator",
    {
        chart: "postgres-operator",
        // specify the version of the chart here if necessary
        // version: "<chart version>",
        fetchOpts:{
            // Set the repo where the Helm chart is located
            repo: "https://charts.bitnami.com/bitnami",
        },
        values: {
            // Customize your PostgreSQL deployment here
            // Refer to the chart's values.yaml for detailed configuration

// Example: Set a custom admin password (you should use a secret for this)
            // postgresql: {
            //   postgresqlPassword: "mysecurepassword",
            // },
        },
    },
    { providers: { kubernetes: provider } } // Ensure you pass the EKS cluster K8s provider
);

// Export relevant resources
export const clusterName = cluster.eksCluster.name; // exports the cluster name
export const clusterEndpoint = cluster.eksCluster.endpoint; // exports the cluster endpoint
export const postgresOperatorStatus = postgresChart.status; // exports the postgres chart status
```

## What the above program does:

1. **EKS Cluster Creation**: It sets up an EKS cluster with default settings regarding instance types and quantity.

2. **Kubernetes Provider Setup**: It creates a Kubernetes provider that enables Pulumi to communicate with the new EKS cluster.

3. **PostgreSQL Helm Deployment**: It then takes that EKS cluster provider to deploy the `postgres-with-operator` Helm chart from the Bitnami Helm repository to your Kubernetes cluster.

## How to use this Pulumi Program:

To execute this Pulumi program, follow these steps:

1. **Install Pulumi**: Make sure you have Pulumi CLI installed on your machine.

2. **Prepare your Environment**:
   - Configure AWS CLI with access keys and default region that has EKS available.
   - Create a new Pulumi project or use an existing one.

3. **Write the TypeScript Program**:
   - Copy the above program into your `index.ts` file in your Pulumi project.
  
4. **Run Pulumi**:
   - Navigate to your Pulumi project directory in the terminal.
   - Run the command `pulumi up` to preview and deploy the changes. You'll see a summary of what will be deployed. Confirm the deployment to proceed.

5. **Accessing the Cluster**:
   - After the deployment is complete, the `kubeconfig` will be outputted by Pulumi. 
   - You can use this `kubeconfig` to interact with your Kubernetes cluster using `kubectl`.

6. **Helm Chart Configuration**:
   - If you have specific configurations for your PostgreSQL Helm chart, modify the `values` section of the `Chart` resource.

Remember to store sensitive information, such as passwords, in a secure manner, ideally using Pulumi's secrets manager or another secrets management tool.