Practical Helm Charts For Beginners

Learn to install the lab environment for practical helm charts, including Docker Desktop, Kubernetes, and the helm CLI, with macOS and Windows guidance and access to unit tests.

Install Docker desktop on macOS for Apple and Intel systems, including M1, then verify with docker run hello world.

Install Docker Desktop for Windows Home using Windows Subsystem for Linux. Follow optional Hyper-V method for Windows Pro and complete a kernel update, then test with docker run hello world.

Install Docker Desktop on Windows 10 Pro using Hyper-V, following the download, installer run, and configuration steps. Verify the setup with a docker run hello world test.

Enable Kubernetes in Docker Desktop on macOS and Windows, then verify the kubectl version to confirm the Kubernetes CLI is ready.

Install the helm CLI on macOS via the Homebrew package manager, then test the setup by running helm with no arguments to confirm the Kubernetes package manager is ready.

Install the helm CLI on Windows with Chocolatey, then locate the kubernetes-helm package and run the Cocoa install kubernetes helm command in an administrator PowerShell, verifying by typing helm.

Download the lab git repository to access example charts and exercises; clone with ssh or https and cd into the Helm Labs directory to begin.

Install the helm unit test plugin to enable unit tests in Helm, learn platform-specific steps for macOS, Linux, and Windows, and explore Docker-based testing and batch scripts.

install watch exec on macOS with homebrew to run a command when a file changes, using the helm unit test command as the example.

Install watch exec on Windows using Chocolatey to auto-run commands like helm unit test when a file changes, requiring an admin PowerShell session.

Explore the anatomy of a helm chart by examining templates, charts, chart.yaml, values.yaml, and notes.txt, plus the helm ignore file, and learn how templates and values produce Kubernetes manifests.

Explore the basic components of a helm chart template, including templates in the templates directory, go template actions, and how values.yaml drives rendered Kubernetes manifests like a configmap.

Render Helm templates into Kubernetes manifests and examine the pod manifest structure, including apiVersion, kind, metadata, and spec with containers, images, ports, environment variables, and volume mounts.

Learn the yaml format essential to helm and kubernetes, covering basic types, mappings, lists, whitespace, and indentation for kubernetes manifests.

Discover how the Go template library renders Helm templates into Kubernetes manifests from values and templates. Understand actions, double curly brace syntax, the vals map, and how io.writer controls output.

Learn how Helm values combine with templates to produce the final Kubernetes manifest using the values.yaml file and dot values syntax, and make fields like the name configurable.

Explore how to override values.yaml at runtime using dash dash set and helm template, enabling unique names per namespace, multiple configmaps, and chart customization without editing files.

Override helm values using file-based overrides with yaml files and the -f options. Centralize configurations in git for dev and prod, enabling ci-friendly, multi-parameter customization for charts such as grafana.

Explore chart.yaml, the helm chart metadata file, detailing api version, name, description, type, version, and appVersion, with guidance on dependencies, semantic versioning, and internal versus library charts.

Explore the charts directory, where Helm stores sub charts and dependencies as folders or tgz archives. Reuse sub charts in your main chart templates and tailor manifests for Kubernetes.

Explore how Notes.txt in the templates directory of helm charts prints usage, values, and configurable messages for debugging, using helm template actions and examples from the default generator.

Learn how the helmignore file prevents files from being rendered by Helm, like a gitignore for charts. Use it to protect credentials and exclude build artifacts from rendering in deployments.

Explore the helm CLI and its release lifecycle, from not deployed to deployed, failed, and upgrade, including install, upgrade, rollback, and uninstall commands for managing Kubernetes applications.

Use the helm template command to generate yaml manifests and inspect the chart output. Run in the labs directory to preview the values checker chart and its default values.

Learn to override helm template values using --set and --values (-f) options, layering overrides on top of values.yaml and verifying final values with the values checker.

Deploy your helm chart to Kubernetes with Helm install, moving from not deployed to pending install and then deployed, using a release name and a chart directory.

Learn how to verify Helm install by inspecting Kubernetes resources with kubectl get, including configmaps, pods, and annotations, and understand Helm managed labels and release metadata.

Learn to use the helm list command to query Kubernetes and view helm releases with status, namespace, revision, and chart information. Track release statuses at a glance.

Learn how to use the helm status command with a single argument, the release name, to view key-value details for a specific release.

Learn how to upgrade a deployed release with helm upgrade, after using helm install, moving from pending upgrade to deployed or failed, using the same release name and chart reference.

Explore the helm git all command to fetch full release information, including user supplied and computed values, overrides, hooks, and generated manifests for debugging.

Run helm uninstall with the release name to return the release to not deployed status and remove all associated Kubernetes resources. Verify cleanup with kubectl get configmap.

Master the helm upgrade --install option to upgrade a chart or install it when a release doesn’t exist, avoiding name reuse errors and easing CI deployments.

Learn to use helm rollback to revert a release to a previous version after a failed upgrade, completing the chart lifecycle with verification via helm git manifest.

Explore how Kubernetes secrets power the Helm CLI, including secret types and release data, then inspect with helm history and perform cleanup with kubectl delete secret.

Learn to use helm create to generate a new chart with default templates, including chart.yaml, deployment, ingress, service, hpa, and a service account, plus sub charts and the include keyword.

Conclude the cli section by showing how to manage helm releases across their life cycle and access command lists, including install and list, with helm --help.

Explore the helm template language, its two parts, how normal text passes through in templates and how actions in curly braces print values into the final config map.

Learn how helm actions, functions, and pipelines render templates. See how the quote function outputs strings and how dot values and built-in data are accessed.

Explore the Helm template type system, including booleans, strings, int64, float64, dictionaries, maps, structs, and lists, and learn how Go templates shape Helm data types.

Explore helm function syntax in templates, including using function names followed by space-separated arguments without parentheses, handling quotes, and nested calls like add with multiple numbers.

Explore built-in Helm template functions, including Go template default functions and the Sprig library, and learn to navigate function categories, usage examples, and the Helm docs.

Discover how helm pipelines simplify complex template logic by using pipe syntax alongside function calls, compare execution order between pipelines and parentheses, and learn to convert dictionaries to indented yaml.

Explore how the Helm template cursor exposes values, chart, release, subcharts, files, and capabilities, and learn to access nested data with dot values and dot chart keys.

Explore helm string functions, learn to use strings the helm way one function at a time, including yaml-specific string handling, with hands-on labs.

Master string concatenation in helm by using the print function to build a final string for the manifest, and learn to leverage pipelines for consistent templating.

use printf in helm through go's fmt package, applying a format string and verbs with percent V as a universal placeholder to substitute arguments.

Explore how to check string contents with Helm's contains function, including its argument order and pipeline-friendly design, and use has prefix and has suffix for start and end checks.

Apply the Helm trim function to remove leading and trailing spaces from strings, ensuring indentation and valid yaml when reading values.yaml.

Learn how to manage indentation in helm templates using the indent function to format yaml blocks, including values checker templates and common patterns for dictionaries and lists.

Discover how the nindent function in helm charts automatically adds a newline and indents a string within templates. Compare nindent with indent and choose your preferred style for templates.

Learn to use the helm quote function to enforce string values in templates, avoiding yaml booleans and numbers by quoting strings for Kubernetes manifests.

Learn to extract string parts in helm with the Substr function. Use three arguments, start and end indices (zero-based, inclusive start, exclusive end), and the target string for pipeline-friendly results.

Learn to switch strings among snakecase, camel case, and kebab case using helm functions, and apply these conversions in manifests and values for Helm charts.

Learn how to use the regex match function in Helm templates to validate string formats, parse text with regular expressions, and enable conditional logic when user defined functions are unavailable.

Explore Helm's regex split function, which splits a string using a regular expression with three arguments and an optional minus one to return all matches.

Explore the remaining Helm string functions, including random string generators, abbreviations, initials, pluralization, wrap, and capitalization utilities. Learn when to use them to improve readability while noting potential non-reproducibility.

Fix helm chart unit tests by updating the YAML template and applying the helm upper function to match test assertions, using values.yaml.

Open the test file and the template in the strings chart's exercises directory, then run the test runner to fix 13 failed unit tests.

Explore fixing helm charts by using the test runner to identify failing tests, adjust manifests and template actions, and verify assertions and diffs until all tests pass.

Learn practical debugging of helm charts by tracing unit test errors with helm template and using --debug to diagnose yaml issues.

Walk through the strings chart in the Helm lab, showing how to use the test runner and unit tests to implement contains, trim, indent, and kebab case.

Learn how helm handles numbers in chart templates by using integers and floats, performing arithmetic with functions, and using dot notation for whole and decimal parts.

Explore Helm's basic math operations using prefix notation with add, div, sub, and mul. numbers coerce to integers, division by zero triggers an error, and floats are truncated.

Learn to perform float arithmetic in helm charts using the add f suffix and other float functions, avoiding integer-only operators and type coercion by selecting the right return type.

Explore helm utilities for rounding floats in numbers, using ceil, floor, and round. Learn how round accepts a second argument for decimal places with practical examples.

Explore how helm compares numbers using six boolean functions, such as gt, g, lt, l, eq, and ne, and apply these primitives in control flow.

Learn how the modulo operator returns remainders, with examples like 10 mod 6 and 10 mod 3, and note helm's mod function is used in templating, not heavy math.

Open the numbers yaml and numbers test yaml, run the test runner for the numbers chart, and implement add, sub, div, mul, mod, and rounding and comparison tests to pass.

Explore branching logic in helm templates with if, else, and else-if statements. Understand helm's two-action if structure and use boolean checks like equals and contains to control output.

Learn to declare and reference variables in helm templates using Go template syntax, including the dollar sign, colon equals, and value store paths, and if-else statements.

Learn how to use helm's with statement to set a local cursor in templates, switch to the values object with dot notation, and restore the previous cursor at end.

Learn how to handle nil values with the Helm with statement, using else blocks to provide a default value when a value path is nil.

Learn how to reference the original cursor value inside helm template actions using the dollar sign, enabling access to values like chart.values and values.other within width and other overrides.

Learn to trim whitespace in helm templates using go template syntax; apply minus signs after opening braces or before closing braces to remove newlines in if-else blocks, ensuring clean yaml.

Explore the ternary function as an expression that resolves to a value, selecting between two results based on a condition, with examples in JavaScript, Java, and Helm.

Walk through control flow by editing template and test files, implementing letter grade logic with if-else and ternary operators, then run tests to reach full passes.

Explore lists in the helm template language as ordered collections for Kubernetes manifests, including containers, volumes, and secrets, and learn helm functions across values.yaml and Go slices.

Learn how to use the Helm template list function to declare new lists in templates, from zero to many arguments. Understand building lists from values.yaml and mixing Helm types.

Learn how the helm range action uses the Go template library to iterate through a list, executing a template block for each element and updating the cursor accordingly.

Learn to use variable names with the range action in helm templates. Set a named variable after range with the colon equals operator and iterate a list using item variable.

Learn to use the range action in Helm to capture both index and item while iterating a list, with index coming first and an example printing 'index: item'.

Learn to use the index function in Helm templates to retrieve list items by a zero-based index and handle out-of-bounds cases in templates.

Learn to use the Helm length function to safely access list elements and avoid errors. Implement if-else logic to provide fallbacks when the list is too short.

Learn to check for value in helm charts using the has function, which takes a list and an element and returns a boolean for primitive values to drive conditional templates.

Learn how to use the first function in Helm to retrieve the first list element and handle nil values, including empty lists and nil checks with if-else blocks.

learn how the uniq function in helm, which takes a single list, removes duplicates and returns a new list, serving as a set substitute in helm templates.

Learn to slice lists in Go by using the slice syntax to return a part of a list, with start and end indices, including examples and end-exclusive behavior.

Learn how to add elements to a list in Helm using append and prepend, each taking a list and a new element, for end or start insertion.

Learn to join lists in Helm using cat and concat. The concat function can combine many lists and insert individual elements via the list function, with slice enabling placement.

Remove elements from a helm list with the without function, which takes a list and an item to remove, returning a new list; for index removal, use slice and concat.

Learn how to print lists in helm templates using json and the two yaml functions, handle indentation, and ensure valid yaml or json output in helm manifests.

Learn how to compare lists in helm using deep equal instead of the standard equal, enabling value equality checks for lists and dictionaries and avoiding non comparable type errors.

Explore the sort alpha function in Helm templates, which sorts lists of strings alphabetically. It works only on strings and there is no general purpose sort function in Helm.

Walk through the list lab, opening template and test files, running the test suite, and fixing list properties with to yaml, indent, range, first, index, and without.

Explore helm dictionaries, a key-value mapping in yaml sourced from values.yaml, learn to create and access dicts with the dict function in helm templates, and keys must be strings.

Learn how to print a dictionary in helm templates using to json or to yaml, and manage indentation and whitespace to produce valid yaml mappings.

Learn how to get a value from a dictionary by key in Helm templates using dot syntax and the Jit function for keys with spaces.

Handle Helm dictionary lookups when keys may be missing by using the Jit function with the if action, and validate with the has_key function to reliably print values.

Add a dictionary item in Helm templates using the set function, supplying the dictionary, key, and value; override existing keys and assign to a variable to avoid extra prints.

Learn how to create deep copies of dictionaries, modify the copy without changing the original, and avoid bugs by copying before updates.

Learn how to remove a key from a dictionary with helm's unset function, compare with set, see it returns the dictionary, and use deepcopy to avoid mutating the original.

Learn how to check dictionary equality in Helm templates by using deep equal to compare dictionaries' keys and values, since the eq function cannot handle non-primitive map types.

Learn how the omit function in helm templates removes multiple keys from a dictionary, always returns a new dictionary, and differs from unset by not modifying the original.

Learn how the keys function in helm templates returns a list of dictionary keys and how to iterate them with range to print yaml list items.

Explore the Helm values function that returns dictionary values, compare it to keys, process with range, and ensure consistent output by applying sort alpha to sort strings alphabetically before printing.

Learn how the helm split function from sprig returns a dictionary of results keyed by _0, _1, _2, and how it differs from the split list function.

Walk through a lab for the dictionary section in practical helm charts for beginners, guiding you through creating, updating, and querying dictionaries with yaml outputs and test-driven validation.