Unleash Kustomize Superpowers: Generate Multiple Kubernetes Manifests From a Single File

Want to streamline your Kubernetes configurations? Discover how the Kustomize plugin merger can revolutionize your workflow! This comprehensive guide provides a simple yet powerful example of generating multiple manifests from a single source, boosting efficiency and reducing redundancy.

The Challenge: Reverse Patching in Kustomize

Kustomize excels at using a single patch to modify multiple resources. But what if you need to generate multiple resources from a single template? The standard Kustomize approach falls short. This is where the kustomize-plugin-merger steps in!

Use Case: CronJob Generation

Imagine you need to deploy multiple CronJobs with slightly different configurations. Instead of duplicating the entire manifest for each CronJob, you can use the plugin merger to efficiently generate them. Let's walk through a real-world example.

Input: Base and Overlays

We start with a base CronJob manifest (input/cronjob-common.yaml) defining the common structure and parameters. Think of this as your master template:

apiVersion: batch/v1
kind: CronJob
metadata:
  name: this-will-be-applied-to-multiple-cronjobs
spec:
  failedJobsHistoryLimit: 2
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: my-app
            image: my-app
            command: [] # The command will be updated via Merger.
            imagePullPolicy: Always
            restartPolicy: Never
            imagePullSecrets:
            - name: docker-registry
  schedule: " " # The schedule will be updated via Merger.
  successfulJobsHistoryLimit: 0

Next, we have overlay files (input/cronjob-01.yaml, input/cronjob-02.yaml, input/cronjob-03.yaml) that define the specific properties for each CronJob instance. These overlays will modify the name, schedule, and command fields in the base manifest.

Example Overlay (input/cronjob-01.yaml):

apiVersion: batch/v1
kind: CronJob
metadata:
  name: cronjob01
spec:
  schedule: ' 0 1 * * * '
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: my-app
            command:
            - echo
            - cronjob01

Manifest: Kustomization Configuration

The kustomization.yaml file defines the Kustomize build process and utilizes the kustomize-plugin-merger.

apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
generators:
- merger.yaml

The merger.yaml configures the plugin:

apiVersion: generators.kustomize.devopshive.net/v1alpha1
kind: Merger
metadata:
  name: merge
  annotations:
    # Containerized KRM function.
    config.kubernetes.io/function: |
      container:
        image: ghcr.io/devopshivehq/kustomize-generator-merger
        mounts:
        - type: bind
          src:./
          dst: /mnt
spec:
  resources:
  - name: my-cronjobs
    input:
      method: overlay
      files:
        # The same as in the KRM container above, omit it if Exec KRM is used.
        root: /mnt
      sources:
      - input/cronjob-01.yaml
      - input/cronjob-02.yaml
      - input/cronjob-03.yaml
      destination: input/cronjob-common.yaml
    merge:
      strategy: combine
  output:
    format: raw

Key elements in merger.yaml:

• config.kubernetes.io/function: Specifies the KRM (Kubernetes Resource Management) function, defining the execution environment (containerized in this example).
• resources: Defines the merging process. Includes the sources and destination files, paths and the merge strategy.
• input: Determines the input method, in this case, an overlay.
• sources: Defines the overlay input files that will be merged into the common base file.
• destination: Determines the source file that represents the base object configurations.

Build: Execute Kustomize

To build the manifests, run the following command:

kustomize build --enable-alpha-plugins

Note: Make sure you have Kustomize installed and have enabled alpha plugins. This will use the kustomize-plugin-merger to perform the merging.

Output: Multiple CronJob Manifests

The output is three individual CronJob manifests, each with the properties from the base AND their respective overlay files. Each manifest will have it's own name, schedule, and command from the specific cronjob-xx.yaml overlay.

Example Output (cronjob01):

apiVersion: batch/v1
kind: CronJob
metadata:
  name: cronjob01
spec:
  failedJobsHistoryLimit: 2
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - command:
            - echo
            - cronjob01
            image: my-app
            imagePullPolicy: Always
            name: my-app
            imagePullSecrets:
            - name: docker-registry
            restartPolicy: Never
  schedule: 0 1 * * *
  successfulJobsHistoryLimit: 0

Applying this configuration will create 3 separate CronJob resources in Kubernetes with each following the specific configuration from the overlay files.

Benefits of Using the Kustomize Plugin Merger:

• Reduced Redundancy: Avoid duplicating large manifest files.
• Increased Efficiency: Streamline the creation of multiple similar resources.
• Improved Maintainability: Centralized base configuration simplifies updates.

Long-Tail Keywords

• Kustomize generate multiple resources
• Kubernetes resource merging
• Kustomize plugin example

By leveraging the kustomize-plugin-merger, you can significantly enhance your Kustomize workflow, creating more efficient, maintainable, and scalable Kubernetes deployments. Take your Kustomize skills to the next level and embrace the power of manifest generation!