Deploy the postgres-cluster helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy a PostgreSQL cluster on DigitalOcean Kubernetes Service (DOKS) using a Helm chart with Pulumi, you'll have to perform a few steps. Here's what you generally need to do:

1. Instantiate a DigitalOcean Kubernetes cluster using Pulumi's `digitalocean.KubernetesCluster` resource.
2. Use Pulumi's `kubernetes.helm.v3.Chart` resource to deploy a PostgreSQL Helm chart onto the Kubernetes cluster.

Let's break this down into stages and go through the code required for each step.

### Stage 1: Provision the Kubernetes Cluster

First, you need to declare a Kubernetes cluster in DigitalOcean. We will use the `digitalocean.KubernetesCluster` resource to create it with the required node pool specifications.

### Stage 2: Deploy the PostgreSQL Helm Chart

Once the Kubernetes cluster is provisioned, we can deploy applications onto it. For deploying a PostgreSQL Helm chart, we will use Pulumi's `kubernetes.helm.v3.Chart` resource. This resource allows us to specify the Helm chart we want to install, its version, and any additional configurations we want to apply.

### Putting It All Together

Below is the TypeScript program which combines the two stages:

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

// Step 1: Create the DigitalOcean Kubernetes Cluster
const cluster = new digitalocean.KubernetesCluster("do-cluster", {
    region: "nyc3", // You can choose the region that best suits your location
    version: "latest", // Specify the version of Kubernetes
    nodePool: {
        name: "worker-pool",
        size: "s-2vcpu-2gb", // The droplet size for each worker node
        nodeCount: 3 // The number of worker nodes in the pool
    }
});

// Step 2: Deploy the PostgreSQL Helm Chart on the newly created cluster
const postgresChart = new k8s.helm.v3.Chart("postgres-chart", {
    chart: "postgresql",
    version: "10.3.11", // Make sure to choose the desired chart version
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami", // The repository where the chart is located
    },
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig: cluster.kubeConfigs[0].rawConfig }) });

// Export the cluster's kubeconfig
export const kubeconfig = cluster.kubeConfigs[0].rawConfig;

// Optional: Export the endpoint of the PostgreSQL service
export const postgresEndpoint = postgresChart.getResourceProperty("v1/Service", "postgres-chart-postgresql", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

Here's what each part of the code does:

- We import the `pulumi`, `digitalocean`, and `kubernetes` libraries to work with Pulumi's toolset for these services.
- We use `digitalocean.KubernetesCluster` to create a cluster in the `nyc3` region with a single node pool containing three nodes of size `s-2vcpu-2gb`.
- We then create a `k8s.helm.v3.Chart` resource, specifying the name (`postgresql`), version (`10.3.11`), and repository (`https://charts.bitnami.com/bitnami`) for the PostgreSQL chart we wish to install.
- The `kubeconfig` of the created cluster is exported so that you may use it with `kubectl` or other Kubernetes tools to interact with your cluster.
- Optionally, we export the load balancer's IP address of the PostgreSQL service for direct access.

### Running the Code

1. Create a new directory for your Pulumi project and change into it.
2. Run `pulumi new typescript` to create a new Pulumi TypeScript project. Follow the prompts to set up your project.
3. Install the required packages using npm:

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

4. Replace the contents of `index.ts` with the above TypeScript program.
5. Run `pulumi up` to preview and deploy the changes. Pulumi will report on the resources to be created.

After you run `pulumi up` and approve the plan, Pulumi will provision the necessary resources on DigitalOcean and deploy the PostgreSQL Helm chart to your cluster. You will be able to use the exported `kubeconfig` and `postgresEndpoint` to interact with the PostgreSQL deployment.