Mastering Helm Charts: From Kubernetes Basics to Deployment

In this session, we introduce Helm Charts and explain their importance in modern Kubernetes and DevOps environments. The session establishes the prerequisites for learning Helm, emphasizing that learners should have a basic understanding of Kubernetes or OpenShift before proceeding with hands-on activities. No prior experience with Helm or Helm Charts is required, as the concepts are introduced from the beginning. The session also explains the goal of the training: learning not only how to use existing Helm Charts but also how to create custom charts from scratch to meet real-world corporate requirements.

Key topics covered include:

• Introduction to Helm Charts and the purpose of the training.

• Understanding why organizations create custom Helm Charts.

• The importance of Kubernetes or OpenShift knowledge as a prerequisite.

• Understanding containerized applications and Kubernetes environments.

• Introduction to automating application deployments.

• Understanding the difference between using existing charts and creating custom charts.

• Overview of the practical, hands-on learning approach.

By the end of this session, you will understand the prerequisites for learning Helm Charts, why Helm is useful in Kubernetes environments, and what you will learn throughout the training, including creating custom Helm Charts for real-world deployment requirements.

In this session, we explore the fundamental concepts of Helm and Helm Charts and understand how they simplify application deployment on Kubernetes. The session explains how a typical application requires multiple Kubernetes resources, such as Pods, Services, storage, and secrets, to operate correctly. Helm helps automate the deployment and management of these resources by packaging the required configuration into a Helm Chart. We also explore Helm as a package manager for Kubernetes and learn about chart repositories and Artifact Hub, where ready-made charts for applications such as Jenkins, WordPress, Prometheus, and Grafana can be discovered.

Key topics covered include:

• Understanding Helm and Helm Charts.

• Understanding the role of Kubernetes in container management.

• Understanding Kubernetes resources required for application deployment.

• Why deploying an entire application requires multiple resources.

• How Helm automates the deployment of application components.

• Understanding Helm as a package manager for Kubernetes.

• Understanding charts as packages containing deployment instructions.

• Introduction to Helm chart repositories.

• Exploring Artifact Hub to discover pre-built Helm Charts.

• Understanding the benefits of creating custom charts for business requirements.

By the end of this session, you will understand the purpose of Helm Charts, how they simplify application deployment, and how to explore existing charts before creating your own custom charts.

In this session, we explore how Helm Charts help deploy complete applications on Kubernetes and simplify the management of multiple resources. The session introduces the concept of Helm repositories and Artifact Hub, where users can discover existing charts for commonly used applications. Examples include Jenkins, WordPress, Prometheus, Grafana, MySQL, and MongoDB. We also discuss how pre-created charts can automate deployment tasks and why organizations may need custom charts to meet their specific infrastructure and application requirements.

Key topics covered include:

• Understanding project deployment using Helm Charts.

• Introduction to Helm chart repositories.

• Exploring Artifact Hub to find available charts.

• Understanding the relationship between charts, packages, and repositories.

• Discovering pre-created charts for Jenkins and WordPress.

• Exploring charts for monitoring tools and databases.

• Understanding how Helm automates the deployment of multiple Kubernetes resources.

• Comparing ready-made charts with custom charts.

• Understanding the role of custom requirements in chart development.

By the end of this session, you will understand how to explore Helm chart repositories, identify charts for common applications, and recognize when to use an existing chart or create a custom solution.

In this session, we examine the purpose of Helm Charts through practical application deployment examples. The session explains how deploying an application such as Jenkins or WordPress may require several Kubernetes resources, including deployments, Services, storage, and secrets. Helm simplifies this process by packaging the required Kubernetes manifests into a chart that can be installed using Helm commands. The session also demonstrates why custom Helm Charts are valuable when standard charts do not meet an organization's specific requirements.

Key topics covered include:

• Understanding the main purpose of Helm Charts.

• Automating the deployment of complete applications.

• Understanding Kubernetes resources required for Jenkins deployment.

• Exploring pre-created Helm Charts for Jenkins and WordPress.

• Understanding how charts simplify multi-resource deployment.

• Learning how a single Helm installation can deploy multiple resources.

• Understanding the benefits of industry-created charts.

• Identifying custom requirements for storage, roles, Services, and Pods.

• Understanding when to create a custom Helm Chart.

• Introduction to building custom charts from scratch.

By the end of this session, you will understand how Helm Charts simplify application deployment and why creating custom charts is useful for organizations with specific infrastructure requirements.

In this session, we prepare the practical environment required for working with Helm Charts. The session covers the role of Minikube in running a local Kubernetes cluster and explains how Helm is installed and executed from a client system. We also explore Helm version selection, the Helm command-line binary, and the importance of configuring the correct executable path. The session emphasizes that Helm must be used from a system with a properly configured Kubernetes or OpenShift client connection.

Key topics covered include:

• Understanding Minikube as a local Kubernetes environment.

• Starting a Kubernetes cluster for practical exercises.

• Understanding Helm as a command-line client tool.

• Downloading and installing Helm.

• Extracting and accessing the Helm executable.

• Understanding Helm 2 and Helm 3 differences.

• Checking the installed Helm version.

• Configuring the Helm executable path.

• Understanding the relationship between Helm and kubectl.

• Understanding the OpenShift oc client as an alternative.

• Verifying client connectivity to the Kubernetes cluster.

• Preparing the environment for Helm chart installation and deployment.

By the end of this session, you will understand how to prepare a local Kubernetes environment, install Helm, verify its version, and configure the client tools required for the upcoming hands-on chart development exercises.

In this session, we begin creating a custom Helm Chart from scratch. The session explains why understanding application requirements is the first step in chart development and demonstrates how a manual Kubernetes deployment can be converted into an automated, reusable package. Using a simple web application as an example, we explore the steps required to deploy an application and expose it through a Service. The session introduces the initial chart structure and explains how Helm identifies a folder as a chart through its metadata.

Key topics covered include:

• Understanding the purpose of creating a custom Helm Chart.

• Identifying application deployment requirements.

• Converting manual deployment steps into an automation workflow.

• Understanding the difference between deploying a Pod and deploying a complete application.

• Creating a folder for the custom chart.

• Understanding the relationship between the chart name and its folder.

• Introduction to the Chart.yaml metadata file.

• Defining the chart name and version.

• Understanding chart metadata and package identification.

• Recognizing common chart creation errors and missing configuration.

By the end of this session, you will understand the initial steps involved in creating a Helm Chart, defining its metadata, and preparing the foundation for automating Kubernetes application deployments.

In this session, we continue building a custom Helm Chart and learn how to organize the files required for application deployment. The session focuses on creating the chart metadata, defining the chart version, and understanding how Helm uses the chart structure to identify and install a package. Through practical command-line exercises, we learn how to create a chart folder, configure its required metadata, and install the chart using Helm. The session also introduces the relationship between chart versions, installation names, and Helm release management.

Key topics covered include:

• Creating a custom Helm Chart folder.

• Understanding the structure of a Helm chart.

• Creating and configuring the Chart.yaml file.

• Defining the chart name and version.

• Understanding the purpose of chart metadata.

• Installing a chart using the Helm command line.

• Understanding Helm release names.

• Using Helm commands to list installed releases.

• Understanding common chart validation errors.

• Learning how chart metadata supports versioning and release management.

By the end of this session, you will understand how to create a basic Helm Chart, define its metadata, install it, and verify the chart release using Helm commands.

In this session, we learn how to use Helm Charts to deploy Kubernetes resources automatically. The session explains that chart metadata alone does not deploy an application; Kubernetes manifest files must also be provided. We explore the templates directory, where Kubernetes YAML manifests such as Deployment and Service definitions are stored. Using a practical web application example, the session demonstrates how Helm processes the chart templates and creates the required Kubernetes resources when a chart is installed.

Key topics covered include:

• Understanding the role of Kubernetes YAML manifests in Helm Charts.

• Creating the templates directory inside a chart.

• Understanding the relationship between chart metadata and templates.

• Using Kubernetes Deployment manifests within a chart.

• Generating YAML manifests from Kubernetes commands.

• Deploying application resources through Helm.

• Understanding how a Deployment creates ReplicaSets and Pods.

• Adding a Service manifest to expose an application.

• Installing a chart containing multiple templates.

• Verifying deployed resources using Kubernetes commands.

• Understanding how Helm manages application resources as a release.

By the end of this session, you will understand how to add Kubernetes manifest files to a Helm Chart and use Helm to deploy application resources, including Deployments, Pods, and Services, through a single installation workflow.

In this session, we extend the custom Helm Chart to support changing application requirements without repeatedly editing the Kubernetes manifest files. The session explains how hard-coded values, such as container image versions, can limit reuse across development, testing, staging, and production environments. We introduce parameterization and the values.yaml file as a centralized location for configuring chart values. Helm templates use these values to generate the appropriate Kubernetes manifests when a chart is installed.

Key topics covered include:

• Deploying applications using Helm chart templates.

• Understanding hard-coded values in Kubernetes manifests.

• Introduction to Helm template parameterization.

• Understanding variables and template expressions.

• Creating and using the values.yaml file.

• Defining configurable values such as container image versions.

• Referencing values from templates.

• Replacing hard-coded configuration with reusable parameters.

• Supporting different configurations for development, testing, staging, and production.

• Understanding how the same chart can be reused across multiple environments.

• Installing charts and verifying the resulting application configuration.

By the end of this session, you will understand how to create configurable Helm Charts using templates and values.yaml, allowing the same chart to support different application versions and environment-specific requirements.

In this session, we explore how Helm manages application releases and supports updates to deployed applications. The session explains why deleting and reinstalling an entire application is not the preferred approach when a new version needs to be deployed. Instead, Helm provides upgrade and rollback capabilities that help manage changes to an existing release. We examine how Helm tracks release revisions and how chart upgrades can apply updated configuration through Kubernetes deployment strategies, including rolling updates where supported by the application manifests.

Key topics covered include:

• Understanding Helm releases and revision history.

• Understanding why deleting an application is different from upgrading it.

• Updating application configuration through Helm.

• Using Helm's upgrade functionality to release changes.

• Understanding how release revisions change after upgrades.

• Checking installed releases using Helm commands.

• Understanding rolling updates in Kubernetes deployments.

• Using Helm to manage application changes through chart releases.

• Understanding the purpose of rollback when an earlier release needs to be restored.

• Recognizing the importance of release history in application management.

By the end of this session, you will understand how Helm supports application upgrades and release management, why revision history matters, and how rollback can help restore an earlier release when a deployment change needs to be reversed.

In this session, we explore how Helm manages application updates and supports rolling upgrades through chart releases. We learn how to update configuration values using the command line, perform upgrades, and understand the relationship between Helm revisions and Kubernetes deployment strategies. The session also explains how Helm maintains release history and allows users to roll back to an earlier revision when a new version does not work as expected.

Key topics covered include:

• Understanding Helm chart upgrades and new releases.

• Updating chart values through the values.yaml file.

• Changing configuration values using the --set option.

• Using Helm upgrade commands to apply changes.

• Understanding Helm release revisions.

• Understanding rolling updates in Kubernetes.

• Recognizing how deployment strategies affect application downtime.

• Exploring Helm release history using helm list --all.

• Rolling back to an earlier release revision.

• Understanding the benefits of version tracking and rollback.

• Using the helm create command to generate a chart structure.

• Exploring default templates and configurable values in generated charts.

By the end of this session, you will understand how to upgrade Helm releases, change deployment values, review revision history, and roll back deployments when required.

In this session, we explore how to create and customize Helm charts for different application deployment requirements. We learn about the standard chart directory structure, chart metadata, values files, and Go templating. The session also explains how to use different configuration files for development, testing, staging, and production environments, along with customizing existing charts for application deployment.

Key topics covered include:

• Creating Helm charts using the helm create command.

• Understanding the standard Helm chart directory structure.

• Exploring Chart.yaml and its metadata, including the application version.

• Understanding the purpose of values.yaml.

• Configuring image repositories, image tags, image pull policies, and replica counts.

• Customizing service types and service ports.

• Using separate values files for development, QA, staging, and production environments.

• Passing configuration files using the -f or --values option.

• Overriding configuration values using the --set option.

• Using helm show all and helm show values to inspect chart information.

• Exploring templates for Deployments, Services, Service Accounts, Ingress, and Horizontal Pod Autoscalers.

• Adding custom Kubernetes resource definitions, such as PVCs and Secrets, to chart templates.

• Understanding Go templating, conditional statements, and functions such as default and indent.

• Exploring the use of existing chart repositories to deploy applications such as Jenkins.

• Customizing chart configurations for persistence, resources, and service exposure.

By the end of this session, you will understand how to create reusable Helm charts, customize templates and values, and manage application deployments across multiple environments.

In this session, we learn how to use external Helm chart repositories to deploy applications in Kubernetes. The session demonstrates how to add a repository, update repository information, search for available charts, and install Jenkins using a pre-built Helm chart. We also explore how a single Helm chart can support multiple environments through customized values files.

Key topics covered include:

• Understanding Helm chart repositories and their purpose.

• Adding a Jenkins chart repository to the local Helm configuration.

• Listing configured Helm repositories.

• Updating repository information to access available charts.

• Searching for charts available in a repository.

• Understanding the difference between a release name and a chart name.

• Installing Jenkins using an existing Helm chart.

• Understanding Helm version and path considerations in the demonstrated setup.

• Creating separate values files for development, QA, testing, and staging environments.

• Customizing application versions and configurations for different environments.

• Exploring Kubernetes resources created by a Jenkins chart, including Deployments, Services, and Persistent Volume Claims.

• Understanding how pre-built charts simplify application deployment.

• Exploring the possibility of creating and sharing custom Helm charts for applications such as WordPress and microservices.

By the end of this session, you will understand how to configure Helm repositories, find and install existing charts, deploy Jenkins in Kubernetes, and manage environment-specific configurations.

In this session, we explore how Helm simplifies Jenkins deployment by using an existing chart with predefined Kubernetes resources and configurable parameters. We learn how to customize chart values without modifying the original templates, understand Helm's Go-based templating syntax, and access the Jenkins application after deployment. The session also highlights the importance of persistence, reusable configurations, and automation in DevOps.

Key topics covered include:

• Understanding Go templating in Helm charts.

• Exploring conditional statements such as if and else.

• Understanding template functions and formatting, including default and indent.

• Using template logic to customize Kubernetes resource definitions.

• Deploying Jenkins using a pre-created Helm chart.

• Understanding the Kubernetes resources required for Jenkins deployment.

• Exploring Deployments, Services, Persistent Volume Claims, and Secrets.

• Understanding the role of persistent storage in retaining Jenkins data.

• Accessing Jenkins through an appropriate service configuration or Kubernetes port-forwarding/proxy setup.

• Understanding how chart instructions help users configure and access an application.

• Exploring default chart values and available configuration parameters.

• Customizing persistence settings, resource requirements, and other deployment options using values files or the --set option.

• Upgrading a chart after changing its configuration.

• Understanding how reusable Helm charts reduce repetitive manual configuration.

• Identifying repetitive DevOps tasks and opportunities for automation.

• Practicing project development, creating custom Helm charts, sharing them with teams, and improving them through feedback.

By the end of this session, you will understand how to deploy and customize Jenkins using Helm, configure its Kubernetes resources, and apply automation principles to build reusable deployment solutions.