Helm template need to get and set value in dict

ONLINECAST

2 min read

·

05-10-2024

21

0

Share

Mastering Helm Templates: Accessing and Modifying Data with Dictionaries

Helm, the package manager for Kubernetes, empowers developers to manage applications across multiple environments with ease. Its powerful templating engine, leveraging Go templates, offers immense flexibility in defining resource configurations. One common scenario involves managing complex data structures within a Helm chart, specifically using dictionaries (maps) to store and manipulate information.

Let's dive into the world of Helm templates and explore how to seamlessly access and modify values stored in dictionaries, enhancing your chart's capabilities.

Scenario: A Dynamic Configuration

Imagine a scenario where you need to configure a deployment with different settings based on the environment. A common approach is to store environment-specific configurations in a dictionary within your values.yaml file:

environment:
  dev:
    replicas: 2
    resources:
      requests:
        cpu: 100m
        memory: 256Mi
  prod:
    replicas: 5
    resources:
      requests:
        cpu: 500m
        memory: 1Gi

Now, our goal is to use Helm's templating engine to dynamically fetch and apply the appropriate configuration for our deployment based on the current environment.

The Power of Go Templates

Helm leverages Go templates, a powerful and flexible templating language. To access and manipulate values within a dictionary, we utilize the dot (.) operator and curly braces ({{ }}).

Here's how to access the replicas value for the dev environment:

replicas: {{ .Values.environment.dev.replicas }}

Breakdown:

• {{ }}: This encloses our Go template expression.
• .Values: Accesses the main values.yaml dictionary.
• .environment: Navigates into the environment sub-dictionary.
• .dev: Selects the specific environment (dev) we are interested in.
• .replicas: Finally, extracts the replicas value.

Modifying Values with range

The range keyword in Go templates provides a powerful mechanism to iterate over lists and dictionaries, allowing us to manipulate data in a structured way.

Let's assume we need to dynamically adjust the resources.requests.cpu value based on the environment.

resources:
  requests:
    cpu: {{ range .Values.environment | keys }}
      {{ if eq . "prod" }}
        500m
      {{ else if eq . "dev" }}
        100m
      {{ end }}
      {{ end }}
    memory: 256Mi 

Explanation:

• range .Values.environment | keys : Iterates over the keys (environment names) within the environment dictionary.
• if eq . "prod": Checks if the current environment is "prod".
• else if eq . "dev": Checks if the current environment is "dev".
• 500m or 100m: Sets the appropriate CPU request based on the environment.

This snippet dynamically sets the CPU request based on the current environment.

Further Exploration: Advanced Techniques

Helm's templating engine offers a wealth of powerful features to manipulate dictionaries. Explore advanced techniques like:

• with block: Used to define variables or conditionally include blocks of code.
• index function: Accesses specific elements in lists or dictionaries by index.
• default function: Provides fallback values if a key doesn't exist.

Best Practices: Maintaining Clarity and Organization

• Modularize Your Templates: Break down complex logic into smaller, reusable templates for enhanced readability and maintainability.
• Use Comments: Explain complex logic within your templates using comments for easy understanding.
• Test Thoroughly: Ensure your charts function as intended across various environments by testing your templates against different values.

By harnessing the power of Go templates and dictionaries, you can create dynamic and robust Helm charts that adapt seamlessly to different environments. Master these techniques to elevate your Helm workflow to new heights!