blob: 32da205108de3ff0a536ad3cbc626cfb1242e7ac (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
Kontemplate templates
=====================
The template file format is based on Go's [templating engine][] in combination
with a small extension library called [sprig][] that adds additional template
functions.
Go templates can either simply display variables or build more complicated
*pipelines* in which variables are passed to functions for further processing,
or in which conditionals are evaluated for more complex template logic.
It is recommended that you check out the Golang [documentation][] for the templating
engine in addition to the cherry-picked features listed here.
<!-- markdown-toc start - Don't edit this section. Run M-x markdown-toc-refresh-toc -->
**Table of Contents**
- [Kontemplate templates](#kontemplate-templates)
- [Basic variable interpolation](#basic-variable-interpolation)
- [Example:](#example)
- [Template functions](#template-functions)
- [Examples:](#examples)
- [Conditionals & ranges](#conditionals--ranges)
- [Caveats](#caveats)
<!-- markdown-toc end -->
## Basic variable interpolation
The basic template format uses `{{ .variableName }}` as the interpolation format.
### Example:
Assuming that you include a resource set as such:
```
- name: api-gateway
values:
internalHost: http://my-internal-host/
```
And the api-gateway resource set includes a ConfigMap (some fields left out for
the example):
```
# api-gateway/configmap.yaml:
---
kind: ConfigMap
metadata:
name: api-gateway-config
data:
internalHost: {{ .internalHost }}
```
The resulting output will be:
```
---
kind: ConfigMap
metadata:
name: api-gateway-config
data:
internalHost: http://my-internal-host/
```
## Template functions
Go templates support template functions which you can think of as a sort of
shell-like pipeline where text flows through transformations from left to
right.
Some template functions come from Go's standard library and are listed in the
[Go documentation][]. In addition the functions declared by [sprig][] are
available in kontemplate, as well as five custom functions:
* `json`: Encodes any supplied data structure as JSON.
* `gitHEAD`: Retrieves the commit hash at Git `HEAD`.
* `passLookup`: Looks up the supplied key in [pass][].
* `insertFile`: Insert the contents of the given file in the resource
set folder as a string.
* `insertTemplate`: Insert the contents of the given template in the resource
set folder as a string.
## Examples:
```
# With the following values:
name: Donald
certKeyPath: my-website/cert-key
# The following interpolations are possible:
{{ .name | upper }}
-> DONALD
{{ .name | upper | repeat 2 }}
-> DONALD DONALD
{{ .certKeyPath | passLookup }}
-> Returns content of 'my-website/cert-key' from pass
{{ gitHEAD }}
-> Returns the Git commit hash at HEAD.
```
## Conditionals & ranges
Some logic is supported in Golang templates and can be used in Kontemplate, too.
With the following values:
```
useKube2IAM: true
servicePorts:
- 8080
- 9090
```
The following interpolations are possible:
```
# Conditionally insert something in the template:
metadata:
annotations:
foo: bar
{{ if .useKube2IAM -}} iam.amazonaws.com/role: my-api {{- end }}
```
```
# Iterate over a list of values
ports:
{{ range .servicePorts }}
- port: {{ . }}
{{ end }}
```
Check out the Golang documentation (linked above) for more information about template logic.
## Caveats
Kontemplate does not by itself parse any of the content of the templates, which
means that it does not validate whether the resources you supply are valid YAML
or JSON.
You can perform some validation by using `kontemplate apply --dry-run` which
will make use of the Dry-Run functionality in `kubectl`.
[templating engine]: https://golang.org/pkg/text/template/
[documentation]: https://golang.org/pkg/text/template/
[sprig]: http://masterminds.github.io/sprig/
[Go documentation]: https://golang.org/pkg/text/template/#hdr-Functions
[pass]: https://www.passwordstore.org/
|
