Using kubernetes kustomize.toolkit.fluxcd.io with helm.toolkit.fluxcd.io

Question

Pulumi · Accepted Answer

To use Kubernetes with FluxCD's `kustomize.toolkit.fluxcd.io` and `helm.toolkit.fluxcd.io`, you can apply the principles of GitOps and Infrastructure as Code (IaC). FluxCD is a set of GitOps tools that help you manage your Kubernetes clusters and applications. It works by watching for changes in your Git repositories and automatically applying the Kubernetes manifests found within.

Here's the general idea to get you started:

1. **Set up a Kubernetes Cluster**: You'll need a Kubernetes cluster as the foundation for deploying your resources. You can create one using cloud provider-specific services such as Amazon EKS, Google GKE, or Azure AKS, or you can provision one manually.

2. **Install FluxCD on your Cluster**: This will set up the FluxCD controllers and custom resource definitions (CRDs) in your cluster, allowing you to manage resources in a GitOps fashion.

3. **Create Git Repositories for Your Manifests**: You will need a Git repository to store your Kubernetes manifests. With FluxCD, you'll have repositories for raw Kubernetes YAML, Helm charts, and Kustomize overlays.

4. **Configure FluxCD to Watch Your Repositories**: You'll create custom resources that tell FluxCD where to find your manifests and how to apply them. For Helm charts, you'll use HelmRelease resources, and for raw YAML or Kustomize, you'll define Kustomization resources.

5. **Iterate on Your Application**: As you modify your application manifests and push changes to your Git repository, FluxCD will detect the changes and automatically apply them to your cluster.

Here is an example in TypeScript using Pulumi to create a Kubernetes cluster and set up FluxCD with both Helm and Kustomize support:

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

// Create a Kubernetes cluster using EKS, GKE, AKS or any other managed Kubernetes service.
// For simplicity, let's assume you already have a cluster and you have the kubeconfig available.

// Load the cluster configuration from an existing Kubernetes cluster's kubeconfig file.
const cluster = new k8s.Provider("my-cluster", {
    kubeconfig: "path-to-your-kubeconfig.yaml", // Replace with the correct path to your kubeconfig
});

// Deploy the FluxCD components to your cluster
// We'll start by applying the CRDs for `helm.toolkit.fluxcd.io` and `kustomize.toolkit.fluxcd.io`.
const fluxHelmCrds = new k8s.yaml.ConfigGroup("flux-helm-crds", {
    files: ["https://github.com/fluxcd/helm-controller/blob/main/config/crd/bases/helm.toolkit.fluxcd.io_helmreleases.yaml"],
}, { provider: cluster });

const fluxKustomizeCrds = new k8s.yaml.ConfigGroup("flux-kustomize-crds", {
    files: ["https://github.com/fluxcd/kustomize-controller/blob/main/config/crd/bases/kustomize.toolkit.fluxcd.io_kustomizations.yaml"],
}, { provider: cluster });

// Deploy FluxCD components including Helm and Kustomize controllers.
// The specific FluxCD setup depends on several factors and may involve more configuration than shown here.
const fluxComponents = new k8s.yaml.ConfigGroup("flux-components", {
    files: ["https://github.com/fluxcd/flux2/releases/download/v0.23.0/install.yaml"], // Use the latest version
}, { provider: cluster, dependsOn: [fluxHelmCrds, fluxKustomizeCrds] });

// After setting up FluxCD on your cluster, you would typically define a `GitRepository` object pointing to your manifests,
// and then set up `HelmRelease` and `Kustomization` objects for each application.

// An example of a HelmRelease object:
const myHelmRelease = new k8s.apiextensions.CustomResource("my-helm-release", {
    apiVersion: "helm.toolkit.fluxcd.io/v2beta1",
    kind: "HelmRelease",
    metadata: {
        namespace: "default", // Namespace where the Helm chart should be released
    },
    spec: {
        interval: "5m", // Periodic check to ensure the release state matches the desired state
        chart: {
            spec: {
                // Details about the chart to be released
                chart: "the-name-of-your-chart",
                version: "x.y.z", // The chart version
                sourceRef: {
                    kind: "GitRepository",
                    name: "my-git-repo",
                    namespace: "flux-system", // Ensure this matches the namespace of your GitRepository
                },
                interval: "1m", // How often to fetch the chart from the source
            },
        },
    },
}, { provider: cluster });

// Similarly, define your Kustomization resources.

// Sync your applications
// Now that FluxCD is set up and watching your repository, any changes pushed to your Git repository for Helm or Kustomize configurations
// will automatically trigger an update within your cluster.

export const kubeconfig = cluster.kubeconfig;
```

In this example, `@pulumi/kubernetes` is used to interface with your Kubernetes cluster from Pulumi. Remember to replace placeholder values like `"path-to-your-kubeconfig.yaml"` and chart details with actual values appropriate for your setup.

This program will set up the FluxCD components on your cluster and demonstrate how to define a `HelmRelease` custom resource. Your actual FluxCD configuration will depend on the specifics of your environment and use case. You would also need to create `GitRepository` custom resources and potentially others, depending on your setup.

Please note that depending on the version of the Helm and Kustomize controllers you use, the CRD URLs and layout may differ. The URLs provided in this example should point to the correct versions of the files at the time of your setup.

For more information on using FluxCD, configurations, and detailed setup, refer to the [FluxCD Documentation](https://fluxcd.io/docs/). To learn more about Pulumi's Kubernetes integration, check out the [Pulumi Kubernetes documentation](https://www.pulumi.com/docs/intro/cloud-providers/kubernetes/).