Helm Kubernetes Packaging Manager for Developers and DevOps

Explore the challenges of deploying Kubernetes without Helm—static yaml files, consistency gaps, and no revision history—and see how Helm enables parameterization and versioned deployments.

Discover how Helm simplifies Kubernetes deployments with charts and templates, enabling dynamic values via values.yaml, automatic resource ordering, revision history, and secure, trusted charts.

Install Helm on your machine using packaging managers or binary releases, then verify with helm --help. Use your kubeconfig (the file kubectl uses) or override with the kubeconfig environment variable.

Learn to work with Helm chart repositories by listing, adding, searching, and removing repositories, and viewing available chart versions.

Learn Helm in action using the Bitnami legacy repository, with the required --set image.repository=Bitnami legacy/mysql flag and ensure pods run with status running and ready 1/1.

Learn that Helm install requires a unique installation name per namespace, and avoid conflicts by using a different namespace (for example team two) or the -n/--namespace option.

Learn to list installed helm deployments in kubernetes and uninstall them, using helm list and helm uninstall with optional namespace, inspecting installation details like name, namespace, revision, and status.

Pass custom configuration for a helm mysql chart by using a values.yaml file to set the root password, instead of the generated one, then verify with a client pod.

Upgrade an existing mysql chart by updating the Helm repo, fetching latest charts, and applying changes with Helm upgrade using the root password.

Discover how helm install loads a chart and dependencies from local or remote sources, applies values and templates, and renders yaml validated against Kubernetes schema before handing to the cluster.

Use helm template to generate Kubernetes templates without a cluster or API server validation, suitable for CI/CD, unlike dry run that validates and differentiates install versus upgrade.

Learn how Helm stores release records in Kubernetes secrets, tracks versioned upgrades, and preserves deployment templates for rollbacks by inspecting secrets and using helm install, upgrade, and kubectl commands.

Use helm get to fetch release notes, values, and manifests for a release like mydb. Inspect revisions and defaults with --revision and --all to see current and past configurations.

Learn how helm history reveals the release history of installations and upgrades, with revisions and error details from failed upgrades, and how secrets and version information appear.

learn to create and use a namespace with helm install using the --create-namespace flag, install to that namespace, verify with helm ls --namespace, and note there is no delete-namespace option.

Learn to use the Helm upgrade --install command to install or upgrade a release, automatically upgrading existing deployments or installing new ones in CI/CD pipelines.

Generate a release name automatically with Helm by using the --generate-name flag and, optionally, a --name-template with expressions like rand alpha and lower to ensure lowercase, Kubernetes-friendly names.

Use helm install with the --wait option to ensure services, deployments, and pods are up before marking the installation successful; adjust --timeout in ci/cd to account for image pulls.

Learn to use the Helm upgrade flags, including --force, to delete and recreate deployments, causing downtime, and note it is not suited for CI/CD pipelines.

Learn to create and use your own Helm charts, explore the chart structure and files, package charts for distribution and installation, and preview future topics on templates and repositories.

Learn to create a helm chart with helm create first chart, then examine chart.yaml, values.yaml, charts folder for dependencies, and templates with deployment, ingress, and service manifests.

Install the Helm chart with a release name from your chart folder, render templates using values.yaml or --set, and forward ports to access nginx on localhost:8080.

Learn how the chart.yaml metadata drives a helm chart, with mandatory apiVersion, name, and version, plus optional fields; distinguish application versus library charts and track appVersion and releases.

Explore the templates folder, the heart of a helm chart, and see how yaml templates generate Kubernetes manifests and resources like deployment, hpa, ingress, service, and service account.

Discover how Helm templates control Kubernetes resources by substituting values from values.yaml into generated yaml. Learn Go templating syntax, template actions, conditional logic, loops, and variables.

Discover how Helm uses the dot object to pass data from values.yaml and the chart into templates, via dot values and chart metadata, enabling dynamic decisions at release.

Learn to use conditional logic in helm templates with if and else blocks driven by values.yaml flags, including not, and, or operators, to control deployment, HPA, and ingress outputs.

Define and use variables in Helm template YAMLs by declaring a variable (my flag), sourcing its value from values.yaml, and conditionally rendering booleans or strings in the deployment template.

Learn to use range loops in helm template YAML to iterate over a values list, outputting each value with indentation and applying the upper and quote functions.

Use range to loop through a dictionary of values, capturing keys and values into dollar key and dollar value variables, then format and assign them in templates.

Investigate how the range construct is used in the template folder's yaml files and describe its purpose for looping within Helm templates.

Fetch the manifest from a helm release with helm get manifest and compare it with current Kubernetes resources via kubectl to detect drift and note service mesh effects.

Explore the _helpers.tpl in Helm to reuse templates across charts and understand namespaces for library charts. Learn how include and template differ and how names are truncated to 63 characters.

Learn to define and use custom Helm templates, pull values from values.yaml, and control defaults with include versus template, then test deployments using Helm template.

Explore helm chart dependencies by packaging an application with a MySQL chart, enabling automatic releases in a Kubernetes cluster, and testing charts with hooks and value exchanges.

Configure and use chart dependencies in Helm, add MySQL as a dependency, update and pull dependencies, and deploy the app with MySQL service created automatically in Kubernetes.

Explore defining Helm dependencies using the repository url or the repo name, and why url references work across environments without requiring the bitnami repository to be added locally.

Learn to manage multiple helm chart dependencies with tags for conditional installs of mysql and apache. Use a global enabled flag in values.yaml to control all dependencies.

Override dependency values in a Helm chart by editing the parent chart's values.yaml, configuring MySql settings and service type to NodePort, then install or uninstall the app.

Learn to access a child chart's service details without exported values by using a parent element to import and expose MySQL service settings, then reference them in deployments.

Explore how Helm hooks work, mark resources with hook annotations, and manage lifecycle events like pre-install, post-install, pre-delete, and rollback, including hook weight and deletion policy.

Learn to create and use a helm hook, including pre-install hooks and annotations. Understand hook weight, deletion policies, and how pre-install pods run during chart install.

Explore testing helm charts using a test hook that creates a busybox pod, runs wget against the service on its port, and reports success for CI.

Learn to run helm test against a release (not a chart), using test hooks in the test phase, verify an Injinex service, and iterate failures by updating the test manifest.

Explore how helm chart repositories work, generate index.yaml with the helm command-line interface, and host repositories locally via a Python web server or publicly on GitHub pages, plus OCI support.

Set up a local helm chart repository by creating a charts repo folder, generating and updating an index.yaml with helm repo index, and packaging the first chart into the repository.

Install Python to run the built-in web server for hosting a helm repository locally, verify version with python --version or python3 --version, and ensure it's above 3.0.

Pull the chart from the repository with helm pull and use the tarball for installation. Delete the old packaged version, then install using the local chart tarball.

Helm chart repositories lack namespace isolation and fine-grained access, causing duplication. Enable OCI registries (experimental in Helm 3.0) by setting HELM_EXPERIMENTAL_OCI=1 and launching a local OCI registry.

Learn to host and manage Helm charts in an OCI registry using the OCA registry, packaging, pushing, pulling, and deploying charts with install and upgrade workflows.

Learn how helm ensures chart provenance and integrity using PGP, generating a keypair and dot profile, and how users verify charts with public keys during helm install or verify.

Learn to install gnupg, generate a private and public key pair with gpg, and store keys under the user's dot gnupg directory to sign and secure charts.

Sign helm charts with a private key using the key alias and keyring path, then verify with helm verify using the public key and generate a provenance file.

Deploy a dockerized java microservice to a kubernetes cluster using helm, exposing a coupon API backed by a MySQL database, with liveness and readiness checks via Spring Boot actuator.

Deploy a microservice to kubernetes with helm by creating a chart, configuring the image and registry, updating deployment and nodeport service, and adding a mysql dependency via a config map.

Create a helm chart for a microservice, prune unused templates, and configure values.yaml to pull the image from docker.io using the specified repository and the latest tag.

update deployment to configure liveness and readiness probes using spring boot actuator health endpoints at /actuator/health/liveness and /actuator/health/readiness on port 9091.

Change the service type from cluster ip to node port by editing service.yaml and values.yaml, setting the port and target port (9091) to expose the app outside the cluster.

Configure helm values for the mysql dependency to enable app connection, override root password, auto-create database, set nodeport service, and apply full name override.

Create and deploy a config map containing initdb SQL instructions for MySQL, placed under the templates folder and referenced in values.yaml for automatic creation during a helm release.

Make a small correction to values.yaml for mysql primary: add a service element under service, correcting the missing nodport service type before releasing the chart.