skip to content

Defaults & Schema

values.yaml is the chart's public surface — the defaults helm show values prints — and values.schema.json is a machine-checked contract over it. Asked because a mistyped values key ships silently.

part ofHelmoverview, primer and where to startread it →
on this pageshow

questions

4

What does `helm show values` print for a Helm chart, and why is values.yaml the chart's public API?

level: juniorimportance: must knowfreq 66%

answer

  1. Reading a chart before you install it
  2. One file, printed unrendered
  3. Comments survive, so they are the docs
  4. The chart's default surface, not a release's
  5. Contrast with helm get values

basics

~20 s

helm show values prints a chart's values.yaml exactly as the author wrote it, comments included, without installing or rendering anything. That file is the chart's default surface: every key a consumer may override, and the value they get if they do not.

solid answer

~50 s

`helm show values CHART` resolves the chart the same way an install would - a local directory, a packaged `.tgz`, a `repo/name` reference, or an `oci://` reference - and writes its `values.yaml` to stdout verbatim. Nothing is rendered, nothing is validated, no release is touched. Because the file is printed byte for byte, its comments survive, which is why a chart's values.yaml comments are its de facto documentation. It is the normal way to start a consumer values file: redirect it to a file and delete everything you are not overriding. Treat values.yaml as the chart's public API - templates read those key paths through `.Values` and consumers write files against them, so renaming or removing a key is a breaking change for the chart, not an internal refactor. It shows defaults only; what a live release was actually installed with is a different thing, read with `helm get values`.

code

bash · 3 lines
bash
helm show values oci://registry.example.com/charts/order-checkout --version 2.14.3 > upstream-defaults.yaml
helm show chart oci://registry.example.com/charts/order-checkout --version 2.14.3
helm get values order-checkout -n payments

go deeper

for a junior

Be ready to say in one sentence what values.yaml is and how you would read a chart's defaults before installing it. Knowing that the command prints the raw file, comments and all, is enough at this level.

for a middle

Explain the mechanics: the chart reference forms it accepts, that it neither renders nor validates, and how the printed defaults relate to what .Values finally contains after a caller's file is merged over them.

for a senior

Show the operational instinct: during an incident you compare the chart's current defaults against the values the live release actually recorded, and you keep consumer values files trimmed to real overrides so upstream default changes still reach you.

for a principal

Own the consequence that values.yaml is a versioned interface with no deprecation channel. Decide how your teams publish default changes and key renames, and what a chart version bump is expected to signal to every consumer.

### What the command does `helm show values CHART` takes the same chart reference `helm install` takes: a directory on disk, a packaged `name-version.tgz`, a `myrepo/order-checkout` reference resolved through a repository you have added, or an `oci://` reference to a registry. Helm fetches just enough of the chart to read it and writes the chart's `values.yaml` file to stdout, unchanged. It renders no templates, applies no schema, creates no release and needs no cluster. Its siblings round out the same idea: `helm show chart` prints `Chart.yaml`, `helm show readme` prints the chart's README, `helm show crds` prints what sits under `crds/`, and `helm show all` concatenates them. The verbatim part matters more than it sounds. Helm is not re-serialising a parsed structure, so the ordering, the blank lines and above all the comments come through. Chart authors exploit that: the comment above a key is the only documentation many charts ship for it, and it reaches consumers only through this command or through reading the packaged file. ### Why the file is a public API A chart's templates reach configuration through the built-in object `.Values`, indexing paths such as `.Values.image.tag` or `.Values.resources.limits.memory`. Consumers never see the templates; they see the key paths. So the chart's contract is exactly the set of key names, their shapes and their defaults, and `values.yaml` is where that contract is written down. Two consequences follow. First, defaults are behaviour. A chart that defaults `replicaCount` to 2 has decided something for every installation that does not override it, and changing that default changes production for everyone who upgrades without touching their own file. Second, renames are breaking. Helm has no deprecation channel for a values key. If an order-checkout chart published to an OCI registry by CI renames `image.tag` to `image.version`, callers who still pass `image.tag` get no error at all - Helm accepts the unknown key, the template reads the new path, finds nothing, and the release quietly installs the default. A key rename therefore belongs to a deliberate chart version bump with a note to consumers, not to a tidy-up commit. ### What it does not tell you `helm show values` shows the left-hand side of a merge and nothing else. It does not tell you which keys are required, what type a key expects, or whether a key you invent will be rejected - that is `values.schema.json`'s job, and Helm applies no validation of any kind unless the chart ships one. It also does not tell you which keys the templates actually read: a values.yaml can carry a dead key that no template has referenced for three releases. On an umbrella chart it prints only the parent's own `values.yaml`. That file normally carries one block per subchart plus a `global` block, but a subchart's full surface lives in the subchart's own values.yaml, so to see everything you can configure you show the subchart too. ### The four things called values The word is overloaded, and interviews probe the seam. `values.yaml` is the defaults file inside the chart. A file you pass with `-f` is a caller's override document. `.Values` inside a template is the merged result the renderer sees. And the values *stored with a release* are what Helm recorded in the release record when that revision was created. `helm show values` reads the first. `helm get values RELEASE` reads the last, and can also show you the fully computed set rather than only what the caller supplied - which is what you want during an incident, because the chart in the registry may have moved on since the release was installed. ### Practical workflow The habit worth demonstrating is: show the values of the exact chart version you intend to install, save them, strip the file down to the handful of keys you are actually changing, and commit that. Keeping a full copy of upstream defaults in your own repository looks thorough and is a trap - it silently pins values the chart author later changed, so you inherit none of their fixes and none of their new defaults.

  • How is `helm show values` different from `helm get values`?
    `helm show values` reads a chart and prints its `values.yaml` defaults; it needs no cluster and no release. `helm get values` reads a release from its stored record in the namespace and prints what that release was installed with - by default only what the caller supplied, and optionally the full computed set. They disagree whenever the chart has been updated since the release was created, which is exactly when you are debugging.
  • Does `helm show values` validate or render anything?
    No. It prints the file. No Go template is executed, no `values.schema.json` is applied, no Kubernetes API is contacted beyond fetching the chart from its repository or registry. That is why it is safe to run against an untrusted chart to inspect it, and why it will never warn you that a key you plan to set does not exist.
  • What do the other `helm show` subcommands print?
    `helm show chart` prints `Chart.yaml` - name, version, appVersion, dependencies and the rest of the metadata. `helm show readme` prints the chart's README. `helm show crds` prints the manifests under `crds/`. `helm show all` prints everything concatenated, which is the quickest single command for sizing up an unfamiliar chart before installing it.

It is the package's default configuration file shipped alongside it - like reading the annotated config a distribution installs before you edit your own copy, rather than reading the config a running server has loaded.

saying these in an interview costs you the question

  • Says helm show values prints a release's merged values
  • Thinks Helm rejects any key not present in values.yaml
  • Claims the command renders the chart's templates
  • Treats renaming a values key as an internal refactor
  • Confuses values.yaml with Chart.yaml metadata
  • Assumes the command needs a cluster connection

context

open as a page

Why does a misspelled key in a Helm values file cause no error, and what makes Helm reject it?

level: middleimportance: must knowfreq 71%

basics

~20 s

Helm merges caller values onto chart defaults as an untyped map, so an unknown key is simply added and never read - the template still sees the default and the release installs cleanly. A values.schema.json with additionalProperties: false turns that typo into a failed install.

open as a page

When does Helm enforce values.schema.json, and how does it apply to a chart's subcharts?

level: seniorimportance: should knowfreq 43%

basics

~20 s

Helm validates the coalesced values against values.schema.json before rendering - on install, upgrade, template and lint. Every chart in the dependency tree is checked against its own schema over the slice of values scoped to it, and the failures are reported together.

open as a page

In a platform's 18-chart Helm umbrella, how strict would you make each chart's values.schema.json?

level: principalimportance: should knowfreq 31%

basics

~20 s

Strict where the chart makes a promise, open where it passes values through. Type and close the objects the chart owns, leave subchart and global subtrees to their own schemas, and treat tightening a published schema as a breaking chart version rather than a patch.

open as a page