Using kubernetes postgresql.cnpg.io with discovery.k8s.io

Question

Pulumi · Accepted Answer

To create a PostgreSQL instance using `postgresql.cnpg.io` in a Kubernetes cluster with `discovery.k8s.io`, you'll need to take several steps. These steps will involve setting up the required CRDs (Custom Resource Definitions) for `postgresql.cnpg.io` and using Kubernetes service discovery to make the PostgreSQL instance available within your cluster.

Unfortunately, the Pulumi Registry Results provided do not directly match your request for `postgresql.cnpg.io`. However, you can use the Pulumi Kubernetes Provider to create the necessary resources, like a PostgreSQL Custom Resource, assuming that the CRDs are already available in your cluster or you have the definitions ready to apply.

I'll guide you through the general steps needed to achieve this in Pulumi with TypeScript. We'll assume you have the necessary CRD definitions for `postgresql.cnpg.io` available, and we will focus on setting up a PostgreSQL instance and making it discoverable using the service discovery feature of Kubernetes.

Here is a Pulumi TypeScript program that outlines the steps you will need to follow:

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

// Step 1: Apply the PostgreSQL CRD (Custom Resource Definition)
// If the PostgreSQL CRD is not already set up in your cluster, you would need to apply it first.
// This step is usually a one-time setup and should be done by a cluster administrator.
// You would use the following if you have the CRD manifest available locally:
const postgresCrd = new k8s.yaml.ConfigFile("postgresCrd", {
    file: "path/to/your/postgresql-crd.yaml",
});

// Step 2: Create a new PostgreSQL instance
// Here you would create a new resource using the PostgreSQL CRD.
// The `postgresql.cnpg.io/v1` version and kind `PostgreSQL` will likely differ depending
// on the actual apiVersion and kind specified in the CRD.
// The `spec` would contain the configuration for your PostgreSQL instance.
// This will typically include things like version, storage, replicas, etc.

const postgresInstance = new k8s.apiextensions.CustomResource("postgresInstance", {
    apiVersion: "postgresql.cnpg.io/v1",
    kind: "PostgreSQL",
    metadata: {
        name: "my-postgres-db"
    },
    spec: {
        // Specify the details for the PostgreSQL instance such as version, storage, etc.
    }
}, { dependsOn: [postgresCrd] });

// Step 3: Set up Service Discovery
// Service discovery in Kubernetes is typically managed by Services and Endpoints.
// The following example shows how you might create a Service that points to the PostgreSQL
// instance you've just created, which can then be discovered by other pods in the cluster.
// Typically, the operator that manages the PostgreSQL instances would create this for you,
// or you would need the specific pod and port details to create a service.

const postgresService = new k8s.core.v1.Service("postgresService", {
    metadata: {
        name: "postgres-service"
    },
    spec: {
        selector: {
            // You need to specify the appropriate selector to target the PostgreSQL pods,
            // which might be set up by the PostgreSQL operator automatically.
        },
        ports: [{
            port: 5432,
            targetPort: 5432,
        }],
    }
});

// The above steps assume you have an operator or a controller that understands how to process
// the `PostgreSQL` resource you've created. If that's not the case, you would need to create
// the underlying Kubernetes deployments, services, and other resources manually or use an
// existing operator that provides this CRD.

// Output the service name to access it in the cluster
export const serviceName = postgresService.metadata.name;

```

This program will:

1. **Apply the PostgreSQL CRD**: If needed, it will apply a CRD for PostgreSQL to the cluster. You must replace `"path/to/your/postgresql-crd.yaml"` with the proper path to your CRD manifest file.

2. **Create a new PostgreSQL instance**: It will create a new instance of PostgreSQL using the CRD. You need to specify the actual `apiVersion` and `kind` based on the CRDs installed in your Kubernetes cluster, and also fill out the `spec` section according to your PostgreSQL configuration needs.

3. **Set up Service Discovery**: It creates a Kubernetes Service to enable service discovery. This allows other components within your Kubernetes cluster to communicate with your PostgreSQL instance. The selector for the Service should match the labels of your PostgreSQL pods. Depending on how the PostgreSQL operator deploys Pods, this might be handled automatically.

Ensure you have the correct access rights to apply CRDs and create resources in your Kubernetes cluster. To execute this program, you would run it through the Pulumi CLI after setting up your Pulumi project and stack. This program does not handle potentially complex configurations and assumes that an Operator will manage the PostgreSQL aspect in your Kubernetes cluster. If such an Operator is not available, additional steps would be needed to configure PostgreSQL directly as a Deployment, along with persistent storage and proper networking.

Be sure to replace placeholder comments and values with actual labels, versions, or other configuration relevant to your deployment.