Deploy the postgrest helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy the PostgREST Helm chart on the DigitalOcean Kubernetes Service (DOKS), we'll use Pulumi with TypeScript. Below is a program that sets up a Kubernetes cluster on DigitalOcean and then deploys PostgREST onto it using the Helm chart.

Steps involved in the below program:

1. **Create a Kubernetes Cluster**: We will create a Kubernetes cluster on DigitalOcean using the `digitalocean.KubernetesCluster` resource.
2. **Install PostgREST with Helm**: After the cluster is ready, we'll deploy PostgREST using the Helm package, `kubernetes.helm.v3.Chart`, that Pulumi provides for working with Helm charts in Kubernetes clusters.

The PostgREST Helm chart itself isn't included in the Pulumi registry results, but you can typically find Helm charts on artifact hubs or repositories like Helm Hub.

Let's go through the Pulumi TypeScript program:

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

// Step 1: Create a DigitalOcean Kubernetes Cluster
const cluster = new digitalocean.KubernetesCluster('do-cluster', {
    // Specify the region where the cluster should be created
    region: digitalocean.Regions.NYC3,

// Specify the version of Kubernetes to use
    version: '1.21.5-do.0',

// Define the node pool for the cluster
    nodePool: {
        size: 's-2vcpu-2gb',
        name: 'default-pool',
        nodeCount: 2,
    },
});

// Obtain the kubeconfig from the cluster we created
const kubeconfig = cluster.kubeConfigs[0].rawConfig;

// Step 2: Initialize the Kubernetes Provider with the kubeconfig from DOKS
const k8sProvider = new kubernetes.Provider('k8s-provider', {
    kubeconfig: kubeconfig,
});

// Step 3: Deploy the PostgREST Helm chart using the Kubernetes provider
const postgrestChart = new kubernetes.helm.v3.Chart('postgrest', {
    chart: 'postgrest', // This is the name of the chart in the helm repository
    // Specify the values to customize the PostgREST Helm chart.
    // Values can be sourced from the chart’s values.yaml file or the chart’s repository.
    values: {
        // Edit the values based on PostgREST Helm chart's available configurations
    },
}, { provider: k8sProvider });

// Export the kubeconfig to access the cluster with kubectl
export const kubeconfigOutput = pulumi.secret(kubeconfig);

// Export the cluster's name
export const clusterName = cluster.name;
```

**What this code does:**

- **Imports Required Modules**: The Pulumi modules for Kubernetes, DigitalOcean, and other utilities are imported.
- **Creates a Kubernetes Cluster in DigitalOcean**: A cluster is defined with the necessary configuration such as the region, node size, and Kubernetes version.
- **Initializes a Kubernetes Provider**: This provider uses the kubeconfig from the newly created DOKS, which allows Pulumi to interact with the cluster.
- **Deploys the Helm Chart**: The PostgREST Helm chart is orchestrated to deploy onto the Kubernetes cluster using the Kubernetes provider. Note that you need to specify the actual chart name, and in this case, I assumed it to be 'postgrest'. You might need to adjust the `chart` field and `values` accordingly to the real Helm chart and its settings that you want to use.
- **Exports Outputs**: Important details like the `kubeconfig` are marked as outputs, and they are also marked as secrets to avoid displaying sensitive information in plaintext.

Before running this code, ensure that you have an account on DigitalOcean and you’ve set up the Pulumi CLI with the necessary credentials to access your DigitalOcean account. The Pulumi program assumes this setup is already done.

Once the Pulumi program is applied, it will use the DigitalOcean API to create the Kubernetes cluster and then deploy PostgREST into it.

To run this program:
- Save the code to a file, for example, `index.ts`.
- Use `npm` or `yarn` to install the necessary packages, like so:
  ```bash
  npm install @pulumi/pulumi @pulumi/digitalocean @pulumi/kubernetes
  ```
- Run `pulumi up` to execute the code and create your infrastructure.

After the cluster and PostgREST are successfully deployed, you can interact with your Kubernetes cluster using `kubectl`. The kubeconfig needed for `kubectl` can be obtained from the Pulumi stack output named `kubeconfigOutput`. Keep in mind that handling kubeconfig securely is important to protect your cluster's integrity.