Using kubernetes source.toolkit.fluxcd.io with postgresql.cnpg.io

Question

Pulumi · Accepted Answer

To use FluxCD with a PostgreSQL database in a Kubernetes cluster using Pulumi, we'll look at two parts: setting up FluxCD and deploying a PostgreSQL instance. FluxCD is a set of continuous and progressive delivery solutions for Kubernetes, and deploying it involves creating custom resource definitions and setting up the FluxCD controllers. The PostgreSQL aspect will involve deploying a PostgreSQL database using the postgresql.cnpg.io CustomResourceDefinition provided by the Cloud Native PostgreSQL Operator.

Setting up FluxCD

First, install the FluxCD resources on your cluster. You can do this by creating a GitRepository that points to your cluster configuration in Git and a Kustomization that refers to the repository and instructs Flux on what to apply.

Deploying PostgreSQL

Next, you would define a PostgreSQL instance using the Cloud Native PostgreSQL operator. This operator is usually installed separately and provides a postgresql.cnpg.io CustomResourceDefinition. To use it with Pulumi, you'll have to have it created or apply it through a file.

Below is an example of how you might write this in TypeScript using Pulumi. This program assumes that you have the FluxCD and PostgreSQL operators already installed in your Kubernetes cluster and that you have configured your Pulumi with the appropriate access to that cluster.

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

// Initialize a Kubernetes provider for Pulumi
const provider = new k8s.Provider("provider", { kubeconfig: "<your kubeconfig here>" });

// Define a GitRepository resource for FluxCD that points to your configurations
const gitRepo = new k8s.core.v1.ConfigMap("flux-git-repo", {
    metadata: { name: "flux-system" },
    data: {
        url: "https://github.com/<your-repo>",
        // Specify further details as needed for your Git repository
    },
}, { provider });

// Define a Kustomization resource for FluxCD
const kustomization = new k8s.apiextensions.CustomResource("flux-kustomization", {
    apiVersion: "source.toolkit.fluxcd.io/v1beta1",
    kind: "Kustomization",
    metadata: { name: "flux-system" },
    spec: {
        interval: "10m",
        path: "./deploy",
        prune: true,
        sourceRef: {
            kind: "GitRepository",
            name: "flux-system",
        },
        // You can define additional kustomization specs here
    },
}, { provider });

// Define a PostgreSQL instance using the 'postgresql.cnpg.io' CustomResourceDefinition
const postgresqlInstance = new k8s.apiextensions.CustomResource("postgresql-instance", {
    apiVersion: "postgresql.cnpg.io/v1",
    kind: "Postgresql",
    metadata: { name: "my-database" },
    spec: {
        // Define your PostgreSQL spec here, such as version, size, and storage details
    },
}, { provider });

// Export the public Service endpoint of PostgreSQL
export const postgresqlServiceEndpoint = postgresqlInstance.status.apply(status => {
    return status?.service?.name || "";
});

Explanation

GitRepository: This object represents a source of configuration data that Flux will synchronize with your cluster. You will need to adjust the url to point to your Git repository where your Kubernetes manifests or Kustomize configuration is stored.
Kustomization: This is a FluxCD custom resource that tells the Flux controllers how to apply the contents of the GitRepository to the cluster. It has several parameters, such as how often to pull the repo (interval), where inside the repo to look for the Kubernetes manifests (path), and the source reference of the git repository (sourceRef).
Postgresql: This custom resource is provided by the Cloud Native PostgreSQL operator and defines a PostgreSQL database within your cluster. You would specify things like the PostgreSQL version, storage, and replica details in the spec block.
Provider: This is a Pulumi concept that allows us to point to specific Kubernetes clusters if you manage multiple or want to specify a specific configuration. Here, it's created but not used explicitly—Pulumi assumes that resources use the default provider if another isn't specified.

Make sure to substitute <your kubeconfig here>, <your-repo>, and other placeholder comments with your actual configuration details. The specifics of your GitRepo and PostgreSQL instances (like version or required storage) would depend on your actual use cases and configurations you have set up in your version control.

The export statement makes the Pulumi program output the endpoint of the PostgreSQL service when it's done setting up the database which can be useful to connect to your database.

Before you run this Pulumi program, remember to have FluxCD and the PostgreSQL operator installed in your cluster. Ensure that your Kubernetes cluster is also configured correctly with Pulumi with the necessary permissions to deploy resources.