Skip to main content
Mapagam

50 SECTIONS · 743 TOPICS

Helm Charts Roadmap

  1. Understanding Helm Fundamentals

    1. 1. Understanding Helm Architecture
    2. Helm 3 Client-Only Flow
    3. 2. Understanding Chart Concept
    4. 3. Understanding Release Concept
    5. 4. Understanding Repository Concept
    6. 5. Understanding Values Hierarchy
    7. 6. Understanding Template Rendering
    8. Render Pipeline
    9. 7. Understanding Chart Lifecycle
    10. Lifecycle States
    11. 8. Understanding Helm Three-Way Merge
    12. 9. Understanding Chart API Versions
    13. 10. Comparing Helm vs Kustomize
    14. Helm
    15. Kustomize

  2. Installing and Configuring Helm

    1. 1. Installing Helm CLI
    2. 2. Verifying Helm Installation
    3. 3. Configuring Repository Settings
    4. 4. Setting Up Kubeconfig Context
    5. Example: Target a specific cluster + namespace
    6. 5. Configuring Helm Environment Variables
    7. 6. Setting Default Namespace
    8. Example: Per-shell default
    9. 7. Configuring Helm Cache Directory
    10. 8. Setting Up Helm Plugins Directory
    11. 9. Configuring Helm Data Directory
    12. 10. Configuring Helm Config Directory

  3. Working with Chart Repositories

    1. 1. Adding Chart Repository
    2. Example: Add popular repos
    3. 2. Listing Repositories
    4. 3. Updating Repository Index
    5. 4. Removing Repository
    6. Example: Remove + verify
    7. 5. Searching Repository Charts
    8. Example: Find a chart
    9. 6. Viewing Repository Index
    10. 7. Using Private Repositories
    11. Example: HTTPS basic auth
    12. 8. Configuring Repository Credentials
    13. 9. Setting Repository Cache
    14. 10. Managing Multiple Repositories
    15. Example: Scripted CI bootstrap

  4. Searching Helm Charts

    1. 1. Searching Repositories
    2. 2. Searching Artifact Hub
    3. Example: Discover charts across all public repos
    4. 3. Using Search Keywords
    5. 4. Filtering by Version
    6. Example: Constraint queries
    7. 5. Using Regular Expressions
    8. 6. Limiting Search Results
    9. 7. Viewing All Versions
    10. Example: Inspect history of a chart
    11. 8. Searching with Output Format
    12. 9. Finding Latest Version
    13. Example: Script latest stable version
    14. 10. Searching Specific Repository

  5. Creating Chart Structure

    1. 1. Generating New Chart
    2. Example: Scaffold a chart
    3. 2. Understanding Chart Directory Layout
    4. 3. Creating Chart.yaml Metadata
    5. Example: Minimal Chart.yaml
    6. 4. Defining Chart Type
    7. 5. Creating values.yaml File
    8. Example: Idiomatic structure
    9. 6. Creating .helmignore File
    10. 7. Organizing Template Files
    11. 8. Creating NOTES.txt File
    12. Example: NOTES.txt with conditional URL
    13. 9. Setting Up charts/ Subdirectory
    14. 10. Creating crds/ Directory
    15. 11. Creating templates/_helpers.tpl
    16. Example: Standard helpers from

  6. Working with Chart.yaml

    1. 1. Defining Chart Name and Version
    2. 2. Setting Application Version
    3. Example: Quote appVersion
    4. 3. Declaring API Version
    5. 4. Specifying Chart Type
    6. 5. Adding Chart Description
    7. Example: Description field
    8. 6. Adding Keywords and Sources
    9. Example: Discoverability metadata
    10. 7. Listing Chart Maintainers
    11. Example: maintainers block
    12. 8. Setting Home URL
    13. 9. Adding Icon URL
    14. 10. Marking Chart Deprecated
    15. Example: Deprecate with migration note
    16. 11. Setting Kubernetes Version Constraint

  7. Working with Values Files

    1. 1. Creating values.yaml Default Values
    2. Example: Layered defaults
    3. 2. Understanding Values Hierarchy
    4. 3. Using Custom Values Files
    5. Example: Stack multiple files
    6. 4. Setting Individual Values
    7. 5. Using String Values
    8. Example: Force string interpretation
    9. 6. Setting File Content Values
    10. Example: Load TLS cert from disk
    11. 7. Setting JSON Values
    12. Example: Complex list of objects
    13. 8. Merging Multiple Values Files
    14. 9. Creating Environment-Specific Values
    15. Example: Layout
    16. 10. Documenting Values
    17. 11. Using Global Values
    18. Example: Shared across parent + subcharts

  8. Implementing Values Schema Validation

    1. 1. Creating values.schema.json File
    2. Example: Minimal schema
    3. 2. Defining Schema Properties
    4. 3. Setting Required Fields
    5. Example: Multiple required keys
    6. 4. Defining Value Types
    7. 5. Adding Property Constraints
    8. 6. Using Enum Values
    9. Example: Restrict allowed strings
    10. 7. Setting Default Values
    11. 8. Adding Schema Descriptions
    12. Example: Self-documenting schema
    13. 9. Validating Nested Objects
    14. Example: Deep schema
    15. 10. Testing Schema Validation

  9. Creating Template Files

    1. 1. Understanding Template Syntax
    2. 2. Creating Deployment Template
    3. Example: Standard Deployment
    4. 3. Creating Service Template
    5. Example: ClusterIP Service
    6. 4. Creating ConfigMap Template
    7. Example: App configuration
    8. 5. Creating Secret Template
    9. Example: Encoded Secret
    10. 6. Creating Ingress Template
    11. Example: Conditional Ingress
    12. 7. Creating ServiceAccount Template
    13. Example: Optional SA
    14. 8. Creating RBAC Templates
    15. Example: Role + RoleBinding
    16. 9. Creating PersistentVolumeClaim Template
    17. Example: PVC
    18. 10. Using Template Comments ({{/* */}})
    19. 11. Using Multi-Document Templates
    20. Example: Multiple resources per file

  10. Working with Template Functions

    1. 1. Accessing Values ({{ .Values.key }})
    2. 2. Using Pipeline Operations
    3. Example: Chained transformations
    4. 3. Quoting Strings
    5. 4. Converting to YAML
    6. Example: Render arbitrary structure
    7. 5. Converting to JSON
    8. 6. Using Default Values
    9. Example: Fallback chain
    10. 7. String Manipulation
    11. 8. Type Conversion
    12. 9. Encoding Functions
    13. 10. Date Functions
    14. 11. UUID Generation
    15. Example: Random UUID v4
    16. 12. Using fail Function
    17. Example: Hard validation

  11. Working with Advanced Template Functions

    1. 1. Using String Functions
    2. 2. Using List Functions
    3. 3. Using Dict Functions
    4. 4. Using Type Functions
    5. 5. Using Path Functions
    6. 6. Using Crypto Functions
    7. 7. Using URL Functions
    8. 8. Using Regex Functions
    9. 9. Using Sprig Functions
    10. 10. Using Math Functions

  12. Implementing Template Flow Control

    1. 1. Using Conditional Statements
    2. Example: if/else if/else
    3. 2. Implementing Loops
    4. Example: range over list and map
    5. 3. Using with Scope
    6. Example: Rebind dot
    7. 4. Defining Variables
    8. 5. Checking Value Existence
    9. Example: Safe access patterns
    10. 6. Using Boolean Logic
    11. 7. Comparing Values
    12. 8. Breaking Loop Iteration
    13. 9. Handling Empty Values
    14. Example: Avoid emitting empty fields
    15. 10. Using Complex Conditionals
    16. Example: Combined predicate
    17. 11. Implementing Dynamic Resource Creation
    18. Example: Generate one ConfigMap per entry

  13. Working with Named Templates

    1. 1. Defining Named Templates
    2. Example: Define block
    3. 2. Including Templates
    4. 3. Using Template Directive
    5. Example: include vs template
    6. 4. Creating Partial Templates
    7. Example: Reusable selector labels
    8. 5. Passing Scope to Templates
    9. 6. Defining Common Labels
    10. Example: Standard label set
    11. 7. Creating Selector Templates
    12. 8. Building Image Strings
    13. Example: Image helper supporting registry + digest
    14. 9. Generating Resource Names
    15. 10. Reusing Template Logic
    16. Example: Composition
    17. 11. Using Template Inheritance

  14. Working with Built-in Objects

    1. 1. Accessing Release Object (.Release.Name)
    2. 2. Using Chart Object (.Chart.Name)
    3. 3. Accessing Files Object (.Files.Get)
    4. 4. Using Capabilities Object (.Capabilities.KubeVersion)
    5. 5. Working with Template Object (.Template.Name)
    6. 6. Accessing Release Service (.Release.Service)
    7. Example: Standard managed-by label
    8. 7. Getting Release Namespace (.Release.Namespace)
    9. 8. Checking Release IsUpgrade (.Release.IsUpgrade)
    10. Example: Upgrade-only hook logic
    11. 9. Checking Release IsInstall (.Release.IsInstall)
    12. 10. Using Chart Version (.Chart.Version)
    13. Example: Chart version label
    14. 11. Accessing Capabilities APIVersions (.Capabilities.APIVersions)
    15. Example: Detect API availability

  15. Managing Chart Files

    1. 1. Reading File Content
    2. Example: Inline file in ConfigMap
    3. 2. Listing Files
    4. 3. Reading Files as Bytes
    5. Example: Binary file
    6. 4. Using Files in ConfigMaps
    7. Example: Glob to ConfigMap
    8. 5. Using Files in Secrets
    9. Example: Glob to Secret
    10. 6. Iterating Over Files
    11. Example: Loop with range
    12. 7. Checking File Existence
    13. 8. Encoding File Content
    14. 9. Including Binary Files
    15. 10. Organizing Static Files

  16. Using Lookup Function

    1. 1. Reading Existing Resources
    2. 2. Querying ConfigMaps
    3. Example: Read existing CM
    4. 3. Querying Secrets
    5. Example: Preserve existing secret across upgrades
    6. 4. Checking Resource Existence
    7. 5. Reading Resource Fields
    8. Example: Navigate fields
    9. 6. Using Lookup in Conditionals
    10. Example: Create only if absent
    11. 7. Handling Missing Resources
    12. 8. Querying Across Namespaces
    13. Example: All Services across ns
    14. 9. Understanding Performance Implications
    15. 10. Understanding Security Implications

  17. Implementing Template Whitespace Control

    1. 1. Understanding Whitespace Behavior
    2. 2. Using Left Trim ({{-)
    3. Example: Remove preceding blank line
    4. 3. Using Right Trim (-}})
    5. Example: Inline rendering
    6. 4. Combining Trim Markers ({{- -}})
    7. 5. Controlling Indentation
    8. 6. Managing YAML Formatting
    9. Example: toYaml with nindent
    10. 7. Using Template Comments ({{/* */}})
    11. 8. Avoiding Extra Blank Lines
    12. Example: Compare bad vs good
    13. 9. Formatting Multi-line Strings (| and >)
    14. 10. Debugging Whitespace Issues

  18. Working with Chart Hooks

    1. 1. Defining Hook Annotations
    2. Example: Basic hook
    3. 2. Using pre-install Hook
    4. 3. Using post-install Hook
    5. 4. Using pre-upgrade Hook
    6. 5. Using post-upgrade Hook
    7. 6. Using pre-delete Hook
    8. 7. Using post-delete Hook
    9. 8. Using pre-rollback Hook
    10. 9. Using post-rollback Hook
    11. 10. Setting Hook Weight
    12. 11. Setting Hook Deletion Policy
    13. 12. Using test Hook
    14. Example: Connectivity test

  19. Managing Chart Dependencies

    1. 1. Declaring Dependencies
    2. Example: Chart.yaml dependencies block
    3. 2. Specifying Dependency Version
    4. 3. Setting Dependency Repository
    5. 4. Using Local Dependencies
    6. Example: Sibling chart
    7. 5. Enabling Conditional Dependencies
    8. 6. Using Tag-based Dependencies
    9. Example: Toggle group of charts
    10. 7. Downloading Dependencies
    11. 8. Building Dependency Charts
    12. Example: Reproducible CI build
    13. 9. Listing Dependencies
    14. 10. Importing Child Values
    15. Example: Surface subchart values at parent level
    16. 11. Overriding Subchart Values
    17. Example: Parent values.yaml
    18. 12. Managing Chart.lock File

  20. Installing Charts

    1. 1. Installing Chart from Repository
    2. Example: Install from added repo
    3. 2. Installing from Local Path
    4. Example: Dev install
    5. 3. Installing from URL
    6. 4. Installing from Archive
    7. Example: Local .tgz
    8. 5. Generating Release Name
    9. 6. Setting Custom Release Name
    10. 7. Installing in Specific Namespace
    11. 8. Creating Namespace
    12. Example: Combined
    13. 9. Using Dry Run Mode
    14. 10. Waiting for Resources
    15. 11. Setting Wait Timeout
    16. 12. Installing with Values
    17. Example: Combined inputs

  21. Upgrading Releases

    1. 1. Upgrading Release
    2. Example: Standard upgrade
    3. 2. Installing or Upgrading
    4. 3. Forcing Resource Update
    5. 4. Resetting Values
    6. 5. Reusing Previous Values
    7. 6. Upgrading with New Values
    8. Example: Versioned upgrade
    9. 7. Using Atomic Upgrades
    10. 8. Cleaning Up on Failed Upgrade
    11. Example: Safe CI upgrade
    12. 9. Setting Revision Limits
    13. 10. Waiting for Upgrade Completion

  22. Rolling Back Releases

    1. 1. Rolling Back Release
    2. Example: Roll back to previous revision
    3. 2. Rolling Back to Revision
    4. 3. Viewing Release History
    5. 4. Understanding Rollback Behavior
    6. 5. Using Atomic Rollback
    7. 6. Forcing Rollback
    8. 7. Setting Rollback Timeout
    9. 8. Waiting for Rollback Completion
    10. Example: Safe rollback
    11. 9. Cleaning Up on Failed Rollback
    12. 10. Troubleshooting Failed Rollbacks

  23. Managing Releases

    1. 1. Listing Active Releases
    2. 2. Listing All Releases
    3. 3. Filtering by Namespace
    4. 4. Listing Across Namespaces
    5. Example: Cluster-wide JSON list
    6. 5. Getting Release Status
    7. 6. Getting Release Values
    8. Example: Inspect computed values
    9. 7. Getting Release Manifest
    10. 8. Getting Release Notes
    11. 9. Getting Release Hooks
    12. 10. Filtering Release Output

  24. Uninstalling Releases

    1. 1. Uninstalling Release
    2. Example: Remove release
    3. 2. Keeping Release History
    4. 3. Waiting for Deletion
    5. 4. Setting Deletion Timeout
    6. 5. Performing Dry Run Uninstall
    7. Example: Preview deletion
    8. 6. Uninstalling with Cascade
    9. 7. Viewing Uninstall Output
    10. 8. Uninstalling Multiple Releases
    11. Example: Batch uninstall
    12. 9. Handling Failed Uninstalls
    13. 10. Cleaning Up Orphaned Resources

  25. Linting and Validating Charts

    1. 1. Linting Chart Templates
    2. Example: Run lint
    3. 2. Checking Chart Structure
    4. 3. Validating Chart.yaml
    5. 4. Validating Template Syntax
    6. Example: Render + parse
    7. 5. Using Strict Linting
    8. 6. Checking Values Schema
    9. Example: Schema-enforced lint
    10. 7. Validating Kubernetes Resources
    11. 8. Generating Dry-Run Output
    12. 9. Using Template Command
    13. Example: Render without cluster
    14. 10. Debugging Template Rendering
    15. 11. Validating Dependencies

  26. Testing Charts

    1. 1. Running Chart Tests
    2. Example: Run tests after install
    3. 2. Creating Test Pods
    4. Example: HTTP smoke test
    5. 3. Using Test Annotations
    6. 4. Running Specific Tests
    7. 5. Viewing Test Logs
    8. 6. Setting Test Timeout
    9. 7. Filtering Test Results
    10. Example: Inspect failed test pod
    11. 8. Cleaning Test Pods
    12. 9. Testing with Different Values
    13. Example: Per-env test matrix
    14. 10. Automating Chart Tests

  27. Debugging and Troubleshooting

    1. 1. Using Debug Mode
    2. 2. Generating Templates Locally
    3. Example: Render to file
    4. 3. Performing Dry Run
    5. 4. Viewing Rendered Manifests
    6. 5. Checking Release Status
    7. Example: Detailed status
    8. 6. Viewing Release History
    9. 7. Inspecting Hook Execution
    10. Example: View hook pods/jobs
    11. 8. Checking Resource Events
    12. 9. Validating Current Values
    13. Example: Diff values vs file
    14. 10. Using Verbose Output
    15. 11. Troubleshooting Failed Upgrades
    16. 12. Debugging Template Rendering
    17. Example: Pinpoint failure

  28. Packaging Charts

    1. 1. Creating Chart Package
    2. Example: Package chart
    3. 2. Setting Package Destination
    4. 3. Signing Chart Package
    5. Example: GPG sign at packaging
    6. 4. Using Package Key
    7. 5. Setting Package Version
    8. 6. Setting App Version
    9. 7. Updating Dependencies Before Packaging
    10. 8. Creating Package from Path
    11. Example: Package multiple
    12. 9. Verifying Package Contents
    13. 10. Generating Package Checksum
    14. Example: SHA-256 for integrity

  29. Publishing Charts to Repository

    1. 1. Generating Repository Index
    2. Example: Build index from directory
    3. 2. Updating Index with New Chart
    4. Example: Incremental index
    5. 3. Setting Base URL
    6. 4. Hosting Static Repository
    7. 5. Using GitHub Pages
    8. Example: Publish via gh-pages
    9. 6. Publishing to ChartMuseum
    10. Example: Push via cm-push plugin
    11. 7. Publishing to Harbor
    12. Example: Harbor OCI
    13. 8. Publishing to Artifactory
    14. 9. Automating Repository Updates
    15. Example: Release workflow
    16. 10. Managing Repository Versions

  30. Working with OCI Registries

    1. 1. Understanding OCI Registry Support
    2. 2. Logging into Registry
    3. Example: Login
    4. 3. Logging out of Registry
    5. 4. Pushing Chart to OCI
    6. Example: Push packaged chart
    7. 5. Pulling Chart from OCI
    8. Example: Pull tarball locally
    9. 6. Installing from OCI
    10. 7. Using OCI References
    11. 8. Listing OCI Chart Tags
    12. Example: List versions via crane/oras
    13. 9. Setting OCI Credentials
    14. 10. Using Docker Config
    15. Example: Reuse docker credentials
    16. 11. Working with Private OCI Registries

  31. Working with Subcharts

    1. 1. Adding Subcharts to Chart
    2. 2. Declaring Subchart Dependencies
    3. Example: Multiple subcharts
    4. 3. Overriding Subchart Values
    5. Example: Override under subchart key
    6. 4. Using Global Values
    7. Example: Shared global block
    8. 5. Importing Subchart Values
    9. Example: Surface subchart exports
    10. 6. Conditionally Enabling Subcharts
    11. 7. Using Subchart Tags
    12. Example: Group enable/disable
    13. 8. Accessing Parent Values
    14. 9. Sharing Templates Across Charts
    15. 10. Managing Subchart Versions

  32. Creating Library Charts

    1. 1. Defining Library Chart Type
    2. Example: Library Chart.yaml
    3. 2. Creating Reusable Templates
    4. Example: Common deployment helper
    5. 3. Sharing Common Helpers
    6. 4. Using Library as Dependency
    7. Example: Consumer Chart.yaml
    8. 5. Including Library Templates
    9. Example: Consumer's templates/deployment.yaml
    10. 6. Versioning Library Charts
    11. 7. Documenting Library Usage
    12. 8. Organizing Library Templates
    13. 9. Testing Library Templates
    14. 10. Publishing Library Charts

  33. Working with Custom Resource Definitions

    1. 1. Understanding CRD Handling
    2. 2. Installing CRDs with Charts
    3. 3. Creating CRD Templates
    4. Example: crds/myresource.yaml (NOT templated)
    5. 4. Managing CRD Versions
    6. 5. Handling CRD Upgrades
    7. 6. Avoiding CRD Deletion on Uninstall
    8. 7. Validating CRD Schemas
    9. 8. Using CRDs with Operators
    10. Example: Operator chart layout
    11. 9. Testing CRD Installation
    12. Example: Verify CRD post-install
    13. 10. Troubleshooting CRD Issues

  34. Implementing Chart Security

    1. 1. Signing Chart Packages
    2. Example: Sign + verify
    3. 2. Verifying Chart Signatures
    4. 3. Using GPG Keys
    5. 4. Creating Provenance File
    6. 5. Validating Chart Integrity
    7. Example: Verify before install
    8. 6. Implementing RBAC in Charts
    9. Example: Least-privilege Role
    10. 7. Setting Security Context
    11. Example: Restricted pod
    12. 8. Using Network Policies
    13. Example: Default-deny + allow ingress
    14. 9. Scanning Charts for Vulnerabilities
    15. 10. Following Security Best Practices
    16. 11. Validating Image Sources

  35. Working with Secrets and Sensitive Data

    1. 1. Creating Secret Templates
    2. Example: Opaque Secret
    3. 2. Encoding Secret Values
    4. 3. Using External Secrets
    5. Example: ExternalSecret CR
    6. 4. Integrating with HashiCorp Vault
    7. 5. Using SOPS for Encryption
    8. Example: helm-secrets plugin
    9. 6. Managing TLS Certificates
    10. Example: cert-manager Certificate
    11. 7. Using Sealed Secrets
    12. 8. Passing Secrets via Values
    13. Example: CI injection
    14. 9. Using Secret Files
    15. 10. Avoiding Hardcoded Secrets

  36. Managing Chart Versions

    1. 1. Using Semantic Versioning
    2. 2. Incrementing Chart Version
    3. 3. Setting Application Version
    4. 4. Creating Version Constraints
    5. 5. Using Version Ranges
    6. Example: Composite
    7. 6. Pinning Exact Versions
    8. 7. Using Tilde Range
    9. 8. Using Caret Range
    10. 9. Maintaining Changelog
    11. Example: Annotations-based changelog
    12. 10. Tagging Chart Releases

  37. Migrating and Upgrading Charts

    1. 1. Upgrading Chart API Version
    2. Example: v1 → v2
    3. 2. Migrating from requirements.yaml
    4. 3. Updating Deprecated Kubernetes APIs
    5. 4. Handling Breaking Changes
    6. 5. Testing Migration Changes
    7. 6. Rolling Back Failed Migrations
    8. Example: Atomic with auto-rollback
    9. 7. Updating Chart Dependencies
    10. 8. Migrating to OCI Registries
    11. 9. Converting to Library Charts
    12. 10. Documenting Migration Steps

  38. Managing Chart Metadata

    1. 1. Setting Chart Annotations
    2. Example: Artifact Hub annotations
    3. 2. Adding Custom Metadata
    4. 3. Documenting Chart Purpose
    5. 4. Listing Chart Dependencies
    6. Example: View resolved deps
    7. 5. Setting Minimum Kubernetes Version
    8. 6. Adding Chart Maturity
    9. 7. Linking to Source Code
    10. Example: sources list
    11. 8. Providing Support Contacts
    12. Example: maintainers + links
    13. 9. Setting Chart License
    14. 10. Adding Chart Category

  39. Implementing Advanced Templating

    1. 1. Creating Recursive Templates
    2. Example: Recursive label flattener
    3. 2. Building Dynamic Names
    4. Example: Name from values
    5. 3. Implementing Feature Flags
    6. 4. Creating Environment-Aware Templates
    7. Example: Per-env resources
    8. 5. Using Template Variables
    9. 6. Implementing Complex Data Structures
    10. Example: Build dict dynamically
    11. 7. Building Resource Templates Dynamically
    12. Example: Many Services from one map
    13. 8. Using Template Includes Efficiently
    14. 9. Handling Edge Cases
    15. 10. Creating Maintainable Templates

  40. Using Post-Renderers

    1. 1. Understanding Post-Renderers
    2. 2. Configuring Post-Renderer Command
    3. 3. Using Kustomize as Post-Renderer
    4. Example: kustomize.sh wrapper
    5. 4. Applying Custom Patches
    6. Example: Strategic-merge patch via Kustomize
    7. 5. Adding Labels and Annotations
    8. Example: Cluster-wide labels
    9. 6. Modifying Generated Resources
    10. 7. Chaining Multiple Post-Renderers
    11. 8. Debugging Post-Renderer Output
    12. Example: Capture intermediate output
    13. 9. Handling Post-Renderer Errors
    14. 10. Integrating Post-Renderers in CI/CD
    15. Example: Pipeline step

  41. Working with Helm Plugins

    1. 1. Installing Helm Plugins
    2. Example: Install from Git
    3. 2. Listing Installed Plugins
    4. 3. Updating Plugins
    5. Example: Update commands
    6. 4. Removing Plugins
    7. 5. Using helm-diff Plugin
    8. Example: Preview upgrade
    9. 6. Using helm-secrets Plugin
    10. Example: SOPS workflow
    11. 7. Using helm-git Plugin
    12. Example: Chart from Git repo
    13. 8. Using helm-s3 Plugin
    14. Example: S3-backed repo
    15. 9. Creating Custom Plugins
    16. Example: plugin.yaml
    17. 10. Configuring Plugin Environment

  42. Managing Namespaces and Multi-Tenancy

    1. 1. Creating Namespace in Chart
    2. 2. Using Release Namespace
    3. 3. Installing Charts Across Namespaces
    4. Example: Per-namespace releases
    5. 4. Implementing Namespace Isolation
    6. 5. Using Namespace-scoped Resources
    7. 6. Managing Cluster-scoped Resources
    8. 7. Implementing Resource Quotas
    9. Example: Tenant ResourceQuota
    10. 8. Using LimitRange for Namespaces
    11. Example: Default container limits
    12. 9. Handling Cross-Namespace References
    13. 10. Implementing Multi-Tenant Charts

  43. Working with Helm Starters

    1. 1. Understanding Helm Starters
    2. 2. Creating Starter Charts
    3. Example: Build + install starter
    4. 3. Using Starter Templates
    5. 4. Organizing Starters Directory
    6. Example: Layout
    7. 5. Customizing Starter Templates
    8. 6. Sharing Starter Charts
    9. 7. Implementing Organization Standards
    10. 8. Using Starter Variables
    11. 9. Testing Starter Charts
    12. Example: Smoke test in CI
    13. 10. Maintaining Starter Charts

  44. Deploying to Air-Gapped Environments

    1. 1. Downloading Charts for Offline Use
    2. Example: Pull chart + deps
    3. 2. Bundling Chart Dependencies
    4. Example: Vendor all deps
    5. 3. Mirroring Container Images
    6. Example: Use skopeo / crane
    7. 4. Setting Up Private Registry
    8. 5. Configuring Air-Gapped Repository
    9. Example: Internal repo + OCI
    10. 6. Updating Image References
    11. Example: Override registries
    12. 7. Packaging All Dependencies
    13. 8. Validating Offline Installation
    14. Example: Dry-run + render check
    15. 9. Managing Updates in Air-Gapped
    16. 10. Documenting Air-Gapped Procedures

  45. Implementing Multi-Cluster Deployments

    1. 1. Understanding Multi-Cluster Patterns
    2. 2. Managing Kubeconfig Contexts
    3. Example: Per-cluster commands
    4. 3. Using Environment-Specific Values
    5. Example: Layered values
    6. 4. Implementing GitOps Workflow
    7. 5. Synchronizing Releases Across Clusters
    8. Example: Argo CD ApplicationSet
    9. 6. Handling Cluster-Specific Configuration
    10. 7. Managing Cross-Cluster Dependencies
    11. 8. Implementing Blue-Green Deployments
    12. Example: Two releases + traffic switch
    13. 9. Managing Canary Releases
    14. 10. Monitoring Multi-Cluster Deployments

  46. Automating with Helm in CI/CD

    1. 1. Installing Helm in Pipeline
    2. Example: GitHub Actions
    3. 2. Authenticating to Kubernetes
    4. 3. Running Helm Lint
    5. Example: Lint with strict mode
    6. 4. Performing Dry Run
    7. Example: Server-side dry-run
    8. 5. Deploying Charts
    9. Example: Atomic deploy with timeout
    10. 6. Running Chart Tests
    11. Example: Post-deploy validation
    12. 7. Rolling Back on Failure
    13. 8. Publishing Charts
    14. Example: Chart-releaser action
    15. 9. Versioning with CI Variables
    16. Example: Inject build metadata
    17. 10. Using GitOps Workflows
    18. 11. Implementing Blue-Green Deployments
    19. Example: Pipeline blue-green

  47. Optimizing Chart Performance

    1. 1. Minimizing Template Complexity
    2. 2. Caching Template Results
    3. Example: Cache expensive include
    4. 3. Reducing Value Lookups
    5. Example: Bind once with
    6. 4. Optimizing Loop Iterations
    7. 5. Using Conditional Rendering
    8. Example: Skip unused blocks
    9. 6. Minimizing File Reads
    10. 7. Reducing Chart Size
    11. 8. Optimizing Dependencies
    12. 9. Using Lazy Evaluation
    13. Example: Short-circuit expensive checks
    14. 10. Profiling Chart Rendering
    15. Example: Measure render time

  48. Customizing Helm Behavior

    1. 1. Configuring Helm Environment
    2. 2. Setting Default Namespace
    3. Example: Per-shell default
    4. 3. Configuring Kubeconfig Path
    5. 4. Setting Repository Cache
    6. 5. Configuring Plugins Path
    7. 6. Setting Registry Config
    8. 7. Enabling Experimental Features
    9. 8. Configuring Max History
    10. Example: Limit revision history
    11. 9. Setting Debug Output
    12. 10. Using Custom Configuration
    13. Example: Pipeline-isolated config

  49. Implementing Chart Best Practices

    1. 1. Following Naming Conventions
    2. 2. Using Fullname Templates
    3. Example: Standard fullname helper
    4. 3. Implementing Proper Labels
    5. Example: Standard label set
    6. 4. Using Annotations Appropriately
    7. 5. Making Charts Configurable
    8. 6. Providing Sensible Defaults
    9. 7. Documenting Chart Usage
    10. 8. Creating Comprehensive NOTES.txt
    11. Example: Helpful post-install message
    12. 9. Implementing Resource Limits
    13. Example: Always-set limits pattern
    14. 10. Using Health Checks
    15. Example: All three probe types
    16. 11. Following Helm Chart Conventions

  50. Implementing Chart Deprecation Strategies

    1. 1. Marking Charts as Deprecated
    2. Example: Deprecated chart
    3. 2. Documenting Deprecation Reasons
    4. Example: Annotations + README
    5. 3. Providing Migration Paths
    6. 4. Setting Deprecation Timeline
    7. 5. Communicating to Users
    8. 6. Maintaining Deprecated Charts
    9. 7. Removing Deprecated Charts
    10. 8. Archiving Old Chart Versions
    11. 9. Redirecting to Replacements
    12. Example: NOTES.txt redirect
    13. 10. Handling Breaking Changes