Deploy the airports-postgres helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To accomplish your goal of deploying the `airports-postgres` Helm chart on AWS EKS using Pulumi, you'll follow these steps:

1. Create an EKS cluster using the [`eks.Cluster`](https://www.pulumi.com/registry/packages/eks/api-docs/cluster/) component.
2. Deploy the `airports-postgres` Helm chart to EKS using the [`kubernetes.helm.v3.Chart`](https://www.pulumi.com/registry/packages/kubernetes/api-docs/helm/v3/chart/) resource.

Below is a detailed program that demonstrates how to do this. This program is written in TypeScript and will require you to have `@pulumi/eks` and `@pulumi/kubernetes` packages installed.

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

// Create an EKS cluster.
// This will provision a new EKS cluster on AWS with the default settings, including the default node group.
const cluster = new eks.Cluster("my-cluster", {
    instanceType: "t2.medium",
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 3,
    storageClasses: "gp2",
    deployDashboard: false,
});

// Export the cluster's kubeconfig.
export const kubeConfig = cluster.kubeconfig;

// Create a Kubernetes provider instance that uses the kubeconfig from the created EKS cluster.
const k8sProvider = new kubernetes.Provider("k8s-provider", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Deploy the airports-postgres Helm chart.
const chart = new kubernetes.helm.v3.Chart("airports-postgres", {
    chart: "airports-postgres",
    version: "1.0.0", // Specify the exact chart version.
    fetchOpts: {
        repo: "http://charts.yourcompany.com/", // Replace with the actual Helm repository URL.
    },
}, { provider: k8sProvider });

// Export the endpoint of the Postgres service.
export const postgresEndpoint = pulumi.output(chart.getResourceProperty("v1/Service", "airports-postgres", "status"))
    .apply(status => status.loadBalancer.ingress[0].ip || status.loadBalancer.ingress[0].hostname);
```

Here's what each part of the program does:

- **EKS Cluster Creation**: We initialize a new EKS cluster using the `eks.Cluster` component. The cluster will have one managed node group with the specified instance type and scaling parameters.

- **Kubeconfig Export**: We export the kubeconfig of the created EKS cluster, which you'll need to interact with your Kubernetes cluster using `kubectl` or other Kubernetes tools.

- **Kubernetes Provider Setup**: We set up a Pulumi Kubernetes provider to interact with our EKS cluster. This requires the kubeconfig from the created EKS cluster.

- **Deploying Helm Chart**: Using the Kubernetes provider, we deploy the `airports-postgres` Helm chart. Here you need to specify the version of the chart and the repository where your Helm chart is located.

- **Export Postgres Endpoint**: Once the Helm chart is deployed, we export the endpoint (IP address or hostname) of the Postgres service so that it can be accessed externally.

To use this code, you'll need to replace the Helm chart version and repository URL with appropriate values for the `airports-postgres` Helm chart. If the Helm chart requires additional configuration, those values can be provided in the `values` argument of the `Chart` resource.

After you've written this code in your Pulumi project, install the necessary dependencies with npm or yarn:

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

Once complete, you can deploy your code using the Pulumi CLI:

```bash
pulumi up
```

Pulumi will provision the resources in the order outlined, and if successful, the Postgres service endpoint will be printed as an output.