Implementing Template Logic with Go Templates

Learners will utilize Go templating syntax to inject dynamic variables and conditional logic into static Kubernetes manifest files within a chart.

In this lesson, you will learn how to leverage Go template syntax to transform static Kubernetes manifests into dynamic, reusable resources using Helm charts.

When you manage applications at scale, hardcoding values like replica counts, environment variables, or resource limits into YAML files becomes unsustainable. Helm solves this by using the Go text/template engine to inject variables and logic directly into your manifest files during deployment.

Injecting Variables

The most basic form of templating is accessing values defined in your values.yaml file. You use double curly braces {{ }} to signify a template action. For example, to set a dynamic number of replicas:

# templates/deployment.yaml
apiVersion: apps/v1
kind: Deployment
spec:
  replicas: {{ .Values.replicaCount }}

When Helm renders this chart, it replaces {{ .Values.replicaCount }} with the actual integer defined in your values file.

Adding Conditional Logic

Templates become truly powerful when you introduce control structures like if/else blocks. This allows you to include or exclude manifest sections based on your configuration. Suppose you only want to add a specific sidecar container if a flag is set to true:

spec:
  containers:
    - name: main-app
      image: my-app:1.0
    {{- if .Values.enableSidecar }}
    - name: log-exporter
      image: sidecar:latest
    {{- end }}

The {{- syntax (with the hyphen) is a special Go template directive that trims the whitespace before the tag, ensuring your rendered YAML file remains clean and properly indented. By wrapping your manifests in these conditions, you can manage complex infrastructure variations—such as deploying different configurations for development versus production—using a single, unified codebase.

These logic blocks transform your manifests from static "blueprints" into flexible "recipes" that adapt to your specific deployment environment. As you build more sophisticated charts, you will combine these techniques with pipelines (loops) and functions to handle highly complex deployment requirements with minimal overhead.

Key Takeaway: Go templates turn static YAML manifests into dynamic configuration engines, allowing you to inject variables and conditional logic to manage environment-specific deployment requirements efficiently.