How to provide an in-memory data (map/struct) as the datasource/context when rendering a template with Gomplate APIs in Go?

[phong2tran]

Current Context:
We got introduced to this great tool recently by the mention of "Gomplate" on this project page when working on OPA policies. Our use case and template implementation are very much inspired and based on this "One template, many outputs" post by @hairyhenderson. Basically we just loop through a list of user groups in the datasource from a local YAML file and based on info in each group/namespace provided, we construct an in-memory map data (coll.Dict) and render set of different output files (OPA policies) from the defined templates with the map as the current context (datasource):

datasources/groups.yaml:

groups:
  - name: group-a
    nodePool: nodepool-a
    namespaces:
      - ns1
      - ns2

  - name: group-b
    nodePool: nodepool-b
    namespaces:
      - ns1
      - ns2
      - ns3
...

This is the short redacted snippet from .gomplate file:

in: |
 {{ range (datasource "groups") }} 
    {{ range $groupIndex, $group := . }}
      {{ range $namespaceIndex, $namespaceName := $group.namespaces }}        
        {{ tmpl.Exec "podAffinityTemplate" (coll.Dict "namespace" $namespaceName "nodePool" $group.nodePool) | file.Write $filePath }}        
...			
      {{ end }}            
    {{ end }}
  {{ end }}		

datasources:
  groups:
    url: datasources/groups.yaml

templates:
  - podAffinityTemplate=pod-affinity.yaml
...   

Next Exploration:
Although the current implementation is working quite well, but as we're looking to expand our current implementation to include K8S RBAC policies and more functionality, we have a little reservation on adding more logic to the root template in .gomplate file due to the readability and maintenance concerns. We're currently contemplating to use Gomplate package (https://pkg.go.dev/github.com/hairyhenderson/gomplate/v3) and write template rendering logic directly in Go program for other benefits as well (tooling/IDE support).

1. Do you have any concern with our direction using Gomplate APIs to drive the template rendering logic?
2. When looking at one of examples using Gomplate API with a datasource, it's noticed that Datasource provided as part of Options for gomplate.NewRenderer() is probably used to access the external data source like file and URL, and etc.

type Datasource struct {
	URL    *url.URL
	Header http.Header
}

If we want to provide an in-memory data (Go map/struct) as the datasource (context) similarly to what we're using in the Gomplate root template:

{{ tmpl.Exec "podAffinityTemplate" (coll.Dict "namespace" $namespaceName "nodePool" $group.nodePool) | file.Write $filePath }}

How can we achieve this similar task by providing a map as the datasource/context when rendering a template with Gomplate APIs in Go?

Thanks a lot in advance for the support!

[hairyhenderson]

Thanks for the post @phong2tran, always nice to hear of projects where gomplate's being used!

I see you're looking at using the v3 gomplate module, which is fine - that's the latest major release. However, be aware that there's also a v4 module which may be slightly easier to use (I'm thinking of the Renderer in particular).

In particular, if you use the v4 module, you can provide NewRenderer with an FSProvider option, where you can supply an in-memory filesystem as provider. It's somewhat more awkward than simply using text/template directly though, where you can provide arbitrary structs or maps directly as the context. Speaking of which, if you just want to render templates programatically, you can just use text/template instead, and if you want the gomplate functions you can get them with gomplate.CreateFuncs.

There's a caveat too - v4 is not yet released, and there will be a few more breaking changes before it is. Thanks for this question though, because it highlights a particular difficulty in using gomplate programatically!

[phong2tran]

Thank you @hairyhenderson for the reply with suggestions on some alternative options!