Helm: The Definitive Guide from Beginner to Master

In this lecture, we explore how to install MiniKube and create a local Kubernetes cluster. Students learn about system requirements, choosing the correct version based on their operating system, and running essential commands to get everything up and running smoothly.

In this lecture, you will learn how to install and set up Kubectl on macOS, ensuring compatibility with your existing Kubernetes cluster. The session covers version verification, installation methods, and basic connectivity testing, equipping you with the essential skills to manage Kubernetes applications effectively.

In this lecture, we explore how to install the Helm CLI, an essential tool for managing Kubernetes applications. We cover the various installation methods, including direct downloads and using Homebrew, ensuring you have the right version for your operating system. By the end of the session, you will confidently set up Helm in your development environment.

In this lecture, we go through the overall structure and content topics for this section.

In this lecture, we explore ArtifactHub as a platform for finding Helm charts from reputable publishers. The session covers how to search for applications, filter results, and evaluate chart documentation, empowering participants to effectively deploy applications in Kubernetes.

In this lecture, we examine how to interact with Helm repositories using the Helm client. The focus is on adding repositories, updating chart information, and searching for specific charts, with practical examples using the Bitnami and Prometheus community repositories.

In this lecture, we learn to install our first Helm chart, specifically a WordPress application, from the Bitnami repository onto a Kubernetes cluster. The session emphasizes hands-on experience, guiding students through the necessary commands and steps required to successfully deploy and access a Helm application.

In this lecture, we explore the default configurations of a newly deployed WordPress application within a Kubernetes cluster, focusing on accessing the admin panel and retrieving necessary credentials. We emphasize practical application through a step-by-step approach to empower participants to manage their installations effectively.

In this lecture, we explore the process of uninstalling a specific Helm release from a Kubernetes cluster, including how to clean up associated resources such as services and persistent storage. Through practical examples, we emphasize the importance of resource management during the uninstallation process, equipping you with the skills needed for effective cluster maintenance.

In this lecture, we explore the consequences of not deleting persistent volume claims when uninstalling Helm releases. Through a hands-on exercise involving the installation and reinstallation of WordPress, participants learn how generated values impact MariaDB configurations and the necessity of managing persistent data for successful application deployment.

In this lecture, we explore how to customize deployment values for the WordPress chart in Helm. We focus on setting specific parameters via the CLI, particularly the MariaDB authentication values, and emphasize best practices for managing sensitive information securely.

In this lecture, we explore how to use YAML files to set custom values for Helm releases, specifically for a WordPress installation. The goal is to enhance understanding and implementation of secure practices when managing sensitive information and configuring applications in Kubernetes.

This lecture delves into the mechanics of upgrading Helm releases, focusing on how to modify custom configuration values using the helm upgrade command. By the end of the lecture, you will gain hands-on experience with the upgrade process and understand how to apply changes with minimal disruption to your applications.

In this lecture, we focus on using the helm upgrade command to install a newer version of a chart, specifically the Bitnami WordPress chart. We go through the process of updating our helm repository charts, selecting and applying the new version, and verifying the success of the upgrade by examining the release history and pod statuses.

In this lecture, we explore the process of performing a rollback in Helm following a failed upgrade, using WordPress as an example. We learn to intentionally trigger an error during an upgrade, analyze the Helm release history, and successfully revert to a prior stable version while also addressing resource cleanup practices.

In this lecture, we explore the usage of helpful flags with the helm upgrade command to ensure smooth upgrades in Kubernetes. We cover how to manage services, handle upgrade failures, and maintain clean states during deployment processes, providing practical examples and best practices along the way.

In this lecture, we go through the overall structure and content topics for this section.

In this lecture, we explore the importance and benefits of creating custom Helm charts. We discuss various reasons for building your own charts, including application-specific needs, deployment configurations, versioning strategies, and organizational policy enforcement, along with guidance on the implementation process.

This lecture provides an overview of the main components of Helm charts, discussing the importance and role of various files and directories within a chart. It aims to equip participants with the knowledge needed to build their own charts and navigate existing ones effectively.

In this lecture, we explore the creation of a basic Helm chart for deploying Nginx on Kubernetes. We'll walk through setting up the necessary directories and files, writing the Kubernetes manifests, and validating the chart using Helm commands, setting the foundation for future customization.

This lecture introduces students to the foundational concepts of Go Templating. We cover the creation of Helm charts, including how to set up templates, configure values, and generate YAML outputs, while also emphasizing the importance of whitespace and comment management in templates.

This lecture provides an introduction to Go templating in Helm, covering the essential context, objects, and functions available to customize Helm charts. Participants learn about the dot notation, key objects, and how to employ functions effectively, including the use of the pipe operator for chaining function calls.

In this lecture, we introduce Go templating for Helm templates, focusing on flow control through conditionals and loops. Participants learn to set environment variables and render dynamic outputs based on conditions, setting a strong foundation for more advanced templating techniques.

In this lecture, we explore how to enhance our Helm chart by integrating customizable values into the values.yaml file, focusing on parameters like the replica count, image configurations, and service settings. By the end, you will understand how to define, document, and reference these values in your deployment and service templates effectively.

In this lecture, we focus on removing hardcoded strings from Helm chart templates, introducing dynamic naming conventions using release and chart information to ensure unique identifiers across deployments in Kubernetes environments. The session promotes practical experimentation and encourages students to refine their Helm skills.

In this lecture, we focus on enhancing Helm chart templates by implementing conditional service deployment based on user-defined values. You’ll learn how to modify the values.yaml file and wrap service definitions with if conditions to control their deployment based on specific criteria.

In this lecture, we explore the packaging and publishing process for Helm charts, guiding you through generating, linting, installing, and ultimately creating a portable artifact that can be shared and installed easily. You'll gain hands-on experience in managing Helm charts effectively.

In this lecture, we set up a GitHub repository and enabled GitHub Pages to publish Helm charts. We covered the necessary steps to create a public repository, clone it locally, manage Helm charts, and ensure that our charts are accessible via a generated URL.

In this lecture, we guide you through the process of installing NGINX from a Helm repository that you’ve created. You will learn how to add, search, and install charts using Helm, as well as verify that your services are running correctly. This interactive session empowers you to take charge of your deployment processes in Kubernetes.

In this lecture, we explore the helm create command to demonstrate how to automatically generate Helm chart files and directories. We'll examine the structure and content of the generated files to enhance understanding of Kubernetes manifests and the Go template syntax as we prepare for the next deep dive into templating capabilities.

In this lecture, we recap the complete process of developing and publishing home charts, highlighting the key steps involved, including creating files, developing templates, and writing tests. We aim to provide a comprehensive overview that clarifies the ongoing nature of chart development, paving the way for deeper exploration of advanced functionalities in future sessions.

In this lecture, we go through the overall structure and content topics for this section.

In this lecture, we explore the available functions in Helm's templating system, emphasizing how to manipulate data using strings, lists, and dictionaries. We also discuss the crucial role of proper indentation in YAML, the syntax of functions, and how to utilize pipelines to improve readability and functionality in Helm charts.

In this lecture, we explore the benefits of using named templates in Helm to minimize duplication in Kubernetes configurations. We walk through the creation of a helpers file, defining various templates, and implementing them within deployment manifests, all while emphasizing best practices for maintainability and consistency.

In this lecture, we explore if-else statements within Helm and Go templates, focusing on how to conditionally render elements in our Kubernetes configurations. Participants learn to implement named templates and test their configurations through practical examples, enhancing their templating skills.

In this lecture, we explore the use of variables in Helm templates to create cleaner code and optimize resource naming configurations. We learn how to define variables, implement conditional logic for custom names, and utilize the `default` function for simplified naming. This session emphasizes practical coding skills and best practices for maintaining efficiency in Helm chart development.

In this lecture, we discuss variable scopes in Helm templates, focusing on how to correctly declare and access variables within different blocks of code. We aim to clarify the relationship between variable declaration and scope, equipping you with the skills to avoid common pitfalls while working with Helm templates.

In this lecture, we focus on leveraging the "range" function in Go templates to handle multiple services in Helm charts. You'll learn how to adjust your "values.yaml" interface, implement robust template logic to accommodate service lists, and handle common pitfalls such as null pointers and template errors while ensuring your configurations remain maintainable and scalable.

In this lecture, we learn how to implement more stable service definitions in Kubernetes by utilizing maps instead of lists. The focus is on understanding key-value pairs and how they prevent issues related to the order of services during resource recreation. By refactoring our service definitions and syntax accordingly, we achieve greater consistency and reliability in our configurations.

In this lecture, we explore the behavior of the dot variable in templates, especially when using structures like lists and maps. The goal is to understand how the dot variable's value changes based on its context within templates and how to reference information reliably using both dot and dollar sign notation.

In this lecture, we explore the practical aspects of implementing security context options in Helm templates using "with" blocks. You'll learn how to define security context values, apply conditional logic, and manage variable scopes effectively, all aimed at enhancing readability and maintainability in their template code.

This lecture focuses on input validation functions in Helm, discussing how to use the "required" and "fail" functions to verify that necessary values are specified when generating templates. By mastering these validations, you can prevent deployment failures and enhance the clarity of error messages for users.

In this lecture, we delve into combining named templates with validation functionalities in Go templates. The goal is to implement inline validation for properties such as port numbers and service types, ensuring that values passed to templates are valid before rendering. Through practical examples and step-by-step guidance, learners will gain hands-on experience in creating and utilizing custom validators to enhance their Helm chart templates.

In this lecture, we focus on the optional coding setup for the Config Store application, guiding you through repository creation on GitHub, local project setup, and essential dependency management to ensure compatibility for future development.

In this lecture, you learn how to set up a functional Express application using Docker, creating a minimal server that responds to HTTP requests. The session focuses on implementing a Dockerfile, utilizing multi-stage builds, and configuring Docker Compose for managing application services.

In this lecture, we configure a PostgreSQL database and integrate it with an application using Sequelize. The focus is on creating environment variables, setting up a Docker Compose configuration, and ensuring a successful connection to the database.

In this lecture, we focus on implementing routes for CRUD operations on a key-value pair model using Express and Sequelize. Students learn to create models, define API endpoints, and perform operations such as retrieving, creating, updating, and deleting data from a database.

In this lecture, we focus on testing API functionality and the process of building and pushing Docker images to Docker Hub. Students gain hands-on experience in manipulating key-value pairs through an API while learning essential Docker commands for image management.

In this lecture, we go through the overall structure and content topics for this section.

In this lecture, we explore the concept of subcharts and chart dependencies in Helm. Students learn how to include entire Helm charts as dependencies, manage these dependencies effectively using CLI commands, and enhance their Kubernetes applications through better organization and functionality.

In this lecture, you dive into the process of bootstrapping the Config Store chart, focusing on configuring the project structure, managing dependencies, and setting up essential services using Helm. You will gain insights into validating configurations and installing your chart while troubleshooting common issues related to database connectivity.

In this lecture, we explore how to add a PostgreSQL dependency to a config stored chart using Helm. The session addresses repository management, dependency updates, and the significance of maintaining a chart lock file, providing a practical foundation for managing Helm charts and their dependencies effectively.

In this lecture, we focus on demonstrating how to pass configuration values from a parent Helm chart to its subcharts. Students will learn practical techniques for managing dependencies and overriding values effectively, facilitating better project organization and workflow in their Helm deployments.

In this lecture, we examine the concept of using global values in Helm charts to share configurations across various subcharts. The session covers how to define, access, and verify these global values, enhancing your ability to manage complex Helm applications efficiently.

In this lecture, you learn how to include named templates from subcharts into a parent chart in Helm. The focus is on understanding the context that is passed when including templates and how name overrides impact both parent and subchart functionalities. This knowledge designs a pathway for better code reuse and modularization in Helm charts.

In this lecture, we discuss how to conditionally enable and disable subcharts within Helm configurations, focusing on managing database dependencies. Students will learn to apply conditions in configuration files, modify values, and use tags, all while reinforcing best practices for flexible deployment strategies.

This lecture focuses on integrating the PostgreSQL subchart into a Helm project, emphasizing best practices for configuration management and secret handling. Students will learn to customize the PostgreSQL settings, manage Kubernetes secrets, and ensure seamless interaction between services through effective deployment configurations.

In this lecture, we go through the overall structure and content topics for this section.

In this lecture, we explore the process of accessing and retrieving file contents from within a Helm chart. We create a structured chart, define a ConfigMap, and utilize built-in functions to load data from files, providing a practical understanding of Helm templates and their capabilities.

In this lecture, we discuss how to retrieve content from multiple properties files in Helm templates using glob patterns. We explore the benefits of this approach, demonstrate the step-by-step implementation, and emphasize best practices for managing configuration files effectively.

This lecture focuses on utilizing utility functions in Helm to streamline the creation of config maps and secrets from multiple files at once. Participants will learn to effectively use the ".Files.Glob" function alongside the ".AsConfig" and ".AsSecret" methods, while also understanding best practices regarding sensitive data management.

In this lecture, we review Helm hooks, which are integral Kubernetes resources that facilitate custom logic execution at specified points in the release lifecycle. Students learn about the various hook types, how to define them in Helm chart templates, and the significance of hook weight and delete policies.

In this lecture, we explore the concept of Helm hooks, focusing on creating a backup job that executes before various action events such as upgrades and deletions. We discuss how to implement hooks correctly, manage their lifecycle, and ensure that deployments are efficient and safe, all while guiding participants through a hands-on implementation process.

In this session, we investigate how to leverage weights for executing hooks sequentially in Helm. You will learn about delete policies and their implications when managing multiple hooks. The goal is to understand how to control the execution order and lifecycle of hooks effectively.

In this lecture, we examine and experiment with the behavior of Helm when hooks fail during execution. By modifying hook commands and observing their impact on the Helm upgrade process, we identify the significance of hooks in maintaining the integrity of deployments. Through practical experiments, we learn about the rollback functionality and the importance of the "--atomic" flag.

In this lecture, learners focus on the cleanup process of a Kubernetes cluster after utilizing hooks. They will understand how to effectively manage and delete leftover jobs and pods to maintain a clean working environment, preparing for future tasks.

In this lecture, we explore the creation and implementation of library charts in Helm, focusing on how to set up reusable utility functions for enhanced chart functionality. We provide a practical, step-by-step guide to facilitate understanding and implementation of library charts in your projects.

In this lecture, participants explore Helm test hooks, learning how to implement them within Helm charts. They will create a test chart, install it, and execute tests to validate their application deployments, gaining practical experience with Helm commands and configurations.

In this lecture, we explore the process of improving our testing architecture by extracting test commands into scripts, storing them in config maps, and using volumes to mount them in containers. The goal is to create a cleaner separation between tests and their execution environment, enhancing maintainability and clarity.

In this lecture, we explore how to update a pod definition file to utilize configuration maps, focusing on configuring container images, commands, defining volumes, and implementing hook weights to ensure proper execution order. Through practical examples, you will gain hands-on experience in enhancing your Kubernetes deployments.

In this lecture, we explore how to effectively customize values in Helm charts to enhance flexibility in Kubernetes object configurations, particularly focusing on test connection files. Students learn to implement conditional rendering, set configurations in the "values.yaml" file, and apply deletion policies for test resources.

In this lecture, we explore the Helm Dashboard plugin, a community-driven tool that enhances Helm's capabilities by providing a user-friendly interface. Students will learn to install, manage, and utilize the dashboard to visualize and interact with their Kubernetes resources managed by Helm.

In this lecture, we explore the Helm Diff plugin, focusing on its features and how it can help visualize changes in Helm releases. We will go through practical steps to install the plugin, check for differences between chart revisions, and perform upgrades, ensuring that we fully understand the implications of our changes.

In this lecture, we focus on the Helm Unittest plugin, exploring how to validate Helm charts using unit tests. You’ll learn about the installation process of the plugin, the creation of test files, and best practices to ensure your charts function as intended without impacting your Kubernetes cluster.