
Explore kustomize fundamentals, including overlays, bases, config maps, secret generators, and custom resource definitions—and learn to manage namespaces, multi-environment setups, and CI/CD integration.
Explore kustomize as a Kubernetes configuration tool that hydrates template-free, purely declarative YAML into outputs, enabling layered, customizable configurations. Use a multicolored mugs example to show base and variant reuse.
Learn kustomize hands-on by layering base manifests with customization files to deploy versioned WordPress apps on Kubernetes, without duplicating YAML, using namespaces and hydration.
Discover why kustomize streamlines Kubernetes configuration by using a base yaml with environment-specific overlays, managing images, secrets, and certificates, with fast, template-free hydration.
Explore the customization file and transformers to master kubernetes configuration, including secrets, config maps, prefixes, namespaces, labels, annotations, CRDs, patching, and a real-world customized workflow with GitHub actions.
Install customize as a standalone package to manage versions independently from Cube CTL. Explore macOS options with Homebrew or MacPorts, Docker images, and building from source.
Set up a Kubernetes cluster using Docker Desktop with its Kubernetes feature or a lightweight k3d installation, then create a two-node cluster for demos.
Explore the Kustomize customization file, a declarative YAML that applies transformations to base Kubernetes resources and generates resources. Understand the four lists—resources, generators, transformers, validators—and the hydration order.
Discover how Kustomize transformers modify Kubernetes manifests, using configuration files, inline settings, or convenience fields, and prefix resource names like V1 across bases and overlays.
Learn how kustomize generators create Kubernetes resources, including config map and secret generators, and control behavior, files, literals, generator options, and labels.
Learn to use config map generators in customize to create config maps from env files, literals, and files, apply them to deployments, and control hash behavior with generator options.
Explore secret generators in Kubernetes, similar to config map generators, creating opaque secrets with base64-encoded data for MySQL configuration, and verify them in a deployment.
Explore resources field usage: local paths or URLs, including remote repositories, and apply Hashicorp URL format with double slash syntax for remote bases.
Learn to manage kubernetes namespaces with kustomize by using the customization file's namespace convenience field and transformers, including onset only behavior to attach or preserve namespaces across resources.
Master how to manage labels and annotations with customize, using the labels key to update only resource labels and avoid changing selectors or templates that could cause downtime.
Master how to apply patches in customize using strategic merge and JSON patch, targeting resources by group version kind, namespace, and label or annotation selectors, with inline or file-based patches.
Master strategic merge patches in Kubernetes to patch resources, including inline or file patches, while using targets and directives, and letting customize create namespaces when needed.
Discover json6902 patches in kustomize to replace fields in Kubernetes manifests, targeting resources with path-based operations and optional json or yaml patch formats.
learn how custom resource definitions extend the Kubernetes API and how customize uses transformer configurations to update CRD spec fields like config map ref and image.
Master multi-env workflows in kustomize using a base and overlays to generate production-ready yaml for the Kubernetes API. Organize per-service directories and address hard-coded environment variables.
Explore multi-environment workflows with kustomize, using base and overlays for dev, stage, and prod to deploy online boutique application. Extract components for ops and security, then apply with port-forward verification.
Structure complex microservice manifests with a base directory and overlays, grouping services into subdirectories and using customization files to assemble deployments, namespaces, and environment-specific config maps.
Leverage customized components in Kustomize Mastery to reuse configuration across overlays with a components directory, shared annotations and labels, and optional databases like MySQL or Postgres.
Use replacements in kustomize to copy fields from a source to target resources, updating environment variables and resource names during hydration across overlays.
Set up a GitHub actions workflow with kustomize to hydrate customization manifests and deploy to a GKE cluster, using workload identity federation for secure authentication.
Continue exploring kustomize with upcoming videos, including helm comparisons, limitations, and real-world use cases. Join the Slack channel for suggestions and build something fun.
Explore the Kustomize CLI to build and hydrate Kubernetes manifests from a customization file, and leverage cfg, create, edit, and completion commands for managing resources.
Learn to work with customize using helm charts and the Helm CLI. Enable Helm in customize and deploy MySQL and Prometheus in database and monitoring namespaces from Helm charts.
In this course, you will:
Understand how Kustomize works.
Understand how to use kustomize to manage kubernetes manifests for multiple environments from scratch.
Apply kustomize to existing kubernetes configurations manifests.
Assess and decide when to use Kustomize and when the use case isn’t suitable.
Understand various ways to set up Kustomize and pros and cons of each.
Before taking this course, you should be:
Familiar with what Kubernetes is and the basic structure of a Kubernetes manifest file.
Have basic knowledge or experience working with YAML files.
Interested in writing clean YAML code and applying best practices such as DRY (Dont Repeat Yourself) in your Kubernetes configurations.
This course is intended for:
Beginner, Intermediate to advanced Kubernetes developers who are seeking new ways to manage their Kubernetes configurations.
Developers who just want to get more familiar with Kustomize and the possibilities it offers.
Developers looking for best practices around Kubernetes configuration management with minimal overhead. (I want to stick to YAML. I don't want to learn a new language just to manage my configurations).
Why you should take this course:
Configuration management in Kubernetes becomes complicated the more you use it and the more complex your infrastructure gets, especially when you need to manage multiple environments.
New Kubernetes developers end up duplicating their Kubernetes configurations across multiple environment directories, resulting in even more complication.
Updating deployment manifests becomes really difficult when you need to make a simple manifest change, since this will need to be made in several places due to the duplication.
Most other Kubernetes configuration management tools add more complexity to simple workflows, e.g. helm charts.
The name “Kustomize” is just cool and now integrated into kubectl :)
Extra things that come with this course:
Access to the course Slack team, for getting help/advice from me and other students.