讲师：李振良

官方网站： http://www.ctnrs.com

第三章：《Helm应用包管理器》 下

说明：

  1. 强烈建议学习课堂视频，更多细节都在里面！
  2. 本文档为内部学员资料，请不要随意转发。

3.6 Chart模板

Helm最核心的就是模板，即模板化的K8S manifests文件。

它本质上就是一个Go的template模板。Helm在Go template模板的基础上，还会增加很多东西。如一些自定义的元数据信息、扩展的库以及一些类似于编程形式的工作流，例如条件语句、管道等等。这些东西都会使得我们的模板变得更加丰富。

1、模板

有了模板，我们怎么把我们的配置融入进去呢？用的就是这个values文件。这两部分内容其实就是chart的核心功能。

接下来，部署nginx应用，熟悉模板使用，先把templates 目录下面所有文件全部删除掉，这里我们自己来创建模板文件：

  1. # rm -rf mychart/templates/*
  2. # vi templates/deployment.yaml
  3. apiVersion: apps/v1
  4. kind: Deployment
  5. metadata:
  6.   name: nginx
  7. spec:
  8.   replicas: 1
  9.   selector:
  10.     matchLabels:
  11.       app: nginx
  12.   template:
  13.     metadata:
  14.       labels:
  15.         app: nginx
  16.     spec:
  17.       containers:
  18.       - image: nginx:1.16
  19.         name: nginx

实际上，这已经是一个可安装的Chart包了，通过 helm install命令来进行安装：

  1. # helm install web mychart

这样部署，其实与直接apply没什么两样。

然后使用如下命令可以看到实际的模板被渲染过后的资源文件：

  1. # helm get manifest web

可以看到，这与刚开始写的内容是一样的，包括名字、镜像等，我们希望能在一个地方统一定义这些会经常变换的字段，这就需要用到Chart的模板了。

  1. # vi templates/deployment.yaml 
  2. apiVersion: apps/v1
  3. kind: Deployment
  4. metadata:
  5.   name: {{ .Release.Name }}-deployment
  6. spec:
  7.   replicas: 1
  8.   selector:
  9.     matchLabels:
  10.       app: nginx
  11.   template:
  12.     metadata:
  13.       labels:
  14.         app: nginx
  15.     spec:
  16.       containers:
  17.       - image: nginx:1.16
  18.         name: nginx

这个deployment就是一个Go template的模板，这里定义的Release模板对象属于Helm内置的一种对象，是从values文件中读取出来的。这样一来，我们可以将需要变化的地方都定义变量。

再执行helm install chart 可以看到现在生成的名称变成了web-deployment，证明已经生效了。也可以使用命令helm get manifest查看最终生成的文件内容。

2、调试

Helm也提供了--dry-run --debug调试参数，帮助你验证模板正确性。在执行helm install时候带上这两个参数就可以把对应的values值和渲染的资源清单打印出来，而不会真正的去部署一个release。

比如我们来调试上面创建的 chart 包：

  1. # helm install web2 --dry-run /root/mychart

3、内置对象

刚刚我们使用 {{.Release.Name}}将 release 的名称插入到模板中。这里的 Release 就是 Helm 的内置对象，下面是一些常用的内置对象：

Release.Name release 名称
Release.Name release 名字
Release.Namespace release 命名空间
Release.Service release 服务的名称
Release.Revision release 修订版本号，从1开始累加

4、Values

Values对象是为Chart模板提供值，这个对象的值有4个来源：

  • chart 包中的 values.yaml 文件

  • 父 chart 包的 values.yaml 文件

  • 通过 helm install 或者 helm upgrade 的 -f或者 --values参数传入的自定义的 yaml 文件

  • 通过 --set 参数传入的值

chart 的 values.yaml 提供的值可以被用户提供的 values 文件覆盖，而该文件同样可以被 --set提供的参数所覆盖。

这里我们来重新编辑 mychart/values.yaml 文件，将默认的值全部清空，然后添加一个副本数：

  1. # cat values.yaml 
  2. replicas: 3
  3. image: "nginx"
  4. imageTag: "1.17"
  6. # cat templates/deployment.yaml 
  7. apiVersion: apps/v1
  8. kind: Deployment
  9. metadata:
  10.   name: {{ .Release.Name }}-deployment
  11. spec:
  12.   replicas: {{ .Values.replicas }}
  13.   selector:
  14.     matchLabels:
  15.       app: nginx
  16.   template:
  17.     metadata:
  18.       labels:
  19.         app: nginx
  20.     spec:
  21.       containers:
  22.       - image: {{ .Values.image }}:{{ .Values.imageTag }}
  23.         name: nginx

查看渲染结果：

  1. # helm install --dry-run web ../mychart/

values 文件也可以包含结构化内容，例如：

  1. # cat values.yaml 
  2. ...
  3. label:
  4.   project: ms
  5.   app: nginx
  7. # cat templates/deployment.yaml 
  8. apiVersion: apps/v1
  9. kind: Deployment
  10. metadata:
  11.   name: {{ .Release.Name }}-deployment 
  12. spec:
  13.   replicas: {{ .Values.replicas }} 
  14.   selector:
  15.     matchLabels:
  16.       project: {{ .Values.label.project }}
  17.       app: {{ .Values.label.app }}
  18.   template:
  19.     metadata:
  20.       labels:
  21.         project: {{ .Values.label.project }}
  22.         app: {{ .Values.label.app }}
  23.     spec:
  24.       containers:
  25.       - image: {{ .Values.image }}:{{ .Values.imageTag }} 
  26.         name: nginx

查看渲染结果：

  1. # helm install --dry-run web ../mychart/

5、管道与函数

前面讲的模块，其实就是将值传给模板引擎进行渲染，模板引擎还支持对拿到数据进行二次处理。

例如从.Values中读取的值变成字符串，可以使用quote函数实现：

  1. # vi templates/deployment.yaml
  2. app: {{ quote .Values.label.app }}
  3. # helm install --dry-run web ../mychart/ 
  4.         project: ms
  5.         app: "nginx"

quote .Values.label.app 将后面的值作为参数传递给quote函数。

模板函数调用语法为：functionName arg1 arg2…

另外还会经常使用一个default函数，该函数允许在模板中指定默认值，以防止该值被忽略掉。

例如忘记定义，执行helm install 会因为缺少字段无法创建资源，这时就可以定义一个默认值。

  1. # cat values.yaml 
  2. replicas: 2
  3. # cat templates/deployment.yaml 
  4. apiVersion: apps/v1
  5. kind: Deployment
  6. metadata:
  7.   name: {{ .Release.Name }}-deployment
  1. - name: {{ .Values.name | default "nginx" }}

其他函数：

缩进：{{ .Values.resources | indent 12 }}

大写：{{ upper .Values.resources }}

首字母大写：{{ title .Values.resources }}

6、流程控制

流程控制是为模板提供了一种能力，满足更复杂的数据逻辑处理。

Helm模板语言提供以下流程控制语句：

  • if/else 条件块
  • with 指定范围
  • range 循环块

if

if/else块是用于在模板中有条件地包含文本块的方法，条件块的基本结构如下：

  1. {{ if PIPELINE }}
  2.   # Do something
  3. {{ else if OTHER PIPELINE }}
  4.   # Do something else
  5. {{ else }}
  6.   # Default case
  7. {{ end }}

示例：

  1. # cat values.yaml 
  2. devops: k8
  4. # cat templates/deployment.yaml 
  5. ...
  6.   template:
  7.     metadata:
  8.       labels:
  9.         app: nginx
  10.         {{ if eq .Values.devops "k8s" }}
  11.         devops: 123
  12.         {{ else }}
  13.         devops: 456
  14.         {{ end }}

在上面条件语句使用了eq运算符判断是否相等，除此之外，还支持ne、 lt、 gt、 and、 or等运算符。

通过模板引擎来渲染一下，会得到如下结果：

  1. # helm install --dry-run web ../mychart/ 
  2. ...
  3.       labels:
  4.         app: nginx
  6.         devops: 456

可以看到渲染出来会有多余的空行，这是因为当模板引擎运行时，会将控制指令删除，所有之前占的位置也就空白了，需要使用{{- if …}} 的方式消除此空行：

  1. # cat templates/deploymemt.yaml
  2. ...
  3.         env:
  4.         {{- if eq .Values.env.hello "world" }}
  5.           - name: hello
  6.             value: 123
  7.         {{- end }}

现在是不是没有多余的空格了，如果使用-}}需谨慎，比如上面模板文件中：

  1. # cat templates/deploymemt.yaml
  2. ...
  3.        env:
  4.         {{- if eq .Values.env.hello "world" -}}
  5.            - hello: true
  6.         {{- end }}

这会渲染成：

  1.         env:- hello: true

因为-}}它删除了双方的换行符。

条件判断就是判断条件是否为真，如果值为以下几种情况则为false：

  • 一个布尔类型的 假

  • 一个数字 零

  • 一个 空的字符串

  • 一个 nil（空或 null）

  • 一个空的集合（ map、 slice、 tuple、 dict、 array）

除了上面的这些情况外，其他所有条件都为 真。

例如，判断一个空的数组

  1. # cat values.yaml 
  2. resources: {}
  3.   # limits:
  4.   #   cpu: 100m
  5.   #   memory: 128Mi
  6.   # requests:
  7.   #   cpu: 100m
  8.   #   memory: 128Mi
  1. # cat templates/deploymemt.yaml
  2. ...
  3.     spec:
  4.       containers:
  5.       - image: nginx:1.16
  6.         name: nginx
  7.         {{- if .Values.resources }}
  8.         resources:
  9. {{ toYaml .Values.resources | indent 10 }}
  10.         {{- end }}

例如，判断一个布尔值

  1. # cat values.yaml 
  2. service:
  3.   type: ClusterIP
  4.   port: 80
  6. ingress:
  7.   enabled: true 
  8.   host: example.ctnrs.com
  10. # cat templates/ingress.yaml 
  11. {{- if .Values.ingress.enabled -}}
  12. apiVersion: networking.k8s.io/v1beta1
  13. kind: Ingress
  14. metadata:
  15.   name: {{ .Release.Name }}-ingress
  16. spec:
  17.   rules:
  18.   - host: {{ .Values.ingress.host }}
  19.     http:
  20.       paths:
  21.       - path: /
  22.         backend:
  23.           serviceName: {{ .Release.Name }}
  24.           servicePort: {{ .Values.service.port }}
  25. {{ end }}

with

with ：控制变量作用域。

还记得之前我们的 {{.Release.xxx}}或者 {{.Values.xxx}}吗？其中的 .就是表示对当前范围的引用， .Values就是告诉模板在当前范围中查找 Values对象的值。而 with语句就可以来控制变量的作用域范围，其语法和一个简单的 if语句比较类似：

  1. {{ with PIPELINE }}
  2.   #  restricted scope
  3. {{ end }}

with语句可以允许将当前范围 .设置为特定的对象，比如我们前面一直使用的 .Values.label，我们可以使用 with来将 .范围指向 .Values.label：

  1. # cat values.yaml 
  2. ...
  3. replicas: 3
  4. label:
  5.   project: ms
  6.   app: nginx
  8. # cat templates/deployment.yaml 
  9. apiVersion: apps/v1
  10. kind: Deployment
  11. metadata:
  12.   name: {{ .Release.Name }}-deployment
  13. spec:
  14.   replicas: 1
  15.   selector:
  16.     matchLabels:
  17.       app: nginx
  18.   template:
  19.     metadata:
  20.       labels:
  21.         app: nginx
  22.     spec:
  23.       {{- with .Values.nodeSelector }}
  24.       nodeSelector:
  25.         team: {{ .team }}
  26.         gpu: {{ .gpu }}
  27.       {{- end }}
  28.       containers:
  29.       - image: nginx:1.16
  30.         name: nginx

优化后：

  2.       {{- with .Values.nodeSelector }}
  3.       nodeSelector:
  4.         {{- toYaml . | nindent 8 }}
  5.       {{- end }}

上面增加了一个{{- with .Values.label }} xxx {{- end }}的一个块，这样的话就可以在当前的块里面直接引用 .team和 .gpu了。

with是一个循环构造。使用.Values.nodeSelector中的值：将其转换为Yaml。

toYaml之后的点是循环中.Values.nodeSelector的当前值

range

在 Helm 模板语言中，使用 range关键字来进行循环操作。

我们在 values.yaml文件中添加上一个变量列表：

  1. # cat values.yaml 
  2. test:
  3.   - 1
  4.   - 2
  5.   - 3

循环打印该列表：

  1. apiVersion: v1
  2. kind: ConfigMap
  3. metadata:
  4.   name: {{ .Release.Name }}
  5. data:
  6.   test: |
  7.   {{- range .Values.test }}
  8.     {{ . }}
  9.   {{- end }}

循环内部我们使用的是一个 .，这是因为当前的作用域就在当前循环内，这个 .引用的当前读取的元素。

7、变量

接下来学习一个语言中基本的概念：变量，在模板中，使用变量的场合不多，但我们将看到如何使用它来简化代码，并更好地利用with和range。

问题1：获取列表键值

  1. # cat ../values.yaml
  2. env:
  3.   NAME: "gateway"
  4.   JAVA_OPTS: "-Xmx1G"
  6. # cat deployment.yaml 
  7. ...
  8.         env:
  9.         {{- range $k, $v := .Values.env }}
  10.            - name: {{ $k }}
  11.              value: {{ $v | quote }}
  12.         {{- end }}

结果如下：

  1.     env:
  2.        - name: JAVA_OPTS
  3.          value: "-Xmx1G"
  4.        - name: NAME
  5.          value: "gateway"

上面在 range循环中使用 $key和 $value两个变量来接收后面列表循环的键和值。

问题2：with中不能使用内置对象

with语句块内不能再 .Release.Name对象，否则报错。

我们可以将该对象赋值给一个变量可以来解决这个问题：

  1. apiVersion: apps/v1
  2. kind: Deployment
  3. metadata:
  4.   name: {{ .Release.Name }}-deployment
  5. spec:
  6.   replicas: {{ .Values.replicas }}
  7.   template:
  8.     metadata:
  9.       labels:
  10.         project: {{ .Values.label.project }}
  11.         app: {{ quote .Values.label.app }}
  12.       {{- with .Values.label }}
  13.         project: {{ .project }}
  14.         app: {{ .app }}
  15.         release: {{ .Release.Name }}
  16.       {{- end }}

上面会出错。

  1.       {{- $releaseName := .Release.Name -}}
  2.       {{- with .Values.label }}
  3.         project: {{ .project }}
  4.         app: {{ .app }}
  5.         release: {{ $releaseName }}
  6.         # 或者可以使用$符号,引入全局命名空间
  7.         release: {{ $.Release.Name }}
  8.       {{- end }}

可以看到在 with语句上面增加了一句 {{-$releaseName:=.Release.Name-}}，其中 $releaseName就是后面的对象的一个引用变量，它的形式就是 $name，赋值操作使用 :=，这样 with语句块内部的 $releaseName变量仍然指向的是 .Release.Name

8、命名模板

命名模板：使用define定义，template引入，在templates目录中默认下划线_开头的文件为公共模板(_helpers.tpl)

  1. # cat _helpers.tpl
  2. {{- define "demo.fullname" -}}
  3. {{- .Chart.Name -}}-{{ .Release.Name }}
  4. {{- end -}}
  6. # cat deployment.yaml 
  7. apiVersion: apps/v1
  8. kind: Deployment
  9. metadata:
  10.   name: {{ template "demo.fullname" . }}
  11. ...

template指令是将一个模板包含在另一个模板中的方法。但是，template函数不能用于Go模板管道。为了解决该问题，增加include功能。

  1. # cat _helpers.tpl
  2. {{- define "demo.labels" -}}
  3. app: {{ template "demo.fullname" . }}
  4. chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
  5. release: "{{ .Release.Name }}"
  6. {{- end -}}
  8. # cat deployment.yaml 
  9. apiVersion: apps/v1
  10. kind: Deployment
  11. metadata:
  12.   name: {{ include "demo.fullname" . }}
  13.   labels:
  14.     {{- include "demo.labels" . | nindent 4 }}
  15. ...

上面包含一个名为 demo.labels 的模板，然后将值 . 传递给模板，最后将该模板的输出传递给 nindent 函数。

3.7 开发自己的Chart：Java应用为例

  1. 先创建模板
    1. helm create demo

  1. 修改Chart.yaml，Values.yaml，添加常用的变量

  2. 在templates目录下创建部署镜像所需要的yaml文件，并变量引用yaml里经常变动的字段

3.8 使用Harbor作为Chart仓库

1、启用Harbor的Chart仓库服务

  1. # ./install.sh --with-chartmuseum

启用后，默认创建的项目就带有helm charts功能了。

2、安装push插件

https://github.com/chartmuseum/helm-push

  1. helm plugin install https://github.com/chartmuseum/helm-push

3、添加repo

  1. helm repo add  --username admin --password Harbor12345 myrepo http://192.168.31.70/chartrepo/library

4、推送与安装Chart

  1. # helm push mysql-1.4.0.tgz --username=admin --password=Harbor12345 http://192.168.31.70/chartrepo/library
  2. # helm install web --version 1.4.0 myrepo/demo

讲师：李振良

官方网站： http://www.ctnrs.com