Introduction to Kustomize

The DevNinjas Kustomize training lets you build bases, overlays and patches and inspect Kubernetes configurations across environments. For development and operations teams with Kubernetes and YAML practice; no Kustomize experience is required.

  • Level: Beginner, Level 1 of 3
  • Workshop code DW22
  • 2 days
  • Live online
  • German or English
Dates & priceGo to the fit check

What can you do after two days?

What you will put into practice

With Kustomize in the DevNinjas Dojo, you build Kubernetes variants without manifest copies and trace each change through to rendered output.

  • Structure environments: Build bases and overlays for shared resources and deliberate differences.
  • Change resources deliberately: Combine labels, images, patches, generators and components, then inspect references.
  • Assess output: Compare rendered YAML documents and adapt Helm output.

Take structuring and review patterns into your repository; the Helm workshop explores the template-based alternative further.

What foundation does your team gain?

Manually copied Kubernetes manifests complicate reviews and delay releases; the training equips your team to organise shared resources and environment variants transparently.

  • Save time: Separate reusable resources from deliberate variants.
  • Reduce risks: Inspect patches, generators and transformers before deployment.
  • Support decisions: Distinguish responsibilities of Kustomize, Helm and GitOps automation.

Your team gains criteria for shared configuration standards and practised review procedures. Production repository migration and setting up GitOps automation are beyond this training's scope.

What you need to know

The workshop starts with Kustomize, not Kubernetes manifests. Introduction to Kubernetes provides suitable preparation.

Required:

  • understand Deployments, Services, and ConfigMaps at a basic level
  • read simple YAML manifests and apply them with kubectl
  • work with a terminal and Git directory layouts

Not required:

  • Kustomize or Helm experience
  • programming skills

8 questions, about 5 minutes

Does the content match your level?

Check anonymously which fundamentals you already know and whether the topics in DW22 match your level. The result gives you an honest recommendation for your next step.

Start the knowledge check

No account, no email, no exam

What does “Introduction to Kustomize” cover?

The agenda shows both workshop days with topics in order. Open each topic for the outline, exercises and technical details.

Day 1: Set up Kustomize and structure environments

5 topics, Tap to open
09:00–10:00Introduction Round
10:00–11:00

Understand Kustomize's configuration role

Kustomize changes Kubernetes objects declaratively and without resource duplication without introducing a separate template language. You compare copied manifests, parameterized templates, and transformations using the same sample application. From this, you identify Kustomize's responsibilities, the resources that remain unchanged, and where packaging or deployment automation still requires other tools.

11:00–12:00

Understand kustomization and build output

A kustomization describes resources and changes, while the build produces ordinary Kubernetes manifests. In the DevNinjas Dojo, our cloud learning environment, you render a prepared application structure and compare source configuration, build output and stored cluster objects. You trace name references and assess which fields Kustomize changes and which remain unchanged.

12:00–13:00Lunch Break
13:00–14:00

Connect bases and overlays

A base groups shared resources; an overlay references that foundation and adds only deliberate differences. You create development, staging, and production variants and deliberately change replicas, resource values, and Namespaces. You inspect what remains shared and how transparent directory structures separate shared from environment-specific fields.

14:00–15:00

Transform labels, names, and images

Cross-cutting fields change multiple resources consistently without editing each manifest separately. You set labels and annotations in the learning environment, add name prefixes and suffixes, select a Namespace, and replace an image name or tag. You then inspect selector and reference changes and limit transformations to the intended objects.

15:00–16:00

Deploy several environment variants deliberately

A shared application is rendered from several overlays for separate environments. You compare their outputs and planned changes before applying selected variants. You correct an unintended difference in the kustomization and use it to explain why generated manifests should not be maintained directly in the repository.

16:00Questions & Answers

Day 2: Combine patches, generators, and components

5 topics, Tap to open
09:00–10:00Questions & Answers
10:00–11:00

Compare patch formats deliberately

Kustomize can process changes in the shared patches field as strategic merge or JSON Patch. You change the same Deployment with both formats and compare target selection, list handling, and exact paths. You then choose the clearer approach for different changes and identify faulty or overly broad targets in the rendered result.

11:00–12:00

Generate ConfigMaps and secrets

configMapGenerator and secretGenerator create resources from files or literals and append a content hash to names by default. You generate both types, inspect updated references, and observe a rollout in the sample application after a configuration change. You record that generation and base64 representation do not provide encryption for secret values.

12:00–13:00Lunch Break
13:00–14:00

Use reusable components deliberately

Components group optional, reusable changes that several overlays can enable independently. Using a prepared optional extension, you examine how several overlays can include it independently. You then compare the component, base, and overlay and derive criteria for a structure in which optional features remain transparent and do not become unintentionally coupled.

14:00–15:00

Customize Helm output with Kustomize

Helm renders a chart; Kustomize can then process the generated resources as a foundation. You enable Helm integration for a prepared chart, set values, and change the output with an overlay. You inspect external execution, reproducible chart versions, and the boundary between package parameters and final environment-specific customization.

15:00–16:00

Build a GitOps structure hands-on

In the final project, you structure a frontend, backend, and data component using shared resources, environment overlays, and optional components. You render each target variant, inspect differences between environments, and correct a faulty reference. Finally, you justify which directories a GitOps controller could watch without configuring a production controller.

16:00Questions & Answers

How does the training work and what is included?

“Introduction to Kustomize”: 2 days live with an instructor. Browser exercises, no local installation. Public sessions: maximum 8 participants. PDF certificate of attendance and Open Badge included.

How you work in the workshop

First Kustomize configurations → patches and generators

  • Practise on your own resources

    You work through exercises on your own resources in DevNinjas Dojo. Your exercise environment is not shared with other participants.

  • Control your own environment

    You have full control over your exercise infrastructure in DevNinjas Dojo. Access uses open protocols such as SSH and HTTPS, as well as web terminals.

  • Ask the instructor live

    Short explanations lead into the exercises. The instructor answers your technical questions live during the workshop.

What is included

No local installation, with proof of attendance for your records

  • Cloud access in your browser

    Your cloud environment in DevNinjas Dojo runs in your browser without local installation, including on restricted corporate networks with VPNs, proxies and firewalls.

    View the Dojo environment

  • A maximum of 8 participants

    Public sessions have no more than 8 participants. For in-house corporate training, we agree the group size with you.

  • Certificate of attendance and Open Badge

    After the workshop, DevNinjas provides a PDF certificate of attendance and an Open Badge. Both document your attendance, not a passed exam.

What does “Introduction to Kustomize” cost and which dates are available?

“Introduction to Kustomize” is a two-day course with a catalogue list price of €1,110 per person plus 19% VAT. The price for an individual date may differ.

Dates and in-house training

Find all current public dates in the dates overview.

View all datesRequest corporate training

What do participants say about “Introduction to Kustomize”?

Selected voices from the DevNinjas portfolio, each labelled with its source.

4.9/ 5

1047+ participant ratings across all DevNinjas workshops · unfiltered

Instructor
5.0
Content
4.8
Hands-on
4.8

DevNinjas overall: approximately 1,384 participants (partly estimated) · 208 companies · 241 workshops

Voice from DW1

“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 BernsteinTRIMET Gelsenkirchen SE

Voice from DW4

“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

Voice from DW5

“All expectations met. Good technical expertise.”

Manuel KöhnMercedes-Benz Tech Innovation

More than 200 customers, including BMW, Bundeswehr and Deutsche Bahn, trust DevNinjas.

How does this workshop fit into your learning path?

This training is the final core step in the learning path “Containers and Kubernetes zero to hero”.

Containers and Kubernetes zero to hero

Core route
4 workshops · 9–10 days
View the full learning path

RECOMMENDED LEARNING ROUTE

  1. ALTERNATIVE AVAILABLEDocker fundamentals

  2. DW2, 3 daysKubernetes basics, Introduction to Kubernetes
  3. DW3, 2 daysKubernetes Advanced, Advanced Kubernetes

  4. CHOOSE 1 OF 2Manage manifests

Prior knowledge can replace individual steps.

Prices per person, plus 19% VAT.

Also part of: Cloud-native developer and GitOps and Continuous Delivery

Vincent Sturm - DevNinjas

Your contact

Vincent Sturm

Key Account Manager

Vincent personally advises you on “Introduction to Kustomize”, public dates and in-house training.

vincent@devninjas.io
+49 221 9865099-4
WhatsApp chat

What should you clarify before booking?

The most common questions on prerequisites, scope, learning path and format.

What Kubernetes knowledge do I need for Kustomize?

You should understand Deployments, Services and ConfigMaps, read simple YAML manifests and apply them with kubectl.

Kustomize, Helm or programming experience is not required. If you still need the Kubernetes foundation, Introduction to Kubernetes teaches the necessary object and manifest fundamentals.

How do Kustomize and Helm differ in use?

The distinction is between resource transformation and package management.

  • Kustomize transforms existing Kubernetes resources without its own template language.
  • Helm renders parameterized charts and manages releases as packages.

The approaches can complement each other: a chart provides the package foundation, while Kustomize applies deliberate final changes. The Helm training explores packaging and release lifecycle in depth.

Is Kustomize alone sufficient for production Kubernetes deployments?

No, Kustomize manages configuration rather than complete production deployment operations. Responsibilities remain separate:

  • Kustomize generates manifests from shared resources and deliberate variants.
  • A GitOps controller continuously reconciles them with the cluster.
  • Reviews, access and operational processes remain your team’s responsibility.

The training structures configuration for this context; Advanced Kubernetes covers advanced operational controls.

Which Kustomize tasks can I work on afterwards?

You can structure basic configuration variants with Kustomize and assess their changes. You practice how to:

  • Group shared resources as bases and adapt them with overlays.
  • Choose transformations, patches and generators for their purpose.
  • Include optional components and rendered Helm output.

The workshop teaches patterns and their boundaries. Applying them to your own repository requires additional reviews and tests; production readiness is not promised.

Does the Kustomize secretGenerator encrypt my secrets?

No, the secretGenerator creates Kubernetes Secrets but does not encrypt confidential values.

  • Files or literal values supply the generated resources.
  • A content hash in the name enables updated references.
  • Base64 representation provides no encryption.

Additional access controls and an appropriate encrypted storage or Git workflow remain necessary. The training explicitly addresses this security boundary.

How do bases and overlays work in practice?

A base groups shared resources; an overlay describes deliberate differences for a target environment.

  • The base contains reusable Kubernetes manifests.
  • The overlay references them and changes a Namespace, image or resource values.

Kustomize renders complete manifests without changing the base. You build and compare development, staging and production variants in the workshop.

What hands-on practice does the Kustomize training include?

You create and inspect configuration variants in the DevNinjas Dojo, our cloud learning environment. The exercises connect:

  • Shared resources and overlays for several environments.
  • Patches, generators and optional components.
  • Helm output and a multi-service example with a GitOps-ready directory structure.

You compare rendered manifests and correct differences. A production repository migration or GitOps installation is outside the scope.

What are the usual hours for DevNinjas training?

DevNinjas training usually runs from 9:00 to 16:00 with a lunch break. Public courses take place live online with an instructor on consecutive days. For corporate training, remote or on site, you can arrange different hours or several training blocks with us.

How does the cloud learning environment (DevNinjas Dojo) work?

DevNinjas Dojo provides the cloud learning environment for your exercises during the booked course. Depending on the workshop, you work with Kubernetes clusters, VMs or containers; the OpenShift training uses a shared cluster. Access uses SSH, HTTPS and web terminals, without a proprietary client or local installation.

You need a current browser and internet access. Restricted corporate networks may require VPN, proxy or firewall permissions. For corporate training, a technical check establishes access beforehand.

What certificate do I receive after DevNinjas training?

After DevNinjas training, you receive a PDF certificate of attendance and an Open Badge. Both are included in public sessions and corporate training. The PDF lists the topics covered and the course period from the start date to the end date, without an hour total.

Even for exam preparation courses, both records confirm attendance, not a passed exam.

How would you like to book “Introduction to Kustomize”?

Choose a public date or request DW22 as in-house training: online or on site, with a date agreed with you.
View public datesRequest corporate training