helm: Tpl funcion does not work in range

I spend some time to find a workaround for this, so, this might be useful for someone:

{{- range $key, $value := .Values.list }}
{{- $_ := set $ "key" $key }}
{{- $_ := set $ "value" $value }}
{{- tpl ($.Files.Get "sub.yaml") $ }}
{{- end }}

Inside the nested template the global context of the parent template is accessible as usual through dot, the range variables are accessible like .key, .value.

To use the tpl funciton inside a range loop , i m passing $ (global ctx) instead of .

{{ range .Values.list }} {{ tpl .item.template $ }} {{ end }}

For anyone who stumbles upon this issues, one solution is to pass the Template object into the tpl function alongside your other values via dict.

See this implementation:

kind: ConfigMap
apiVersion: v1
metadata:
    name: {{ include "config-map-name" . | quote }}
    labels:
        {{- include "config-map-labels" . | nindent 8 }}
    annotations:
        {{- /*
        Use checksums to track config template/value changes.
        If the checksum of this file is then used elsewhere (ie by a deployment) when config template/values changes,
        this files checksum changes which would cause the consumer to update itself to take in these changes.
        */}}
        checksum/config-nginx-server.conf: {{ $.Files.Get (print .Template.BasePath "config/nginx/server.conf") | sha256sum | quote }}
        checksum/values-sites: {{ .Values.sites | toString | sha256sum | quote }}
data:
    {{- range $siteName, $siteConfig := .Values.sites }}
    {{ $siteName }}.conf: |-
        {{- tpl ($.Files.Get "config/nginx/server.conf") (dict "Values" $siteConfig "Template" $.Template) | nindent 8 }}
    {{- end }}

@bacongobbler this seems like the ‘cleanest’ approach, i wonder if it’s worth noting in documentation?

At runtime, the rendering engine needs to know the path of the original template as well as the name of the template, both of which cannot be inferred ahead of time. tpl checks those values in order to know which template it is modifying. Looking at the code, that seems like the intended behaviour. The issue here is the range function: when inside a range function, the scope of dot (.) is limited to the scope of the range. In other words, your call to tpl is the equivalent of

{{ tpl "{{ .name }}" .Values.anything }}

Because the tpl function relies on objects that are in the root scope of the dot (.) value (like .Template), the rendering fails. Replacing . with $ as you pointed out should allow the tpl function to work.

If you can determine another way to find out which template is calling tpl, we’d happily accept a PR.

@chudytom that should work find yes.

Obviously the structure of the dict depends on how the template used in the tpl function expects its values. This structure can be anything and the Values key is not necessarily required.

For example, if the template looks for values at: .someValue .anotherValue, your tpl call could look like

{{ tpl "file.yaml" (dict "someValue" $someValue "anotherValue" $anotherValue "Template" $.Template) }}

Another example, if the template looks for values at .data.someValue .data.AnotherValue, your tpl call could look like

{{ $data := dict "someValue" "foo" "anotherValue" "bar" }}
{{ tpl "file.yaml" (dict "data" $data "Template" $.Template) }}

As long as you pass through the root .Template object it should all work fine.

Hope that clears things up.

@zffocussss $ is a reference to the global scope. For example, these two lines mean the same (if they’re located in the top scope):

{{ .Values.list }}
{{ $.Values.list }}

Now let’s take a look at the following values.yaml:

foo: bar
list:
- Values:
    foo: 1
- Values:
    foo: 2

{{ .Values.foo }} returns "bar"
{{ $.Values.foo }} also returns "bar"
{{ range .Values.list }}
    {{ .Values.foo }} returns 1 and then 2
    {{ $.Values.foo }} returns bar
{{ end }}

I seem to be running into the same issue here and cannot figure out how to apply @Zebradil workaround values.yaml:

 app_role:
  - app: test
    namespace: test-namespace
    roles:
      test-admin:
        rules: |
          resources:
            - "*"
          verbs:
            - "*"
      test-analytics:
        rules: |
          resources:
            - "pods"
            - "configmaps"
          verbs:
            - "get"
            - "list"
  - app: test2
    namespace: test2-namespace
    roles:
      test2-admin:
        rules: |
          resources:
            - "*"
          verbs:
            - "*"

templates/roles.yaml

{{- range .Values.app_role }}
{{- template "roles" . }}
{{- end }}

templates/_helpers.tpl

{{- define "roles" }}
{{- range $key, $value := .roles }}
---
kind: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  namespace: {{ $.namespace }}
  name: {{ $key }}
rules:
- apiGroups: [""]
  {{ tpl .rules . | indent 4 }}
  {{- end }}
{{- end -}}

@wmiller112 did you figure it out?