Installing charts in Kubernetes - Mechanics & Internals

Overview - Installing charts

What is it?

Installing charts means adding pre-packaged sets of Kubernetes resources to your cluster using Helm, a tool that simplifies managing applications. A chart is like a recipe that tells Kubernetes what to create and how to configure it. When you install a chart, Helm reads this recipe and sets up the application for you automatically. This saves you from writing complex configuration files by hand.

Why it matters

Without installing charts, setting up applications on Kubernetes would be slow and error-prone because you'd have to write and manage many configuration files manually. Charts make it easy to deploy, update, and share applications consistently. This means faster development, fewer mistakes, and easier collaboration across teams.

Where it fits

Before learning to install charts, you should understand basic Kubernetes concepts like pods, services, and deployments, and have Helm installed on your system. After mastering chart installation, you can learn about customizing charts with values files, managing releases, and creating your own charts.

Mental Model

Core Idea

Installing charts is like using a ready-made recipe to quickly and reliably set up applications on Kubernetes clusters.

Think of it like...

Imagine you want to bake a cake but don’t want to figure out the recipe yourself. Installing a chart is like using a trusted cake mix box that has all ingredients and instructions ready, so you just follow simple steps to get a perfect cake every time.

┌───────────────┐      ┌───────────────┐      ┌───────────────┐
│ Helm Client   │─────▶│ Chart Package │─────▶│ Kubernetes    │
│ (your laptop) │      │ (recipe files)│      │ Cluster       │
└───────────────┘      └───────────────┘      └───────────────┘
       │                     │                      │
       │ helm install        │                      │
       │ command             │                      │
       ▼                     ▼                      ▼
  User runs          Helm reads chart         Kubernetes creates
  install command    and sends resources      pods, services,
                     to cluster              deployments...

Build-Up - 7 Steps

1

Foundation

What is a Helm chart?

Concept: Introduce the basic idea of a Helm chart as a package of Kubernetes resources.

A Helm chart is a folder with files that describe Kubernetes objects like pods and services. It includes templates and default settings. Charts let you install complex apps with one command instead of many manual steps.

Result

You understand that a chart is a reusable package that simplifies deploying apps on Kubernetes.

Knowing that charts are packages helps you see how Helm automates complex setups into simple commands.

2

Foundation

Installing Helm and adding repositories

Concept: Explain how to set up Helm and access charts from repositories.

First, install Helm on your computer using official instructions. Then add a chart repository, which is like a library of charts, using: helm repo add stable https://charts.helm.sh/stable Next, update your local list with: helm repo update

Result

Helm is ready to find and install charts from repositories.

Understanding repositories as libraries helps you grasp how Helm finds charts to install.

3

Intermediate

Basic helm install command usage

🤔Before reading on: do you think helm install requires the exact chart name or can it install from any folder? Commit to your answer.

Concept: Learn the syntax and options of the helm install command to deploy charts.

To install a chart, run: helm install Example: helm install my-nginx stable/nginx This creates a release named 'my-nginx' using the nginx chart from the stable repo. Helm sends the chart's resources to Kubernetes to create the app.

Result

The application described by the chart is running in your Kubernetes cluster.

Knowing the release name lets you manage multiple installations of the same chart independently.

4

Intermediate

Customizing installs with values files

🤔Before reading on: do you think you can change app settings during install without editing the chart files? Commit to your answer.

Concept: Charts can be customized by providing your own settings in a values file during installation.

Charts have default settings, but you can override them by creating a YAML file with your values. Then install with: helm install my-nginx stable/nginx -f myvalues.yaml This changes the app configuration without modifying the chart itself.

Result

The app runs with your custom settings applied.

Understanding values files lets you tailor apps to your needs while keeping charts reusable.

5

Intermediate

Installing charts from local files

Concept: You can install charts stored on your computer instead of from a repository.

If you have a chart folder or packaged chart file (.tgz), install it with: helm install myapp ./mychart or helm install myapp ./mychart-0.1.0.tgz This is useful for testing or private charts.

Result

The local chart is deployed to your cluster.

Knowing local installs helps you develop and test charts before sharing them.

6

Advanced

Understanding release lifecycle during install

🤔Before reading on: do you think helm install creates a permanent record of the app in Kubernetes? Commit to your answer.

Concept: Helm tracks each install as a release with version history and metadata stored in Kubernetes secrets.

When you run helm install, Helm creates a release object that records what was installed and its version. This lets you upgrade, rollback, or uninstall cleanly later. The release info is stored inside Kubernetes, so Helm knows the app state.

Result

You can manage app versions and rollbacks easily.

Knowing Helm’s release tracking explains how upgrades and rollbacks work reliably.

7

Expert

Handling install failures and hooks

🤔Before reading on: do you think helm install always cleans up after a failed install automatically? Commit to your answer.

Concept: Helm supports hooks to run extra commands during install and has strategies for handling failures.

Charts can include hooks—special Kubernetes jobs that run before or after install steps. If an install fails, Helm can rollback changes automatically or leave resources for debugging depending on flags used. Understanding hooks helps customize complex installs.

Result

You can control install behavior and troubleshoot failures effectively.

Knowing hooks and failure handling prevents stuck or broken installs in production.

Under the Hood

Helm acts as a client that reads chart templates and values, then renders them into Kubernetes resource definitions. It sends these definitions to the Kubernetes API server, which creates the actual objects like pods and services. Helm also stores release metadata as secrets inside Kubernetes to track installed apps and their versions.

Why designed this way?

Helm was designed to simplify Kubernetes app management by packaging resources and tracking releases inside the cluster. Storing release data in Kubernetes avoids external databases and keeps state close to the apps. Using templates and values files allows flexibility without rewriting charts.

┌───────────────┐      ┌───────────────┐      ┌───────────────┐
│ Helm Client   │─────▶│ Template      │─────▶│ Kubernetes    │
│               │      │ Rendering     │      │ API Server    │
└───────────────┘      └───────────────┘      └───────────────┘
       │                     │                      │
       │ helm install        │                      │
       │ command             │                      │
       ▼                     ▼                      ▼
  User runs          Helm renders YAML      Kubernetes creates
  install command    manifests from chart   resources (pods,
                     and values             services, etc.)
       │                                            │
       ▼                                            ▼
  Helm stores release info as Kubernetes secrets for tracking

Myth Busters - 4 Common Misconceptions

Quick: Does helm install automatically update an existing release if the name matches? Commit to yes or no.

Common Belief: Running helm install with the same release name updates the existing app automatically.

Reality: helm install fails if the release name already exists; you must use helm upgrade to update an existing release.

Why it matters: Trying to install with the same name causes errors and confusion; knowing the difference prevents deployment failures.

Quick: Do you think helm install modifies the original chart files on your computer? Commit to yes or no.

Common Belief: Installing a chart changes the chart files locally to match the deployed app.

Reality: Helm never modifies chart files; it renders templates in memory and sends the output to Kubernetes without changing source files.

Why it matters: Believing charts change on install can cause unnecessary troubleshooting and fear of corrupting charts.

Quick: Does helm install always clean up all resources if the install fails? Commit to yes or no.

Common Belief: If helm install fails, it automatically removes all created resources to leave the cluster clean.

Reality: By default, helm install may leave some resources if the failure happens mid-way; cleanup depends on flags and hooks.

Why it matters: Assuming automatic cleanup can leave orphaned resources causing conflicts or resource waste.

Quick: Can you install a chart without internet access if you have the chart files locally? Commit to yes or no.

Common Belief: You must always have internet access to install charts because Helm downloads them from repositories.

Reality: You can install charts from local files without internet, useful for air-gapped environments or private charts.

Why it matters: Knowing this enables offline deployments and better security practices.

Expert Zone

1

Helm stores release metadata as Kubernetes secrets by default, but this can be changed to ConfigMaps for different security or performance needs.

2

Charts can include pre-install and post-install hooks that run jobs or scripts, allowing complex setup steps beyond simple resource creation.

3

Helm’s template rendering supports conditional logic and loops, enabling highly customizable and reusable charts for diverse environments.

When NOT to use

Avoid using Helm charts for very simple or static Kubernetes resources where plain YAML files suffice. Also, for highly dynamic or custom resource management, tools like Kustomize or direct kubectl apply may be better. Helm adds complexity and state management that is unnecessary for trivial deployments.

Production Patterns

In production, teams use Helm to manage app lifecycles with CI/CD pipelines automating helm install and helm upgrade commands. They store custom values files per environment and use Helm hooks for database migrations. Releases are monitored and rolled back automatically on failures to ensure stability.

Connections

Package Managers (e.g., apt, npm)

Helm charts are like package managers for Kubernetes, managing app installation and versions.

Understanding Helm as a package manager helps grasp how it simplifies app deployment and upgrades similar to software on your computer.

Infrastructure as Code (IaC)

Installing charts is a form of IaC where app infrastructure is defined and deployed via code templates.

Knowing IaC principles clarifies why charts use templates and values files to automate and version control deployments.

Cooking Recipes

Charts are structured like recipes that specify ingredients and steps to create a final product.

This connection helps understand the importance of templates and values as ingredients and instructions for Kubernetes apps.

Common Pitfalls

#1 Trying to install a chart with a release name that already exists causes an error.

Wrong approach:

helm install myapp stable/nginx
helm install myapp stable/mysql

Correct approach:

helm install myapp stable/nginx
helm upgrade myapp stable/mysql

Root cause:

Confusing helm install with helm upgrade and not understanding release name uniqueness.

#2 Editing chart files directly to customize settings instead of using values files.

Wrong approach:

Modify templates/deployment.yaml inside the chart folder before install.

Correct approach:

Create a myvalues.yaml file with overrides and run helm install -f myvalues.yaml

Root cause:

Not knowing that charts are reusable packages and customization should be done via values.

#3 Assuming helm install cleans up all resources on failure, leading to leftover broken resources.

Wrong approach:

helm install myapp stable/nginx
(install fails but no cleanup command run)

Correct approach:

helm install --atomic myapp stable/nginx
(automatic rollback on failure)

Root cause:

Not using the --atomic flag or understanding Helm’s failure handling.

Key Takeaways

Helm charts package Kubernetes resources into reusable recipes that simplify app deployment.

Installing charts with Helm automates creating and configuring apps on Kubernetes with one command.

Customizing installs is done by providing values files, not by editing chart source files.

Helm tracks each install as a release inside Kubernetes, enabling upgrades and rollbacks.

Understanding Helm’s install process and failure handling prevents common deployment mistakes.