Using kubernetes source.toolkit.fluxcd.io with operators.coreos.com

Question

Pulumi · Accepted Answer

To use Flux with your Kubernetes cluster, you can deploy Flux resources using Pulumi. Flux is a set of continuous and progressive delivery solutions for Kubernetes that are open and extensible. To manage Kubernetes resources through automated reconciliation, Flux follows the GitOps principles.

Flux works with Kubernetes operators provided by operators.coreos.com, which is another aspect of the GitOps toolkit, responsible for things like package management within a Kubernetes cluster. To ensure we create a setup that uses Flux and is in line with operators, we will create a Flux configuration that synchronizes a cluster state with a Git repository and can further manage operators from Operator Lifecycle Manager (OLM).

I'll walk you through setting up Flux in a Kubernetes cluster using Pulumi in TypeScript. First, we'll declare a Flux `GitRepository` and `Kustomization` resource that tell Flux where to pull the configurations from and how to apply them. Then, we'll tie these resources into the necessary Operator Lifecycle Manager (OLM) components if needed, but to keep things simple, we'll focus on setting up Flux first.

Below is a Pulumi TypeScript program that sets up Flux on a Kubernetes cluster. The pulumi/flux package contains all the resources necessary to install Flux on a Kubernetes cluster.

```typescript
import * as flux from "@pulumi/flux";

// Create a GitRepository resource pointing to the repository with your Kubernetes manifests.
const gitRepo = new flux.GitRepository("my-flux-repo", {
    spec: {
        // Replace with the URL to your git repository
        url: "https://github.com/your-org/your-repo.git",
        // Use the "main" branch as the source branch
        ref: {
            branch: "main",
        },
        // Specify the interval at which to pull changes from the repository
        interval: "1m",
    }
});

// Create a Kustomization resource that tells Flux what to do with the manifests in the GitRepository.
const kustomization = new flux.Kustomization("my-flux-kustomization", {
    spec: {
        // Use the GitRepository we just set up
        sourceRef: {
            kind: "GitRepository",
            name: gitRepo.metadata.name,
        },
        // The path within the repository to the Kubernetes manifests
        path: "./k8s/production",
        // The interval at which to apply the manifests
        interval: "1m",
        // Tell Flux to prune resources that are no longer present in the Git repository
        prune: true,
    },
});

// Export the URL to the git repository so we can access it easily later
export const gitRepositoryUrl = gitRepo.spec.url;
```

What this program does:
1. Imports the flux package from Pulumi's ecosystem.
2. Creates a `GitRepository` resource that tells Flux where in the Git repository the Kubernetes manifests are located.
3. Specifies the branch and the synchronization interval. Flux will check for new changes in this interval.
4. Creates a `Kustomization` resource that references the `GitRepository`.
5. Specifies the path to the Kubernetes manifests within the repo, how often to apply the manifests, and whether to prune resources that have been removed from the repository.
6. Exports the git repository URL as a stack output.

Please replace the placeholder `https://github.com/your-org/your-repo.git` with the URL to your git repository where your Kubernetes manifests are committed. Additionally, adjust the `./k8s/production` path to point to the directory within your repo that contains the manifests Flux should apply to the cluster.

You will need to have Pulumi and kubectl already set up, and your Kubernetes cluster should be accessible via kubectl. After deploying this Pulumi program, Flux will be configured on your cluster, and it will continuously synchronize the cluster state with the state defined in the provided git repository.

This setup does not include the configuration for operators.coreos.com; that would be an additional step to integrate Operator Lifecycle Manager into this workflow, which typically involves creating Subscription and OperatorGroup resources in your Kubernetes cluster. This process depends heavily on which operators you intend to use and your specific use case.

Please feel free to ask if you'd like to know how to include Operator Lifecycle Manager in this setup or have other questions related to using Pulumi.