Chart values and customization in Kubernetes - Deep Dive

Overview - Chart values and customization

What is it?

Chart values and customization refer to the way you configure Helm charts in Kubernetes. Helm charts are packages that describe how to deploy applications. Values are settings you can change to customize how the application runs without changing the chart itself. This lets you reuse charts for different environments or needs by simply adjusting these values.

Why it matters

Without chart values and customization, you would have to edit the chart files directly every time you want to change something. This is slow, error-prone, and hard to manage across many deployments. Customizing with values makes deployments flexible, repeatable, and easier to maintain, saving time and reducing mistakes.

Where it fits

Before learning this, you should understand basic Kubernetes concepts and Helm chart structure. After mastering values and customization, you can learn advanced Helm features like hooks, chart dependencies, and creating your own charts.

Mental Model

Core Idea

Chart values are like a menu of options you fill out to customize a ready-made recipe (the Helm chart) for your specific taste and environment.

Think of it like...

Imagine ordering a pizza where the chart is the pizza recipe, and the values are your choice of toppings, crust type, and size. You don’t change the recipe book; you just tell the chef your preferences.

┌───────────────┐
│ Helm Chart    │
│ (Recipe)     │
├───────────────┤
│ Templates     │
│ Default Values│
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Values File   │
│ (Your Choices)│
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Rendered      │
│ Kubernetes    │
│ Manifests     │
└───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Helm Chart Basics

Concept: Learn what a Helm chart is and its main parts including templates and default values.

A Helm chart is a package that contains Kubernetes resource templates and a default values file called values.yaml. Templates define what Kubernetes objects to create. The values.yaml file holds default settings that templates use to fill in details like image names or ports.

Result

You know that a Helm chart is a reusable package with templates and default settings.

Understanding the structure of a Helm chart is essential before customizing it because values only make sense when you know what they control.

2

Foundation

What Are Chart Values?

Concept: Chart values are settings that control how templates generate Kubernetes manifests.

Values are key-value pairs defined in values.yaml or passed during installation. Templates use these values to fill in details dynamically. For example, a value might set the container image tag or the number of replicas.

Result

You see that values let you change deployment details without editing templates.

Knowing that values drive template rendering helps you realize customization is safe and flexible.

3

Intermediate

Overriding Default Values

🤔Before reading on: do you think you can change chart behavior by editing the chart files or by providing a separate file? Commit to your answer.

Concept: You can override default values by providing your own values file or command-line options during Helm install or upgrade.

When installing a chart, use the --values or -f flag to provide a custom YAML file with your values. You can also use --set to override individual values directly in the command line. Helm merges these with defaults, using your overrides.

Result

Your deployment uses your custom settings instead of defaults without changing the original chart files.

Understanding how to override values externally is key to managing deployments safely and consistently across environments.

4

Intermediate

Using Nested and Complex Values

🤔Before reading on: do you think chart values can only be simple key-value pairs or can they be nested structures? Commit to your answer.

Concept: Chart values can be nested YAML structures like dictionaries and lists to represent complex configurations.

Values.yaml can contain nested keys, for example, setting resources.limits.cpu or defining a list of environment variables. Templates access these nested values using dot notation like {{ .Values.resources.limits.cpu }}.

Result

You can customize detailed and structured settings in your deployment.

Knowing that values support complex structures allows you to configure sophisticated applications without changing templates.

5

Intermediate

Using Conditional Logic in Templates

Concept: Templates can use values to decide which resources to create or how to configure them using conditionals.

Helm templates use Go templating syntax. You can write if-else blocks that check values to include or exclude parts of the manifest. For example, you can enable or disable a feature by setting a value to true or false.

Result

Your deployment can adapt dynamically based on the values you provide.

Understanding conditional logic in templates shows how values control not just data but also deployment structure.

6

Advanced

Managing Multiple Environments with Values

🤔Before reading on: do you think one values file is enough for all environments or should you use multiple? Commit to your answer.

Concept: Use different values files for different environments like development, staging, and production to customize deployments safely.

Create separate YAML files like values-dev.yaml and values-prod.yaml with environment-specific settings. Use the -f flag multiple times or switch files when deploying to different clusters. This keeps environment differences clear and manageable.

Result

You can deploy the same chart with different configurations easily and reliably.

Knowing how to separate environment configurations prevents errors and simplifies deployment workflows.

7

Expert

Advanced Customization with Value Files and Overrides

🤔Before reading on: do you think Helm merges multiple values files in order or does it replace them entirely? Commit to your answer.

Concept: Helm merges multiple values files and command-line overrides in a specific order, allowing layered customization.

When you provide multiple -f files, Helm merges them from left to right, with later files overriding earlier ones. Command-line --set overrides all files. This lets you build base values and layer environment or user-specific overrides cleanly.

Result

You achieve fine-grained control over configuration with predictable precedence.

Understanding Helm’s merge order and override precedence is crucial to avoid unexpected configuration conflicts in production.

Under the Hood

Helm uses Go templating to process chart templates. It loads the default values.yaml, then merges any user-provided values files and command-line overrides. The merged values are passed to the template engine, which replaces placeholders with actual values. This generates Kubernetes manifests that Helm applies to the cluster.

Why designed this way?

This design separates configuration from code, allowing charts to be reusable and flexible. Merging values files supports layering configurations for different environments. Using Go templating provides powerful logic without changing the chart source.

┌───────────────┐
│ Default       │
│ values.yaml   │
└──────┬────────┘
       │
┌──────▼────────┐
│ User values   │
│ (custom.yaml) │
└──────┬────────┘
       │
┌──────▼────────┐
│ Command-line  │
│ --set flags   │
└──────┬────────┘
       │
┌──────▼────────┐
│ Merged Values │
└──────┬────────┘
       │
┌──────▼────────┐
│ Template      │
│ Rendering     │
└──────┬────────┘
       │
┌──────▼────────┐
│ Kubernetes    │
│ Manifests     │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think editing the chart templates is the best way to customize deployments? Commit to yes or no.

Common Belief: Customizing a Helm chart means editing its templates directly.

Reality: The best practice is to customize using values files or command-line overrides, not by changing templates.

Why it matters: Editing templates breaks chart reuse and makes upgrades difficult, causing maintenance headaches.

Quick: Do you think Helm values files completely replace each other when multiple are used? Commit to yes or no.

Common Belief: When using multiple values files, the last one replaces all previous ones entirely.

Reality: Helm merges values files, combining keys and overriding conflicts, not replacing whole files.

Why it matters: Misunderstanding merge behavior can cause unexpected configuration and deployment failures.

Quick: Do you think all values must be defined in values.yaml? Commit to yes or no.

Common Belief: You must define every value you want to use in the default values.yaml file.

Reality: You can add new values in your custom files or command-line overrides even if they are not in defaults.

Why it matters: Believing otherwise limits flexibility and prevents using advanced customization.

Quick: Do you think values can only be simple strings or numbers? Commit to yes or no.

Common Belief: Chart values are only simple key-value pairs like strings or numbers.

Reality: Values can be complex nested structures like lists and dictionaries.

Why it matters: Ignoring this limits your ability to configure complex applications properly.

Expert Zone

1

Helm’s value merging is deep, meaning nested keys merge recursively, not just top-level keys.

2

Templates can use default functions to provide fallback values if a value is missing, preventing errors.

3

Using --set with complex nested values requires careful syntax with dots and quotes to avoid parsing errors.

When NOT to use

If you need very dynamic or runtime configuration changes, Helm values are static at deploy time. Use Kubernetes ConfigMaps or Secrets for runtime config. For very complex logic, consider operators or custom controllers instead of heavy templating.

Production Patterns

Teams maintain a base values.yaml in version control and environment-specific overrides separately. CI/CD pipelines inject secrets and environment values via --set or sealed secrets. Charts are upgraded by applying new values files, enabling safe rollbacks and audits.

Connections

Configuration Management

Chart values are a form of configuration management for Kubernetes deployments.

Understanding chart values helps grasp how configuration management tools separate code from settings to enable flexible deployments.

Software Packaging

Helm charts package applications like software installers, and values customize the installation options.

Knowing this connection clarifies why Helm charts behave like packages and why values are like installer options.

User Interface Forms

Chart values are like filling out a form to customize a product before purchase.

This cross-domain link shows how user input drives customization in many systems, from software to shopping.

Common Pitfalls

#1 Trying to customize by editing chart templates directly.

Wrong approach:

vim mychart/templates/deployment.yaml # edit image tag directly

Correct approach:

helm install myapp mychart -f custom-values.yaml # override image tag here

Root cause:

Misunderstanding that templates are reusable code and should not be changed per deployment.

#2 Passing multiple values files without knowing merge order.

Wrong approach:

helm install myapp mychart -f prod.yaml -f dev.yaml # wrong order

Correct approach:

helm install myapp mychart -f dev.yaml -f prod.yaml # prod overrides dev

Root cause:

Not knowing Helm merges files left to right, so order affects which values take precedence.

#3 Using --set with complex nested values incorrectly.

Wrong approach:

helm install myapp mychart --set resources.limits.cpu=2 --set resources.limits.memory=1Gi

Correct approach:

helm install myapp mychart --set resources.limits.cpu=2,resources.limits.memory=1Gi

Root cause:

Misunderstanding how to pass multiple nested keys in --set; commas separate keys, not spaces.

Key Takeaways

Helm chart values let you customize deployments safely without changing chart code.

You can override default values using files or command-line flags, and Helm merges them predictably.

Values support complex nested structures and control both data and deployment logic via templates.

Using separate values files for different environments keeps deployments organized and error-free.

Understanding Helm’s value merging and template conditionals is key to mastering chart customization.