Using kubernetes postgresql.cnpg.io with node-group

Question

Pulumi · Accepted Answer

To deploy a PostgreSQL instance using the `postgresql.cnpg.io` API within a Kubernetes cluster, you will need to have a Kubernetes cluster and node group set up.

Let's start by creating an Elastic Kubernetes Service (EKS) cluster and a managed node group in AWS using Pulumi. Once the cluster is set up, we will define a PostgreSQL database instance using the `postgresql.cnpg.io` Operator.

Before we get to the code, here are some key points regarding the resources we're creating:

1. `awsx.eks.Cluster`: This is a high-level component that encapsulates the creation of an EKS cluster, abstracting away many complexities around creating and configuring the EKS cluster.

2. `eks.NodeGroup`: This represents a managed group of EC2 instances that are registered as nodes in the Kubernetes cluster.

3. `kubernetes.apiextensions.CustomResource`: This is the way we create instances of custom resources in Kubernetes. Since `postgresql.cnpg.io` is a Custom Resource Definition (CRD) on your Kubernetes cluster, you create instances of PostgreSQL databases as `CustomResource` objects in Pulumi.

Here's a TypeScript program that provisions these resources using Pulumi:

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

// Create an EKS cluster with the default configuration.
const cluster = new awsx.eks.Cluster("my-cluster");

// Create a managed node group using the EKS cluster.
const nodeGroup = new eks.NodeGroup("my-node-group", {
    cluster: cluster,
    // Define the size and type of the EC2 instances for the node group.
    instanceType: "t3.medium",
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 3,
}, { provider: cluster.provider });

// Kubernetes provider to connect to the created EKS cluster.
const k8sProvider = new kubernetes.Provider("k8s-provider", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// PostgreSQL instance using the 'postgresql.cnpg.io' API.
const postgresqlInstance = new kubernetes.apiextensions.CustomResource("my-postgresql-instance", {
    apiVersion: "postgresql.cnpg.io/v1",
    kind: "PostgreSQL",
    metadata: { 
        name: "my-postgres-db",
    },
    spec: {
        // Define your PostgreSQL instance specifications here.
        // This will vary depending on the 'postgresql.cnpg.io' CRD's spec.
    }
}, { provider: k8sProvider });

// Export the Kubeconfig
export const kubeconfig = cluster.kubeconfig;
```

In this code, we're setting up an EKS cluster and an associated managed node group using the default configuration for simplicity; you can customize this as needed for your use case. We are assuming that you've set up the `postgresql.cnpg.io` on your Kubernetes cluster already. Postgres instance specs must be filled in based on your requirements and the specific schema of `postgresql.cnpg.io` CRD.

To use the Pulumi program provided:

1. Install the Pulumi CLI on your machine and set up your [AWS credentials](https://www.pulumi.com/docs/intro/cloud-providers/aws/setup/).
2. Create a new directory, initialize a Pulumi project, and install the necessary dependencies with `npm` or `yarn`.
3. Copy the above TypeScript code into your `index.ts` file in your Pulumi project directory.
4. Review the Postgres instance specs and fill them in as per the `postgresql.cnpg.io` CRD specification.
5. Run `pulumi up` to deploy the resources.

After deploying, you will have an EKS cluster with a managed node group ready to host your PostgreSQL deployment defined by the CRD configuration you set.

Remember to consult the official [Pulumi AWSX documentation](https://www.pulumi.com/registry/packages/awsx/) for further customization options for your EKS cluster, and also check the PostgreSQL operator documentation for valid configurations.