Guaranteed to runFew spots left
20. – 21. August 2026
09:00 - 16:00 (CET/CEST, German time)
Online🇩🇪German
1.110,00 €
per person · plus 19% VAT
Introduction to Kustomize
In two days, confidently manage Kubernetes configurations with Kustomize. From the kustomization.yaml through bases, overlays, and patches to ConfigMap generators and components. All exercises run in your own dedicated cloud environment.
- Workshop levelNo prior knowledge needed
- Satisfied participants2340+
- Days2
- LanguageGerman & English
- Workshop codeDW22
Workshop Details
What makes this workshop stand out
What you will learn and take away
After two days of Kustomize training, you manage Kubernetes configurations cleanly across multiple environments. Here is what you take away:
- Build multi-environment setups with bases and overlays, adjusting configurations via transformers and patches without duplicating manifests
- Automatically generate ConfigMaps and Secrets using generators and trigger rolling updates on changes
- Create reusable components and structure a repository following GitOps conventions
All exercises run in our cloud environment. No local setup, no fiddling. You take a ready-made project structure home with you.
Already experienced with Helm? Our Helm workshop covers the template-based alternative.
Why the investment pays off
When your team manually copies and adjusts Kubernetes manifests for each environment, configuration errors cost time and delay releases. This Kustomize training changes that:
- Reduce configuration errors: A shared base instead of copied YAML files ensures changes are made once and automatically propagated to all environments
- Faster deployments: Standardized overlays and generators make environment switches predictable and repeatable
- No additional tooling needed: Kustomize is built into kubectl and requires no separate installation or license
Small groups with a maximum of 8 participants, so we can address questions from your specific project context.
Prerequisites
Required:
- Basic Kubernetes knowledge: you know what Pods, Deployments, and Services are
- Experience with kubectl and creating simple YAML manifests
- Comfortable working with the Linux terminal
Not required:
- Kustomize experience (built up from scratch)
- Helm knowledge
- Programming skills
Our Kubernetes fundamentals training provides ideal preparation.
Workshop Agenda
Your Agenda at a Glance
Hands-on and structured. Every participant works in their own cloud environment. The agenda shows you what to expect each day.
Day 1: Understand Kustomize and build your first configurations
5 topics09:00–10:00💬 Introduction Round
Running Kubernetes applications across multiple environments leads to a familiar problem: copied YAML files that differ only in small details. One typo in the staging copy, and the deployment fails. Kustomize solves this without templates by combining a shared base with environment-specific modifications. Using a concrete example, you will see how quickly YAML duplication spirals and why Kustomize has been part of the standard kubectl toolkit since v1.14.
The kustomization.yaml file is the central piece: it lists resources, defines transformations, and controls the entire build. You create your first kustomization.yaml, add Deployments and Services as resources, and build the result with kustomize build and kubectl apply -k. By the end of this block, you understand how Kustomize assembles manifests and can review the output before deploying.
12:00–13:00🥪 Lunch Break
The concept of Base and Overlays separates shared configuration from environment-specific adjustments. You create a base with Deployment, Service, and ConfigMap, then build overlays for dev, staging, and production on top. Each overlay changes only what differs: replica count, resource limits, or namespace. The directory structure follows a clear convention that maps directly into a Git repository.
Transformers modify resources without touching the original files. You work with commonLabels and commonAnnotations to set metadata consistently across all resources. Using namePrefix, nameSuffix, and namespace, you adjust resource names and target namespaces per environment. The image transformer replaces container images and tags centrally in the kustomization.yaml instead of editing each Deployment individually.
Time to bring everything together. You deploy an application with a shared base and separate overlays for dev, staging, and production on your own cluster. You use transformers for namespaces, labels, and image tags, and verify with kubectl diff that each environment contains the correct values. By the end, the same application runs in three variants on your cluster.
16:00–16:30💭 Questions & Answers
Day 2: Patches, generators, and production-ready patterns
5 topics09:00–10:00💭 Questions & Answers
Overlays alone are not enough for every adjustment. Strategic Merge Patches add or override fields as if you were editing the original manifest directly. JSON 6902 Patches use targeted operations like add, remove, and replace on exact paths instead. You apply both approaches to the same Deployment and learn when each one is less error-prone.
Instead of maintaining ConfigMaps and Secrets as manual YAML, the configMapGenerator and secretGenerator handle that for you. Kustomize automatically creates a hash suffix in the resource name and updates all references in Deployments. The result: changes to configuration data trigger a rolling update without manually touching the Deployment. You test the full cycle from file change to automatic rollout.
12:00–13:00🥪 Lunch Break
What if multiple overlays need the same adjustment (e.g., a logging sidecar or a standard NetworkPolicy)? Components solve exactly this problem. Unlike bases, components can be optionally included in any overlay without a fixed hierarchy. You build a component for a shared feature and selectively include it in your environments.
In practice, Kustomize and Helm are not mutually exclusive. Many teams use Helm Charts for third-party software and Kustomize for their own applications. You see how helmCharts in the kustomization.yaml renders external charts and customizes them with overlays. For teams coming from pure Helm, we demonstrate the step-by-step migration path: from Helm template output to a Kustomize base.
In the final project, you build a complete multi-service setup with frontend, backend, and database. Each service gets its own base, the overlays for dev and production use components for shared policies. The directory structure follows GitOps conventions that sync directly with ArgoCD or Flux. By the end, you have a repository layout you can use as a template for your own projects.
16:00–16:30💭 Questions & Answers
Our Benefits
All from one hand!
With our high-quality trainings and workshops, you can bring yourself and your team up to date. All this with many benefits that you get from us.
- High Practical Content
- 70% hands-on, 30% theory. You work continuously with real scenarios and take working code home with you. No PowerPoint battles, but directly applicable knowledge for your projects.
- Cloud Learning Environment
- DevNinjas Dojo: Your own Kubernetes clusters and VMs for each participant in the browser. No installation, works despite VPN/proxy/firewalls. You work with dedicated resources, not in shared environments.
- Experienced Trainers
- Full-time DevOps engineers and consultants from DevNinjas lead the workshops. Not external trainers, but specialized employees actively working on client projects and sharing real-world experience.
- Small Groups
- Maximum 8 participants per workshop. Everyone gets individual support from the trainer. Your specific questions and use cases get answered, not passed over in anonymous crowds.
- Real-World Scenarios
- No toy examples or hello-world demos. You work with production-grade setups: multi-container applications, CI/CD pipelines, monitoring stacks. Directly transferable to your production environments.
- Certification
- You receive an official certificate of attendance as PDF and a verified LinkedIn badge. Document your professional development for your employer, HR, and recruiters professionally.
Testimonials
How participants experience our trainings
4.9/ 5
1047+ participant reviews · unfiltered
across all DevNinjas trainings
Trainer
5.0
Content
4.8
Hands-on
4.8
DevNinjas overall: over 1,384 participants · 207 companies · 241 workshops
Including BMW, Bundeswehr, Deutsche Bahn and many more.
"My colleagues specifically looked for a sysadmin course for Docker with another provider and had an instructor who only set up an IDE for them and then only worked on a task sheet with development tasks. I had a course with lots of background information, an instructor who had a really extensive knowledge of the whole subject matter beyond the slides, and I feel optimally informed."
Johannes Bernstein
@TRIMET Gelsenkirchen SE
"The advanced Kubernetes workshop at DevNinjas really helped me grow professionally. The content was practical and excellently prepared, so even complex topics like RBAC, network policies and Ingress were conveyed in an understandable and directly applicable way. The deep expertise of the trainer was especially impressive and noticeable in every session. I can recommend this workshop to anyone who wants to use Kubernetes in production!"
Marius Büttner
@Siemens AG
"From my perspective, the workshop had the right speed and an appropriate level of challenge. The subject matter was explained clearly by the instructor and practically consolidated with well-distributed exercises. Adjusting the workshop focus to the participants wishes was not a problem. Valuable practical experiences were shared, and even more specific questions were gladly answered. The instructor's professional expertise and extensive practical experience on the subject gave this workshop a special quality."
S. Kaiser
@forcont business technology GmbH
"The instructor is very competent and was able to answer all questions satisfactorily even outside the presentation. It was a very pleasant workshop with a good learning pace. I learned a lot and look forward to applying and expanding my acquired knowledge in everyday work, as well as privately."
Schmucker
@RODIAS GmbH
"The training exceeded my expectations by far. It was excellently structured, and the trainer's expertise was evident from the very first moment. The topics were presented vividly and with practical examples, and the exercises were pleasantly challenging, exactly right for a course like this. Through targeted questions, the trainer drew me so deeply into the subject that I absolutely wanted to keep working after the session ended. The teaching was outstanding too: topics were explained clearly and the trainer always addressed follow-up questions. I can recommend DevNinjas one hundred percent."
Patrick J.
"In the workshop the most important Docker and Kubernetes topics were put together, prepared and explained superbly. The exercises fit precisely and were very well chosen in terms of difficulty. I am very satisfied with how much I learned in the five days and feel well prepared for upcoming tasks at work. Sure, you can teach yourself a lot on your own with AI tools, but without the workshop I would not have gained this overview or worked through so many exercises independently."
Christine L.
"The seminar was superbly prepared, the group pleasantly small and the materials first-class. An excellent instructor who knows the subject inside out, takes time for the participants and answers questions in detail. The learning material alternated in a balanced way between theory and hands-on exercises that were timed excellently."
Kevin H.
@Oest Holding GmbH
"All expectations met. Good technical expertise."
Manuel Köhn
@Mercedes-Benz Tech Innovation
"Nico was very organized, technically excellent, and brought a great atmosphere from day one. He knows how to get people excited about the subject and conveys the knowledge very well. Questions were answered right away unless they would have given away later topics, and he then picked those up again at the right moment. All in all a very successful course and definitely a recommendation. Thank you, Nico, for the instructive and cool time."
Pascal S.
"I really enjoyed the Docker & Kubernetes workshop at DevNinjas. Nico explained the complex topics around containers and orchestration in a very understandable and practical way. The mix of theory and hands-on exercises was perfect for being able to apply everything directly. I was able to take a lot away for my everyday work and now feel significantly more confident working with Docker and Kubernetes."
Dominik Kneissl
@Siemens Healthineers
"Overall, I thought the training was very good. The instructor was technically very competent and gave plenty of input on every topic. On a personal level it was very pleasant too, which made it fun. The learning environment was absolutely exemplary in its setup and usability. I will definitely recommend the training and DevNinjas."
Marius B.
@Dataport
"The trainer's materials were very well prepared, and the approach was clearly structured, moving from the easy to the more demanding blocks of content. Advanced Kubernetes fundamentals and the path to a solution were shown using practical examples, and questions were always resolved with an answer and a fitting real-world example. My expectations were met, and I can only recommend this seminar."
Stefan J.
@BMI
"The "Docker & Kubernetes Bundle" training provided me with solid, practical knowledge for everyday work and enabled me to handle Docker and Kubernetes professionally. The excellently structured material offers real added value, even beyond the workshop. The combination of technical depth and interactive delivery by the trainer rounded off the whole experience. An experience that continues to help me even after the training."
Swen Strangfeld
@Bundesdruckerei GmbH
"It was fun and I learned a lot that I can actually apply directly in my company. The trainer's approach was very hands-on, and he repeatedly brought in real-world examples."
Felix R.
@Dirk Rossmann GmbH
"The workshop gave me a very good insight into Kubernetes and made working with containers much clearer. Nico delivered the content in a practical and well-structured way, so I could quickly find my way around. The hands-on exercises in particular helped me apply what I learned directly. For anyone looking for a solid introduction to Kubernetes, this workshop is definitely recommended."
Daniel Hagen
@DKB Service GmbH
"The CKAD content is extensive, and the hands-on exercises are helpful and necessary to really learn it. This course struck a good balance between enough practice and sufficient depth. The understanding conveyed over the three days is definitely enough to work through the remaining CKAD topics on your own, because the concepts are taught clearly. The learning environment worked smoothly and reliably."
Peter Menze
Continue Learning
Related Workshops for You
Alternative
Intermediate
Introduction to Kubernetes Helm
Develop production-ready Helm charts in 3 days: From installation through OCI registry publishing to GitOps integration. You create custom charts, test with helm-unittest, and deploy multi-environment setups. All exercises run on dedicated Kubernetes clusters in the DevNinjas Dojo.
3 Days€1,665.00
FoundationBeginner
Introduction to Kubernetes
Learn to use Kubernetes confidently in three days. From Pods and Deployments to Storage and deployment strategies. You work hands-on in your own cloud environment with kubectl, K9s, and Helm.
3 Days€1,665.00
Next StepIntermediate
Kubernetes Advanced
Two-day Kubernetes Advanced Training for production-ready deployments. You'll learn StatefulSets for databases, RBAC for security, HPA and VPA for auto-scaling, and Prometheus and Grafana for monitoring. Perfect after the introductory course or with comparable Kubernetes experience. Live online in groups of up to 8 participants.
2 Days€1,110.00
Your Contact
Vincent Sturm
Key Account Manager
Looking for the right Kubernetes or DevOps training for your team? Vincent personally advises you on open workshops, certification prep and customized in-house training. He can also connect you with our consulting services. Get in touch with him directly.
Frequently asked questions
Yes, basic Kubernetes knowledge is a prerequisite. You should know what Pods, Deployments, and Services are and be able to apply simple manifests with kubectl. Experience with Kustomize itself is not required; we build that up from scratch.
If you are missing the Kubernetes fundamentals: Our Kubernetes fundamentals training provides ideal preparation.
Kustomize and Helm take different approaches to Kubernetes configuration management:
Kustomize works directly with plain YAML. You define a base and adjust it via overlays, patches, and transformers. No templating, no separate package structure. Kustomize has been built into kubectl since v1.14 and requires no separate installation.
Helm uses Go templates and packages applications as Charts with their own repository system. More flexible for complex parameterization, but with a steeper learning curve.
In practice, many teams use both: Helm Charts for third-party software (e.g., Prometheus, Nginx Ingress), Kustomize for their own applications. Our Helm workshop covers the template-based approach.
For many teams: yes. Kustomize covers configuration management for your own applications, from simple setups to multi-cluster deployments with dozens of services. Combined with a GitOps tool like Argo CD or Flux CD, you get a complete deployment workflow.
Where Kustomize reaches its limits: if you want to build reusable packages for other teams or the community, Helm with its chart format is better suited. Many teams therefore use Kustomize for their own applications and Helm for external charts. We cover both approaches in the workshop.
After two days, you can:
- Build multi-environment setups with bases and overlays for dev, staging, and production
- Adjust manifests via transformers (labels, namespaces, images) and patches (strategic merge, JSON 6902)
- Automatically generate ConfigMaps and Secrets using generators and trigger rolling updates
- Create components as reusable building blocks for cross-team policies
- Combine Kustomize with Helm Charts for a hybrid setup
Reality check: Two days are enough to use Kustomize productively. For advanced patterns (custom transformer plugins, complex SOPS integration), we recommend continuing with the provided materials after the workshop.
Yes, and that is exactly what many teams do in practice. Since version 4.1, Kustomize can render Helm Charts directly by defining a helmCharts block in your kustomization.yaml. Kustomize then runs helm template and applies your overlays and patches to the result.
A typical setup: you install third-party software (e.g., Prometheus or cert-manager) as a Helm Chart and customize it via Kustomize overlay for your environment. Your own applications are managed directly with Kustomize bases and overlays. We practice this integration on the second day of the workshop.
An overlay references an existing base and defines only the differences. Your base contains, for example, a Deployment with 1 replica and default resources. The production overlay increases replicas to 3, sets higher CPU and memory limits, and switches the Namespace.
The directory structure reflects this: a base/ folder with shared manifests, alongside overlays/dev/, overlays/staging/, and overlays/prod/, each with its own kustomization.yaml. With kubectl apply -k overlays/prod/, you deploy the production variant. The original files in the base remain unchanged.
Kustomize provides a secretGenerator that creates Secrets from files or literal values. The generated resources automatically receive a hash suffix in their name. When the content changes, a new name is created, and Kubernetes triggers a rolling update.
Important: The secretGenerator handles creating Secrets, not encrypting them. Secret values still appear as Base64 in the manifest. For encrypted Secrets in Git repositories, teams additionally use tools like SOPS or Sealed Secrets. In the workshop, we focus on the generator workflow and the automatic rollout behavior.
Our trainings usually take place from 9:00 to 16:00, both on-site and for public remote trainings.
For corporate trainings, other time models are flexible and can be worked out together.
We recommend a maximum of 8 participants per training to ensure individual attention for each participant. For corporate trainings, arrangements for larger groups are possible.
Yes, upon completion you will receive an official certificate of attendance from DevNinjas as PDF. This confirms your successful participation and the topics covered. The certificate is perfect for conversations with your employer and your personnel file.
Additionally, you will receive a verified digital badge that you can directly embed in your LinkedIn profile (section "Licenses & Certifications"). The badge follows the Open Badges 2.0 standard and is verifiable via QR code at any time. This way you showcase your qualification and position yourself with recruiters.