Skip to main content
Mapagam

50 SECTIONS · 1269 TOPICS

Helm Charts Roadmap

  1. Understanding Helm Fundamentals

    1. 1. Understanding Helm Architecture
    2. Example: Helm Chart Structure
    3. 2. Understanding Chart Concept
    4. Example: Chart.yaml structure
    5. 3. Understanding Release Concept
    6. Example: Release Status Check
    7. Release Lifecycle
    8. 4. Understanding Repository Concept
    9. Example: Adding a Helm Repository
    10. Example: Listing Repositories
    11. 5. Understanding Values Hierarchy
    12. Example: Setting Values Hierarchy
    13. 6. Understanding Template Rendering
    14. Example: Basic Template Rendering
    15. Example: Conditional Rendering
    16. 7. Understanding Chart Lifecycle
    17. Helm Chart Lifecycle Overview
    18. Example: Chart Versioning
    19. 8. Understanding Helm Three-Way Merge
    20. Example: Merge Conflict Resolution
    21. Three-Way Merge Process
    22. 9. Understanding Chart API Versions
    23. 10. Comparing Helm vs Kustomize
    24. Helm vs Kustomize: Key Differences
    25. Example: Helm Chart Structure
    26. Example: Kustomize Structure

  2. Installing and Configuring Helm

    1. 1. Installing Helm CLI
    2. Example: Verify Installation
    3. 2. Verifying Helm Installation
    4. Example: Helm version check
    5. 3. Configuring Repository Settings
    6. Example: Adding a repository
    7. Example: Listing repositories
    8. Example: Updating repositories
    9. 4. Setting Up Kubeconfig Context
    10. Example: Configure kubeconfig for a cluster
    11. 5. Configuring Helm Environment Variables
    12. Example: Setting Environment Variables
    13. 6. Setting Default Namespace
    14. Example: Setting Default Namespace
    15. 7. Configuring Helm Cache Directory
    16. Example: Setting Helm Cache Directory
    17. 8. Setting Up Helm Plugins Directory
    18. Example: Setting Plugins Directory via Environment Variable
    19. 9. Configuring Helm Data Directory
    20. Example: Setting Helm Data Directory
    21. 10. Configuring Helm Config Directory
    22. Example: Setting Helm Config Directory

  3. Working with Chart Repositories

    1. 1. Adding Chart Repository
    2. Example: Adding a public repository
    3. Example: Adding a private repository with credentials
    4. 2. Listing Repositories
    5. Example: Listing repositories
    6. 3. Updating Repository Index
    7. Example: Update repository index
    8. 4. Removing Repository
    9. Example: Remove a repository
    10. 5. Searching Repository Charts
    11. Example: Search for charts with a specific keyword
    12. Example: Search for charts with version constraint
    13. 6. Viewing Repository Index
    14. 7. Using Private Repositories
    15. Example: Adding a Private Repository
    16. Example: Installing Chart from Private Repo
    17. 8. Configuring Repository Credentials
    18. Example: Adding a Private Repository with Credentials
    19. Example: Adding a Repository with TLS and GPG
    20. 9. Setting Repository Cache
    21. Example: Configure Helm Repository Cache
    22. 10. Managing Multiple Repositories
    23. Example: Adding and Listing Repositories
    24. Workflow: Managing Repository Priority

  4. Searching Helm Charts

    1. 1. Searching Repositories
    2. Example: Search for charts containing "nginx"
    3. Example: Search with version constraint
    4. 2. Searching Artifact Hub
    5. Example: Search for charts with specific keywords
    6. Example: Search for charts from a specific repository
    7. 3. Using Search Keywords
    8. Example: Search for charts with specific name and version
    9. Example: Search charts by maintainer and tag
    10. 4. Filtering by Version
    11. Example: Search for specific version
    12. Example: Search with version range
    13. 5. Using Regular Expressions
    14. Example: Filtering Charts with Regex
    15. 6. Limiting Search Results
    16. Example: Limiting search results to 5 charts
    17. Example: Skipping first 10 results and showing next 5
    18. Example: Filtering charts by name containing "nginx"
    19. 7. Viewing All Versions
    20. Example: Listing all versions of a chart
    21. 8. Searching with Output Format
    22. Example: Search with JSON Output
    23. Example: Search with Filter
    24. 9. Finding Latest Version
    25. Example: Find Latest Stable Version
    26. Example: Find Specific Version
    27. 10. Searching Specific Repository
    28. Example: Search for a specific chart in a repository
    29. Example: Search for all charts in a repository

  5. Creating Chart Structure

    1. 1. Generating New Chart
    2. Example: Using Helm CLI to create a new chart
    3. 2. Understanding Chart Directory Layout
    4. Example: Chart.yaml structure
    5. 3. Creating Chart.yaml Metadata
    6. Example: Chart.yaml
    7. 4. Defining Chart Type
    8. Example: Chart.yaml for Application Type
    9. 5. Creating values.yaml File
    10. Example: Default values.yaml
    11. 6. Creating .helmignore File
    12. Example: .helmignore content
    13. 7. Organizing Template Files
    14. Example: Deployment Template
    15. Example: Service Template
    16. 8. Creating NOTES.txt File
    17. Example: Basic NOTES.txt Content
    18. 9. Setting Up charts/ Subdirectory
    19. Example: Adding a dependency
    20. 10. Creating crds/ Directory
    21. Example: Defining a CRD in Helm Chart
    22. 11. Creating templates/_helpers.tpl
    23. Example: Basic helpers template

  6. Working with Chart.yaml

    1. 1. Defining Chart Name and Version
    2. Example: Chart.yaml with name and version
    3. 2. Setting Application Version
    4. Example: Setting appVersion in Chart.yaml
    5. 3. Declaring API Version
    6. 4. Specifying Chart Type
    7. Example: Setting Chart Type
    8. 5. Adding Chart Description
    9. Example: Chart Description
    10. 6. Adding Keywords and Sources
    11. Example: Chart.yaml with keywords and sources
    12. 7. Listing Chart Maintainers
    13. Example: Chart.yaml with Maintainers
    14. 8. Setting Home URL
    15. Example: Setting Home URL in Chart.yaml
    16. 9. Adding Icon URL
    17. Example: Setting Icon URL in Chart.yaml
    18. 10. Marking Chart Deprecated
    19. Example: Marking a Chart as Deprecated
    20. 11. Setting Kubernetes Version Constraint
    21. Example: kubeVersion in Chart.yaml

  7. Working with Values Files

    1. 1. Creating values.yaml Default Values
    2. Example: Default values.yaml
    3. 2. Understanding Values Hierarchy
    4. Example: Values Hierarchy in Action
    5. 3. Using Custom Values Files
    6. Example: Using custom values file
    7. Example: Overriding with --set
    8. 4. Setting Individual Values
    9. Example: Setting a nested value
    10. Example: Setting multiple values at once
    11. 5. Using String Values
    12. Example: Setting String Values
    13. 6. Setting File Content Values
    14. Example: Setting File Content in ConfigMap
    15. Example: Setting File Content in Secret
    16. 7. Setting JSON Values
    17. Example: Setting JSON Values in Values File
    18. 8. Merging Multiple Values Files
    19. Example: Merging values files
    20. Workflow: Merging multiple values files
    21. 9. Creating Environment-Specific Values
    22. Example: values-dev.yaml
    23. Example: values-prod.yaml
    24. 10. Documenting Values
    25. Example: Using Comments in Values Files
    26. 11. Using Global Values
    27. Example: Setting global values in values.yaml

  8. Implementing Values Schema Validation

    1. 1. Creating values.schema.json File
    2. Example: Basic values.schema.json
    3. 2. Defining Schema Properties
    4. Example: Defining Schema Properties
    5. 3. Setting Required Fields
    6. Example: Required Fields in Values Schema
    7. 4. Defining Value Types
    8. Example: Defining Value Types in Values Schema
    9. 5. Adding Property Constraints
    10. Example: Validating Property Constraints
    11. 6. Using Enum Values
    12. Example: Setting Enum Values in Values Schema
    13. 7. Setting Default Values
    14. Example: Default Values in values.yaml
    15. 8. Adding Schema Descriptions
    16. Example: Schema with Descriptions
    17. 9. Validating Nested Objects
    18. Example: Nested Object Schema Validation
    19. 10. Testing Schema Validation
    20. Example: Unit Test with Chart Testing

  9. Creating Template Files

    1. 1. Understanding Template Syntax
    2. Example: Basic Template Syntax
    3. Example: Using Template Functions
    4. 2. Creating Deployment Template
    5. Example: Basic Deployment Template
    6. 3. Creating Service Template
    7. Example: Basic Service Template
    8. 4. Creating ConfigMap Template
    9. Example: Basic ConfigMap Template
    10. 5. Creating Secret Template
    11. Example: Creating a Secret Template
    12. 6. Creating Ingress Template
    13. Example: Ingress Template
    14. 7. Creating ServiceAccount Template
    15. Example: ServiceAccount Template
    16. 8. Creating RBAC Templates
    17. Example: RBAC Configuration in values.yaml
    18. 9. Creating PersistentVolumeClaim Template
    19. Example: PersistentVolumeClaim Template
    20. 10. Using Template Comments ({{/* */}})
    21. Example: Using Template Comments
    22. 11. Using Multi-Document Templates
    23. Example: Multi-Document Template Usage

  10. Working with Template Functions

    1. 1. Accessing Values ({{ .Values.key }})
    2. 2. Using Pipeline Operations
    3. 3. Quoting Strings
    4. Example: Quoting a value for shell usage
    5. 4. Converting to YAML
    6. 5. Converting to JSON
    7. Example: Using toYaml and toJson
    8. 6. Using Default Values
    9. 7. String Manipulation
    10. 8. Type Conversion
    11. 9. Encoding Functions
    12. 10. Date Functions
    13. 11. UUID Generation
    14. Example: Generating a UUID
    15. 12. Using fail Function
    16. Example: Failing if a condition is not met

  11. Working with Advanced Template Functions

    1. 1. Using String Functions
    2. Example: Using
    3. Example: Using
    4. 2. Using List Functions
    5. Example: Using list and splitList
    6. Example: Using compact and uniq
    7. 3. Using Dict Functions
    8. Example: Merging Dictionaries
    9. Example: Using get with Default Value
    10. 4. Using Type Functions
    11. Example: Using typeOf in a template
    12. Example: Using isArray to handle lists
    13. 5. Using Path Functions
    14. Example: Using path functions in a template
    15. 6. Using Crypto Functions
    16. Example: Generating a SHA-256 Hash
    17. 7. Using URL Functions
    18. Example: Parsing a URL
    19. Example: Building a URL
    20. 8. Using Regex Functions
    21. Example: Using regexMatch to validate version format
    22. Example: Using regexReplaceAll to sanitize version
    23. 9. Using Sprig Functions
    24. Example: Using Sprig Functions in Values
    25. Example: Date Formatting with Sprig
    26. 10. Using Math Functions
    27. Example: Using math functions in values.yaml
    28. Example: Combining math with conditionals

  12. Implementing Template Flow Control

    1. 1. Using Conditional Statements
    2. Example: Conditional ConfigMap Creation
    3. Example: Environment-Based Deployment
    4. 2. Implementing Loops
    5. Example: Looping Over Items
    6. Example: Looping with Index
    7. 3. Using with Scope
    8. Example: Accessing Release Info
    9. Example: Using Chart Metadata
    10. 4. Defining Variables
    11. Example: Setting and Using Variables in Values
    12. Example: Using Variables in Templates
    13. 5. Checking Value Existence
    14. Example: Checking for a specific key in values
    15. Example: Using multiple conditions to check existence and value
    16. 6. Using Boolean Logic
    17. Example: Conditional rendering with boolean logic
    18. Example: Combining conditions with
    19. 7. Comparing Values
    20. Example: Using
    21. Example: Using
    22. 8. Breaking Loop Iteration
    23. Example: Breaking Loop Iteration
    24. 9. Handling Empty Values
    25. Example: Using default for empty values
    26. Example: Conditional rendering with empty values
    27. 10. Using Complex Conditionals
    28. Example: Complex Conditional Logic
    29. Example: Nested Conditionals with Variables
    30. 11. Implementing Dynamic Resource Creation
    31. Example: Conditional Deployment Creation
    32. Example: Using Range to Create Multiple Resources

  13. Working with Named Templates

    1. 1. Defining Named Templates
    2. Example: Defining a Named Template
    3. 2. Including Templates
    4. Example: Including a ConfigMap Template
    5. Example: Including with Custom Values
    6. 3. Using Template Directive
    7. Example: Using template directive
    8. 4. Creating Partial Templates
    9. Example: Defining a Partial Template
    10. Example: Using a Partial Template
    11. 5. Passing Scope to Templates
    12. Example: Using .Values in a Template
    13. Example: Accessing Chart Metadata
    14. 6. Defining Common Labels
    15. Example: Defining Common Labels in a Template
    16. 7. Creating Selector Templates
    17. Example: Selector Template
    18. 8. Building Image Strings
    19. Example: Building Image String
    20. 9. Generating Resource Names
    21. Example: Using name and fullname in templates
    22. 10. Reusing Template Logic
    23. Example: Using Release Variables
    24. Example: Conditional Logic with Release Variables
    25. 11. Using Template Inheritance
    26. Example: Base Template with Block
    27. Example: Child Template Extending Base

  14. Working with Built-in Objects

    1. 1. Accessing Release Object (.Release.Name)
    2. Example: Using .Release.Name in a Template
    3. 2. Using Chart Object (.Chart.Name)
    4. Example: Accessing Chart Name in Template
    5. 3. Accessing Files Object (.Files.Get)
    6. Example: Reading a Config File
    7. 4. Using Capabilities Object (.Capabilities.KubeVersion)
    8. Example: Accessing KubeVersion in a Template
    9. 5. Working with Template Object (.Template.Name)
    10. Example: Using .Template.Name in a Template
    11. 6. Accessing Release Service (.Release.Service)
    12. Example: Using .Release.Service in a Template
    13. 7. Getting Release Namespace (.Release.Namespace)
    14. Example: Accessing Release Namespace
    15. 8. Checking Release IsUpgrade (.Release.IsUpgrade)
    16. Example: Using .Release.IsUpgrade in a Template
    17. 9. Checking Release IsInstall (.Release.IsInstall)
    18. Example: Using .Release.IsInstall in a Template
    19. 10. Using Chart Version (.Chart.Version)
    20. Example: Accessing Chart Version in Template
    21. 11. Accessing Capabilities APIVersions (.Capabilities.APIVersions)
    22. Example: Checking API Version Support

  15. Managing Chart Files

    1. 1. Reading File Content
    2. Example: Reading values.yaml
    3. Example: Reading Chart.yaml
    4. 2. Listing Files
    5. Example: List all releases
    6. Example: Show chart values
    7. 3. Reading Files as Bytes
    8. Example: Reading a Values File as Bytes
    9. 4. Using Files in ConfigMaps
    10. Example: Mounting ConfigMap Files
    11. 5. Using Files in Secrets
    12. Example: Defining a Secret with Files
    13. Example: Using Secret in Deployment
    14. 6. Iterating Over Files
    15. Example: Reading a file line by line
    16. Example: Using glob to iterate over templates
    17. 7. Checking File Existence
    18. Example: Verifying Chart Files
    19. Example: Listing Templates
    20. 8. Encoding File Content
    21. Example: Embedding Base64 Encoded File
    22. 9. Including Binary Files
    23. Example: Including Binary in Resources
    24. Example: Embedding Binary in Template
    25. 10. Organizing Static Files
    26. Example: Including Static Files in Templates

  16. Using Lookup Function

    1. 1. Reading Existing Resources
    2. Example: Reading a Secret
    3. Example: Reading a ConfigMap
    4. 2. Querying ConfigMaps
    5. Example: Retrieving ConfigMap Value
    6. Example: Using Lookup in Helm Template
    7. 3. Querying Secrets
    8. Example: Retrieving Secret Value
    9. 4. Checking Resource Existence
    10. Example: Checking if a ConfigMap Exists
    11. 5. Reading Resource Fields
    12. Example: Accessing Resource Fields
    13. 6. Using Lookup in Conditionals
    14. Example: Using Lookup in Conditionals
    15. 7. Handling Missing Resources
    16. Example: Using lookup with default value
    17. 8. Querying Across Namespaces
    18. Example: Querying a ConfigMap in a Different Namespace
    19. 9. Understanding Performance Implications
    20. Best Practices for Performance
    21. 10. Understanding Security Implications
    22. Example: Secure Usage of Lookup Function

  17. Implementing Template Whitespace Control

    1. 1. Understanding Whitespace Behavior
    2. Example: Whitespace Control in Values
    3. 2. Using Left Trim ({{-)
    4. Example: Left Trim in Multi-line Template
    5. 3. Using Right Trim (-}})
    6. Example: Using Right Trim in a List
    7. Example: Trimming Whitespace in a Multi-line Block
    8. 4. Combining Trim Markers ({{- -}})
    9. Example: Using {{- -}} to Control Whitespace
    10. 5. Controlling Indentation
    11. Example: Using Indent
    12. 6. Managing YAML Formatting
    13. Example: YAML Formatting Control
    14. 7. Using Template Comments ({{/* */}})
    15. Example: Commenting Out Configuration
    16. 8. Avoiding Extra Blank Lines
    17. Example: Controlling Whitespace in Helm Templates
    18. 9. Formatting Multi-line Strings (| and >)
    19. Example: Using
    20. Example: Using
    21. 10. Debugging Whitespace Issues
    22. Example: Identifying Extra Spaces in Rendered Template
    23. Common Whitespace Debugging Techniques

  18. Working with Chart Hooks

    1. 1. Defining Hook Annotations
    2. Example: Defining a Pre-Install Hook
    3. 2. Using pre-install Hook
    4. Example: pre-install hook in values.yaml
    5. Example: pre-install hook in chart template
    6. 3. Using post-install Hook
    7. Example: post-install Hook in a Chart
    8. 4. Using pre-upgrade Hook
    9. Example: pre-upgrade Hook Configuration
    10. 5. Using post-upgrade Hook
    11. Example: post-upgrade Hook Configuration
    12. 6. Using pre-delete Hook
    13. Example: pre-delete hook in values.yaml
    14. 7. Using post-delete Hook
    15. Example: post-delete Hook in a Chart
    16. 8. Using pre-rollback Hook
    17. Example: pre-rollback Hook Configuration
    18. 9. Using post-rollback Hook
    19. Example: post-rollback Hook Definition
    20. 10. Setting Hook Weight
    21. Example: Setting Hook Weight in Chart.yaml
    22. 11. Setting Hook Deletion Policy
    23. Example: Hook Deletion Policy Configuration
    24. 12. Using test Hook
    25. Example: Test Hook in Chart
    26. Test Hook Usage

  19. Managing Chart Dependencies

    1. 1. Declaring Dependencies
    2. Example: Declaring a dependency in Chart.yaml
    3. 2. Specifying Dependency Version
    4. Example: Specifying Chart Version in requirements.yaml
    5. 3. Setting Dependency Repository
    6. Example: Adding a Repository
    7. Example: Listing Repositories
    8. 4. Using Local Dependencies
    9. Example: Local Dependency in Chart.yaml
    10. Example: Using Local Dependency in Values
    11. 5. Enabling Conditional Dependencies
    12. Example: Using condition in Chart.yaml
    13. Example: Using tags in Chart.yaml
    14. 6. Using Tag-based Dependencies
    15. Example: Tag-based dependency in requirements.yaml
    16. 7. Downloading Dependencies
    17. Example: Downloading Dependencies
    18. Example: Updating Dependencies
    19. 8. Building Dependency Charts
    20. Example: Defining a dependency in Chart.yaml
    21. Example: Using import-values to pass values
    22. 9. Listing Dependencies
    23. Example: Listing Dependencies
    24. 10. Importing Child Values
    25. Example: Importing Values from Child Chart
    26. 11. Overriding Subchart Values
    27. Example: Overriding MySQL Subchart Values
    28. 12. Managing Chart.lock File
    29. Example: Chart.lock content

  20. Installing Charts

    1. 1. Installing Chart from Repository
    2. Example: Installing a Chart from Bitnami Repository
    3. 2. Installing from Local Path
    4. Example: Installing a local chart
    5. Example: Installing with custom values
    6. 3. Installing from URL
    7. Example: Installing a Chart from URL
    8. Example: Installing with Custom Values
    9. 4. Installing from Archive
    10. Example: Installing a Chart Archive
    11. Example: Installing with Custom Values
    12. 5. Generating Release Name
    13. Example: Using --generate-name
    14. Example: Using --name-template
    15. 6. Setting Custom Release Name
    16. Example: Setting a Custom Release Name
    17. 7. Installing in Specific Namespace
    18. Example: Install Chart in Specific Namespace
    19. 8. Creating Namespace
    20. Example: Create a Namespace
    21. Workflow: Creating and Using a Namespace
    22. 9. Using Dry Run Mode
    23. Example: Dry run with debug output
    24. 10. Waiting for Resources
    25. Example: Waiting for Deployment
    26. 11. Setting Wait Timeout
    27. Example: Setting Wait Timeout
    28. 12. Installing with Values
    29. Example: Setting Values via Command Line
    30. Example: Using a Values File

  21. Upgrading Releases

    1. 1. Upgrading Release
    2. Example: Upgrading a Release with New Values
    3. Example: Upgrading with Values File
    4. 2. Installing or Upgrading
    5. Example: Installing a Release
    6. Example: Upgrading a Release
    7. 3. Forcing Resource Update
    8. Example: Forcing Resource Update
    9. 4. Resetting Values
    10. Example: Resetting Values During Upgrade
    11. 5. Reusing Previous Values
    12. Example: Reusing Previous Values
    13. 6. Upgrading with New Values
    14. Example: Upgrading with new values
    15. 7. Using Atomic Upgrades
    16. Example: Performing an Atomic Upgrade
    17. 8. Cleaning Up on Failed Upgrade
    18. Example: Upgrade with cleanup on failure
    19. 9. Setting Revision Limits
    20. Example: Setting Revision Limit During Upgrade
    21. 10. Waiting for Upgrade Completion
    22. Example: Waiting for Upgrade Completion

  22. Rolling Back Releases

    1. 1. Rolling Back Release
    2. Example: Rollback to previous revision
    3. Example: Rollback to specific revision
    4. 2. Rolling Back to Revision
    5. Example: Rolling Back to Revision 2
    6. 3. Viewing Release History
    7. Example: Viewing release history
    8. Example: Viewing release history with max entries
    9. 4. Understanding Rollback Behavior
    10. Example: Rollback to a Specific Revision
    11. 5. Using Atomic Rollback
    12. Example: Performing an atomic rollback
    13. 6. Forcing Rollback
    14. Example: Forcing a Rollback
    15. 7. Setting Rollback Timeout
    16. Example: Setting rollback timeout
    17. 8. Waiting for Rollback Completion
    18. Example: Waiting for Rollback Completion
    19. 9. Cleaning Up on Failed Rollback
    20. Example: Cleaning up failed rollback resources
    21. 10. Troubleshooting Failed Rollbacks
    22. Example: Debugging rollback issues
    23. Common Rollback Troubleshooting Steps

  23. Managing Releases

    1. 1. Listing Active Releases
    2. Example: Listing Helm Releases
    3. 2. Listing All Releases
    4. Example: Listing All Releases
    5. Example: Listing Releases in a Specific Namespace
    6. Example: Listing Releases in Quiet Mode
    7. 3. Filtering by Namespace
    8. Example: List releases in a specific namespace
    9. Example: List all releases across namespaces
    10. 4. Listing Across Namespaces
    11. Example: Listing Releases Across Namespaces
    12. 5. Getting Release Status
    13. 6. Getting Release Values
    14. Example: Fetching Release Values
    15. Example: Fetching Release Values in YAML
    16. Example: Fetching All Release Values Including Defaults
    17. 7. Getting Release Manifest
    18. Example: Retrieve Manifest
    19. Example: Retrieve Manifest in Specific Namespace
    20. 8. Getting Release Notes
    21. Example: Fetching Release Notes
    22. 9. Getting Release Hooks
    23. Example: Defining a pre-install Hook
    24. 10. Filtering Release Output
    25. Example: Using --output to get JSON
    26. Example: Using --filter to show only failed releases

  24. Uninstalling Releases

    1. 1. Uninstalling Release
    2. Example: Uninstall a release
    3. Example: Uninstall with timeout and wait
    4. 2. Keeping Release History
    5. Example: Uninstall with History Preservation
    6. 3. Waiting for Deletion
    7. Example: Waiting for Deletion with Timeout
    8. Example: Waiting for Jobs Before Deletion
    9. 4. Setting Deletion Timeout
    10. Example: Uninstall with Timeout
    11. 5. Performing Dry Run Uninstall
    12. Example: Dry Run Uninstall Command
    13. 6. Uninstalling with Cascade
    14. Example: Uninstalling with Cascade
    15. 7. Viewing Uninstall Output
    16. Example: Uninstalling a Release and Viewing Output
    17. 8. Uninstalling Multiple Releases
    18. Example: Uninstalling Specific Releases
    19. Example: Uninstall All Releases in Namespace
    20. 9. Handling Failed Uninstalls
    21. Example: Retry failed uninstall with timeout
    22. Example: Manual cleanup of stuck resources
    23. 10. Cleaning Up Orphaned Resources
    24. Example: Identify Orphaned Resources

  25. Linting and Validating Charts

    1. 1. Linting Chart Templates
    2. Example: Linting a Deployment Template
    3. 2. Checking Chart Structure
    4. Example: Validating Chart Structure
    5. 3. Validating Chart.yaml
    6. Example: Valid Chart.yaml
    7. 4. Validating Template Syntax
    8. Example: Validating Template Syntax
    9. 5. Using Strict Linting
    10. Example: Enabling strict linting in Helm
    11. 6. Checking Values Schema
    12. Example: values.schema in Chart.yaml
    13. Example: values.schema.json
    14. 7. Validating Kubernetes Resources
    15. Example: Validating Deployment Image
    16. 8. Generating Dry-Run Output
    17. Example: Helm Template Command
    18. 9. Using Template Command
    19. Example: Template Chart
    20. 10. Debugging Template Rendering
    21. Example: Using
    22. Debugging Workflow
    23. 11. Validating Dependencies
    24. Example: Validating Dependencies in Chart.yaml

  26. Testing Charts

    1. 1. Running Chart Tests
    2. Example: Running Chart Tests
    3. 2. Creating Test Pods
    4. Example: Basic Test Pod Configuration
    5. 3. Using Test Annotations
    6. Example: Defining a Test Case with Annotations
    7. 4. Running Specific Tests
    8. Example: Running a specific test suite
    9. 5. Viewing Test Logs
    10. Example: Running Helm Tests with Logs
    11. Test Log Output Structure
    12. 6. Setting Test Timeout
    13. Example: Setting Test Timeout in Chart Values
    14. 7. Filtering Test Results
    15. Example: Filtering by Status
    16. 8. Cleaning Test Pods
    17. Example: Run tests with cleanup
    18. 9. Testing with Different Values
    19. Example: Testing with Different Replica Count
    20. Example: Testing with Different Image Tag
    21. 10. Automating Chart Tests
    22. Example: Running Unit Tests
    23. Example: Running Integration Tests
    24. Best Practices for Chart Testing

  27. Debugging and Troubleshooting

    1. 1. Using Debug Mode
    2. Example: Enable debug mode during installation
    3. Example: Dry run to preview changes
    4. 2. Generating Templates Locally
    5. Example: Rendering a Chart Template
    6. Example: Linting a Chart
    7. 3. Performing Dry Run
    8. Example: Helm Dry Run
    9. 4. Viewing Rendered Manifests
    10. Example: Using
    11. Example: Rendering with debug output
    12. Example: Rendering with custom values file
    13. 5. Checking Release Status
    14. Example: Checking Release Status
    15. Example: Checking Release Status with Resources
    16. 6. Viewing Release History
    17. Example: View release history
    18. Example: View release history with max entries
    19. 7. Inspecting Hook Execution
    20. Example: Hook Configuration in values.yaml
    21. Example: Inspecting Hook Logs
    22. 8. Checking Resource Events
    23. Example: Fetching Events for a Specific Pod
    24. 9. Validating Current Values
    25. Example: Check current values
    26. 10. Using Verbose Output
    27. Example: Debugging a failed Helm install
    28. 11. Troubleshooting Failed Upgrades
    29. Example: Upgrade with timeout and force
    30. Common Upgrade Failure Patterns
    31. 12. Debugging Template Rendering
    32. Example: Rendering a Chart with Debug Info
    33. Example: Inspecting Values Used in Template

  28. Packaging Charts

    1. 1. Creating Chart Package
    2. Example: Creating a basic Chart.yaml
    3. 2. Setting Package Destination
    4. Example: Packaging to a specific directory
    5. 3. Signing Chart Package
    6. Example: Signing a Chart Package
    7. 4. Using Package Key
    8. Example: Signing a Helm Chart Package
    9. 5. Setting Package Version
    10. Example: Setting version in Chart.yaml
    11. 6. Setting App Version
    12. Example: Setting appVersion in Chart.yaml
    13. 7. Updating Dependencies Before Packaging
    14. Example: Updating dependencies using Helm dependency plugin
    15. Summary of Dependency Management
    16. 8. Creating Package from Path
    17. Example: Creating a Helm Package
    18. 9. Verifying Package Contents
    19. Example: Check chart contents
    20. Example: Validate chart structure
    21. 10. Generating Package Checksum
    22. Example: Generating Checksum

  29. Publishing Charts to Repository

    1. 1. Generating Repository Index
    2. Example: Generate index.yaml for local repository
    3. 2. Updating Index with New Chart
    4. Example: Update index with new chart
    5. 3. Setting Base URL
    6. Example: Setting base URL in chart metadata
    7. 4. Hosting Static Repository
    8. Example: Add Static Repository
    9. Example: Install Chart from Static Repo
    10. 5. Using GitHub Pages
    11. Example: Publishing a Chart to GitHub Pages
    12. 6. Publishing to ChartMuseum
    13. Example: Publishing Chart to ChartMuseum
    14. 7. Publishing to Harbor
    15. Example: Pushing Chart to Harbor
    16. 8. Publishing to Artifactory
    17. Example: Publishing Chart to Artifactory
    18. 9. Automating Repository Updates
    19. Example: Using GitHub Actions for Chart Publishing
    20. Best Practices
    21. 10. Managing Repository Versions
    22. Example: Chart Versioning
    23. Version Management Best Practices

  30. Working with OCI Registries

    1. 1. Understanding OCI Registry Support
    2. Example: Pushing a Chart to OCI Registry
    3. 2. Logging into Registry
    4. Example: Logging into an OCI registry
    5. 3. Logging out of Registry
    6. Example: Logging out of a registry
    7. 4. Pushing Chart to OCI
    8. Example: Pushing a Chart to OCI Registry
    9. 5. Pulling Chart from OCI
    10. Example: Pulling a Chart from OCI Registry
    11. 6. Installing from OCI
    12. Example: Installing a Chart from OCI Registry
    13. 7. Using OCI References
    14. Example: Pulling Chart via OCI Reference
    15. Example: Installing Chart via OCI Reference
    16. 8. Listing OCI Chart Tags
    17. Example: Listing OCI Chart Tags
    18. 9. Setting OCI Credentials
    19. Example: Using Helm Registry Login with Token
    20. 10. Using Docker Config
    21. Example: Configure Docker Registry Access
    22. 11. Working with Private OCI Registries
    23. Example: Login to Private OCI Registry
    24. Example: Push Chart to Private Registry

  31. Working with Subcharts

    1. 1. Adding Subcharts to Chart
    2. Example: Adding a subchart to Chart.yaml
    3. 2. Declaring Subchart Dependencies
    4. Example: Declaring a subchart dependency
    5. 3. Overriding Subchart Values
    6. Example: Overriding subchart values in
    7. 4. Using Global Values
    8. Example: Setting global values in a values.yaml file
    9. Example: Accessing global values in a template
    10. 5. Importing Subchart Values
    11. Example: Importing Values from Parent Chart
    12. 6. Conditionally Enabling Subcharts
    13. Example: Enabling subchart based on condition
    14. Example: Using values to control subchart enabling
    15. 7. Using Subchart Tags
    16. Example: Setting Chart Tags in values.yaml
    17. 8. Accessing Parent Values
    18. Example: Accessing Parent Values in Subchart Template
    19. 9. Sharing Templates Across Charts
    20. Example: Using _helpers.tpl
    21. Example: Including a shared template
    22. 10. Managing Subchart Versions
    23. Example: Defining subchart dependencies

  32. Creating Library Charts

    1. 1. Defining Library Chart Type
    2. 2. Creating Reusable Templates
    3. Example: Defining a Helper Template
    4. Example: Using a Helper Template
    5. Key Points
    6. 3. Sharing Common Helpers
    7. Example: Defining a Common Label Helper
    8. Example: Using a Shared ConfigMap Template
    9. 4. Using Library as Dependency
    10. Example: Adding Library Dependency
    11. Workflow: Using Library Chart as Dependency
    12. 5. Including Library Templates
    13. Example: Including a Library Template
    14. Example: Defining a Library Template
    15. 6. Versioning Library Charts
    16. Example: Chart.yaml versioning
    17. 7. Documenting Library Usage
    18. Example: Chart Metadata
    19. 8. Organizing Library Templates
    20. Example: Using _helpers.tpl for Reusable Functions
    21. Template Organization Guidelines
    22. 9. Testing Library Templates
    23. Example: Unit testing with Helm Test
    24. Testing Best Practices
    25. 10. Publishing Library Charts
    26. Example: Publishing a Library Chart

  33. Working with Custom Resource Definitions

    1. 1. Understanding CRD Handling
    2. Example: Basic CRD Definition
    3. CRD Handling in Helm Charts
    4. 2. Installing CRDs with Charts
    5. Example: CRD Installation in Chart
    6. 3. Creating CRD Templates
    7. Example: Basic CRD Template
    8. 4. Managing CRD Versions
    9. Example: CRD v1 Schema Definition
    10. 5. Handling CRD Upgrades
    11. Example: Upgrading CRD with New Field
    12. CRD Upgrade Workflow
    13. CRD Upgrade Approaches
    14. 6. Avoiding CRD Deletion on Uninstall
    15. Example: Preventing CRD Deletion
    16. 7. Validating CRD Schemas
    17. Example: Basic CRD Schema Validation
    18. 8. Using CRDs with Operators
    19. Example: Operator Deployment
    20. Example: CRD Definition
    21. Key Concepts
    22. 9. Testing CRD Installation
    23. Example: Verify CRD Installation
    24. Example: Validate CRD with Sample Resource
    25. Testing Workflow
    26. 10. Troubleshooting CRD Issues
    27. Example: Invalid CRD Schema
    28. Common CRD Troubleshooting Steps
    29. CRD Handling in Helm Charts
    30. 2. Installing CRDs with Charts
    31. Example: CRD Installation in Chart
    32. 3. Creating CRD Templates
    33. Example: Basic CRD Template
    34. 4. Managing CRD Versions
    35. Example: CRD v1 Schema Definition
    36. 5. Handling CRD Upgrades
    37. Example: Upgrading CRD with New Field
    38. CRD Upgrade Workflow
    39. CRD Upgrade Approaches
    40. 6. Avoiding CRD Deletion on Uninstall
    41. Example: Preventing CRD Deletion
    42. 7. Validating CRD Schemas
    43. Example: Basic CRD Schema Validation
    44. 8. Using CRDs with Operators
    45. Example: Operator Deployment
    46. Example: CRD Definition
    47. Key Concepts
    48. 9. Testing CRD Installation
    49. Example: Verify CRD Installation
    50. Example: Validate CRD with Sample Resource
    51. Testing Workflow
    52. 10. Troubleshooting CRD Issues
    53. Example: Invalid CRD Schema
    54. Common CRD Troubleshooting Steps

  34. Implementing Chart Security

    1. 1. Signing Chart Packages
    2. Example: Signing Chart Package
    3. 2. Verifying Chart Signatures
    4. Example: Verifying Chart Signature
    5. 3. Using GPG Keys
    6. Example: Creating GPG Key
    7. 4. Creating Provenance File
    8. Example: Creating Provenance File
    9. 5. Validating Chart Integrity
    10. Example: Validating Chart Integrity
    11. 6. Implementing RBAC in Charts
    12. Example: RBAC in Chart
    13. 7. Setting Security Context
    14. Example: Setting Security Context
    15. 8. Using Network Policies
    16. Example: Network Policy in Chart
    17. 9. Scanning Charts for Vulnerabilities
    18. Example: Scanning Chart for Vulnerabilities
    19. 10. Following Security Best Practices
    20. Summary of Best Practices
    21. 11. Validating Image Sources
    22. Example: Validating Image Source

  35. Working with Secrets and Sensitive Data

    1. 1. Creating Secret Templates
    2. Example: Basic Secret Template
    3. 2. Encoding Secret Values
    4. Example: Using StringData
    5. 3. Using External Secrets
    6. Example: External Secret Definition
    7. 4. Integrating with HashiCorp Vault
    8. Example: Vault Secret Store
    9. 5. Using SOPS for Encryption
    10. Example: SOPS Encrypted Secret
    11. 6. Managing TLS Certificates
    12. Example: TLS Secret
    13. 7. Using Sealed Secrets
    14. Example: Sealed Secret
    15. 8. Passing Secrets via Values
    16. Example: Chart Values with Secrets
    17. 9. Using Secret Files
    18. Example: Secret File Mount
    19. 10. Avoiding Hardcoded Secrets

  36. Managing Chart Versions

    1. 1. Using Semantic Versioning
    2. Example: Chart Version in
    3. 2. Incrementing Chart Version
    4. Example: Updating Chart Version
    5. 3. Setting Application Version
    6. Example: Setting appVersion in Chart.yaml
    7. 4. Creating Version Constraints
    8. Example: Using Version Constraints in Chart Dependencies
    9. 5. Using Version Ranges
    10. Example: Specifying Version Ranges in Chart Dependencies
    11. 6. Pinning Exact Versions
    12. Example: Pinning Chart Version in requirements.yaml
    13. Example: Pinning Chart Version in values.yaml
    14. 7. Using Tilde Range
    15. Example: Tilde Range in Chart Dependencies
    16. 8. Using Caret Range
    17. Example: Using Caret Range in Chart Dependencies
    18. 9. Maintaining Changelog
    19. Example: Changelog Entry Format
    20. 10. Tagging Chart Releases
    21. Example: Tagging Chart Release

  37. Migrating and Upgrading Charts

    1. 1. Upgrading Chart API Version
    2. Example: Migrating from v1 to v2
    3. 2. Migrating from requirements.yaml
    4. Example: Migrating dependencies
    5. 3. Updating Deprecated Kubernetes APIs
    6. Example: Updating Ingress API Version
    7. 4. Handling Breaking Changes
    8. Example: Updating API Version in Deployment Template
    9. Example: Updating Values Schema
    10. Best Practices for Breaking Change Handling
    11. Workflow for Handling Breaking Changes
    12. 5. Testing Migration Changes
    13. Example: Running Tests Locally
    14. 6. Rolling Back Failed Migrations
    15. Example: Rolling Back to Previous Revision
    16. Example: Rolling Back to Specific Revision
    17. 7. Updating Chart Dependencies
    18. Example: Updating dependencies in Chart.yaml
    19. 8. Migrating to OCI Registries
    20. Example: Pushing Chart to OCI Registry
    21. Example: Installing Chart from OCI Registry
    22. Migration Steps
    23. 9. Converting to Library Charts
    24. Example: Library Chart Configuration
    25. Library Chart vs Application Chart
    26. 10. Documenting Migration Steps
    27. Example: Migration Documentation Template

  38. Managing Chart Metadata

    1. 1. Setting Chart Annotations
    2. Example: Setting Annotations in Chart.yaml
    3. 2. Adding Custom Metadata
    4. Example: Custom Metadata in Chart.yaml
    5. 3. Documenting Chart Purpose
    6. Example: Chart Metadata
    7. 4. Listing Chart Dependencies
    8. Example: Listing Chart Dependencies
    9. Summary of Helm Dependency Commands
    10. 5. Setting Minimum Kubernetes Version
    11. Example: kubeVersion in Chart.yaml
    12. 6. Adding Chart Maturity
    13. Example: Setting maturity in Chart.yaml
    14. 7. Linking to Source Code
    15. Example: Defining Source URLs
    16. 8. Providing Support Contacts
    17. Example: Maintainer Contact in Chart Metadata
    18. 9. Setting Chart License
    19. Example: Setting License in Chart.yaml
    20. 10. Adding Chart Category
    21. Example: Setting Chart Categories

  39. Implementing Advanced Templating

    1. 1. Creating Recursive Templates
    2. Example: Recursive Template for Tree Structure
    3. 2. Building Dynamic Names
    4. Example: Using nameOverride
    5. Example: Using fullnameOverride
    6. 3. Implementing Feature Flags
    7. Example: Using Feature Flags in Values
    8. Example: Conditional Template Rendering
    9. 4. Creating Environment-Aware Templates
    10. Example: Environment-specific ConfigMap
    11. Example: Conditional Deployment
    12. 5. Using Template Variables
    13. Example: Accessing Release Name
    14. Example: Using Chart Metadata
    15. 6. Implementing Complex Data Structures
    16. Example: Using Maps and Lists in Templates
    17. Example: Nested Maps in Values
    18. Example: List of Services with Variables
    19. 7. Building Resource Templates Dynamically
    20. Example: Using
    21. Example: Using
    22. 8. Using Template Includes Efficiently
    23. Example: Including a Common Header
    24. Example: Using tpl for Dynamic Content
    25. 9. Handling Edge Cases
    26. Example: Default Values for Missing Values
    27. Example: Conditional Logic for Missing Values
    28. Comparison: Default vs Coalesce
    29. 10. Creating Maintainable Templates
    30. Example: Reusable Template for ConfigMap
    31. Example: Conditional Deployment

  40. Using Post-Renderers

    1. 1. Understanding Post-Renderers
    2. Example: Simple Post-Renderer Script
    3. 2. Configuring Post-Renderer Command
    4. Example: Post-renderer script
    5. 3. Using Kustomize as Post-Renderer
    6. Example: Using Kustomize with Helm
    7. Key Points
    8. 4. Applying Custom Patches
    9. Example: Applying a Custom Patch with Post-Renderer
    10. Example: Post-Renderer Script (my-post-renderer.sh)
    11. Key Points
    12. 5. Adding Labels and Annotations
    13. Example: Adding Labels and Annotations via Post-Renderer
    14. 6. Modifying Generated Resources
    15. Example: Using a Post-Renderer Script
    16. Example: Modifying Labels with a Script
    17. 7. Chaining Multiple Post-Renderers
    18. Example: Chaining Post-Renderers
    19. 8. Debugging Post-Renderer Output
    20. Example: Debugging with verbose logging
    21. Debugging Tips
    22. 9. Handling Post-Renderer Errors
    23. Example: Error in Post-Renderer Script
    24. 10. Integrating Post-Renderers in CI/CD
    25. Example: Using Helm Post-Renderer in GitHub Actions
    26. Best Practices for CI/CD Integration

  41. Working with Helm Plugins

    1. 1. Installing Helm Plugins
    2. Example: Install a Helm Plugin from Git
    3. Example: Install a Specific Version of a Plugin
    4. 2. Listing Installed Plugins
    5. Example: Listing Helm Plugins
    6. 3. Updating Plugins
    7. Example: Update all plugins
    8. Example: Update a specific plugin
    9. 4. Removing Plugins
    10. Example: Removing a Plugin
    11. 5. Using helm-diff Plugin
    12. Example: Using helm-diff to preview an upgrade
    13. Example: Decrypting a secret value
    14. Key Features of helm-secrets
    15. 7. Using helm-git Plugin
    16. Example: Installing helm-git Plugin
    17. Example: Using helm-git to fetch chart from Git
    18. 8. Using helm-s3 Plugin
    19. Example: Pushing a chart to S3
    20. Example: Adding an S3 repository
    21. 9. Creating Custom Plugins
    22. Example: Basic plugin structure
    23. Example: plugin.yaml content
    24. Example: plugin.sh content
    25. 10. Configuring Plugin Environment
    26. Example: Setting Plugin Environment Variables

  42. Managing Namespaces and Multi-Tenancy

    1. 1. Creating Namespace in Chart
    2. Example: Creating a Namespace with Annotations and Labels
    3. 2. Using Release Namespace
    4. Example: Setting Release Namespace
    5. 3. Installing Charts Across Namespaces
    6. Example: Installing a Chart in a Specific Namespace
    7. Example: Installing with Atomic Rollback
    8. 4. Implementing Namespace Isolation
    9. Example: Deploying to a Specific Namespace
    10. Example: Using Values to Set Namespace
    11. 5. Using Namespace-scoped Resources
    12. Example: Namespace-scoped Resource in Helm Chart
    13. 6. Managing Cluster-scoped Resources
    14. Example: Defining a ClusterRole for Multi-Tenant Access
    15. Example: Binding ClusterRole to a User
    16. 7. Implementing Resource Quotas
    17. Example: Setting Resource Quotas in a Namespace
    18. 8. Using LimitRange for Namespaces
    19. Example: Define LimitRange in a Helm Chart
    20. 9. Handling Cross-Namespace References
    21. Example: Using Cross-Namespace Service in Deployment
    22. 10. Implementing Multi-Tenant Charts
    23. Example: Multi-Tenant Chart Values
    24. Key Considerations

  43. Working with Helm Starters

    1. 1. Understanding Helm Starters
    2. Example: Using a Helm Starter
    3. 2. Creating Starter Charts
    4. Example: Creating a basic starter chart structure
    5. Example: Creating a minimal Chart.yaml for starter
    6. 3. Using Starter Templates
    7. Example: Creating a Starter Template
    8. 4. Organizing Starters Directory
    9. Example: Directory Structure
    10. 5. Customizing Starter Templates
    11. Example: Creating a Custom Starter Template
    12. 6. Sharing Starter Charts
    13. Example: Creating a Shared Starter Chart Repository
    14. Example: Using a Shared Starter Chart
    15. Best Practices for Sharing
    16. 7. Implementing Organization Standards
    17. Example: Helm Starter Template Structure
    18. Comparison: Helm Starters vs Chart Repositories
    19. Workflow: Creating a Helm Starter
    20. 8. Using Starter Variables
    21. Example: Using Variables in Templates
    22. 9. Testing Starter Charts
    23. Example: Basic Test Structure
    24. Testing Best Practices
    25. 10. Maintaining Starter Charts
    26. Example: Creating a starter chart
    27. Workflow: Publishing a starter chart

  44. Deploying to Air-Gapped Environments

    1. 1. Downloading Charts for Offline Use
    2. Example: Pulling a Chart Locally
    3. Example: Adding a Private Repository
    4. 2. Bundling Chart Dependencies
    5. Example: Chart.yaml with Dependencies
    6. Example: values.yaml with Conditional Dependency
    7. 3. Mirroring Container Images
    8. Example: Using Skopeo to Mirror Images
    9. 4. Setting Up Private Registry
    10. Example: Harbor Configuration
    11. 5. Configuring Air-Gapped Repository
    12. Example: Setting up local Helm repository
    13. 6. Updating Image References
    14. Example: Updating Image References in Values
    15. Example: Using Image Digests
    16. 7. Packaging All Dependencies
    17. Example: Packaging Chart Dependencies
    18. 8. Validating Offline Installation
    19. Example: Check Chart Integrity
    20. Validation Checklist
    21. 9. Managing Updates in Air-Gapped
    22. Example: Pulling and Packaging a Chart
    23. 10. Documenting Air-Gapped Procedures
    24. Example: Helm Chart Documentation Template

  45. Implementing Multi-Cluster Deployments

    1. 1. Understanding Multi-Cluster Patterns
    2. Example: Active-Active Deployment
    3. Key Considerations
    4. 2. Managing Kubeconfig Contexts
    5. Example: Switching Contexts
    6. Example: Using Multiple Contexts
    7. 3. Using Environment-Specific Values
    8. Example: Environment-specific values file
    9. Example: Applying environment-specific values
    10. Best Practices for Environment-Specific Values
    11. 4. Implementing GitOps Workflow
    12. Example: GitOps with Argo CD and Helm
    13. GitOps Workflow Summary
    14. 5. Synchronizing Releases Across Clusters
    15. Example: Synchronizing Release Across Clusters
    16. Key Considerations
    17. 6. Handling Cluster-Specific Configuration
    18. Example: Using Values Files for Different Environments
    19. Comparison: Values Files vs ConfigMaps
    20. 7. Managing Cross-Cluster Dependencies
    21. Example: Using ConfigMap Across Clusters
    22. Example: Referencing Secret in Chart
    23. Best Practices for Cross-Cluster Dependencies
    24. 8. Implementing Blue-Green Deployments
    25. Example: Blue-Green Deployment with Helm
    26. Workflow: Blue-Green Deployment Steps
    27. Comparison: Blue-Green vs Rolling Updates
    28. 9. Managing Canary Releases
    29. Example: Canary Release Configuration
    30. 10. Monitoring Multi-Cluster Deployments
    31. Example: Prometheus Configuration for Multi-Cluster
    32. Key Monitoring Concepts
    33. Monitoring Approaches

  46. Automating with Helm in CI/CD

    1. 1. Installing Helm in Pipeline
    2. Example: Installing Helm in a GitHub Actions Workflow
    3. 2. Authenticating to Kubernetes
    4. Example: Using Service Account in CI/CD
    5. 3. Running Helm Lint
    6. Example: Linting a Helm Chart
    7. 4. Performing Dry Run
    8. Example: Dry run a Helm release
    9. 5. Deploying Charts
    10. Example: Deploying a Chart with Values
    11. Example: Upgrading a Release with Set Values
    12. 6. Running Chart Tests
    13. Example: Running Helm Chart Tests
    14. Example: Running Helm Chart Tests with Timeout
    15. 7. Rolling Back on Failure
    16. Example: Rollback to previous revision
    17. Example: Rollback to specific revision
    18. 8. Publishing Charts
    19. Example: Publishing a Chart to Artifact Hub
    20. 9. Versioning with CI Variables
    21. Example: Using CI Variables in Helm Values
    22. 10. Using GitOps Workflows
    23. Example: GitOps with ArgoCD and Helm
    24. GitOps Workflow Benefits
    25. GitOps vs Traditional CI/CD
    26. 11. Implementing Blue-Green Deployments
    27. Example: Blue-Green Deployment with Helm
    28. Deployment Workflow
    29. Benefits of Blue-Green Deployment

  47. Optimizing Chart Performance

    1. 1. Minimizing Template Complexity
    2. Example: Reducing Template Complexity
    3. Key Tips for Minimizing Template Complexity
    4. 2. Caching Template Results
    5. Example: Enabling Template Caching
    6. 3. Reducing Value Lookups
    7. Example: Flattening nested values
    8. 4. Optimizing Loop Iterations
    9. Example: Looping over a list of services
    10. Example: Using until for retry logic
    11. 5. Using Conditional Rendering
    12. Example: Conditional Deployment
    13. Example: Conditional Service
    14. 6. Minimizing File Reads
    15. Example: Using configMap to reduce file reads
    16. 7. Reducing Chart Size
    17. Example: Using .helmignore to exclude files
    18. 8. Optimizing Dependencies
    19. Example: Dependency Configuration
    20. Best Practices for Dependency Optimization
    21. 9. Using Lazy Evaluation
    22. Example: Lazy Value Computation
    23. 10. Profiling Chart Rendering
    24. Example: Render chart with debug output
    25. Performance Tips

  48. Customizing Helm Behavior

    1. 1. Configuring Helm Environment
    2. Example: Setting Helm Home
    3. 2. Setting Default Namespace
    4. Example: Setting Default Namespace
    5. 3. Configuring Kubeconfig Path
    6. Example: Using Custom Kubeconfig
    7. 4. Setting Repository Cache
    8. Example: Clearing Repository Cache
    9. 5. Configuring Plugins Path
    10. Example: Installing Plugin
    11. 6. Setting Registry Config
    12. Example: Using Registry Config
    13. 7. Enabling Experimental Features
    14. Example: Enabling Experimental Feature
    15. 8. Configuring Max History
    16. Example: Setting Max History
    17. 9. Setting Debug Output
    18. Example: Using Debug Mode
    19. 10. Using Custom Configuration
    20. Example: Custom Configuration File

  49. Implementing Chart Best Practices

    1. 1. Following Naming Conventions
    2. Example: Chart Metadata
    3. 2. Using Fullname Templates
    4. Example: Defining fullname template
    5. 3. Implementing Proper Labels
    6. Example: Setting Labels in Deployment
    7. 4. Using Annotations Appropriately
    8. Example: Setting Annotations in Chart Metadata
    9. 5. Making Charts Configurable
    10. Example: Configuring a Chart with Values
    11. Best Practices for Chart Configuration
    12. 6. Providing Sensible Defaults
    13. Example: Default Values in a Values File
    14. 7. Documenting Chart Usage
    15. Example: README.md structure
    16. Example: Values documentation
    17. 8. Creating Comprehensive NOTES.txt
    18. Example: notes.txt content
    19. Best Practices for NOTES.txt
    20. 9. Implementing Resource Limits
    21. Example: Setting Resource Limits in a Chart
    22. 10. Using Health Checks
    23. Example: Health Check Configuration in Values.yaml
    24. 11. Following Helm Chart Conventions
    25. Example: Chart.yaml structure
    26. Example: Values.yaml structure

  50. Implementing Chart Deprecation Strategies

    1. 1. Marking Charts as Deprecated
    2. Example: Setting Chart as Deprecated
    3. 2. Documenting Deprecation Reasons
    4. Example: Deprecation Notice in Chart Metadata
    5. 3. Providing Migration Paths
    6. Example: Chart Version Migration
    7. Migration Strategy Summary
    8. 4. Setting Deprecation Timeline
    9. Example: Chart.yaml deprecation fields
    10. 5. Communicating to Users
    11. Example: Deprecation Notice in Chart README
    12. Best Practices for User Communication
    13. 6. Maintaining Deprecated Charts
    14. Example: Chart Metadata with Deprecation Notice
    15. 7. Removing Deprecated Charts
    16. Example: Removing a deprecated chart release
    17. Workflow: Removing Deprecated Charts
    18. Summary of Chart Removal Considerations
    19. 8. Archiving Old Chart Versions
    20. Example: Archiving a Chart Version
    21. 9. Redirecting to Replacements
    22. Example: Redirecting to a Replacement Chart
    23. 10. Handling Breaking Changes
    24. Example: Migrating from