Templating & Values

helm template never contacts an API server, so Helm's lookup has nothing to query and returns an empty map rather than failing. Only a render that reaches a cluster — a real install, an upgrade, or --dry-run=server — fills it in.

helm template <release-name> <chart> renders the chart with the values you pass and prints the resulting YAML to stdout — no cluster call, no release record. Adding -s/--show-only templates/job.yaml limits the output to that one template file's manifests.

Helm's default function substitutes a fallback when a values entry is empty, so the render continues. required does the opposite: it aborts the whole render with the message you wrote. Use default for optional settings, required where no safe fallback exists.

include is a function Helm adds: it renders a named template and returns the output as a string, so it can be piped into other functions. template is a Go template action that writes straight to the output and yields no value.

Helm starts from the chart's own values.yaml, merges each -f file in the order given so a later file beats an earlier one, and applies the --set family last. A --set value therefore wins over every file.

Helm's default is conditional: with no -f or --set on the upgrade, the previous release's user-supplied values carry forward. Pass even one value flag and those stored overrides are dropped, leaving only your new flags over the chart's defaults.

A leading {{- deletes every whitespace character before the action, including the newline that ended the previous line, and a trailing -}} deletes the whitespace after it, including its own newline. Chart authors use them so control-flow lines leave no blank lines in the rendered YAML.

Helm reads the target cluster's discovery list and reported server version before rendering. .Capabilities.APIVersions.Has answers whether that cluster serves a given group/version, and .Capabilities.KubeVersion.Version gives its version string for a semver comparison.

helm template renders offline and prints YAML. helm install --dry-run=client renders through the install path against your configured cluster but writes nothing. --dry-run=server also sends the manifests to the API server, so schema validation and admission run and nothing is persisted.

Helm deep-merges maps key by key, but treats a YAML list as one opaque value: an override that supplies a list replaces the chart's list entirely. List elements have no key to match on, so nothing can be merged or appended.

--reuse-values merges your new flags over the previous release's fully coalesced values, which include the old chart's defaults, so a default changed in the new chart is masked. --reset-then-reuse-values merges over only the old user-supplied overrides, letting new defaults through.

$ is the root of the current template execution, and every include or template call starts a new one. Inside that helper $ is .Values.worker, the argument it was handed — so neither dot nor $ can reach .Values or .Release there.

Both prefix every line of the string with N spaces; nindent also emits a leading newline. Because the action sits after literal indentation on the template line, indent double-indents just its first line, while nindent starts the block on a fresh line at exactly N spaces.

with guards as well as re-scopes. An empty map is false, so Helm skips the whole block and every line inside it vanishes from the rendered manifest, silently. Inside the block dot is that map, so .Values no longer resolves.

They describe the operation currently rendering. On install, IsInstall is true, IsUpgrade is false and Revision is 1. On upgrade the first two swap and Revision is the number of the revision being created, one higher than the current one.

Helm registers the sprig function set but deliberately deletes env and expandenv, and Go templates reject unknown function names while parsing. A chart therefore cannot read the environment of whoever runs helm; caller-side data must arrive as values.

They convert between structured values and text inside a Helm template. toYaml serialises any values subtree to a YAML string the caller must indent; fromYaml parses a YAML string back into a map; toJson emits compact JSON, which is also valid YAML.

Bundle the inputs into one value with the dict function and pass that: include "fraud-scoring.probe" (dict "ctx" $ "port" .Values.service.port). Inside the partial, dot is the dict, so the inputs are read as .ctx and .port.

Values are data, not templates: Helm renders the files under templates/, and a string arriving from a values file is inserted verbatim. To evaluate it, the chart must pass it through Helm's tpl function with a context: {{ tpl .Values.ingress.host . }}.

Helm's --set infers types and treats dots, commas and brackets as syntax, so an image tag written 1.10 becomes the number 1.1. Use --set-string for text, --set-file for file contents, --set-json for structure, --set-literal for a verbatim value.

Only the ones that do not change between upgrades: .Release.Name, .Chart.Name and stable values. .Chart.Version, .Chart.AppVersion, .Release.Revision and .Release.IsInstall all move, and a moved name makes Helm create a new object and delete the old one.

With no cluster to query, helm template uses capabilities compiled into the Helm binary — a fixed Kubernetes version and a minimal API list — so capability branches take their fallback path. Pass --kube-version and --api-versions to describe the target cluster.

Read the error, not the YAML: it names the chart's template file, a line and column, and the failing expression in an at <...> clause. A nil pointer means the parent key was absent, so re-render locally with the same values flags.

Deleting a key from your file only removes it from what you pass; --reuse-values merges the previous release's stored values underneath, so it comes back. helm get values prints those stored overrides; helm get values -a prints everything computed.

Compare the manifests stored with the two revisions: the block is absent, not empty, which means a guard collapsed on a falsy value in that tenant's overrides. Helm then withdrew the field, because the new manifest no longer declares it.

The line number indexes the rendered manifest, not the template file Helm names in the same message. Render the chart with the failing release's values, count to that line, and look at it and the line above for a value spliced in at an indentation that does not match its siblings.

kubeVersion in Chart.yaml is a hard semver gate: Helm refuses to install outside the range. .Capabilities branching keeps one chart usable across a span at the cost of permutations nobody tests. Gate the floor; branch only where behaviour genuinely differs.

Make every automated upgrade pass the complete values file and forbid reuse flags there, so the repository is the only description of a release. Allow --reset-then-reuse-values for interactive triage, and audit releases by diffing their stored values against the committed file.

.Files reads non-template files packaged inside the chart, by path relative to the chart root. Get returns one file's contents as a string, Glob returns a set. Files under templates/ and anything .helmignore excluded are invisible, and a missing path returns an empty string rather than an error.