Helm课程资料

 

第一章.helm介绍、组件、安装和目录结构

1.helm3课程简介

helm3课程简介
第一章.helm介绍、组件、安装和目录结构
第二章.编写一个chart和helm内置对象详解
第三章.helm3常用命令和部署应用实战案例
第四章.helm3内置函数详解
第五章.流控制结构语句
第六章.helm3中变量详解
第七章.helm3中子模板的定义和使用
第八章.helm3中获取其他文件的内容或文件名

2.什么是helm和相关组件

1.环境准备
需要准备一套k8s的集群，helm主要是k8s集群的包管理器，主要用来管理helm中的各种chart包。
2.传统服务部署到k8s集群的流程
拉取代码——> 打包编译——>构建镜像——>准备一堆相关部署的yaml文件(如:deployment、service、ingress等)——>kubectl apply 部署到k8s集群
3.传统方式部署引发的问题
1).随着引用的增多，需要维护大量的yaml文件
2).不能根据一套yaml文件来创建多个环境，需要手动进行修改。
例如：一般环境都分为dev、预生产、生产环境，部署完了dev这套环境，后面再部署预生产和生产环境，还需要复制出两套，并手动修改才行。
3.什么是helm
Helm是Kubernetes 的包管理工具，可以方便地发现、共享和构建 Kubernetes 应用
helm是k8s的包管理器，相当于centos系统中的yum工具，可以将一个服务相关的所有资源信息整合到一个chart包中，并且可以使用一套资源发布到多个环境中， 可以将应用程序的所有资源和部署信息组合到单个部署包中。
就像Linux下的rpm包管理器，如yum/apt等，可以很方便的将之前打包好的yaml文件部署到kubernetes上。
4.helm的组件
1).Chart: 就是helm的一个整合后的chart包，包含一个应用所有的kubernetes声明模版，类似于yum的rpm包或者apt的dpkg文件。
理解:
helm将打包的应用程序部署到k8s,并将它们构建成Chart。这些Chart将所有预配置的应用程序资源以及所有版本都包含在一个易于管理的包中。
Helm把kubernetes资源(如deployments、services或ingress等) 打包到一个chart中,chart被保存到chart仓库。通过chart仓库可用来存储和分享chart
2).Helm客户端: helm的客户端组件，负责和k8s apiserver通信
3).Repository: 用于发布和存储chart包的仓库，类似yum仓库或docker仓库
4).Release: 用chart包部署的一个实例。通过chart在k8s中部署的应用都会产生一个唯一的Release. 同一chart部署多次就会产生多个Release.
理解：
将这些yaml部署完成后，他也会记录部署时候的一个版本，维护了一个release版本状态，通过Release这个实例，他会具体帮我们创建pod，deployment等资源
5.helm3和helm2的区别
1).helm3移除了Tiller组件 helm2中helm客户端和k8s通信是通过Tiller组件和k8s通信,helm3移除了Tiller组件,直接使用kubeconfig文件和k8s的apiserver通信
2).删除 release 命令变更
#helm delete release-name --purge ------------>> helm uninstall release-name
3).查看 charts 信息命令变更
#helm inspect release-name ------------>> helm show release-name
4).拉取 charts 包命令变更
#helm fetch chart-name ------------->> helm pull chart-name
5).helm3中必须指定 release 名称，如果需要生成一个随机名称，需要加选项--generate-name，helm2中如果不指定release名称，可以自动生成一个随机名称
#helm install ./mychart --generate-name

 

3.helm3的安装和chart的目录结构

1.二进制方式安装helm3
# kubectl get node
NAME STATUS ROLES AGE VERSION
m1 Ready control-plane,master 257d v1.20.4
m2 Ready control-plane,master 257d v1.20.4
m3 Ready control-plane,master 257d v1.20.4
n1 Ready <none> 257d v1.20.4
# wget https://get.helm.sh/helm-v3.5.2-linux-amd64.tar.gz 
# ls helm-v3.5.2-linux-amd64.tar.gz
helm-v3.5.2-linux-amd64.tar.gz
# tar -zxf helm-v3.5.2-linux-amd64.tar.gz
# ls
helm-v3.5.2-linux-amd64.tar.gz linux-amd64
# ls linux-amd64/
helm LICENSE README.md
# mv linux-amd64/helm /usr/local/bin/
# helm version
version.BuildInfo{Version:"v3.5.2", GitCommit:"167aac70832d3a384f65f9745335e9fb40169dc2", GitTreeState:"dirty", GoVersion:"go1.15.7"}
2.chart的目录结构
# helm create mychart #创建一个chart，指定chart名：mychart
# tree mychart/
mychart/ #chart包的名称
├── charts #存放子chart的目录，目录里存放这个chart依赖的所有子chart
├── Chart.yaml #保存chart的基本信息，包括名字、描述信息及版本等，这个变量文件都可以被templates目录下文件所引用
├── templates #模板文件目录，目录里面存放所有yaml模板文件，包含了所有部署应用的yaml文件
│   ├── deployment.yaml #创建deployment对象的模板文件
│   ├── _helpers.tpl #放置模板助手的文件，可以在整个chart中重复使用，是放一些templates目录下这些yaml都有可能会用的一些模板
│   ├── hpa.yaml
│   ├── ingress.yaml
│   ├── NOTES.txt #存放提示信息的文件,介绍chart帮助信息,helm install部署后展示给用户.如何使用chart等,是部署chart后给用户的提示信息
│   ├── serviceaccount.yaml
│   ├── service.yaml
│   └── tests #用于测试的文件，测试完部署完chart后，如web，做一个链接，看看你是否部署正常
│   └── test-connection.yaml
└── values.yaml #用于渲染模板的文件（变量文件，定义变量的值） 定义templates目录下的yaml文件可能引用到的变量
#values.yaml用于存储 templates 目录中模板文件中用到变量的值，这些变量定义都是为了让templates目录下yaml引用
3.Chart.yaml 文件字段说明
# cat Chart.yaml
apiVersion: v2
name: mychart
description: A Helm chart for Kubernetes
# A chart can be either an 'application' or a 'library' chart.
#
# Application charts are a collection of templates that can be packaged into versioned archives
# to be deployed.
#
# Library charts provide useful utilities or functions for the chart developer. They're included as
# a dependency of application charts to inject those utilities and functions into the rendering
# pipeline. Library charts do not define any templates and therefore cannot be deployed.
type: application
# This is the chart version. This version number should be incremented each time you make changes
# to the chart and its templates, including the app version.
# Versions are expected to follow Semantic Versioning (https://semver.org/)
version: 0.1.0
# This is the version number of the application being deployed. This version number should be
# incremented each time you make changes to the application. Versions are not expected to
# follow Semantic Versioning. They should reflect the version the application is using.
# It is recommended to use it with quotes.
appVersion: "1.16.0"
详细字段说明：
apiVersion: # chart API 版本信息, 通常是 "v2" (必须) appVersion字段与version 字段并没有直接的联系。这是指定应用版本的一种方式
#对于部分仅支持helm3的chart，apiVersion应该指定为v2。对于可以同时支持helm3和helm2版本的chart,可以将其设置为v1
name: # chart 的名称 (必须)
version: # chart 包的版本 (必须)，version 字段用于指定 chart 包的版本号，后续更新 chart 包时候也需要同步更新这个字段
kubeVersion: # 指定kubernetes 版本(可选) 用于指定受支持的kubernetes版本,helm在安装时候会验证版本信息。
type: # chart类型(可选) v2版新增了type 字段,用于区分chart类型,取值为application(默认)和library,如"应用类型chart"和"库类型chart"
description: # 对项目的描述 (可选)

第二章.编写一个chart和helm3内置对象详解

1.helm3创建编写一个chart

1.创建一个chart
使用helm create 命令即可创建一个chart，其中包含完整的目录结构
# helm create mychart
# tree mychart/
mychart/
├── charts
├── Chart.yaml
├── templates #chart的模板文件，根据需要自己改动或都删除掉后，编写自己需要的模板yaml文件即可
│   ├── deployment.yaml
│   ├── _helpers.tpl
│   ├── hpa.yaml
│   ├── ingress.yaml
│   ├── NOTES.txt
│   ├── serviceaccount.yaml
│   ├── service.yaml
│   └── tests
│   └── test-connection.yaml
└── values.yaml
2.编写一个chart,不引用内置对象的变量值(用helm3发布创建一个configmap,创建的k8s集群中,发布其他应用也一样,我们由浅入深进行学习)
# kubectl get node
NAME STATUS ROLES AGE VERSION
m1 Ready control-plane,master 252d v1.20.4
m2 Ready control-plane,master 252d v1.20.4
m3 Ready control-plane,master 252d v1.20.4
n1 Ready <none> 251d v1.20.4
1).创建一个chart包:
# helm create mychart #创建一个chart包，chart包名为： mychart 关于helm使用相关的命令，后续我们单独介绍
# cd mychart/
# ls
charts Chart.yaml templates values.yaml
# cd templates/
# ls
deployment.yaml _helpers.tpl hpa.yaml ingress.yaml NOTES.txt serviceaccount.yaml service.yaml tests
# rm -rf * #全部删除
# vim configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: mychart-configmap
data:
myvalue: "hello world"
# cd ~
2).创建一个release实例:
# helm install myconfigmap ./mychart/ #使用helm安装一个release的实例,指定release实例名: myconfigmap，指定chart目录./mychart
NAME: myconfigmap
LAST DEPLOYED: Fri Nov 25 23:55:17 2022
NAMESPACE: default
STATUS: deployed
REVISION: 1
TEST SUITE: None
3).查看创建后的相关信息和验证是否已经在k8s集群中创建了configmap
# helm get manifest myconfigmap #安装成功后,用helm get manifest release名 命令可以查看已经发布到k8s中的release信息
---
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: mychart-configmap
data:
myvalue: "hello world"
# helm list |grep myconfigmap #list列出创建的release实例名
myconfigmap default 1 2022-11-25 23:55:17.825536709 +0800 CST deployed mychart-0.1.0 1.16.0
# kubectl get configmap |grep mychart-configmap #查看使用helm发布后创建的configmap
mychart-configmap 1 11m
4).删除release实例
使用 helm uninstall release实例名 的命令来删除这个release，删除的时候直接指定release 名称即可
# helm uninstall myconfigmap #删除release实例，指定release的实例名: myconfigmap
# helm list |grep myconfigmap
空
# kubectl get configmap |grep mychart-configmap
空
3.编写一个chart,引用内置对象的变量值（用helm3发布创建一个configmap,创建的k8s集群中）
# kubectl get node
NAME STATUS ROLES AGE VERSION
m1 Ready control-plane,master 252d v1.20.4
m2 Ready control-plane,master 252d v1.20.4
m3 Ready control-plane,master 252d v1.20.4
n1 Ready <none> 251d v1.20.4
1).创建一个chart包:
# helm create mychart #创建一个chart包，chart包名为： mychart
# cd mychart/
# ls
charts Chart.yaml templates values.yaml
# cd templates/
# ls
deployment.yaml _helpers.tpl hpa.yaml ingress.yaml NOTES.txt serviceaccount.yaml service.yaml tests
# rm -rf * #全部删除
# vim configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap #最前面的.从作用域最顶层命名空间开始,即: 在顶层命名空间中开始查找Release对象,再查找Name对象
data: #上面就是通过内置对象获取获取内置对象的变量值(Release的名称)作为拼接成configmap的名字
myvalue: {{ .Values.MY_VALUE }}
# vim /root/mychart/values.yaml
MY_VALUE: "Hello World"
引用内置对象变量或其他变量（如values.yaml）的好处：
如果metadata.name 中设置的值是一个固定值,这样的模板是无法在k8s中多次部署的,所以我们可以试着在每次安装chart时,都自动metadata.name的值设置为release的名称，因为每次部署时候release实例名是不一样的，这样部署时候，里面的资源名也就可以作为一个区分，而可以进行重复部署。
2).创建一个release实例:
# helm install myconfigmap2 ./mychart/ #使用helm安装一个release的实例,指定release实例名: myconfigmap，指定chart目录./mychart
3).查看创建后的相关信息和验证是否已经在k8s集群中创建了configmap
# helm list |grep myconfigmap2 #list列出创建的release实例名
myconfigmap2 default 1 2022-11-26 00:38:03.139416104 +0800 CST deployed mychart-0.1.0 1.16.0
# kubectl get configmap |grep myconfigmap2 #查看使用helm发布后创建的configmap
myconfigmap2-configmap 1 2m40s
4).删除release实例
使用 helm uninstall release实例名 的命令来删除这个release，删除的时候直接指定release 名称即可
# helm uninstall myconfigmap2 #删除release实例，指定release的实例名: myconfigmap2
# helm list |grep myconfigmap2
空
# kubectl get configmap |grep myconfigmap2
空
4.helm的测试渲染命令 不真正执行，只是试运行看是否能运行
helm提供了一个用来渲染模板的命令，该命令可以将模板内容渲染出来，但是不会进行任何安装的操作。可以用该命令来测试模板渲染的内容是否正确。
用法： helm install release实例名 chart目录 --debug --dry-run
例： # helm install myconfigmap3 ./mychart/ --debug --dry-run
5.helm通过各种类型chart包安装一个release实例名来部署k8s相关的资源（如：pod,deployment,svc,ingress等,根据模板文件定义）
1).从加入到本地的chart官方仓库(从官方仓库安装)安装release实例
2).将从chart仓库拉下来的压缩包进行安装release实例（下载好的压缩包本地离线安装release）
3).将从chart仓库拉下来的压缩包解压后，从解压目录安装release实例（解压下载好的压缩包，从解压目录离线安装release实例）
4).从一个网络地址仓库压缩包直接安装release实例
#helm install db stable/mysql #从加入到本地的chart官方仓库(从官方仓库安装)安装release实例，db为release实例名
#helm install my-tomcat test-repo/tomcat #从加入到本地的chart社区仓库(从官方仓库安装)安装release实例，my-tomcat 为release实例名
#helm install db mysql-1.6.9.tgz #从chart仓库拉下来的压缩包进行安装release实例(从本地存档文件离线安装),db为release实例名
#helm install db mysql #从chart仓库拉下来的压缩包解压后，从解压目录安装release实例(从解压目录离线安装), db为release实例名
#helm install db http://url.../mysql-1.6.9.tgz #从一个网络地址仓库压缩包直接安装release实例(从下载服务器安装), db为release实例名
卸载release实例:
#helm uninstall release实例名 后面详细介绍命令

2.helm3的内置对象详解

1.helm3常用的内置对象
Release 对象
Values 对象
Chart 对象
Capabilities 对象
Template 对象
2.各内置对象详解
1).Release对象 描述了版本发布自身的一些信息。它包含了以下对象：
对象名称 描述
.Release.Name release 的名称
.Release.Namespace release 的命名空间
.Release.IsUpgrade 如果当前操作是升级或回滚的话，该值为 true
.Release.IsInstall 如果当前操作是安装的话，该值为 true
.Release.Revision 获取此次修订的版本号。初次安装时为 1，每次升级或回滚都会递增
.Release.Service 获取渲染当前模板的服务名称。一般都是 Helm
2).Values 对象 描述的是value.yaml 文件（定义变量的文件）中的内容，默认为空。使用Value 对象可以获取到value.yaml文件中已定义的任何变量数值
Value 键值对 获取方式
name1: test1 .Values.name1
info:
name2: test2 .Values.info.name2
3).Chart 对象 用于获取Chart.yaml 文件中的内容：
对象名称 描述
.Chart.Name 获取Chart 的名称
.Chart.Version 获取Chart 的版本
4).Capabilities对象 提供了关于kubernetes 集群相关的信息。该对象有如下方法：
对象名称 描述
.Capabilities.APIVersions 返回kubernetes集群 API 版本信息集合
.Capabilities.APIVersions.Has $version 用于检测指定的版本或资源在k8s集群中是否可用，例如：apps/v1/Deployment
.Capabilities.KubeVersion和.Capabilities.KubeVersion.Version 都用于获取kubernetes 的版本号
.Capabilities.KubeVersion.Major 获取kubernetes 的主版本号
.Capabilities.KubeVersion.Minor 获取kubernetes 的小版本号
5).Template对象 用于获取当前模板的信息，它包含如下两个对象
对象名称 描述
.Template.Name 用于获取当前模板的名称和路径（例如：mychart/templates/mytemplate.yaml）
.Template.BasePath 用于获取当前模板的路径（例如：mychart/templates）
3.各内置对象调用的演示
1).环境准备 k8s集群
# kubectl get node
NAME STATUS ROLES AGE VERSION
m1 Ready control-plane,master 252d v1.20.4
m2 Ready control-plane,master 252d v1.20.4
m3 Ready control-plane,master 252d v1.20.4
n1 Ready <none> 251d v1.20.4
2).创建一个chart包 (用helm3发布创建一个configmap,创建的k8s集群中,发布其他应用也一样)
# helm create mychart #创建一个chart包，chart包名为： mychart
# cd mychart/
# ls
charts Chart.yaml templates values.yaml
# cd templates/
# ls
deployment.yaml _helpers.tpl hpa.yaml ingress.yaml NOTES.txt serviceaccount.yaml service.yaml tests
# rm -rf * #全部删除
3).编写自己需要的yaml文件，调用上面各自内置对象获取相关变量的值
(1).调用Release对象 描述了版本发布自身的一些信息。
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
value1: "{{ .Release.IsUpgrade }}" #如果当前操作是升级或回滚的话,该值为true
value2: "{{ .Release.IsInstall }}" #如果当前操作是安装的话,该值为true
value3: "{{ .Release.Revision }}" #获取此次修订的版本号
value4: "{{ .Release.Service }}" #获取当前模板的服务名
# cd ~
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
NAME: myconfigmap1
LAST DEPLOYED: Sat Nov 26 09:53:13 2022
NAMESPACE: default
STATUS: pending-install
REVISION: 1
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
value1: "false" #如果当前操作是升级或回滚的话,该值为true
value2: "true" #如果当前操作是安装的话,该值为true
value3: "1" #获取此次修订的版本号
value4: "Helm" #获取当前模板的服务名
(2).调用Values对象 描述的是value.yaml 文件（定义变量的文件）中的内容
# vim /root/mychart/values.yaml #清空里面的初始化信息，设置成我们需要的（变量名和赋值）（里面默认的信息都是初始化信息，仅供参考）
name1: test1
info:
name2: test2
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
value1: "{{ .Values.name1 }}" #获取values.yaml文件中定义的变量的值
value2: "{{ .Values.info.name2 }}" #获取values.yaml文件中定义的层级变量的值
# cd ~
# helm install myconfigmap2 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
NAME: myconfigmap2
LAST DEPLOYED: Sat Nov 26 10:17:53 2022
NAMESPACE: default
STATUS: pending-install
REVISION: 1
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap2-configmap
namespace: default
data:
value1: "test1" #获取values.yaml文件中定义的变量的值
value2: "test2" #获取values.yaml文件中定义的层级变量的值
(3).调用Chart 对象 用于获取Chart.yaml 文件中的内容
# cat /root/mychart/Chart.yaml |grep -vE "#|^$" #先查看下Chart.yaml文件中内容中定义的变量
apiVersion: v2
name: mychart
description: A Helm chart for Kubernetes
type: application
version: 0.1.0
appVersion: "1.16.0"
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
value1: "{{ .Chart.Name }}" #获取Chart的名称,获取Chart.yaml文件中定义的变量的值
value2: "{{ .Chart.Version }}" #获取Chart的版本,获取Chart.yaml文件中定义的变量的值
# cd ~
# helm install myconfigmap3 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
NAME: myconfigmap3
LAST DEPLOYED: Sat Nov 26 10:26:02 2022
NAMESPACE: default
STATUS: pending-install
REVISION: 1
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap3-configmap
namespace: default
data:
value1: "mychart" #获取Chart的名称,获取Chart.yaml文件中定义的变量的值
value2: "0.1.0" #获取Chart的版本,获取Chart.yaml文件中定义的变量的值
(4).调用Capabilities对象 提供了关于kubernetes 集群相关的信息。该对象有如下方法
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
value1: "{{ .Capabilities.APIVersions }}" #返回kubernetes集群 API 版本信息集合
value2: '{{ .Capabilities.APIVersions.Has "apps/v1/Deployment" }}' #用于检测指定的版本或资源在k8s集群中是否可用
value3: "{{ .Capabilities.KubeVersion.Version }}" #用于获取kubernetes的版本号
value4: "{{ .Capabilities.KubeVersion.Major }}" #获取kubernetes 的主版本号
value5: "{{ .Capabilities.KubeVersion.Minor }}" #获取kubernetes 的小版本号
# cd ~
# helm install myconfigmap4 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
NAME: myconfigmap4
LAST DEPLOYED: Sat Nov 26 10:38:52 2022
NAMESPACE: default
STATUS: pending-install
REVISION: 1
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap4-configmap
namespace: default
data:
value1: "[authentication.k8s.io/v1 discovery.k8s.io/v1beta1 batch/v1/Job admissionregistration.k8s.io/v1 scheduling.k8s.io/v1 authorization.k8s.io/v1beta1/SelfSubjectAccessReview autoscaling/v2beta2/HorizontalPodAutoscaler batch/v1beta1 rbac.authorization.k8s.io/v1beta1 v1/Binding authentication.k8s.io/v1beta1/TokenReview autoscaling/v1/HorizontalPodAutoscaler rbac.authorization.k8s.io/v1beta1/ClusterRole autoscaling/v1 apiextensions.k8s.io/v1beta1 v1/ServiceAccount apiextensions.k8s.io/v1 authorization.k8s.io/v1beta1/SelfSubjectRulesReview rbac.authorization.k8s.io/v1beta1/Role admissionregistration.k8s.io/v1beta1/MutatingWebhookConfiguration v1/Endpoints apps/v1/DaemonSet extensions/v1beta1/Ingress apiregistration.k8s.io/v1 authentication.k8s.io/v1beta1 coordination.k8s.io/v1 v1/ReplicationController v1/Scale storage.k8s.io/v1beta1/CSINode batch/v1 events.k8s.io/v1/Event apiregistration.k8s.io/v1beta1 v1/PersistentVolume v1/PodProxyOptions storage.k8s.io/v1/CSINode certificates.k8s.io/v1 v1/PersistentVolumeClaim authorization.k8s.io/v1/LocalSubjectAccessReview authorization.k8s.io/v1beta1/LocalSubjectAccessReview rbac.authorization.k8s.io/v1/Role storage.k8s.io/v1/CSIDriver flowcontrol.apiserver.k8s.io/v1beta1 networking.k8s.io/v1/Ingress policy/v1beta1/PodDisruptionBudget apps/v1 v1/PodPortForwardOptions v1/Secret networking.k8s.io/v1/IngressClass authorization.k8s.io/v1 networking.k8s.io/v1beta1 node.k8s.io/v1/RuntimeClass extensions/v1beta1 node.k8s.io/v1beta1 v1/Service apiregistration.k8s.io/v1/APIService v1/PodTemplate certificates.k8s.io/v1/CertificateSigningRequest storage.k8s.io/v1 v1/Eviction apps/v1/StatefulSet storage.k8s.io/v1/StorageClass coordination.k8s.io/v1beta1/Lease v1 networking.k8s.io/v1 v1/ComponentStatus node.k8s.io/v1beta1/RuntimeClass certificates.k8s.io/v1beta1 v1/Pod v1/TokenRequest autoscaling/v2beta1/HorizontalPodAutoscaler discovery.k8s.io/v1beta1/EndpointSlice v1/PodExecOptions networking.k8s.io/v1/NetworkPolicy admissionregistration.k8s.io/v1/MutatingWebhookConfiguration coordination.k8s.io/v1/Lease v1/LimitRange v1/Node apiregistration.k8s.io/v1beta1/APIService authorization.k8s.io/v1/SelfSubjectRulesReview apiextensions.k8s.io/v1beta1/CustomResourceDefinition admissionregistration.k8s.io/v1beta1 v1/ConfigMap rbac.authorization.k8s.io/v1/RoleBinding apiextensions.k8s.io/v1/CustomResourceDefinition node.k8s.io/v1 v1/NodeProxyOptions policy/v1beta1/PodSecurityPolicy storage.k8s.io/v1beta1 networking.k8s.io/v1beta1/Ingress rbac.authorization.k8s.io/v1/ClusterRoleBinding rbac.authorization.k8s.io/v1beta1/RoleBinding scheduling.k8s.io/v1/PriorityClass v1/Event apps/v1/ReplicaSet storage.k8s.io/v1beta1/CSIDriver coordination.k8s.io/v1beta1 autoscaling/v2beta2 policy/v1beta1 authorization.k8s.io/v1beta1/SubjectAccessReview storage.k8s.io/v1beta1/VolumeAttachment flowcontrol.apiserver.k8s.io/v1beta1/FlowSchema flowcontrol.apiserver.k8s.io/v1beta1/PriorityLevelConfiguration events.k8s.io/v1 events.k8s.io/v1beta1 rbac.authorization.k8s.io/v1 authorization.k8s.io/v1/SubjectAccessReview networking.k8s.io/v1beta1/IngressClass rbac.authorization.k8s.io/v1/ClusterRole admissionregistration.k8s.io/v1beta1/ValidatingWebhookConfiguration authorization.k8s.io/v1beta1 scheduling.k8s.io/v1beta1 v1/PodAttachOptions v1/ResourceQuota authentication.k8s.io/v1/TokenReview storage.k8s.io/v1/VolumeAttachment apps/v1/Scale batch/v1beta1/CronJob rbac.authorization.k8s.io/v1beta1/ClusterRoleBinding admissionregistration.k8s.io/v1/ValidatingWebhookConfiguration scheduling.k8s.io/v1beta1/PriorityClass autoscaling/v2beta1 v1/Namespace authorization.k8s.io/v1/SelfSubjectAccessReview storage.k8s.io/v1beta1/StorageClass v1/ServiceProxyOptions apps/v1/ControllerRevision apps/v1/Deployment events.k8s.io/v1beta1/Event certificates.k8s.io/v1beta1/CertificateSigningRequest]"
#value1返回kubernetes集群 API 版本信息集合
value2: 'true' #用于检测指定的版本或资源在k8s集群中是否可用
value3: "v1.20.4" #用于获取kubernetes的版本号
value4: "1" #获取kubernetes 的主版本号
value5: "20" #获取kubernetes 的小版本号
(5).调用Template对象 用于获取当前模板的信息，它包含如下两个对象
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
value1: "{{ .Template.Name }}" #用于获取当前模板的名称和路径（例如：mychart/templates/configmap.yaml）
value2: "{{ .Template.BasePath }}" #用于获取当前模板的路径（例如：mychart/templates）
# cd ~
# helm install myconfigmap5 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
NAME: myconfigmap5
LAST DEPLOYED: Sat Nov 26 10:44:58 2022
NAMESPACE: default
STATUS: pending-install
REVISION: 1
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap5-configmap
namespace: default
data:
value1: "mychart/templates/configmap.yaml" #用于获取当前模板的名称和路径（例如：mychart/templates/configmap.yaml）
value2: "mychart/templates" #用于获取当前模板的路径（例如：mychart/templates）

 

第三章.helm3常用命令和部署应用实战案例

1.helm3的常用命令

1.helm的常用命令使用
version: 查看helm客户端版本
repo: 添加、列出、移除、更新和索引chart仓库，可用子命令:add、index、list、remove、update
search: 根据关键字搜索chart包
show: 查看chart包的基本信息和详细信息，可用子命令：all、chart、readme、values
pull: 从远程仓库中下载拉取chart包并解压到本地，如：# helm pull test-repo/tomcat --version 0.4.3 --untar ,--untar是解压,不加就是压缩包
create 创建一个chart包并指定chart包名字
install: 通过chart包安装一个release实例
list: 列出release实例名
upgrade: 更新一个release实例
rollback: 从之前版本回滚release实例，也可指定要回滚的版本号
uninstall: 卸载一个release实例
history: 获取release历史，用法： helm history release实例名
package: 将chart目录打包成chart存档文件中，例如: 假如我们修改 chart 后，需要将其进打包
# helm package /opt/helm/work/tomcat（chart的目录路径）
get: 下载一个release,可用子命令：all、hooks、manifest、notes、values
status: 显示release实例名的状态，显示已命名版本的状态
2.helm添加chart仓库和查看仓库 类似yum仓库或docker仓库
添加仓库:
可以添加多个仓库，添加仓库时候，记得起个仓库名，如：stable，aliyun,或其他，一般起个稳定版的stable会优先使用。
# helm repo add stable http://mirror.azure.cn/kubernetes/charts #添加微软的,强烈推荐
# helm repo add aliyun https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts #添加阿里云的
# helm repo add test-repo http://mirror.kaiyuanshe.cn/kubernetes/charts/ #添加开源社区的
# helm repo list #列出仓库
NAME URL
test-repo http://mirror.kaiyuanshe.cn/kubernetes/charts/ 
stable http://mirror.azure.cn/kubernetes/charts 
aliyun https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts
更新仓库：
# helm repo update #更新仓库,能更新添加的所有仓库
Hang tight while we grab the latest from your chart repositories...
...Successfully got an update from the "aliyun" chart repository
...Successfully got an update from the "test-repo" chart repository
...Successfully got an update from the "stable" chart repository
删除仓库： helm repo remove 仓库名
# helm repo remove test-repo
3.创建chart包:
# helm create mychart #创建一个chart包，chart包名为： mychart
4.搜索远程仓库的chart包、查看chart包信息、拉取远程仓库chart包到本地 类似docker search 搜索harbor仓库的镜像
(1)搜索chart包格式: helm search repo chart包名
示例：
# helm search repo tomcat
NAME CHART VERSION APP VERSION DESCRIPTION
stable/tomcat 0.4.3 7.0 DEPRECATED - Deploy a basic tomcat application ...
(2).查看chart包格式: helm show chart chart包名 或 helm show values chart包名 （查看详细信息)
示例:
# helm show chart stable/tomcat #查看chart包基础信息
apiVersion: v1
appVersion: "7.0"
deprecated: true
description: DEPRECATED - Deploy a basic tomcat application server with sidecar as web archive container
home: https://github.com/yahavb
icon: http://tomcat.apache.org/res/images/tomcat.png
name: tomcat
version: 0.4.3
# helm show values stable/tomcat #查看chart包详细信息
replicaCount: 1
image:
webarchive:
repository: ananwaresystems/webarchive
tag: "1.0"
tomcat:
repository: tomcat
tag: "7.0"
pullPolicy: IfNotPresent
pullSecrets: []
deploy:
directory: /usr/local/tomcat/webapps
service:
name: http
type: LoadBalancer
externalPort: 80
internalPort: 8080
hostPort: 8009
ingress:
enabled: false
annotations: {}
...
(3).拉取chart包格式:
# helm pull 远程仓库chart包名 --version 0.4.3 --untar #从远程仓库拉取指定版本的chart包到本地并解压,--untar是解压,不加就是压缩包
# helm pull 远程仓库chart包名 --untar #从远程仓库拉取最新版本的chart包到本地并解压,--untar是解压,不加就是压缩包
示例:
# helm pull stable/tomcat --untar
# helm pull test-repo/tomcat --version 0.4.3 --untar #从远程仓库拉取指定版本的chart包到本地并解压
# ls tomcat/
Chart.yaml README.md templates values.yaml
# helm pull test-repo/tomcat --untar #从远程仓库拉取最新版本的chart包到本地并解压
# ls tomcat/
Chart.yaml README.md templates values.yaml
5.helm通过各种类型chart包安装一个release实例名来部署k8s相关的资源（如：pod,deployment,svc,ingress等,根据模板文件定义）
1).从加入到本地的chart官方仓库(从官方仓库在线安装)安装release实例
2).将从chart仓库拉下来的压缩包进行安装release实例（下载好的压缩包本地离线安装release）
3).将从chart仓库拉下来的压缩包解压后，从解压目录安装release实例（解压下载好的压缩包，从解压目录离线安装release实例）
4).从一个网络地址（如http服务器）仓库压缩包直接安装release实例
5).在本地创建一个chart包，通过自定义编辑自己的yaml文件后，通过本地chart包进行安装release实例
#helm search repo tomcat
#helm install tomcat1 stable/tomcat #从加入到本地的chart社区仓库(从官方仓库在线安装)安装release实例，tomcat1为release实例名
#helm install tomcat2 tomcat-0.4.3.tgz #从chart仓库拉下来的压缩包进行安装release实例(从本地存档文件离线安装),
#helm install tomcat3 tomcat #从chart仓库拉下来的压缩包解压后，从解压目录安装release实例(从解压目录离线安装),
#helm install db http://url.../mysql-1.6.9.tgz #从一个网络地址仓库压缩包直接安装release实例(从下载服务器安装), db为release实例名
卸载release实例:
#helm uninstall release实例名 后面详细介绍命令
6.helm基本命令使用（主要三个命令）
install 安装release实例（实际就是k8s应用的安装）
upgrade 升级release实例（实际就是k8s应用的升级）
rollback 回滚release实例（实际就是k8s应用的回滚）

 

2.helm3部署应用的实战案例(发布、升级、回滚、卸载)

1.回顾一下常用的helm基本命令使用（主要三个命令）
install 安装release实例（实际就是k8s应用的安装）
upgrade 升级release实例（实际就是k8s应用的升级）
rollback 回滚release实例（实际就是k8s应用的回滚）
安装release实例: (上面已经介绍了从多种角度进行安装release实例，下面我们以其中一种进行安装演示）
# helm create chart名 #指定chart名，创建一个chart包，通过对chart里template的yaml文件自定义编写成自己需要的后再进行安装
# helm install release实例名 chart目录路径 #指定release实例名和chart包目录路径进行安装release实例
示例：
# helm create mychart #创建一个chart包，chart包名为： mychart
# helm install test-release ./mychart #指定release实例名和chart包目录路径进行安装release实例
升级release实例:
# helm upgrade release实例名 chart名 --set imageTag=1.19 #指定release名和chart名进行相关set设置的升级
# helm upgrade release实例名 chart名 -f /.../mychart/values.yaml #指定release示例名和chart名和values.yaml文件升级
示例:
# helm upgrade test-release-nginx mychart --set imageTag=1.19 #指定release实例名和chart名set升级
# helm upgrade test-release-nginx mychart -f /root/heml/mychart/values.yaml #指定release示例名和chart名和values.yaml文件升级
回滚release实例:
# helm rollback release实例名     #指定release实例名,回滚到上一个版本
# helm rollback release实例名 版本号 #指定release实例名,回滚到指定版本，注意版本号是release的版本号，不是镜像版本号
示例:
# helm rollback web-nginx   
# helm rollback web-nginx   1.17.10
获取release实例历史：
# helm history release实例名
示例:
# helm history test #test为release实例名
REVISION UPDATED STATUS CHART APP VERSION DESCRIPTION
1 Sun Nov 27 12:34:52 2022 deployed tomcat-0.4.3 7.0 Install complete
卸载release实例:
#helm uninstall release实例名
示例：
#helm uninstall test-release-nginx #uninstall 直接跟release名,卸载release实例
2.helm3部署自定义的应用实战案例（发布、升级、回滚、卸载） 以部署nginx服务为例，其他应用都类似
1).准备环境 k8s集群
[root@m1 ~] kubectl get node
NAME STATUS ROLES AGE VERSION
m1 Ready control-plane,master 253d v1.20.4
m2 Ready control-plane,master 253d v1.20.4
m3 Ready control-plane,master 253d v1.20.4
n1 Ready <none> 253d v1.20.4
2).创建一个模板的chart包，删除原来的内容，自定义成我们自己需要的内容，后面我们自定义部署的yaml文件
[root@m1 ~] helm create nginx-chart
[root@m1 ~]# ls
nginx-chart
[root@m1 ~]# cd nginx-chart/
[root@m1 nginx-chart]# ls
charts Chart.yaml templates values.yaml
[root@m1 nginx-chart]# > values.yaml #清空所有默认定义的变量，后面我们根据需要自定义
[root@m1 nginx-chart]# rm -rf templates/* #删除原来所有默认的部署yaml文件，后面我们根据需要自定义
自定义部署的模板yaml文件:
[root@m1 nginx-chart]# vim templates/nginx-deploy-service.yaml #自定义需要的yaml模板文件，deployment和svc，通过nodeport暴露
apiVersion: apps/v1
kind: Deployment
metadata:
name: {{ .Values.deployment_name }}
spec:
replicas: {{ .Values.replicas }}
selector:
matchLabels:
app: {{ .Values.pod_label }}
template:
metadata:
labels:
app: {{ .Values.pod_label }}
spec:
containers:
- image: {{ .Values.image }}:{{ .Values.imageTag }}
name: {{ .Values.container_name }}
ports:
- containerPort: {{ .Values.containerport }}
---
apiVersion: v1
kind: Service
metadata:
name: {{ .Values.service_name }}
namespace: {{ .Values.namespace }}
spec:
type: NodePort
ports:
- port: {{ .Values.port }}
targetPort: {{ .Values.targetport }}
nodePort: {{ .Values.nodeport }}
protocol: TCP
selector:
app: {{ .Values.pod_label }}
root@m1 nginx-chart]# vim values.yaml #自定义需要的变量文件
deployment_name: nginx-deployment
replicas: 2
pod_label: nginx-pod-label
image: nginx
imageTag: 1.17
container_name: nginx-container
service_name: nginx-service
namespace: default
port: 80
targetport: 80
containerport: 80
nodeport: 30001
3).通过chart包安装一个release实例（即部署一个k8s的nginx应用，版本为:1.17）
[root@m1 ~]# ls nginx-chart/
charts Chart.yaml templates values.yaml
[root@m1 ~]# helm install nginx-release ./nginx-chart/ #安装一个release实例,实例名: nginx-release
NAME: nginx-release
LAST DEPLOYED: Sun Nov 27 14:37:52 2022
NAMESPACE: default
STATUS: deployed
REVISION: 1
TEST SUITE: None
[root@m1 ~]# helm list #列出release实例
NAME NAMESPACE REVISION UPDATED STATUS CHART APP VERSION
nginx-release default 1 2022-11-27 14:37:52.390161033 +0800 CST deployed nginx-chart-0.1.0 1.16.0
[root@m1 ~]# kubectl get pod,svc,ep #查看部署的k8s应用（nginx服务)
NAME READY STATUS RESTARTS AGE
pod/nginx-deployment-5c8469b67f-5pq8m 1/1 Running 0 59s
pod/nginx-deployment-5c8469b67f-j8c7v 1/1 Running 0 59s
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/kubernetes ClusterIP 10.1.0.1 <none> 443/TCP 253d
service/nginx-service NodePort 10.1.28.254 <none> 80:30001/TCP 59s
NAME ENDPOINTS AGE
endpoints/kubernetes 192.168.27.128:6443,192.168.27.129:6443,192.168.27.130:6443 253d
endpoints/nginx-service 10.244.3.16:80,10.244.3.17:80 59s
[root@m1 ~]# kubectl get pod nginx-deployment-5c8469b67f-5pq8m -o yaml |grep image: #查看部署pod的镜像版本
f:image: {}
- image: nginx:1.17
image: nginx:1.17
[root@m1 ~]# curl -I 10.1.28.254
HTTP/1.1 200 OK
Server: nginx/1.17.10
可以通过nodeport方式访问： 在浏览器输入： http://192.168.27.131:30001/ 也可访问到
4).升级release实例版本（将nginx版本1.17升级为1.20.0）
[root@m1 ~]# vim nginx-chart/values.yaml #修改变量文件，指定相应版本
deployment_name: nginx-deployment
replicas: 2
pod_label: nginx-pod-label
image: nginx
imageTag: 1.20.0
container_name: nginx-container
service_name: nginx-service
namespace: default
port: 80
targetport: 80
containerport: 80
nodeport: 30001
# helm upgrade nginx-release nginx-chart -f /root/nginx-chart/values.yaml #指定release实例名和chart名和values.yaml文件升级
Release "nginx-release" has been upgraded. Happy Helming!
NAME: nginx-release
LAST DEPLOYED: Sun Nov 27 14:41:12 2022
NAMESPACE: default
STATUS: deployed
REVISION: 2
TEST SUITE: None
或使用: helm upgrade nginx-release nginx-chart --set imageTag=1.20 指定release实例名和chart名set升级
[root@m1 ~]# helm list #升级后查看
NAME NAMESPACE REVISION UPDATED STATUS CHART APP VERSION
nginx-release default 2 2022-11-27 14:41:12.755644465 +0800 CST deployed nginx-chart-0.1.0 1.16.0
[root@m1 ~]# kubectl get pod,svc,ep #升级后查看
NAME READY STATUS RESTARTS AGE
pod/nginx-deployment-7dd78bf775-lh558 1/1 Running 0 67s
pod/nginx-deployment-7dd78bf775-t4v98 1/1 Running 0 68s
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/kubernetes ClusterIP 10.1.0.1 <none> 443/TCP 253d
service/nginx-service NodePort 10.1.28.254 <none> 80:30001/TCP 4m28s
NAME ENDPOINTS AGE
endpoints/kubernetes 192.168.27.128:6443,192.168.27.129:6443,192.168.27.130:6443 253d
endpoints/nginx-service 10.244.3.18:80,10.244.3.19:80 4m28s
[root@m1 ~]# kubectl get pod nginx-deployment-7dd78bf775-lh558 -o yaml |grep image: #查看升级后部署的版本
f:image: {}
- image: nginx:1.20.0
image: nginx:1.20.0
5).回滚release实例版本（将nginx版本1.20.0回滚为1.17）
# helm rollback release实例名     #指定release实例名,回滚到上一个版本
# helm rollback release实例名 版本号 #指定release实例名,回滚到指定版本，注意版本号是release的版本号，不是镜像版本号
a).回滚到上一个版本:
[root@m1 ~]# helm rollback nginx-release #回滚到上一个版本,指的是release的版本，不是镜像版本
Rollback was a success! Happy Helming!
[root@m1 ~]# helm list #回滚后查看
NAME NAMESPACE REVISION UPDATED STATUS CHART APP VERSION
nginx-release default 3 2022-11-27 14:44:14.618247802 +0800 CST deployed nginx-chart-0.1.0 1.16.0
[root@m1 ~]# kubectl get pod,svc,ep #回滚后查看
NAME READY STATUS RESTARTS AGE
pod/nginx-deployment-5c8469b67f-7tw8c 1/1 Running 0 2m29s
pod/nginx-deployment-5c8469b67f-h4mbv 1/1 Running 0 2m28s
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/kubernetes ClusterIP 10.1.0.1 <none> 443/TCP 253d
service/nginx-service NodePort 10.1.28.254 <none> 80:30001/TCP 8m51s
NAME ENDPOINTS AGE
endpoints/kubernetes 192.168.27.128:6443,192.168.27.129:6443,192.168.27.130:6443 253d
endpoints/nginx-service 10.244.3.20:80,10.244.3.21:80 8m51s
[root@m1 ~]# kubectl get pod nginx-deployment-5c8469b67f-7tw8c -o yaml |grep image: #查看回滚后部署的版本
f:image: {}
- image: nginx:1.17
image: nginx:1.17
b).回滚到指定版本
release版本1 镜像: 1.17
release版本2 镜像:1.20.0
release版本3 镜像: 1.17 (回滚到1.17后，release版本也会增加)
目前是release版本3，对应镜像: 1.17版本，现在要将版本回滚到指定版本2,对应镜像：1.20.0
[root@m1 ~]# helm list
NAME NAMESPACE REVISION UPDATED STATUS CHART APP VERSION
nginx-release default 3 2022-11-27 14:44:14.618247802 +0800 CST deployed nginx-chart-0.1.0 1.16.0
[root@m1 ~]# helm rollback nginx-release 2 #回滚到指定的版本,指的是release的版本，不是镜像版本
Rollback was a success! Happy Helming!
[root@m1 ~]# helm list
NAME NAMESPACE REVISION UPDATED STATUS CHART APP VERSION
nginx-release default 4 2022-11-27 14:52:42.547226093 +0800 CST deployed nginx-chart-0.1.0 1.16.0
[root@m1 ~]# kubectl get pod,svc,ep #回滚后查看
NAME READY STATUS RESTARTS AGE
pod/nginx-deployment-7dd78bf775-sklx6 1/1 Running 0 43s
pod/nginx-deployment-7dd78bf775-xmjp4 1/1 Running 0 42s
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/kubernetes ClusterIP 10.1.0.1 <none> 443/TCP 253d
service/nginx-service NodePort 10.1.28.254 <none> 80:30001/TCP 15m
NAME ENDPOINTS AGE
endpoints/kubernetes 192.168.27.128:6443,192.168.27.129:6443,192.168.27.130:6443 253d
endpoints/nginx-service 10.244.3.22:80,10.244.3.23:80 15m
[root@m1 ~]# kubectl get pod nginx-deployment-7dd78bf775-sklx6 -o yaml |grep image: #查看回滚后部署的版本
f:image: {}
- image: nginx:1.20.0
image: nginx:1.20.0
6).卸载删除release实例
[root@m1 ~]# helm list
NAME NAMESPACE REVISION UPDATED STATUS CHART APP VERSION
nginx-release default 5 2022-11-27 14:54:53.057933249 +0800 CST deployed nginx-chart-0.1.0 1.16.0
[root@m1 ~]# helm uninstall nginx-release #卸载删除release实例
[root@m1 ~]# helm list
NAME NAMESPACE REVISION UPDATED STATUS CHART APP VERSION
空

第四章.helm3内置函数详解
1.helm3的内置函数简单介绍

1.常用的helm3内置函数
(1).quote 或 squote函数
(2). upper 和 lower 函数
(3). repeat 函数
(4). default 函数
(5). lookup 函数
2.函数的使用格式
格式1： 函数名 arg1 arg2 ...， 然而在实际的使用中，我们更偏向于使用管道符 | 来将参数传递给函数
格式2： arg1 | 函数名 这样使用可以使结构看起来更加直观，并且可以方便使用多个函数对数据进行链式处理。
3.各内置函数使用的演示
1).环境准备 k8s集群
# kubectl get node
NAME STATUS ROLES AGE VERSION
m1 Ready control-plane,master 252d v1.20.4
m2 Ready control-plane,master 252d v1.20.4
m3 Ready control-plane,master 252d v1.20.4
n1 Ready <none> 251d v1.20.4
2).创建一个chart包 (用helm3发布创建一个configmap,创建的k8s集群中,发布其他应用也一样)
# helm create mychart #创建一个chart包，chart包名为： mychart
# cd mychart/
# ls
charts Chart.yaml templates values.yaml
# cd templates/
# ls
deployment.yaml _helpers.tpl hpa.yaml ingress.yaml NOTES.txt serviceaccount.yaml service.yaml tests
# rm -rf * #全部删除
3).编写自己需要的yaml文件，使用上面的各个内置函数演示
(1). quote和squote函数 通过向quote或squote函数中传递一个参数，即可为这个参数(调用的变量值)添加一个双引号（quote）或单引号（squote）
# vim /root/mychart/values.yaml #定义变量和赋值
name: test
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件，调用values.yaml的变量，并使用相应函数加双引号或单引号
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
value1: {{ quote .Values.name }} #调用的变量值添加一个双引号(quote)
value2: {{ squote .Values.name }} #调用的变量值添加一个单引号(squote)
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
NAME: myconfigmap1
LAST DEPLOYED: Sat Nov 26 11:23:56 2022
NAMESPACE: default
STATUS: pending-install
REVISION: 1
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
value1: "test" #调用的变量值添加一个双引号(quote)
value2: 'test' #调用的变量值添加一个单引号(squote)
函数的使用格式:
通过前面的示例可以看到，函数的用法是： 函数名 arg1 arg2 ...，然而在实际的使用中，我们更偏向于使用管道符 | 来将参数传递给函数
也就是这种格式：arg1 | 函数名 这样使用可以使结构看起来更加直观，并且可以方便使用多个函数对数据进行链式处理。
使用格式2演示：（效果一样）
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件，调用values.yaml的变量，并使用相应函数加双引号或单引号
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
value1: {{ .Values.name | quote }} #调用的变量值添加一个双引号(quote)
value2: {{ .Values.name | squote }} #调用的变量值添加一个单引号(squote)
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
NAME: myconfigmap1
LAST DEPLOYED: Sat Nov 26 11:33:42 2022
NAMESPACE: default
STATUS: pending-install
REVISION: 1
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
value1: "test" #调用的变量值添加一个双引号(quote)
value2: 'test' #调用的变量值添加一个单引号(squote)
(2). upper 和 lower 函数 使用 upper 和 lower 函数可以分别将字符串转换为大写（upper）和小写字母（lower）的样式
# vim /root/mychart/values.yaml #定义变量和赋值
name1: test
name2: TEST
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件，调用values.yaml的变量，并使用相应函数
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
value1: {{ .Values.name1 | upper | quote }} #调用的变量值,转成大写(upper)且添加一个双引号(quote)
value2: {{ .Values.name2 | lower | squote }} #调用的变量值,转成小写(lower)且添加一个单引号(squote)
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
NAME: myconfigmap1
LAST DEPLOYED: Sat Nov 26 11:41:43 2022
NAMESPACE: default
STATUS: pending-install
REVISION: 1
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
value1: "TEST" #调用的变量值,转成大写(upper)且添加一个双引号(quote)
value2: 'test' #调用的变量值,转成小写(lower)且添加一个单引号(squote)
(3). repeat 函数 使用repeat 函数可以将指定字符串重复输出指定的次数，repeat 函数可以带有一个参数，用于设置重复多少次。
# vim /root/mychart/values.yaml #定义变量和赋值
name1: test
name2: TEST
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件，调用values.yaml的变量，并使用相应函数
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
value1: {{ .Values.name1 | repeat 3 | quote }} #调用的变量值,输出重复3次且添加一个双引号(quote)
value2: {{ .Values.name2 | repeat 2 | squote }} #调用的变量值,输出重复2次且添加一个单引号(squote)
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
NAME: myconfigmap1
LAST DEPLOYED: Sat Nov 26 11:50:43 2022
NAMESPACE: default
STATUS: pending-install
REVISION: 1
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
value1: "testtesttest" #调用的变量值,输出重复3次且添加一个双引号(quote)
value2: 'TESTTEST' #调用的变量值,输出重复2次且添加一个单引号(squote)
(4). default 函数 使用default函数指定一个默认值，这样当引入的值不存在时，就可以使用这个默认值
# vim /root/mychart/values.yaml #定义变量和赋值
name1: test
name2: TEST
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件，调用values.yaml的变量，并使用相应函数
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
value1: {{ .Values.location | default "beijing" | quote }} #调用的变量值,引用的变量location不存在时使用定义的默认值且添加一个双引号(quote)
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
NAME: myconfigmap1
LAST DEPLOYED: Sat Nov 26 11:57:57 2022
NAMESPACE: default
STATUS: pending-install
REVISION: 1
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
value1: "beijing" #调用的变量值,引用的值不存在时使用定义的默认值且添加一个双引号(quote)
(5). lookup 函数 使用lookup 函数用于在当前的k8s集群中获取一些资源的信息，功能有些类似于 kubectl get ...
函数的格式如下：
lookup "apiVersion" "kind" "namespace" "name" 其中"namespace"和"name" 都是可选的,或可以指定为空字符串"",函数执行完成后会返回特定的资源
常用格式和kubect命令相互对应关系：
kubectl命令 lookup 函数
kubectl get pod mypod -n mynamespace lookup "v1" "Pod" "mynamespace" "mypod"
kubectl get pods -n mynamespace lookup "v1" "Pod" "mynamespace" ""
kubectl get pods --all-namespaces lookup "v1" "Pod" "" ""
kubectl get namespace mynamespace lookup "v1" "Namespace" "" "mynamespace"
kubectl get namespaces lookup "v1" "Namespace" "" ""
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件，调用values.yaml的变量，并使用相应函数
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
value1: {{ lookup "v1" "Namespace" "" "" | quote }} #相当于: kubectl get namespaces，并加上双引号(quote )
# helm install myconfigmap1 ./mychart/ #需要安装后才能查看到相应信息
# helm get manifest myconfigmap1 #安装成功后,用helm get manifest release名 命令可以查看已经发布到k8s中的release信息
---
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
value1: "map[apiVersion:v1 items:[map[apiVersion:v1 kind:Namespace metadata:map[creationTimestamp:2022-03-18T15:53:41Z managedFields:[map[apiVersion:v1 fieldsType:FieldsV1 fieldsV1:map[f:status:map[f:phase:map[]]] manager:kube-apiserver operation:Update time:2022-03-18T15:53:41Z]] name:default resourceVersion:191 uid:70c41e0d-bd8b-4c5e-b6c2-ee685bb2490a] spec:map[finalizers:[kubernetes]] status:map[phase:Active]] map[apiVersion:v1 kind:Namespace metadata:map[creationTimestamp:2022-03-18T15:53:39Z managedFields:[map[apiVersion:v1 fieldsType:FieldsV1 fieldsV1:map[f:status:map[f:phase:map[]]] manager:kube-apiserver operation:Update time:2022-03-18T15:53:39Z]] name:kube-node-lease resourceVersion:19 uid:c1881771-e7ba-4073-a932-6dd9318f7f54] spec:map[finalizers:[kubernetes]] status:map[phase:Active]] map[apiVersion:v1 kind:Namespace metadata:map[creationTimestamp:2022-03-18T15:53:39Z managedFields:[map[apiVersion:v1 fieldsType:FieldsV1 fieldsV1:map[f:status:map[f:phase:map[]]] manager:kube-apiserver operation:Update time:2022-03-18T15:53:39Z]] name:kube-public resourceVersion:16 uid:84dac68e-0478-403a-bcb1-1f69a3040fe2] spec:map[finalizers:[kubernetes]] status:map[phase:Active]] map[apiVersion:v1 kind:Namespace metadata:map[creationTimestamp:2022-03-18T15:53:39Z managedFields:[map[apiVersion:v1 fieldsType:FieldsV1 fieldsV1:map[f:status:map[f:phase:map[]]] manager:kube-apiserver operation:Update time:2022-03-18T15:53:39Z]] name:kube-system resourceVersion:5 uid:7bf52f03-8834-4f53-b2b2-0464d764e4a0] spec:map[finalizers:[kubernetes]] status:map[phase:Active]]] kind:NamespaceList metadata:map[resourceVersion:51991]]" #相当于: kubectl get namespaces，并加上双引号(quote )
# helm uninstall myconfigmap1 #删除安装的release，清空环境

2.helm3的逻辑和流控制函数

1.常见的逻辑和流控制函数
eq： 用于判断两个参数是否相等，如果等于则为 true，不等于则为 false。
ne： 用于判断两个参数是否不相等，如果不等于则为 true，等于则为 false。
lt ： lt 函数用于判断第一个参数是否小于第二个参数，如果小于则为 true，如果大于则为 false。
le： 判断第一个参数是否小于等于第二个参数，如果成立则为 true，如果不成立则为 false。
gt： gt 函数用于判断第一个参数是否大于第二个参数，如果大于则为 true，如果小于则为 false。
ge： 判断第一个参数是否大于等于第二个参数，如果成立则为 true，如果不成立则为 false。
and： 返回两个参数的逻辑与结果（布尔值），也就是说如果两个参数为真，则结果为 true。否认哪怕一个为假，则返回false
or： 判断两个参数的逻辑或的关系，两个参数中有一个为真，则为真。返回第一个不为空的参数或者是返回后一个参数
not： 用于对参数的布尔值取反,如果参数是正常参数(非空)，正常为true，取反后就为false，参数是空的,正常是false，取反后是true
default： 用来设置一个默认值，在参数的值为空的情况下，则会使用默认值
empty： 用于判断给定值是否为空，如果为空则返回true
coalesce：用于扫描一个给定的列表，并返回第一个非空的值。
ternary： 接受两个参数和一个 test 值，如果test 的布尔值为 true，则返回第一个参数的值，如果test 的布尔值为false，则返回第二个参数的值
2.常用逻辑和流控制函数使用的演示
1).环境准备 k8s集群
# kubectl get node
NAME STATUS ROLES AGE VERSION
m1 Ready control-plane,master 252d v1.20.4
m2 Ready control-plane,master 252d v1.20.4
m3 Ready control-plane,master 252d v1.20.4
n1 Ready <none> 251d v1.20.4
2).创建一个chart包 (用helm3发布创建一个configmap,创建的k8s集群中,发布其他应用也一样)
# helm create mychart #创建一个chart包，chart包名为： mychart
# cd mychart/
# ls
charts Chart.yaml templates values.yaml
# cd templates/
# ls
deployment.yaml _helpers.tpl hpa.yaml ingress.yaml NOTES.txt serviceaccount.yaml service.yaml tests
# rm -rf * #全部删除
3).编写自己需要的yaml文件，使用上面的各个内置函数演示
(1). eq函数、ne函数 
分别含义如下：
eq函数： 用于判断两个参数是否相等，如果等于则为 true，不等于则为 false。
ne函数： 用于判断两个参数是否不相等，如果不等于则为 true，等于则为 false。
# vim /root/mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
value1: {{ eq 2 2 }} #使用eq函数判断两个参数是否相等,相等返回true,不等返回false
value2: {{ eq 2 1 }} #使用eq函数判断两个参数是否相等,相等返回true,不等返回false
value3: {{ ne 2 1 }} #使用nq函数判断两个参数是否不相等,不相等返回true,相等则返回false
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
value1: true #使用eq函数判断两个参数是否相等,相等返回true,不等返回false
value2: false #使用eq函数判断两个参数是否相等,相等返回true,不等返回false
value3: true #使用eq函数判断两个参数是否不相等,不相等返回true,相等则返回false
(2). lt函数、le函数、gt函数、ge函数 
分别含义如下：
lt ： lt 函数用于判断第一个参数是否小于第二个参数，如果小于则为 true，如果大于则为 false。
le： le判断第一个参数是否小于等于第二个参数，如果成立则为 true，如果不成立则为 false。
gt： gt函数用于判断第一个参数是否大于第二个参数，如果大于则为 true，如果小于则为 false。
ge： ge判断第一个参数是否大于等于第二个参数，如果成立则为 true，如果不成立则为 false。
# vim /root/mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
value1: {{ lt 1 2 }} #lt函数用于判断第一个参数是否小于第二个参数,如果小于则为true,如果大于则为false
value2: {{ le 2 1 }} #le判断第一个参数是否小于等于第二个参数,如果成立则为true,如果不成立则为false
value3: {{ gt 1 2 }} #gt函数用于判断第一个参数是否大于第二个参数,如果大于则为 true,如果小于则为false
value4: {{ ge 2 2 }} #ge判断第一个参数是否大于等于第二个参数,如果成立则为true,如果不成立则为false
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
value1: true #lt函数用于判断第一个参数是否小于第二个参数,如果小于则为true,如果大于则为false
value2: false #le判断第一个参数是否小于等于第二个参数,如果成立则为true,如果不成立则为false
value3: false #gt函数用于判断第一个参数是否大于第二个参数,如果大于则为 true,如果小于则为false
value4: true #ge判断第一个参数是否大于等于第二个参数,如果成立则为true,如果不成立则为false
(3). and函数 如果两个参数都返回为真，则结果为true，否认哪怕一个为假，则返回false
# vim /root/mychart/values.yaml #定义变量和赋值
name1: true
name2: false
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件，调用values.yaml的变量，并使用相应函数加双引号
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
value1: {{ and .Values.name1 .Values.name2 | quote }} #如果两个参数都返回为真,则结果为true,否认哪怕一个为假,则返回false
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
value1: "false" #如果两个参数都返回为真，则结果为true，否认哪怕一个为假，则返回false,并加上双引号(quote )
修改成两个都是true:
# vim /root/mychart/values.yaml #定义变量和赋值
name1: true
name2: true
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件，调用values.yaml的变量，并使用相应函数加双引号或单引号
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
value1: {{ and .Values.name1 .Values.name2 | quote }} #如果两个参数都返回为真,则结果为true,否认哪怕一个为假,则返回false,并加上双引号(quote )
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
value1: "true" #如果两个参数都返回为真，则结果为true，否认哪怕一个为假，则返回false,并加上双引号(quote )
(4). or函数 判断两个参数的逻辑或的关系,两个参数中有一个为真，则为真，会返回第一个不为空的参数或者是返回后一个参数
什么是空类型？主要有以下几种：
整型：0
字符串: ""
列表: []
字典: {}
布尔: false
以及所有的nil (或 null)
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件，并使用相应函数加双引号
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
value1: {{ or 1 "" 2 | quote }} #返回1,返回第一个不为空的参数或者是返回后一个参数,并加上双引号(quote )
value2: {{ or 1 2 "" | quote }} #返回1,返回第一个不为空的参数或者是返回后一个参数,并加上双引号(quote )
value3: {{ or "" 2 3 | quote }} #返回2,返回第一个不为空的参数或者是返回后一个参数,并加上双引号(quote )
value4: {{ or "" "" 3 | quote }} #返回3,返回第一个不为空的参数或者是返回后一个参数,并加上双引号(quote )
value5: {{ or "" "" "" | quote }} #返回空,返回第一个不为空的参数或者是返回后一个参数,并加上双引号(quote )
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
value1: "1" #返回1,返回第一个不为空的参数或者是返回后一个参数,并加上双引号(quote )
value2: "1" #返回1,返回第一个不为空的参数或者是返回后一个参数,并加上双引号(quote )
value3: "2" #返回2,返回第一个不为空的参数或者是返回后一个参数,并加上双引号(quote )
value4: "3" #返回3,返回第一个不为空的参数或者是返回后一个参数,并加上双引号(quote )
value5: "" #返回空,返回第一个不为空的参数或者是返回后一个参数,并加上双引号(quote )
(5). not函数 用于对参数的布尔值取反,如果参数是正常参数(非空)，正常为true，取反后就为false，参数是空的,正常是false，取反后是true
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件，并使用相应函数加双引号
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
type1: {{ not 2 | quote }} #用于对参数的布尔值取反,并加上双引号(quote )
type2: {{ not "" | quote }} #用于对参数的布尔值取反,并加上双引号(quote )
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
type1: "false" #用于对参数的布尔值取反,并加上双引号(quote )
type2: "true" #用于对参数的布尔值取反,并加上双引号(quote )
(6). default 函数 使用default函数指定一个默认值，这样当引入的值不存在时，就可以使用这个默认值
# vim /root/mychart/values.yaml #定义变量和赋值
name1: test
name2: TEST
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件，调用values.yaml的变量，并使用相应函数
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
value1: {{ .Values.address | default "bj" | quote }} #调用的变量值,引用的变量location不存在时使用定义的默认值且添加一个双引号(quote)
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
NAME: myconfigmap1
LAST DEPLOYED: Sat Nov 26 11:57:57 2022
NAMESPACE: default
STATUS: pending-install
REVISION: 1
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
value1: "bj" #调用的变量值,引用的值不存在时使用定义的默认值且添加一个双引号(quote)
(7). empty函数 用于判断给定值是否为空，如果为空则返回true，不为空返回false
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
type1: {{ 0 | empty }} #用于判断给定值是否为空，如果为空则返回true，0是空值
type2: {{ 1 | empty }} #用于判断给定值是否为空，如果为空则返回true
type3: {{ "" | empty }} #用于判断给定值是否为空，如果为空则返回true，""是空值
type4: {{ false | empty }} #用于判断给定值是否为空，如果为空则返回true，false是空值
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
type1: true #用于判断给定值是否为空，如果为空则返回true
type2: false #用于判断给定值是否为空，如果为空则返回true
type3: true #用于判断给定值是否为空，如果为空则返回true
type4: true #用于判断给定值是否为空，如果为空则返回true
(8). coalesce函数 用于扫描一个给定的列表，并返回第一个非空的值
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
type1: {{ coalesce 0 1 2 }} #用于扫描一个给定的列表，并返回第一个非空的值
type2: {{ coalesce "" false "Test" }} #用于扫描一个给定的列表，并返回第一个非空的值
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
type1: 1 #用于扫描一个给定的列表，并返回第一个非空的值
type2: Test #用于扫描一个给定的列表，并返回第一个非空的值
(9). ternary函数 接受两个参数和一个test 值,如果test 的布尔值为true,则返回第一个参数的值，如果test 的布尔值为false，则返回第二个参数的值
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
type1: {{ ternary "First" "Second" true }} #接受两个参数和一个 test值,如果test的布尔值为true,则返回第一个参数的值
type2: {{ ternary "First" "Second" false }} #接受两个参数和一个 test值,如果test的布尔值为false,则返回第二个参数的值
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
type1: First #接受两个参数和一个test值,如果test的布尔值为true,则返回第一个参数的值,如果test的布尔值为false,则返回第二个参数的值
type2: Second #接受两个参数和一个test值,如果test的布尔值为true,则返回第一个参数的值,如果test的布尔值为false,则返回第二个参数的值

3.helm3的字符串函数

1.常用helm3的字符串函数
(1). print 和 println函数
(2). printf函数
(3). trim函数、trimAll 函数、trimPrefix函数 和 trimSuffix函数
(4). lower函数、upper函数、title函数 和 untitle函数
(5). snakecase函数、camelcase函数 和 kebabcase函数
(6). swapcase函数
(7). substr函数
(8). trunc函数
(9). abbrev函数
(10). randAlphaNum函数、randAlpha函数、randNumeric函数 和 randAscii 函数
(11). contains函数
(12). hasPrefix函数 和 hasSuffix函数
(13).repeat函数、nospace函数 和 initials 函数
(14). wrapWith函数
(15). quote函数 和 squote 函数
(16). replace函数
(17). shuffle函数
(18). indent函数和 nindent函数
(19). plural 函数
2.常用helm3字符串函数使用的演示
1).环境准备 k8s集群
# kubectl get node
NAME STATUS ROLES AGE VERSION
m1 Ready control-plane,master 252d v1.20.4
m2 Ready control-plane,master 252d v1.20.4
m3 Ready control-plane,master 252d v1.20.4
n1 Ready <none> 251d v1.20.4
2).创建一个chart包 (用helm3发布创建一个configmap,创建的k8s集群中,发布其他应用也一样)
# helm create mychart #创建一个chart包，chart包名为： mychart
# cd mychart/
# ls
charts Chart.yaml templates values.yaml
# cd templates/
# ls
deployment.yaml _helpers.tpl hpa.yaml ingress.yaml NOTES.txt serviceaccount.yaml service.yaml tests
# rm -rf * #全部删除
3).编写自己需要的yaml文件，使用上面的各个内置函数演示
(1). print 和 println函数 print 和 println 函数用于将所有的参数按照字符串进行输出
与print 不同的是，println 会在每个字符串后面添加一个空格，并且会在输出的末尾添加一个换行符。如果参数中包含非字符串类型，那么输出的时候会转成字符串类型。当相邻两个参数不是字符串时，会在它们中间添加一个空格
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
type1: {{ print "this is" "test" "message" }}
type2: {{ println "this is" "test" "message" }}
type3: {{ print "this is" 2 3 "message" }}
#print 和 println 函数用于将所有的参数按照字符串进行输出
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
type1: this istestmessage #print打印出来的，不会在字符串之间添加空格
type2: this is test message
#println打印出来的，会在字符串之间添加一个空格，且会多打印一个空行，println打印后会在最后添加一个换行符
type3: this is2 3message #print打印出来的，不会在字符串之间添加空格，和type1一样
#print 和 println 函数用于将所有的参数按照字符串进行输出
(2). printf函数 用于格式化输出字符串内容，并且支持使用占位符。占位符取决于传入参数的类型。
printf 函数常用类型 - 整数
%b ：二进制
%c ：表示普通字符
%d ：十进制
%o ：8进制
%O ：带0o前缀的8进制
%q ：安全转义的单引号字符
%x ：16进制，使用小写字符a-f
%X ：16进制，使用小写字符A-F
%U ：Unicode格式： U+1234; 和"U+%04X"相同
printf 函数常用类型 - 浮点数
%b ：指数二次幂的无小数科学计数法，比如 -123456p-78
%e ：科学计数法，比如： -1.234456e+78
%E ：科学计数法，比如： -1.234456E+78
%f ：无指数的小数，比如： 123.456
%F ：与%f同义
%g ：%e的大指数，否则是%f
%G ：%E的大指数，否则是%F
%x ：十六进制计数法(和两个指数的十进制幂)，比如： -0x1.23abcp+20
%X ：大写的十六进制计数法，比如： -0X1.23ABCP+20
printf 函数常用类型 - 字符串
%s ：未解析的二进制字符串或切片
%q ：安全转义的双引号字符串
%x ：十六进制，小写，每个字节两个字符
%X ：十六进制，大写，每个字节两个字符
printf 函数常用类型 - 布尔值
%t ：输出指定的布尔值
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
type1: {{ printf "the bollean is %t" true }} #%t 布尔值占位符: 输出指定的布尔值
type2: {{ printf "the str is %s" "strtest" }} #%s 字符串占位符: 未解析的二进制字符串或切片
type3: {{ printf "the num is %d" 18 }} #%d 整数型占位符: 十进制
type4: {{ printf "the float is %.2f" 3.123 }} #%f 浮点数型占位符，保留两位小数
#printf 用于格式化输出字符串内容，并且支持使用占位符
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
type1: the bollean is true #%t 布尔值占位符: 输出指定的布尔值
type2: the str is strtest #%s 字符串占位符: 未解析的二进制字符串或切片
type3: the num is 18 #%d 整数型占位符: 十进制
type4: the float is 3.12 #%f 浮点数型占位符，保留两位小数
#printf 用于格式化输出字符串内容，并且支持使用占位符
(3). trim函数、trimAll 函数、trimPrefix函数 和 trimSuffix函数
分别含义如下：
trim函数： 可以用来去除字符串两边的空格，示例：trim " hello "
trimAll函数： 用于移除字符串中指定的字符，示例：trimAll "$" "$5.00"
trimPrefix 和 trimSuffix 函数： 分别用于移除字符串中指定的前缀和后缀：示例1：trimPrefix "-" "-hello" 示例2：trimSuffix "+" "hello+"
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ trim " Test " }} #trim函数可以用来去除字符串两边的空格
data2: {{ trimAll "%" "%Test" }} #trimAll函数用于移除字符串中指定的字符，此处指定的字符为"%"
data3: {{ trimPrefix "-" "-hello" }} #trimPrefix函数用于移除字符串中指定的前缀，此处指定的前缀是:"-"
data4: {{ trimSuffix "+" "hello+" }} #trimSuffix函数用于移除字符串中指定的后缀，此处指定的后缀是:"+"
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: Test #trim函数可以用来去除字符串两边的空格
data2: Test #trimAll函数用于移除字符串中指定的字符
data3: hello #trimPrefix函数用于移除字符串中指定的前缀
data4: hello #trimSuffix函数用于移除字符串中指定的后缀
(4). lower函数、upper函数、title函数 和 untitle函数
分别含义如下：
lower函数： 用于将所有字母转换成小写，示例1：lower "HELLO"
upper函数： 用于将所有字母转换成大写，示例2：upper "hello"
title函数： 用于将首字母转换成大写，示例3：title "test"
untitle函数: 用于将大写的首字母转换成小写，示例4：untitle "Test"
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ lower "HELLO" }} #lower函数用于将所有字母转换成小写
data2: {{ upper "hello" }} #upper函数用于将所有字母转换成大写
data3: {{ title "test" }} #title函数用于将首字母转换成大写
data4: {{ untitle "Test" }} #untitle函数用于将大写的首字母转换成小写
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: hello #lower函数用于将所有字母转换成小写
data2: HELLO #upper函数用于将所有字母转换成大写
data3: Test #title函数用于将首字母转换成大写
data4: test #untitle函数用于将大写的首字母转换成小写
(5). snakecase函数、camelcase函数 和 kebabcase函数
分别含义如下：
snakecase函数： 用于将驼峰写法转换为下划线命名写法， 示例：snakecase "UserName" # 返回结果 user_name
camelcase函数： 用于将下划线命名写法转换为驼峰写法，示例：camelcase "user_name" # 返回结果 UserName
kebabcase函数： 用于将驼峰写法转换为中横线写法，示例：kebabcase "UserName" # 返回结果 user-name
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ snakecase "UserName" }} #snakecase函数,用于将驼峰写法转换为下划线命名写法,返回结果 user_name
data2: {{ camelcase "user_name" }} #camelcase函数,用于将下划线命名写法转换为驼峰写法,返回结果 UserName
data3: {{ kebabcase "UserName" }} #kebabcase函数,用于将驼峰写法转换为中横线写法,返回结果 user-name
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: user_name #snakecase函数,用于将驼峰写法转换为下划线命名写法,返回结果 user_name
data2: UserName #camelcase函数,用于将下划线命名写法转换为驼峰写法,返回结果 UserName
data3: user-name #kebabcase函数,用于将驼峰写法转换为中横线写法,返回结果 user-name
(6). swapcase函数 作用是基于内置的算法来切换字符串的大小写
算法规则如下：
a).大写字符变成小写字母
b).首字母变成小写字母
c).空格后或开头的小写字母转换成大写字母
d).其他小写字母转换成大写字母
示例：swapcase "This Is A.Test" # 返回结果："tHIS iS a.tEST"
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ swapcase "This Is A.Test" }} #作用是基于内置的算法来切换字符串的大小写,返回结果："tHIS iS a.tEST"
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: tHIS iS a.tEST #作用是基于内置的算法来切换字符串的大小写,返回结果："tHIS iS a.tEST"
(7). substr函数 用于切割字符串（指定切割起、始位置），并且返回切割后的字串
该函数需要指定三个参数：
start (int)：起始位置，索引位置从0开始
end (int)：结束位置，索引位置从0开始
string (string)：需要切割的字符串
示例：substr 3 5 "message" #返回结果 "sa"
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ substr 3 5 "message" }} #substr函数用于切割字符串,起始位置:3,结束位置:5,并且返回切割后的字串,返回结果"sa"
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: sa #substr函数用于切割字符串,起始位置:3,结束位置:5,并且返回切割后的字串,返回结果"sa"
(8). trunc函数 用于截断字符串。trunc 可以使用正整数或负整数来分别表示从左向右截取的个数和从右向左截取的个数
示例：trunc 5 "Hello World" # 返回结果："Hello"
示例：trunc -5 "Hello World" # 返回结果："World"
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ trunc 5 "Hello World" }} #函数用于截断字符串,从左向右截取5个,返回结果："Hello"
data2: {{ trunc -5 "Hello World" }} #函数用于截断字符串,从右向左截取5个,返回结果："World"
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: Hello #函数用于截断字符串,从左向右截取5个,返回结果："Hello"
data2: World #函数用于截断字符串,从右向左截取5个,返回结果："World"
(9). abbrev函数 作用是使用省略号（...）切割字符串，保留指定的长度，注意省略号的长度是3个。其中省略号也是计算在长度之内的。
例如要将一个字符串保留长度为5，那么字符的个数只有两个，剩下三个是省略号。
示例：abbrev 5 "Hello World" # 返回结果："He..."
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ abbrev 5 "Hello World" }} #使用省略号（...）切割字符串，保留指定的长度，注意省略号的长度是3个,此处保留5个长度,结果:He...
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: He... #使用省略号（...）切割字符串，保留指定的长度，注意省略号的长度是3个,此处保留5个长度,结果:He...
(10). randAlphaNum函数、randAlpha函数、randNumeric函数 和 randAscii 函数 用于生成加密的随机字符串,指定生成的字符串长度（生成几个长度）
分别含义如下：
这四个函数用于生成加密的随机字符串，但是有如下区别：
randAlphaNum： 使用 0-9a-zA-Z，生成随机字符串
randAlpha： 使用 a-zA-Z，生成随机字符串
randNumeric： 使用 0-9，生成随机字符串
randAscii： 使用所有的可使用的 ASCII 字符，生成随机字符串
注意:
每个函数都需要传递一个参数用于指定生成的字符串长度： 示例：randNumeric 3
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ randAlphaNum 10 }} #randAlphaNum函数：使用 0-9a-zA-Z，生成随机字符串
data2: {{ randAlpha 10 }} #randAlpha函数： 使用 a-zA-Z，生成随机字符串
data3: {{ randNumeric 10 }} #randNumeric函数： 使用 0-9，生成随机字符串
data4: {{ randAscii 10 }} #randAscii函数： 使用所有的可使用的 ASCII 字符，生成随机字符串
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: Sg3P8PwYNw #randAlphaNum函数：使用 0-9a-zA-Z，生成随机字符串
data2: aZaGlBFjIF #randAlpha函数： 使用 a-zA-Z，生成随机字符串
data3: 4065269165 #randNumeric函数： 使用 0-9，生成随机字符串
data4: r'~WV3d.z= #randAscii函数： 使用所有的可使用的 ASCII 字符，生成随机字符串
(11). contains函数 用于测试一个字符串是否包含在另一个字符串里面，返回布尔值，true或false，包含返回true，不包含返回false
示例：contains "llo" "Hello" # 结果返回 true
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ contains "llo" "Hello" }} #用于测试一个字符串是否包含在另一个字符串里面，返回布尔值，true或false,结果:true
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
---
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: true #用于测试一个字符串是否包含在另一个字符串里面，返回布尔值，true或false,包含在里面，结果:true
(12). hasPrefix函数 和 hasSuffix函数 这两个函数用于测试一个字符串是否是指定字符串的前缀或者后缀,返回布尔值,true或false,包含返回true,不包含返回false
示例：hasPrefix "He" "Hello" # 判断前缀，是前缀，结果返回 true
示例：hasSuffix "le" "Hello" # 判断后缀，不是后缀，结果返回 false
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ hasPrefix "He" "Hello" }} #测试一个字符串是否是指定字符串的前缀,返回布尔值,true或false,结果:true
data2: {{ hasSuffix "le" "Hello" }} #测试一个字符串是否是指定字符串的后缀,返回布尔值,true或false,结果:false
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: true #测试一个字符串是否是指定字符串的前缀，返回布尔值，true或false，是前缀，结果:true
data2: false #测试一个字符串是否是指定字符串的后缀，返回布尔值，true或false，不是后缀，结果:false
(13).repeat函数、nospace函数 和 initials 函数
分别含义如下：
repeat函数用于将字符串重复输出指定的次数 示例：repeat 3 "Hello" # 结果返回 HelloHelloHello
nospace函数用于去掉字符串中所有的空格 示例：nospace "T e s t" # 返回 Test
initials函数用于截取指定字符串的每个单词的首字母，并拼接在一起 示例：initials "People Like Peace" # 返回 PLP
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ repeat 3 "Hello" }} #repeat函数用于将字符串重复输出指定的次数,结果: HelloHelloHello
data2: {{ nospace "T e s t" }} #nospace函数用于去掉字符串中所有的空格
data3: {{ initials "People Like Peace" }} #initials函数用于截取指定字符串的每个单词的首字母,并拼接在一起,结果:PLP
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: HelloHelloHello #repeat函数用于将字符串重复输出指定的次数,结果: HelloHelloHello
data2: Test #nospace函数用于去掉字符串中所有的空格
data3: PLP #initials函数用于截取指定字符串的每个单词的首字母,并拼接在一起,结果:PLP
(14). wrapWith函数 作用是在文档中在指定的列数添加内容，例如添加内容: "\t"
示例：wrapWith 5 "\t" "HelloWorld", 会在第五个索引的位置添加"\t"，所以结果为："Hello World"
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ wrapWith 5 "\t" "HelloWorld" }} #会在第五个索引的位置添加"\t"，所以结果为："Hello World"
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: Hello World #会在第五个索引的位置添加"\t"，所以结果为："Hello World"
(15). quote函数 和 squote 函数 该函数将字符串用双引号（quote） 或者单引号（squote）括起来
示例：quote hello 示例：squote hello
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ hello | quote }} #该函数将字符串用双引号（quote）括起来,结果: "hello"
data2: {{ hello | squote }} #该函数将字符串用单引号（squote）括起来,结果: 'hello'
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: "Hello!" #该函数将字符串用双引号（quote）括起来,结果: "hello"
data2: 'Hello!' #该函数将字符串用单引号（squote）括起来,结果: 'hello'
(14). cat 函数 用于将多个字符串合并成一个字符串，并使用空格分隔开
示例：cat "Hello" "World" , 结果: Hello World
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ cat "Hello" "World" }} #cat函数用于将多个字符串合并成一个字符串,并使用空格分隔开,结果: Hello World
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: Hello World #cat函数用于将多个字符串合并成一个字符串,并使用空格分隔开,结果: Hello World
(16). replace函数 用于执行简单的字符串替换。该函数需要传递三个参数:待替换的字符串、将要替换的字符串、源字符串
第1个参数： 待替换的字符串
第2个参数： 将要替换的字符串
第3个参数： 源字符串
示例："I Am Test" | replace " " "-" # 返回结果：I-Am-Test
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ "I Am Test" | replace " " "-" }} #执行简单的字符串替换.该函数需要传递三个参数:待替换的字符串、将要替换的字符串、源字符串,结果:I-Am-Test
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: I-Am-Test #执行简单的字符串替换.该函数需要传递三个参数:待替换的字符串、将要替换的字符串、源字符串,结果:I-Am-Test
(17). shuffle函数 用于对字符串中的字符进行重新排序,是基于他内部的一个算法
示例：shuffle "Hello"
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ shuffle "Hello" }} #用于对字符串中的字符进行重新排序
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: Helol #用于对字符串中的字符进行重新排序
(18). indent函数和 nindent函数 用于以指定长度来缩进指定字符串的所在行。其中nindent 函数可以在缩进时在字符串开头添加新行。
示例：indent 4 "this is indent"
示例：nindent 4 "this is nindent"
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: | #定义多行字符串时候用|
{{ nindent 4 "this is nindent" }}
{{ indent 4 "this is indent" }}
#indent函数 和 nindent函数,用法一样，都是用于以指定的长度缩进来缩进指定字符串的所在行。
#区别是: nindent函数可以在缩进时在字符串开头添加新行,也就是在该行字符串上方会添加一行新的空行。
#注意:上面两各都有两部分缩进,{{前面已经手动缩进了4个字符,后面又指定了4个字符的缩进,结果:应该有8个字符缩进)，indent是8个字符
#但是由于nindent会在缩进时在字符串开头添加新行,也就是在该行字符串上方会添加一行新的空行，然后另起一行，所有另起的结果还是缩进4个字符
#一般为了防止麻烦，一般indent和nindent所在行都顶格写最好。
#注意:执行报错，将注释删掉，重新执行
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: |
#一个新的空行
this is nindent #另开一行，还是缩进4个字符
this is indent #原来的行，共缩进8个字符
(19). plural 函数 判断字符串的长度,并且根据长度返回不同的值.如:字符串的长度为1会返回plural 函数的第一个参数,若不是1则返回第二个参数(包括0)
示例：len "a" | plural "one" "many" # 结果返回 one
示例：len "abc" | plrual "one" "many" # 结果返回 many
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ len "a" | plural "one" "many" }} #字符串长度为1,返回第1个参数,结果返回one
data2: {{ len "abc" | plural "one" "many" }} #字符串长度不为1,返回第2个参数,结果返回many
data3: {{ len "" | plural "one" "many" }} #字符串长度不为1(为0),返回第2个参数,结果返回many
#字符串的长度为1会返回plural函数的第一个参数,如果不是1则返回第二个参数(包括0)
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: one #字符串长度为1,返回第1个参数,结果返回one
data2: many #字符串长度不为1,返回第2个参数,结果返回many
data3: many #字符串长度不为1(为0),返回第2个参数,结果返回many
#字符串的长度为1会返回plural函数的第一个参数,如果不是1则返回第二个参数(包括0)
4.helm3的类型转换和正则表达式函数

1.常用helm3的类型转换函数和正则表达式函数
类型转换函数:（常用的有下面标演示的）
atoi函数： 将字符串转换为整型
float64函数： 转换成 float64 类型
int函数： 转换为 int 类型
toString函数： 转换成字符串
int64函数： 转换成 int64 类型
toDecimal函数： 将 unix 八进制转换成 int64
toStrings函数： 将列表、切片或数组转换成字符串列表
toJson函数 (mustToJson)： 将列表、切片、数组、字典或对象转换成JSON
toPrettyJson函数 (mustToPrettyJson)： 将列表、切片、数组、字典或对象转换成格式化JSON
toRawJson函数(mustToRawJson)： 将列表、切片、数组、字典或对象转换成JSON（HTML字符不转义）
正则表达式函数:
regexFind函数 和 mustRegexFind函数
regexFindAll函数 和 mustRegexFindAll函数
regexMatch函数 和 mustRegexMatch函数
regexReplaceAll函数 和 mustRegexReplaceAll函数
regexReplaceAllLiteral函数 和 mustRegexReplaceAllLiteral函数
regexSplit函数 和 mustRegexSplit函数
2.常用helm3的类型转换函数和正则表达式函数使用的演示
1).环境准备 k8s集群
# kubectl get node
NAME STATUS ROLES AGE VERSION
m1 Ready control-plane,master 252d v1.20.4
m2 Ready control-plane,master 252d v1.20.4
m3 Ready control-plane,master 252d v1.20.4
n1 Ready <none> 251d v1.20.4
2).创建一个chart包 (用helm3发布创建一个configmap,创建的k8s集群中,发布其他应用也一样)
# helm create mychart #创建一个chart包，chart包名为： mychart
# cd mychart/
# ls
charts Chart.yaml templates values.yaml
# cd templates/
# ls
deployment.yaml _helpers.tpl hpa.yaml ingress.yaml NOTES.txt serviceaccount.yaml service.yaml tests
# rm -rf * #全部删除
3).编写自己需要的yaml文件，使用上面的各个内置函数演示
(1). atoi函数、float64函数、int函数 和 toString函数
分别含义如下：
atoi函数： 将字符串转换为整型
float64函数： 转换成 float64 类型
int函数： 转换为 int 类型
toString函数： 转换成字符串
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data01: {{ "16" | kindOf }} #转换前查看是啥类型,字符串
data02: {{ 16 | kindOf }} #转换前查看是啥类型,int整数类型
data1: {{ atoi "16" | kindOf }} #atoi函数是将字符串转换为整型,kindOf函数可以判断传入的这个参数的类型是什么,结果由字符串转成了整型
data2: {{ float64 "16.0" | kindOf }} #float64函数是转换成float64类型,kindOf函数可以判断传入的这个参数的类型是什么,结果由字符串转成了float64类型
data3: {{ int "16" | kindOf }} #int函数是将字符串转换为整型,kindOf函数可以判断传入的这个参数的类型是什么,结果由字符串转成了整型
data4: {{ toString 16 | kindOf }} #toString函数是将字符串转换为字符串类型,kindOf函数可以判断传入的这个参数的类型是什么,结果由字符串转成了字符串
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data01: string #转换前查看是啥类型,字符串
data02: int #转换前查看是啥类型,int整数类型
data1: int #atoi函数是将字符串转换为整型,kindOf函数可以判断传入的这个参数的类型是什么,结果由字符串转成了整型
data2: float64 #float64函数是转换成float64类型,kindOf函数可以判断传入的这个参数的类型是什么,结果由字符串转成了float64类型
data3: int #int函数是将字符串转换为整型,kindOf函数可以判断传入的这个参数的类型是什么,结果由字符串转成了整型
data4: string #toString函数是将字符串转换为字符串类型,kindOf函数可以判断传入的这个参数的类型是什么,结果由字符串转成了字符串
(2). regexMatch函数 和 mustRegexMatch函数
分别含义如下：
regexMatch函数 和 mustRegexMatch函数 用于根据指定的正则来匹配字符串,如果匹配成功则返回true.
如果表达式有问题,regexMatch会直接抛出错误,mustRegexMatch会向模板引擎返回错误。
示例：regexMatch "^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$" "test@xxx.com" #正则表达式是一个邮箱地址的格式，能匹配到，返回:true
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ regexMatch "^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$" "test@xxx.com" }} #正则表达式是邮箱格式,能匹配到,结果返回:true
data2: {{ mustRegexMatch "^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$" "test@xxx.com" }} #正则表达式是邮箱格式,能匹配到,结果返回:true
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: true #正则表达式是邮箱格式,能匹配到,结果返回:true
data2: true #正则表达式是邮箱格式,能匹配到,结果返回:true
(3). regexFindAll函数 和 mustRegexFindAll函数
分别含义如下：
用于获取字符串中匹配正则表达式的所有子字符串内容,并且在该函数的最后指定一个整型来表示返回多少个正则匹配的字符串。-1 代表返回所有正则匹配的结果
示例：regexFindAll "[2,4,6,8]" "123456789" 3
示例：regexFindAll "[2,4,6,8]" "123456789" -1
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ regexFindAll "[2,4,6,8]" "123456789" 3 | quote }} #在给的字符串中,匹配正则表达式的所有子字符串内容,并指定返回3个字符串,加双引号quote
data2: {{ regexFindAll "[2,4,6,8]" "123456789" -1 | quote }} #在给的字符串中,匹配正则表达式的所有子字符串内容,-1代表返回所有正则匹配的结果
data3: {{ mustRegexFindAll "[2,4,6,8]" "123456789" 3 | quote }} #在给的字符串中,匹配正则表达式的所有子字符串内容,并指定返回3个字符串,加双引号quote
data4: {{ mustRegexFindAll "[2,4,6,8]" "123456789" -1 | quote }} #在给的字符串中,匹配正则表达式的所有子字符串内容,-1代表返回所有正则匹配的结果
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: "[2 4 6]" #在给的字符串中,匹配正则表达式的所有子字符串内容,并指定返回3个字符串,加双引号quote
data2: "[2 4 6 8]" #在给的字符串中,匹配正则表达式的所有子字符串内容,-1代表返回所有正则匹配的结果
data3: "[2 4 6]" #在给的字符串中,匹配正则表达式的所有子字符串内容,并指定返回3个字符串,加双引号quote
data4: "[2 4 6 8]" #在给的字符串中,匹配正则表达式的所有子字符串内容,-1代表返回所有正则匹配的结果
(4).regexFind函数 和 mustRegexFind函数 根据正则匹配查找匹配的内容,都是用于获取字符串中第一个匹配正则表达式的结果（从左至右）
示例：{{ regexFind "[a-zA-Z][1-9]" "abcd1234c1" }} {{ mustRegexFind "[a-zA-Z][1-9]" "abcd1234c1" }}
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ regexFind "[a-zA-Z][1-9]" "abcd1234c1" }} #都是用于获取字符串中第一个匹配正则表达式的子串(从左至右)
data2: {{ mustRegexFind "[a-zA-Z][1-9]" "abcd1234c1" }} #都是用于获取字符串中第一个匹配正则表达式的子串(从左至右)
#上面两个的正则含义:都是 匹配字母和数字想连的第一个结果:就是d1
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: d1 #都是用于获取字符串中第一个匹配正则表达式的子串(从左至右)正则含义: 匹配字母和数字想连的第一个结果:就是d1
data2: d1 #都是用于获取字符串中第一个匹配正则表达式的子串(从左至右)正则含义: 匹配字母和数字想连的第一个结果:就是d1
(5).regexReplaceAll函数 和 mustRegexReplaceAll函数 都是用指定的替换字符来串替换正则表达式匹配到的字符串
在替换字符串里面，$ 符号代表拓展符号，$1 代表正则表达式的第一个分组
示例：regexReplaceAll "a(x*)b" "-ab-axxb-" "${1}W" #正则含义: a为前缀,b为后缀,中间有多个x
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ regexReplaceAll "ab" "-ab-ab-axxb-" "W" }} #将匹配到的正则形式的ab,替换成W
data2: {{ regexReplaceAll "a(x*)b" "-ab-axxb-" "W" }} #将匹配到的正则形式的:前缀为:a,后缀为b,中间n个x的(包括没有x的),都替换成W
data3: {{ regexReplaceAll "a(x*)b" "-axb-axxb-" "W" }} #将匹配到的正则形式的:前缀为:a,后缀为b,中间n个x的(包括没有x的),都替换成W
data4: {{ regexReplaceAll "a(x*)b" "-ab-axxb-" "${1}W" }} #$1代表正则表达式的第一个分组(第一个括号里的:(x*)),$1的值会保留,其他匹配到正则的都替换为W
data5: {{ mustRegexReplaceAll "ab" "-ab-ab-axxb-" "W" }} #将匹配到的正则形式的ab,替换成W
data6: {{ mustRegexReplaceAll "a(x*)b" "-ab-axxb-" "W" }} #将匹配到的正则形式的:前缀为:a,后缀为b,中间n个x的(包括没有x的),都替换成W
data7: {{ mustRegexReplaceAll "a(x*)b" "-axb-axxb-" "W" }} #将匹配到的正则形式的:前缀为:a,后缀为b,中间n个x的(包括没有x的),都替换成W
data8: {{ mustRegexReplaceAll "a(x*)b" "-ab-axxb-" "${1}W" }} #$1代表正则表达式的第一个分组((x*)),$1的值会保留,其他匹配到正则的都替换为W
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: -W-W-axxb- #将匹配到的正则形式的ab,替换成W
data2: -W-W- #将匹配到的正则形式的:前缀为:a,后缀为b,中间n个x的(包括没有x的),都替换成W
data3: -W-W- #将匹配到的正则形式的:前缀为:a,后缀为b,中间n个x的(包括没有x的),都替换成W
data4: -W-xxW- #$1代表正则表达式的第一个分组(第一个括号里的:(x*)),$1的值会保留,其他匹配到正则的都替换为W
data5: -W-W-axxb- #将匹配到的正则形式的ab,替换成W
data6: -W-W- #将匹配到的正则形式的:前缀为:a,后缀为b,中间n个x的(包括没有x的),都替换成W
data7: -W-W- #将匹配到的正则形式的:前缀为:a,后缀为b,中间n个x的(包括没有x的),都替换成W
data8: -W-xxW- #$1代表正则表达式的第一个分组(第一个括号里的:(x*)),$1的值会保留,其他匹配到正则的都替换为W
(6).regexReplaceAllLiteral函数 和 mustRegexReplaceAllLiteral函数 将通过正则匹配到的内容，替换成其他内容
#regexReplaceAllLiteral 和 mustRegexReplaceAllLiteral函数的用法 和 regexReplaceAll函数/mustRegexReplaceAll函数 其实差不多
#不同的是: regexReplaceAllLiteral 和 mustRegexReplaceAllLiteral函数中不包括$拓展,也就是说会将$也视作字符串直接替换
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ regexReplaceAllLiteral "ab" "-ab-ab-axxb-" "W" }} #将匹配到的正则形式的ab,替换成W
data2: {{ regexReplaceAllLiteral "a(x*)b" "-ab-axxb-" "W" }} #将匹配到的正则形式的:前缀为:a,后缀为b,中间n个x的(包括没有x的),都替换成W
data3: {{ regexReplaceAllLiteral "a(x*)b" "-axb-axxb-" "W" }} #将匹配到的正则形式的:前缀为:a,后缀为b,中间n个x的(包括没有x的),都替换成W
data4: {{ regexReplaceAllLiteral "a(x*)b" "-ab-axxb-" "${1}W" }} #第一个分组(第一个括号里的:(x*)),$1的值不会保留,匹配到正则的都替换为${1}W
data5: {{ mustRegexReplaceAllLiteral "ab" "-ab-ab-axxb-" "W" }} #将匹配到的正则形式的ab,替换成W
data6: {{ mustRegexReplaceAllLiteral "a(x*)b" "-ab-axxb-" "W" }} #将匹配到的正则形式的:前缀为:a,后缀为b,中间n个x的(包括没有x的),都替换成W
data7: {{ mustRegexReplaceAllLiteral "a(x*)b" "-axb-axxb-" "W" }} #将匹配到的正则形式的:前缀为:a,后缀为b,中间n个x的(包括没有x的),都替换成W
data8: {{ mustRegexReplaceAllLiteral "a(x*)b" "-ab-axxb-" "${1}W" }} #第一个分组(第一个括号里的:(x*)),$1的值不会保留,匹配到正则的都替换为${1}W
#regexReplaceAllLiteral 和 mustRegexReplaceAllLiteral函数的用法 和 regexReplaceAll函数/mustRegexReplaceAll函数 其实差不多
#不同的是: regexReplaceAllLiteral 和 mustRegexReplaceAllLiteral函数中不包括$拓展,也就是说会将$也视作字符串直接替换
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: -W-W-axxb- #将匹配到的正则形式的ab,替换成W
data2: -W-W- #将匹配到的正则形式的:前缀为:a,后缀为b,中间n个x的(包括没有x的),都替换成W
data3: -W-W- #将匹配到的正则形式的:前缀为:a,后缀为b,中间n个x的(包括没有x的),都替换成W
data4: -${1}W-${1}W- #$1代表正则表达式的第一个分组(第一个括号里的:(x*)),$1的值不会保留,匹配到正则的都替换为${1}W
data5: -W-W-axxb- #将匹配到的正则形式的ab,替换成W
data6: -W-W- #将匹配到的正则形式的:前缀为:a,后缀为b,中间n个x的(包括没有x的),都替换成W
data7: -W-W- #将匹配到的正则形式的:前缀为:a,后缀为b,中间n个x的(包括没有x的),都替换成W
data8: -${1}W-${1}W- #$1代表正则表达式的第一个分组(第一个括号里的:(x*)),$1的值不会保留,匹配到正则的都替换为${1}W
#regexReplaceAllLiteral 和 mustRegexReplaceAllLiteral函数的用法 和 regexReplaceAll函数/mustRegexReplaceAll函数 其实差不多
#不同的是: regexReplaceAllLiteral 和 mustRegexReplaceAllLiteral函数中不包括$拓展,也就是说会将$也视作字符串直接替换
(7).regexSplit函数 和 mustRegexSplit函数 作用都是指定一个分隔符(以正则表达式匹配的内容为分隔符),将字符串进行切割，并返回切割后的字符串切片
在函数的最后需要指定一个整型，来确定要返回的切片数量，-1 代表返回所有的切片
示例：regexSplit "z+" "pizza" -1 #正则表达式含义: 可以匹配1-多个z， 匹配到正则的内容，
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ regexSplit "z+" "pizza" -1 | quote }} #以正则表达式的内容为分隔符,即以zz为分隔符,默认返回的是数组,将双引号quote转成字符串类型
data2: {{ mustRegexSplit "z+" "pizza" -1 |quote }} #以正则表达式的内容为分隔符,即以zz为分隔符,默认返回的是数组,将双引号quote转成字符串类型
#表达式内容: 可以匹配1-多个z,即:zz
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: "[pi a]" #以正则表达式的内容为分隔符,表达式内容: 可以匹配1-多个z,即:zz,默认返回的是数组,将双引号quote转成字符串类型
data2: "[pi a]" #以正则表达式的内容为分隔符,表达式内容: 可以匹配1-多个z,即:zz,默认返回的是数组,将双引号quote转成字符串类型

5.helm3的加密函数和编码解码函数

1.常用helm3的加密函数和编码解码函数
helm提供了以下几种加密函数：
sha1sum 函数
sha256sum 函数
adler32sum 函数
htpasswd 函数
encryptAES 函数
decryptAES 函数
helm有以下编码和解码函数：
b64enc编码函数和b64dec解码函数：编码或解码 Base64
b32enc编码函数和b32dec解码函数：编码或解码 Base32
2.常用helm3的加密函数和编码解码函数使用的演示
1).环境准备 k8s集群
# kubectl get node
NAME STATUS ROLES AGE VERSION
m1 Ready control-plane,master 252d v1.20.4
m2 Ready control-plane,master 252d v1.20.4
m3 Ready control-plane,master 252d v1.20.4
n1 Ready <none> 251d v1.20.4
2).创建一个chart包 (用helm3发布创建一个configmap,创建的k8s集群中,发布其他应用也一样)
# helm create mychart #创建一个chart包，chart包名为： mychart
# cd mychart/
# ls
charts Chart.yaml templates values.yaml
# cd templates/
# ls
deployment.yaml _helpers.tpl hpa.yaml ingress.yaml NOTES.txt serviceaccount.yaml service.yaml tests
# rm -rf * #全部删除

3).编写自己需要的yaml文件，使用上面的各个内置函数演示
(1). sha1sum函数、sha256sum函数、adler32sum函数 和 htpasswd函数
分别含义如下：
sha1sum 函数： 用于计算字符串的SHA1值进行加密
sha256sum 函数：用于计算字符串的SHA256值进行加密
adler32sum 函数：用于计算字符串的Adler-32校验和进行加密
htpasswd 函数： 可以根据传入的username和password生成一个密码的bcrypt 哈希值,可以用于HTTP Server的基础认证
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ sha1sum "hello world" }} #sha1sum函数:用于计算字符串的SHA1值进行加密
data2: {{ sha256sum "hello world" }} #sha256sum函数:用于计算字符串的SHA256值进行加密
data3: {{ adler32sum "hello world" }} #adler32sum函数:用于计算字符串的Adler-32校验和进行加密
data4: {{ htpasswd "user1" "123456" }} #htpasswd函数:可以根据传入的username和password生成一个密码的bcrypt 哈希值,可以用于HTTP Server的基础认证
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed #sha1sum函数:用于计算字符串的SHA1值进行加密
data2: b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9 #sha256sum函数:用于计算字符串的SHA256值进行加密
data3: 436929629 #adler32sum函数:用于计算字符串的Adler-32校验和进行加密
data4: user1:$2a$10$PWA5aXi1Qgtd6fb1/.34H.rC1cC16DRa6Yq7PD88we3ndQMaPo5t2 #htpasswd函数:可以根据传入的username和password生成一个密码的bcrypt 哈希值,可以用于HTTP Server的基础认证
(2). encryptAES加密函数 和 decryptAES解密函数
分别含义如下：
encryptAES 函数：是加密函数，使用AES-256 CBC 加密文本并返回一个base64编码字符串
decryptAES 函数：是解密函数，接收一个AES-256 CBC编码的字符串并返回解密文本
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ encryptAES "testkey" "hello" }} #encryptAES是加密函数,传入两个参数,第一个是自定义了一个加密后的key名,后面是要加密的内容
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: 2mFYH1h6bdkrGPN1P6nCMepc740w2MNEUMMfBvfimFg= #encryptAES是加密函数,传入两个参数,前面:自定义了一个加密后的key名,后面:要加密的内容
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ decryptAES "testkey" "2mFYH1h6bdkrGPN1P6nCMepc740w2MNEUMMfBvfimFg=" }} #解密,传两个参数,前:指定一个要解密的key名,后:要解密的内容
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: hello #decryptAES是解密函数,传入两个参数,前面:指定一个要解密的key名,后面:要解密的内容
(3). b64enc编码函数和b64dec解码函数 编写k8s的secret文件时候会用到
分别含义如下：
b64enc编码函数和b64dec解码函数：编码或解码 Base64
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ "test" | b64enc }} #b64enc编码函数,将字符串编码为Base64
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: dGVzdA== #b64enc编码函数,将字符串编码为Base64
解密: b64dec
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ "dGVzdA==" | b64dec }} #b64dec解码函数,将编码为Base64的内容解码
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: test #b64dec解码函数,将编码为Base64的内容解码
6.helm3的日期函数

1.常用的helm3的日期函数
now函数
date函数
dateInZone函数
duration函数和durationRound函数
unixEpoch函数
dateModify函数 和 mustDateModify函数
toDate函数 和 mustToDate函数
2.常用helm3的日期函数使用的演示
1).环境准备 k8s集群
# kubectl get node
NAME STATUS ROLES AGE VERSION
m1 Ready control-plane,master 252d v1.20.4
m2 Ready control-plane,master 252d v1.20.4
m3 Ready control-plane,master 252d v1.20.4
n1 Ready <none> 251d v1.20.4
2).创建一个chart包 (用helm3发布创建一个configmap,创建的k8s集群中,发布其他应用也一样)
# helm create mychart #创建一个chart包，chart包名为： mychart
# cd mychart/
# ls
charts Chart.yaml templates values.yaml
# cd templates/
# ls
deployment.yaml _helpers.tpl hpa.yaml ingress.yaml NOTES.txt serviceaccount.yaml service.yaml tests
# rm -rf * #全部删除
3).编写自己需要的yaml文件，使用上面的各个内置函数演示
(1). now函数、date函数、dateInZone函数、duration函数和durationRound函数
分别含义如下：
now函数：用于返回当前日期和时间，通常与其他日期函数共同使用
date函数：用于将日期信息进行格式化。date 函数后面需要指明日期的格式，这个格式内容必须使用"2006-01-02" 或 "02/01/2006" 来标明，否则会出错
示例：now | date "2006-01-02" 或 now | date "02/01/2006" 注意: 格式内容必须是这两个示例的内容，内容换成其他日期都不行。
dateInZone函数：用法与date函数基本一致，只不过dataInZone函数可以指定时区返回时间，如:指定UTC时区返回时间
示例：dateInZone "2006-01-02" (now) "UTC" #指定UTC时区返回时间
duration函数：该函数可以将给定的秒数转换为golang 中的time.Duration类型，例如指定 95秒可以返回1m35s,秒数必须需要使用双引号,否则会返回 0s
示例：duration "95" #结果: 1m35s
durationRound函数：durationRound函数用于将给定的日期进行取整，保留最大的单位
示例：durationRound "2h10m5s" #结果: 2h
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ now }} #now函数:用于返回当前日期和时间,通常与其他日期函数共同使用
data2: {{ now | date "2006-01-02" }} #date函数:用于将日期信息进行格式化,date函数后面需要指明日期的格式
#这个格式内容必须使用"2006-01-02"或"02/01/2006"来标明
data3: {{ dateInZone "2006-01-02" (now) "UTC" }} #dateInZone函数:用法与date函数基本一致,只不过dataInZone函数可以指定时区返回时间
data4: {{ duration "95" }} #该函数可将给定的秒数转换为golang中的time.Duration类型,如:指定95秒可返回1m35s,秒数必须需要使用双引号,否则会返回0s
data5: {{ durationRound "2h10m5s" }} #结果:2h,durationRound函数用于将给定的日期进行取整,保留最大的单位
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: 2022-11-27 09:54:24.687563021 +0800 CST m=+0.083872699 #now函数:用于返回当前日期和时间,通常与其他日期函数共同使用
data2: 2022-11-27 #date函数:用于将日期信息进行格式化,date函数后面需要指明日期的格式,这个格式内容必须使用"2006-01-02"或"02/01/2006"来标明
data3: 2022-11-27 #dateInZone函数:用法与 date函数基本一致,只不过dataInZone函数可以指定时区返回时间,如:指定UTC时区返回时间
data4: 1m35s #该函数可将给定的秒数转换为golang中的time.Duration类型,如:指定95秒可返回1m35s,秒数必须需要使用双引号,否则会返回0s
data5: 2h #结果:2h,durationRound函数用于将给定的日期进行取整,保留最大的单位
(2). unixEpoch函数、dateModify函数 和 mustDateModify函数、toDate函数 和 mustToDate函数
分别含义如下：
unixEpoch函数: 用于返回给定时间的时间戳格式
示例：now | unixEpoch
dateModify和mustDateModify函数:这两个函数用于将一个给定的日期修改一定的时间,并返回修改后的时间
区别是: 如果修改格式错误,dateModify会返回日期未定义.而mustDateModify会返回错误
示例：now | date_modify "-2h" #将当前的时间减去2h再返回
toDate函数和mustToDate函数：这两个函数都是用于将指定的字符串转换成日期,第一个参数需要指明要转成的日期格式,第二个参数需要传递要转换的字符串
区别是：如果字符串无法转换,toDate函数就会返回0值。mustToDate 函数无法转换时会抛出错误
示例： toDate "2006-01-02" "2017-12-31"
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
data1: {{ now | unixEpoch }} #unixEpoch函数:用于返回给定时间的时间戳格式
data2: {{ now | date_modify "-2h" }} #将当前的时间减去2h再返回
data3: {{ now | mustDateModify "-2h" }} #将当前的时间减去2h再返回
date4: {{ toDate "2006-01-02" "2017-12-31" }} #将后面的字符串以前面的格式进行转换输出
date5: {{ mustToDate "2006-01-02" "2017-12-31" }} #将后面的字符串以前面的日期格式进行转换输出
#dateModify和mustDateModify函数:这两个函数用于将一个给定的日期修改一定的时间,并返回修改后的时间
#区别是: 如果修改格式错误,dateModify会返回日期未定义.而mustDateModify会返回错误
#toDate函数和mustToDate函数：这两个函数都是用于将字符串转换成日期,第一个参数需要指明要转成的日期格式,第二个参数需要传递要转换的日期字符串
#区别是：如果字符串无法转换,toDate函数就会返回0值。mustToDate 函数无法转换时会抛出错误
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
data1: 1669515508 #unixEpoch函数:用于返回给定时间的时间戳格式
data2: 2022-11-27 08:18:28.334323828 +0800 CST m=-7199.918106493 #将当前的时间减去2h再返回
data3: 2022-11-27 08:18:28.334381541 +0800 CST m=-7199.918048776 #将当前的时间减去2h再返回
date4: 2017-12-31 00:00:00 +0800 CST #将后面的字符串以前面的格式进行转换输出
date5: 2017-12-31 00:00:00 +0800 CST #将后面的字符串以前面的格式进行转换输出
#dateModify和mustDateModify函数:这两个函数用于将一个给定的日期修改一定的时间,并返回修改后的时间
#区别是: 如果修改格式错误,dateModify会返回日期未定义.而mustDateModify会返回错误
#toDate函数和mustToDate函数：这两个函数都是用于将字符串转换成日期,第一个参数需要指明要转成的日期格式,第二个参数需要传递要转换的日期字符串
#区别是：如果字符串无法转换,toDate函数就会返回0值。mustToDate 函数无法转换时会抛出错误

7.helm3的字典函数

1.常用的helm3的字典函数
(1).dict字典函数、get函数、set函数、unset函数
dict字典函数: 用于存储key/value键值对.其中字典的key必须是字符串,value可以是任何类型
get函数： 函数来获取定义字典myDict的值
set函数： 用于向已有的字典中添加新的键值对,也可修改原来键值对的值
unset函数： 用于删除字典中指定的key
(2).keys函数
(3).hasKey函数
(4).pluck函数
(5).merge函数 和 mustMerge函数
(6).mergeOverwrite函数 和 mustMergeOverwrite函数
(7).values函数
(8).pick函数 和 omit函数
(9).deepCopy函数 和 mustDeepCopy函数
2.常用helm3的字典函数使用的演示
1).环境准备 k8s集群
# kubectl get node
NAME STATUS ROLES AGE VERSION
m1 Ready control-plane,master 252d v1.20.4
m2 Ready control-plane,master 252d v1.20.4
m3 Ready control-plane,master 252d v1.20.4
n1 Ready <none> 251d v1.20.4
2).创建一个chart包 (用helm3发布创建一个configmap,创建的k8s集群中,发布其他应用也一样)
# helm create mychart #创建一个chart包，chart包名为： mychart
# cd mychart/
# ls
charts Chart.yaml templates values.yaml
# cd templates/
# ls
deployment.yaml _helpers.tpl hpa.yaml ingress.yaml NOTES.txt serviceaccount.yaml service.yaml tests
# rm -rf * #全部删除
3).编写自己需要的yaml文件，使用上面的各个内置函数演示
(1).dict字典函数、get函数、set函数、unset函数的使用演示
分别含义如下:
dict字典函数: 用于存储key/value键值对.其中字典的key必须是字符串,value可以是任何类型
get函数： 函数来获取定义字典myDict的值
set函数： 用于向已有的字典中添加新的键值对,也可修改原来键值对的值
unset函数： 用于删除字典中指定的key
(a).dict字典函数:
dict字典类型函数用于存储 key/value 键值对。其中字典的 key 必须是字符串，value 可以是任何类型，包括 dict 或 list （列表会在后面讲解）。
dict函数用于声明一个字典，并且可以将键值对列表传入初始化的字典中：
示例：$myDict := dict "name1" "value1" "name2" "value2" "name3" "value 3"
打印这个变量可以获取如下结果： map[name1:value1 name2:value2 name3:value 3]
(b).get函数：
get 函数用于从一个映射（变量名）中根据 key 值获取对应的 value：
示例：get $myDict "name1"
如果该 key 不存在，或者 value 为空，则会返回""，不会抛出异常。
(c).set函数：
set 函数用于向已有的字典中添加新的键值对：
示例：set $myDict "name4" "value4"
set 函数执行完成后会返回一个字典，所以返回结果如下：
map[name1:value1 name2:value2 name3:value 3 name4:value4]
如果指定的 key 值已存在，那么会更新 key 的 value
(d).unset函数：
unset 函数用于删除字典中指定的 key：
示例：unset $myDict "name3"
unset 也会返回字典，所以结果如下：
map[name1:value1 name2:value2]
如果这个 key 没有找到，则会返回原字典，不会报错。
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
data:
{{- $myDict := dict "name1" "value1" "name2" "value2" "name3" "value3" }}
data1: {{ $myDict }}
data2: {{ get $myDict "name1" }}
data3: {{ set $myDict "name4" "value4"}}
data4: {{ get $myDict "name4" }}
data5: {{ unset $myDict "name4" }}
#dict字典类型函数用于存储key/value键值对.其中字典的key必须是字符串,value可以是任何类型
#$myDict是声明变量的格式,后面会讲解.这里是将字典赋值给$myDict变量(相当于映射),下面$myDict是调用变量输出
#data2: 使用get函数来获取定义字典myDict的值,获取key是name1的值,结果是:value1
#data3: 使用set函数用于向已有的字典中添加新的键值对,也可修改原来键值对的值
#data4: 使用get函数来获取定义字典myDict的值,获取key是name4的值,结果是:value4
#data5: 使用unset函数来删除字典中指定的key
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
data:
data1: map[name1:value1 name2:value2 name3:value3]
data2: value1
data3: map[name1:value1 name2:value2 name3:value3 name4:value4]
data4: value4
data5: map[name1:value1 name2:value2 name3:value3]
#dict字典类型函数用于存储key/value键值对.其中字典的key必须是字符串,value可以是任何类型
#$myDict是声明变量的格式,后面会讲解.这里是将字典赋值给$myDict变量(相当于映射),下面$myDict是调用变量输出
#data2: 使用get函数来获取定义字典myDict的值,获取key是name1的值,结果是:value1
#data3: 使用set函数用于向已有的字典中添加新的键值对,也可修改原来键值对的值
#data4: 使用get函数来获取定义字典myDict的值,获取key是name4的值,结果是:value4
#data5: 使用unset函数来删除字典中指定的key
(2).keys函数的使用演示
keys 函数用于获取一个或多个字典中所有的key 并返回一个列表。由于字典是无序的，所以每次返回的列表中key 的顺序也是会变化的。
在指定多个字典并且字典中存在相同key的时候，这些key 都会保存在列表中。
列表内如果包含多个相同的key，并且是无序的。可以使用sortAlpha 函数对列表进行排序，再使用uniq函数去重。
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
data:
{{- $myDict1 := dict "name1" "value1" "name2" "value2" }}
{{- $myDict2 := dict "name1" "value1" "name3" "value3" }}
{{- $myDict3 := dict "name1" "value1" "name4" "value4" }}
data1: {{ keys $myDict1 $myDict2 $myDict3 | quote }}
data2: {{ keys $myDict1 $myDict2 $myDict3 | sortAlpha | uniq | quote }}
#上面定义3个字典,下面使用keys函数获取多个字典中所有的key名,key名相同也获取,因为返回的是列表可能会报错,用quote函数加上双引号
#data2是在上面基础上用sortAlpha函数排序,再用uniq去重
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
data:
data1: "[name1 name2 name1 name3 name1 name4]"
data2: "[name1 name2 name3 name4]"
#上面定义3个字典,下面使用keys函数获取多个字典中所有的key名,key名相同也获取,因为返回的是列表可能会报错,用quote函数加上双引号
#data2是在上面基础上用sortAlpha函数排序,再用uniq去重
(3).hasKey函数的使用演示
hasKey函数用于判断字典中是否包含指定的key，如果包含则返回 true，否则返回 false：
示例：hasKey $myDict "name4"
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
data:
{{- $myDict1 := dict "name1" "value1" "name2" "value2" }}
{{- $myDict2 := dict "name1" "value1" "name3" "value3" }}
data1: {{ hasKey $myDict1 "name1" }}
data2: {{ hasKey $myDict2 "name4" }}
#上面是定义两个字典
#使用haskey函数判断字典中是否包含后面指定的key,包含返回true,不包含返回false
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
data:
data1: true
data2: false
#上面是定义两个字典
#使用haskey函数判断字典中是否包含后面指定的key,包含返回true,不包含返回false
(4).pluck函数的使用演示
pluck 函数可以根据一个key在多个字典中时获得所有匹配的value，并返回一个value组成的列表。
如果key值在两个字典中都不存在，则会返回一个空列表。
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
data:
{{- $myDict1 := dict "name1" "value1" "name2" "value2" }}
{{- $myDict2 := dict "name1" "value2" "name3" "value3" }}
data1: {{ pluck "name1" $myDict1 $myDict2 | quote }}
data2: {{ pluck "name4" $myDict1 $myDict2 | quote }}
#上面两行是定义两个字典
#下面两行是用pluck函数根据一个key在多个字典中时获得所有匹配的value,并返回一个value组成的列表
#如果key值在两个字典中都不存在,则会返回一个空列表
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
data:
data1: "[value1 value2]"
data2: "[]"
#上面两行是定义两个字典
#下面两行是用pluck函数根据一个key在多个字典中时获得所有匹配的value,并返回一个value组成的列表
#如果key值在两个字典中都不存在,则会返回一个空列表
(5).merge函数 和 mustMerge函数的使用演示
两个函数都是用于合并两个或多个字典，由源字典向目标字典合并，如果目标字典中已经存在相同的key 值，则忽略源字典中对应的键值对，以目标字典为主。
如果源字典中的key没有包含在目标字典中，那么将对应的键值对合并到目标字典中。
使用 mustMerge 合并时，如果合并不成功会抛出错误。
merge 函数的使用格式如下：merge $destDict $sourceDict1 $sourceDict2 # $destDict 是目标字典，把后面的所有字典都合并到第一个字典中
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
data:
{{- $myDict1 := dict "name1" "value1" "name2" "value2" }}
{{- $myDict2 := dict "name1" "value2" "name3" "value3" }}
{{- $myDict3 := dict "name1" "value4" "name5" "value5" }}
data1: {{ merge $myDict1 $myDict2 $myDict3 }}
data1: {{ mustMerge $myDict1 $myDict2 $myDict3 }}
#上面两行是定义三个字典,下面是使用merge函数或mustMerge函数合并字典,第一个是目标字典,把后面的所有字典都合并到第一个字典中
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
data:
data1: map[name1:value1 name2:value2 name3:value3 name5:value5]
data1: map[name1:value1 name2:value2 name3:value3 name5:value5]
#上面两行是定义三个字典,下面是使用merge函数或mustMerge函数合并字典,第一个是目标字典,把后面的所有字典都合并到第一个字典中
(6).mergeOverwrite函数 和 mustMergeOverwrite函数的使用演示
这两个函数也是用来合并字典，但与merge函数不同的是，如果目标字典中存在与源字典中相同的key，那么目标字典中的key会被覆盖，
mustMergeOverwrite会返回错误，以防出现不成功的合并。
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
data:
{{- $myDict1 := dict "name1" "value1" "name2" "value2" }}
{{- $myDict2 := dict "name1" "value2" "name3" "value3" }}
{{- $myDict3 := dict "name1" "value4" "name5" "value5" }}
data1: {{ mergeOverwrite $myDict1 $myDict2 $myDict3 }}
data1: {{ mustMergeOverwrite $myDict1 $myDict2 $myDict3 }}
#上面两行是定义三个字典,下面是使用mergeOverwrite函数或mustMergeOverwrite函数合并字典,第一个是目标字典,把后面的所有字典都合并到第一个字典中
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
data:
data1: map[name1:value4 name2:value2 name3:value3 name5:value5]
data1: map[name1:value4 name2:value2 name3:value3 name5:value5]
#上面两行是定义三个字典,下面是使用mergeOverwrite函数或mustMergeOverwrite函数合并字典,第一个是目标字典,把后面的所有字典都合并到第一个字典中
(7).values函数的使用演示
values函数用于获取一个字典中所有的value值并返回一个列表，由于字典是无序的，所以返回的list 的内容也是无序的，如果需要排序和去重，可以使用sortAlpha 函数对 list 进行排序，再使用 uniq 函数去重。
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
data:
{{- $myDict1 := dict "name1" "value1" "name2" "value2" "name3" "value3" }}
data1: {{ values $myDict1 | quote }}
#上面定义一个字典,下面使用values函数获取一个字典中所有的value值并返回一个列表，由于字典是无序的，所以返回的list 的内容也是无序的
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
data:
data1: "[value3 value1 value2]"
#上面定义一个字典,下面使用values函数获取一个字典中所有的value值并返回一个列表，由于字典是无序的，所以返回的list 的内容也是无序的
(8).pick函数 和 omit函数的使用演示
pick函数用于根据指定的字典和key值获取value，并将key和value 组成一个新的字典返回。
omit函数与pick 函数正好相反，该函数会将指定的key值忽略，获取的是未被指定的key和value（也就是取反），并返回一个新的字典。
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
data:
{{- $myDict1 := dict "name1" "value1" "name2" "value2" "name3" "value3" }}
data1: {{ pick $myDict1 "name1" "name2" }}
data2: {{ omit $myDict1 "name1" "name2" }}
#上面定义一个字典,下面使用pick函数用于根据指定的字典和key值获取value，并将key和value 组成一个新的字典返回
#omit函数与pick函数正好相反,该函数会将指定的key值忽略,获取的是未被指定的key和value(也就是取反),并返回一个新的字典
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
data:
data1: map[name1:value1 name2:value2]
data2: map[name3:value3]
#上面定义一个字典,下面使用pick函数用于根据指定的字典和key值获取value，并将key和value 组成一个新的字典返回
#omit函数与pick函数正好相反,该函数会将指定的key值忽略,获取的是未被指定的key和value(也就是取反),并返回一个新的字典
(9).deepCopy函数 和 mustDeepCopy函数的使用演示
这两个函数都是用于深度拷贝一个字典并返回一个字典（也就是复制一个字典）
deepCopy有问题时会出错，而mustDeepCopy出错时，会返回一个错误给模板系统。
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
data:
{{- $myDict1 := dict "name1" "value1" "name2" "value2" "name3" "value3" }}
data1: {{ $myDict1 | deepCopy }}
data2: {{ $myDict1 | mustDeepCopy }}
#这两个函数都是用于深度拷贝一个字典并返回一个字典(也就是复制一个字典)
#deepCopy有问题时会出错,而mustDeepCopy出错时,会返回一个错误给模板系统
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
data:
data1: map[name1:value1 name2:value2 name3:value3]
data2: map[name1:value1 name2:value2 name3:value3]
#这两个函数都是用于深度拷贝一个字典并返回一个字典(也就是复制一个字典)
#deepCopy有问题时会出错,而mustDeepCopy出错时,会返回一个错误给模板系统

8.helm3的列表函数

1.常用的helm3的列表函数
(1).list函数、first函数、rest函数、last函数、initial函数
(2).append函数、prepend函数、concat函数、reverse函数、uniq函数
(3).without函数、has函数、compact函数
(4).slice函数、until函数、untilStep函数、seq函数
2.常用helm3的列表函数使用的演示
1).环境准备 k8s集群
# kubectl get node
NAME STATUS ROLES AGE VERSION
m1 Ready control-plane,master 252d v1.20.4
m2 Ready control-plane,master 252d v1.20.4
m3 Ready control-plane,master 252d v1.20.4
n1 Ready <none> 251d v1.20.4
2).创建一个chart包 (用helm3发布创建一个configmap,创建的k8s集群中,发布其他应用也一样)
# helm create mychart #创建一个chart包，chart包名为： mychart
# cd mychart/
# ls
charts Chart.yaml templates values.yaml
# cd templates/
# ls
deployment.yaml _helpers.tpl hpa.yaml ingress.yaml NOTES.txt serviceaccount.yaml service.yaml tests
# rm -rf * #全部删除
3).编写自己需要的yaml文件，使用上面的各个内置函数演示
(1).list函数、first函数、rest函数、last函数、initial函数的使用演示
分别含义如下:
list函数: list函数用于生成一个列表，传入的参数将会作为列表中的值，示例：$myList := list 1 2 3 "one" "two" "three"
first函数: first函数用于获取列表的第一项， 示例：first $myList
rest函数: rest函数用于获取列表中除第一项以外的所有内容，示例：rest $myList
last函数: last函数用于获取列表的最后一项，示例：last $myList
initial函数: initial函数会获取到列表中除最后一项以外的所有内容，与rest 正好相反，示例：initial $myList
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
data:
{{- $myList := list 1 2 3 "one" "two" "three" }}
data1: {{ $myList | quote }}
data2: {{ first $myList | quote }}
data3: {{ rest $myList | quote }}
data4: {{ last $myList | quote }}
data5: {{ initial $myList | quote }}
#上面是定义一个列表,将后面的列表值赋值给前面的变量myList,形成一个列表
#下面data1是输出变量的值,即输出列表,并用quote函数加上双引号
#data2是使用first函数获取列表的第一项
#data3是使用rest函数获取列表中除第一项以外的所有内容
#data4是使用last函数获取列表的最后一项
#data5是使用initial函数获取除最后一项以外的所有内容
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
data:
data1: "[1 2 3 one two three]"
data2: "1"
data3: "[2 3 one two three]"
data4: "three"
data5: "[1 2 3 one two]"
#上面是定义一个列表,将后面的列表值赋值给前面的变量myList,形成一个列表
#下面data1是输出变量的值,即输出列表,并用quote函数加上双引号
#data2是使用first函数获取列表的第一项
#data3是使用rest函数获取列表中除第一项以外的所有内容
#data4是使用last函数获取列表的最后一项
#data5是使用initial函数获取除最后一项以外的所有内容
(2).append函数、prepend函数、concat函数、reverse函数、uniq函数的使用演示
分别含义如下:
append函数： 用于在已有的列表中追加一项，并返回一个新的列表。原列表内容保持不变。格式：$newList = append $列表变量 要追加的内容
prepend函数：用于在列表的最前面加入一个新值，并返回一个新的列表，原列表内容不变。格式：$newList = prepend $列表变量 最前面加的值
concat函数： 用于将任意数量的列表合并成一个新的列表，原列表内容保持不变。格式：concat $原列表名 新列表1 新列表2 ...
示例： concat $myList (list 100 101 102) (list a b c)
reverse函数: 用于反转一个列表，并返回一个新的列表。 示例：reverse $myList
uniq函数： 用于去除一个列表中的重复项，并返回一个新的列表：示例：list 1 1 2 2 3 3 | uniq
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
data:
{{- $myList := list 1 2 3 "one" "two" "three" }}
data1: {{ append $myList "apend_test" | quote }}
data2: {{ prepend $myList "prenpend_test" | quote }}
data3: {{ concat $myList (list 100 101 102) (list 200 201) | quote }}
data4: {{ reverse $myList | quote }}
data5: {{ list 1 1 2 2 3 3 | uniq | quote}}
#上面是定义一个列表,将后面的列表值赋值给前面的变量myList,形成一个列表
#data1是使用append函数用于在已有的列表中追加一项,并返回一个新的列表
#data2是使用prepend函数用于在列表的最前面加入一个新值,并返回一个新的列表
#data3是使用concat函数用于将任意数量的列表合并成一个新的列表
#data4是使用reverse函数反转一个列表,并返回一个新的列表
#data5是使用uniq函数用于去除一个列表中的重复项,并返回一个新的列表
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
data:
data1: "[1 2 3 one two three apend_test]"
data2: "[prenpend_test 1 2 3 one two three]"
data3: "[1 2 3 one two three 100 101 102 200 201]"
data4: "[three two one 3 2 1]"
data5: "[1 2 3]"
#上面是定义一个列表,将后面的列表值赋值给前面的变量myList,形成一个列表
#data1是使用append函数用于在已有的列表中追加一项,并返回一个新的列表
#data2是使用prepend函数用于在列表的最前面加入一个新值,并返回一个新的列表
#data3是使用concat函数用于将任意数量的列表合并成一个新的列表
#data4是使用reverse函数反转一个列表,并返回一个新的列表
#data5是使用uniq函数用于去除一个列表中的重复项,并返回一个新的列表
(3).without函数、has函数、compact函数的使用演示
分别作用如下：
without函数： 用于过滤掉列表中的指定值（即:不要某某个值或多个值），并返回包含剩下值的列表：
示例：without (list 1 2 3 4) 3 （过滤掉3） 也可过滤掉多个值： 示例：without (list 1 2 3 4) 2 3 (过滤掉2 3)
has函数：用于判断一个值是否包含在列表中，如果包含返回 true，否则返回 false：
示例：has "hello" ( list 1 2 3 4 ) | quote
compact函数：用来删除一个列表中的空值，并返回一个新的列表：
示例：compact ( list 1 2 3 "" ) | quote
需要注意的是，空值不仅仅只是 ""，在逻辑和流控制函数的部分，讲解 default 函数的时候提到过，空值包括：
整型：0
字符串: ""
列表: []
字典: {}
布尔: false
以及所有的nil (或 null)
所以如果列表中包含这些也会被 compact 函数给删除
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
data:
data1: {{ without (list 1 2 3 4) 3 | quote }}
data2: {{ without (list 1 2 3 4) 2 3 | quote }}
data3: {{ has "hello" ( list 1 2 3 4 ) | quote }}
data4: {{ has 2 ( list 1 2 3 4 ) | quote }}
data5: {{ compact ( list 1 2 3 "" ) | quote }}
#quote是加一个双引号
#data1是使用without函数过滤掉一个值3,data2是过滤掉多个值2和3
#data3和data4是使用has函数判断一个值是否包含在列表中,如果包含返回true,否则返回false
#data5是使用compact函数删除一个列表中的空值
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
data:
data1: "[1 2 4]"
data2: "[1 4]"
data3: "false"
data4: "true"
data5: "[1 2 3]"
#quote是加一个双引号
#data1是使用without函数过滤掉一个值3,data2是过滤掉多个值2和3
#data3和data4是使用has函数判断一个值是否包含在列表中,如果包含返回true,否则返回false
#data5是使用compact函数删除一个列表中的空值
(4).slice函数、until函数、untilStep函数、seq函数的使用演示
slice函数： 用于对列表进行切片，命令格式为 slice list [n] [m]，相当于 list[n:m]
{{- $myList := list 1 2 3 4 5 }}
slice $myList 返回 [1 2 3 4 5]。 等同于 myList[:]，没有设置步长，返回所有
slice $myList 3 返回 [4 5]等同于 myList[3:]，从索引为3的位置进行切片
slice $myList 1 3 返回 [2 3]等同于 myList[1:3]，从索引为1的位置进行切片，切到索引3
slice $myList 0 3 返回 [1 2 3]等同于 myList[:3]，从索引为0的位置进行切片，切到索引3
until函数： 用于构建一个指定整数范围内的列表：示例：until 5
untilStep函数：与until 作用类似，不过可以定义整数的开始和步长：示例：untilStep 3 9 2 输出3-9之间的数字,切步长值为2
seq 函数：与linux 中的seq命令类似，用于生成指定范围内的整数。最多可以传递三个参数：
单个参数 (结束位置) - 会生成所有从1到包含 end 的整数。
多个参数 (开始， 结束) - 会生成所有包含start 和 end 的整数，递增或者递减。
多个参数 (开始， 步长， 结束) - 会生成所有包含 start 和 end 按 step递增或递减的整数。
示例:
seq 5 => 1 2 3 4 5
seq -3 => 1 0 -1 -2 -3
seq 0 2 => 0 1 2
seq 2 -2 => 2 1 0 -1 -2
seq 0 2 10 => 0 2 4 6 8 10
seq 0 -2 -5 => 0 -2 -4
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
data:
{{- $myList := list 1 2 3 4 5 }}
data1: {{ slice $myList | quote }} #没有设置步长，返回所有
data2: {{ slice $myList 3 | quote }} #从索引为3的位置进行切片
data3: {{ slice $myList 1 3 | quote }} #从索引为1的位置进行切片,切到索引3
data4: {{ slice $myList 0 3 | quote }} #从索引为0的位置进行切片,切到索引3
data5: {{ until 5 | quote }} #until函数用于构建一个指定整数范围内的列表,构建5个整数范围的列表
data6: {{ untilStep 3 9 2 | quote }} #untilStep函数与until函数相似,不过可以定义整数的开始和步长, 输出3-9之间的数字,步长值为2
data7: {{ seq 5 | quote }} #单个参数,会生成所有从1到包含end的整数
data8: {{ seq 0 2 | quote }} #开始 结束
data9: {{ seq 0 2 10 | quote }} #开始 步长 结束
#quote是加一个双引号,下面是使用slice函数对列表进行切片
#seq函数与linux中的seq命令类似,用于生成指定范围内的整数
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
data:
data1: "[1 2 3 4 5]" #没有设置步长，返回所有
data2: "[4 5]" #从索引为3的位置进行切片
data3: "[2 3]" #从索引为1的位置进行切片,切到索引3
data4: "[1 2 3]" #从索引为0的位置进行切片,切到索引3
data5: "[0 1 2 3 4]" #until函数用于构建一个指定整数范围内的列表,构建5个整数范围的列表
data6: "[3 5 7]" #untilStep函数与until函数相似,不过可以定义整数的开始和步长, 输出3-9之间的数字,步长值为2
data7: "1 2 3 4 5" #单个参数,会生成所有从1到包含end的整数
data8: "0 1 2" #开始 结束
data9: "0 2 4 6 8 10" #开始 步长 结束
#quote是加一个双引号,下面是使用slice函数对列表进行切片
#seq函数与linux中的seq命令类似,用于生成指定范围内的整数

9.helm3的数学计算函数

1.常用helm3的数学计算函数
(1).add函数、sub函数、mul函数、div、mod、add1函数
(2).max函数、min函数、round函数、len函数、floor函数、ceil函数 
2.常用helm3的数学计算函数使用的演示
1).环境准备 k8s集群
# kubectl get node
NAME STATUS ROLES AGE VERSION
m1 Ready control-plane,master 252d v1.20.4
m2 Ready control-plane,master 252d v1.20.4
m3 Ready control-plane,master 252d v1.20.4
n1 Ready <none> 251d v1.20.4
2).创建一个chart包 (用helm3发布创建一个configmap,创建的k8s集群中,发布其他应用也一样)
# helm create mychart #创建一个chart包，chart包名为： mychart
# cd mychart/
# ls
charts Chart.yaml templates values.yaml
# cd templates/
# ls
deployment.yaml _helpers.tpl hpa.yaml ingress.yaml NOTES.txt serviceaccount.yaml service.yaml tests
# rm -rf * #全部删除
3).编写自己需要的yaml文件，使用上面的各个内置函数演示
(1).add函数、sub函数、mul函数、div、mod、add1函数的使用演示 
分别含义如下:
add、sub、mul、div 、mod函数： 分别用来计算加减乘除和取模，可以接受两个或多个参数
示例:
add 1 2 3 # 计算加，返回 6
sub 3 2 # 计算减，返回 1
mul 3 2 # 计算乘，返回 6
div 6 3 # 计算除，返回 2
mod 9 2 #取模，求余数，返回1
add1函数： 用于给参数加 1。只能接受一个参数，示例: add1 3 给参数3加1，结果是4
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
data:
data1: {{ add 1 2 3 | quote }} #计算加
data2: {{ sub 3 2 | quote }} #计算减
data3: {{ mul 3 2 | quote }} #计算乘
data4: {{ div 6 3 | quote }} #计算除
data5: {{ mod 9 2 | quote }} #取模求余数
data6: {{ add1 3 | quote }} #用于给参数加1,给参数3加1,结果4
#quote是加上双引号
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
data:
data1: "6" #计算加
data2: "1" #计算减
data3: "6" #计算乘
data4: "2" #计算除
data5: "1" #取模求余数
data6: "4" #用于给参数加1,给参数3加1,结果4
#quote是加上双引号
#quote是加上双引号
(2).max函数、min函数、round函数、len函数、floor函数、ceil函数的使用演示 
分别含义如下：
max函数 和 min 函数： 分别用于取出一组参数中的最大值和最小值。 示例1: max 1 2 3 示例2: min 1 2 3
round函数： 用计算输入值四舍五入后的值，需传入两个参数，最后一个参数代表保留的小数位。示例: round 3.1415926 3
len函数： 用于计算参数的长度。 示例: len "abcde"
floor函数： 用于返回小于等于输入值的最大浮点整数。 示例： floor 123.9999 #返回 123
ceil函数： 用于返回大于等于输入值的最小浮点整数，返回的值一定要大于或等于输入的值。 示例: ceil 123.9999 #返回 124
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
data:
data1: {{ max 1 2 3 | quote }} #max函数,取出一组参数中的最大值
data2: {{ min 1 2 3 | quote }} #min函数,取出一组参数中的最小值
data3: {{ round 3.1415926 3 | quote }} #round函数,用计算输入值四舍五入后的值,保留3位小数
data4: {{ len "abcde" | quote }} #len函数,用于计算参数的长度
data5: {{ floor 123.9999 | quote }} #floor函数,用于返回小于等于输入值的最大浮点整数
data6: {{ ceil 123.9999 | quote }} #ceil函数,用于返回大于等于输入值的最小浮点整数
#quote是加上双引号
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
data:
data1: "3" #max函数,取出一组参数中的最大值
data2: "1" #min函数,取出一组参数中的最小值
data3: "3.142" #round函数,用计算输入值四舍五入后的值,保留3位小数
data4: "5" #len函数,用于计算参数的长度
data5: "123" #floor函数,用于返回小于等于输入值的最大浮点整数
data6: "124" #ceil函数,用于返回大于等于输入值的最小浮点整数
#quote是加上双引号

10.helm3的网络函数、文件路径函数、类型检查函数

1.常用helm3的网络函数、文件路径函数、类型检查函数
(1).getHostByName网络函数
(2).文件路径函数 base函数、dir函数、ext函数、isAbs函数
(3).类型检查和对比函数 kindOf函数、kindIs函数、deepEqual函数
2.常用helm3的网络函数、文件路径函数、类型检查函数使用的演示
1).环境准备 k8s集群
# kubectl get node
NAME STATUS ROLES AGE VERSION
m1 Ready control-plane,master 252d v1.20.4
m2 Ready control-plane,master 252d v1.20.4
m3 Ready control-plane,master 252d v1.20.4
n1 Ready <none> 251d v1.20.4
2).创建一个chart包 (用helm3发布创建一个configmap,创建的k8s集群中,发布其他应用也一样)
# helm create mychart #创建一个chart包，chart包名为： mychart
# cd mychart/
# ls
charts Chart.yaml templates values.yaml
# cd templates/
# ls
deployment.yaml _helpers.tpl hpa.yaml ingress.yaml NOTES.txt serviceaccount.yaml service.yaml tests
# rm -rf * #全部删除
3).编写自己需要的yaml文件，使用上面的各个内置函数演示
(1).getHostByName网络函数使用的演示 用于接收一个域名并返回该域名的解析后的IP地址 示例: getHostByName "www.baidu.com"
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
data:
data1: {{ getHostByName "www.baidu.com" | quote }} #getHostByName网络函数,用于接收一个域名并返回该域名的解析后的IP地址
#quote是加上双引号
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
data:
data1: "110.242.68.3" #getHostByName网络函数,用于接收一个域名并返回该域名的解析后的IP地址
#quote是加上双引号
(2).文件路径函数base函数、dir函数、ext函数、isAbs函数使用的演示 用于对文件路径进行处理
分别含义如下：
base函数： 用于返回指定路径的最后一级目录
dir函数： 用于返回指定路径的上一级路径（也就是去掉最后一级路径）
ext函数： 用于返回文件的拓展名
isAbs函数：用于判断文件路径是否是绝对路径，是绝对路径则返回 true，否则返回 false
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
data:
data1: {{ base "/tmp/a/a.txt" }} #返回最后一级目录
data2: {{ dir "/tmp/a/a.txt" }} #去掉最后一级目录
data3: {{ ext "a.txt" }} #返回文件的扩展名
data4: {{ isAbs "/tmp/a" }} #判断文件路径是否为绝对路径
data5: {{ isAbs "tmp/a" }} #判断文件路径是否为绝对路径
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
data:
data1: a.txt #返回最后一级目录
data2: /tmp/a #去掉最后一级目录
data3: .txt #返回文件的扩展名
data4: true #判断文件路径是否为绝对路径
data5: false #判断文件路径是否为绝对路径
(3).类型检查和对比函数 kindOf函数、kindIs函数、deepEqual函数使用的演示
分别含义如下：
kindOf： 用于返回对象的类型
kindIs： 用于检测某个对象是否是指定的类型，返回布尔值，第一个参数需要指定类型，第二个参数需要指定检查的数据对象
deepEqual：用于判断两个对象的值是否完全一致，返回布尔值
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
data:
data1: {{ kindOf ( list 1 2 3 ) }} #kindOf函数：用于返回对象的类型
data2: {{ kindIs "string" "hi" }} #kindIs函数：用于检测某个对象是否是指定的类型,返回布尔值,后面的字符串,是前面定义的类型
data3: {{ deepEqual ( list 1 2 3) (list 1 2 3 ) }} #deepEqual函数:用于判断两个对象的值是否完全一致,返回布尔值,一致返回true
data4: {{ deepEqual ( list 1 2 3) (list 2 3 4 ) }} #deepEqual函数:用于判断两个对象的值是否完全一致,返回布尔值,不一致返回false
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
data:
data1: slice #kindOf函数：用于返回对象的类型
data2: true #kindIs函数：用于检测某个对象是否是指定的类型,返回布尔值,后面的字符串,是前面定义的类型
data3: true #deepEqual函数:用于判断两个对象的值是否完全一致,返回布尔值,一致返回true
data4: false #deepEqual函数:用于判断两个对象的值是否完全一致,返回布尔值,不一致返回false

 

 

第五章.流控制结构语句

流控语句if/else、with语句、range语句

helm3中的几种流控制结构语句
(1).if/else语句 主要用于条件判断，不同的条件做不同的事情
if/else语句中的条件在模板中称为管道，基本结构如下：
{{- if PIPELINE }}
#do something
{{- else if OTHER PIPELINE }}
#do something else
{{- else }}
#default case
{{- end }}
如果管道中存在空值时,管道的返回值会设置为false
(2).with语句 with语句主要是用来控制变量的范围，也就是修改查找变量的作用域
示例:
...
data:
#正常方式调用values.yaml文件,引用好多变量对象时,会重复写很多相同的引用
Name: {{ .Values.people.info.name }}
Age: {{ .Values.people.info.age }}
Sex: {{ .Values.people.info.sex }}
#通过with语句,效果和上面一样,引用很多重复的变量对象时,可用with语句将重复的路径作用域设置过来
{{- with .Values.people }}
Name: {{ .info.name }}
Age: {{ .info.age }}
Sex: {{ .info.sex }}
{{- end }}

(3). range语句 range用于提供循环遍历集合输出的功能
用法格式:
{{- range 要遍历的对象 }}
# do something
{{- end }}
2.helm3中的几种流控制结构语句的实际案例使用
1).环境准备 k8s集群
# kubectl get node
NAME STATUS ROLES AGE VERSION
m1 Ready control-plane,master 252d v1.20.4
m2 Ready control-plane,master 252d v1.20.4
m3 Ready control-plane,master 252d v1.20.4
n1 Ready <none> 251d v1.20.4
2).创建一个chart包 (用helm3发布创建一个configmap,创建的k8s集群中,发布其他应用也一样)
# helm create mychart #创建一个chart包，chart包名为： mychart
# cd mychart/
# ls
charts Chart.yaml templates values.yaml
# cd templates/
# ls
deployment.yaml _helpers.tpl hpa.yaml ingress.yaml NOTES.txt serviceaccount.yaml service.yaml tests
# rm -rf * #全部删除
3).编写自己需要的yaml文件，使用上面的语句演示
(1). if/else语句 
# vim /root/mychart/values.yaml #定义变量和赋值
Person:
name: xiaoming
age: 16
sex: man
work: IT
ingress:
enabled: true
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件，调用values.yaml的变量
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
name: {{ .Values.Person.name | default "test_name" | quote }}
sex: {{ .Values.Person.sex | upper | quote }}
{{- if .Values.ingress.enabled }}
ingress: "配置ingress..." #若ingress开关开启,做ingress相关配置
{{- else }}
ingress: "不配置ingress..." #否则ingress开关没开启,不配置ingress
{{- end }}
{{- if eq .Values.Person.work "IT" }}
WORK: {{ .Values.Person.work | quote }}
{{- else }}
WORK: "other work"
{{- end }}
#注意:执行报错时候，去掉下面注释
#{{- }} 表示向左删除空白包括删除空格和换行,不加可能会增加一个换行,前面加横线是为了去掉该行的空格,如果不加,该行渲染时会形成空格
#{{ -}} 表示向右删除空白,并且会删除换行,一般慎用(因为删除换行时候，打印内容就乱了,还可能语法报错)
测试1: 当ingress开关开启，工作为IT时候，如下输出:
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
name: "xiaoming"
sex: "MAN"
ingress: "配置ingress..." #若ingress开关开启,做ingress相关配置
WORK: "IT"
测试2: 当ingress开关不开启，工作不是IT时候，如下输出:
# vim /root/mychart/values.yaml #定义变量和赋值
Person:
name: xiaoming
age: 16
sex: man
work: IT
ingress:
enabled: false
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件，调用values.yaml的变量
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
name: {{ .Values.Person.name | default "test_name" | quote }}
sex: {{ .Values.Person.sex | upper | quote }}
{{- if .Values.ingress.enabled }}
ingress: "配置ingress..." #若ingress开关开启,做ingress相关配置
{{- else }}
ingress: "不配置ingress..." #否则,不配置ingress
{{- end }}
{{- if eq .Values.Person.work "other" }}
WORK: {{ .Values.Person.work | quote }}
{{- else }}
WORK: "other work"
{{- end }}
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
name: "xiaoming"
sex: "MAN"
ingress: "不配置ingress..." #否则,不配置ingress
WORK: "other work"
(2). with语句 with语句主要是用来控制变量的范围，也就是修改查找变量的作用域。
在前面我们讲到，. 代表的含义是当前作用域，那么 .Values 就是在当前作用域中查找Values 对象。
我们可以使用 with 语句来将特定对象设置为当前作用域，这样设定完成后，就可以使用 . 来代表在这个特定的对象下获取变量了。
最后使用 {{ end }} 作为结束，代表作用域被重置。
引用很多重复的变量对象时,可用with语句将重复的路径作用域设置过来,即:将要引用的作用域设置到当前,那么后面用.引用就是引用的设置的作用域
示例:
...
data:
#正常方式调用values.yaml文件,引用好多变量对象时,会重复写很多相同的引用
Name: {{ .Values.people.info.name }}
Age: {{ .Values.people.info.age }}
Sex: {{ .Values.people.info.sex }}
#通过with语句,效果和上面一样,引用很多重复的变量对象时,可用with语句将重复的路径作用域设置过来
{{- with .Values.people }}
Name: {{ .info.name }}
Age: {{ .info.age }}
Sex: {{ .info.sex }}
{{- end }}
# vim /root/mychart/values.yaml #定义变量和赋值
people:
info:
name: test
age: 18
sex: boy
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件，调用values.yaml的变量
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
#正常方式调用values.yaml文件,引用好多变量对象时,会重复写很多相同的引用
Name: {{ .Values.people.info.name }}
Age: {{ .Values.people.info.age }}
Sex: {{ .Values.people.info.sex }}
#通过with语句,效果和上面一样,引用很多重复的变量对象时,可用with语句将重复的路径作用域设置过来
{{- with .Values.people }}
Name: {{ .info.name }}
Age: {{ .info.age }}
Sex: {{ .info.sex }}
{{- end }}
#执行报错可将下面注释删除:
#{{- }} 表示向左删除空白包括删除空格和换行,不加可能会增加一个换行,前面加横线是为了去掉该行的空格,如果不加,该行渲染时会形成空格
#{{ -}} 表示向右删除空白,并且会删除换行,一般慎用(因为删除换行时候，打印内容就乱了,还可能语法报错)
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
#正常方式调用values.yaml文件,引用好多变量对象时,会重复写很多相同的引用
Name: test
Age: 18
Sex: boy
#通过with语句,效果和上面一样,引用很多重复的变量对象时,可用with语句将重复的路径作用域设置过来,即:将要引用的作用域设置到当前,那么后面用.引用就是引用的设置的作用域
Name: test
Age: 18
Sex: boy
(3). range语句 range用于提供循环遍历集合输出的功能
range指定遍历指定对象，每次循环的时候，都会将作用域设置为当前的对象。直接使用 . 来代表当前作用域并对当前的对象进行输出
除了Values 对象中的集合，range 也可以对 tuple、dict、list 等进行遍历
用法格式:
{{- range 要遍历的对象 }}
# do something
{{- end }}
# vim /root/mychart/values.yaml #定义变量和赋值
address:
- beijing
- shanghai
- xian
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件，调用values.yaml的变量
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
namespace: {{ .Release.Namespace }}
data:
address: |-
{{- range .Values.address }}
- {{ . | title }}
{{- end }}
{{- range tuple "bj" "sh" "guang" }}
- {{ . | title }}
{{- end }}
#执行报错，删掉下面注释再执行
#range用于提供循环遍历集合输出的功能,
#- {{ . | title }} #用.作为输出,并使用title函数进行了修饰为首字母大写,或去掉tile函数,仅使用用.作为输出
#上面是用range对获取的变量字符串内容进行遍历输出
#下面是用range对元组进行遍历输出
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
namespace: default
data:
address: |-
- Beijing
- Shanghai
- Xian
- Bj
- Sh
- Guang

第六章.helm3中变量详解

helm3中变量在作用域、列表或元组、字典中的使用

1. helm3中声明变量的格式和作用
   在 helm3中，变量通常是搭配 with语句 和 range语句 使用，这样能有效的简化代码。
   变量的定义格式如下： $name := value （ := 称为赋值运算符，将后面值赋值给前面的变量:name）
   (1).使用变量解决对象作用域问题 
   因为with语句里不能调用父级别的变量,所以如果需要调用父级别的变量,需要声明一个变量名,将父级别的变量值赋值给声明的变量
   在前面关于helm流控制结构的文章中提到过使用with 更改当前作用域的用法，当时存在一个问题是在with 语句中，无法使用父作用域中的对象，需要使用 $ 符号或者将语句移到 {{- end }} 的外面才可以。现在使用变量也可以解决这个问题。
   示例：
   # vim /root/mychart/values.yaml #定义变量和赋值
   people:
   info:
   name: test
   age: 18
   sex: boy
   # vim xxx.yaml
   apiVersion: v1
   kind: ConfigMap
   metadata:
   name: {{ .Release.Name }}-configmap
   data:
   {{- $releaseName := .Release.Name }}
   {{- with .Values.people.info }}
   name: {{ .name }}
   age: {{ .age }}
   #release1: {{ .Release.Name }} #1.在with语句内（因为改变了变量作用域），不能调用父级别的变量,且会报错
   release2: {{ $releaseName }} #2.通过变量解决调用父级别的变量
   {{ end }}
   release3: {{ .Release.Name }} #3.在with语句外，可以调用父级别的变量
   (2).变量在列表或元组中的使用 变量也常用在遍历列表或元组中，可以获取到索引和值（索引号和值都可以打印出来）
   # vim /root/mychart/values.yaml #定义变量和赋值
   address:
   - beijing
   - shanghai
   - xian
   # vim xxx.yaml
   apiVersion: v1
   kind: ConfigMap
   metadata:
   name: {{ .Release.Name }}-configmap
   data:
   address: |-
   {{- range $index, $add := .Values.address }} #将遍历的列表元素赋值给两个变量,一个是索引号，一个是元素值,并且通过range语句循环遍历出来
   {{ $index }}: {{ $add }}
   {{- end }}
   结果:
   address: |-
   0: beijing
   1: shanghai
   2: xian
   (3).变量在字典中的使用 变量也能用于变量字典，获取每个键值对（k和v)
   对于字典类型的结构，可以使用 range 获取到每个键值对的 key 和 value（注意，字典是无序的，所以遍历出来的结果也是无序的。）
   示例：
   # vim /root/mychart/values.yaml #定义变量和赋值
   person:
   info:
   name: test
   sex: boy
   address: beijing
   age: 18
   #vim xxx.yaml
   apiVersion: v1
   kind: ConfigMap
   metadata:
   name: {{ .Release.Name }}-configmap
   data:
   info: |-
   {{- range $key, $value := .Values.person.info }}
   {{ $key }}: {{ $value }}
   {{- end }}
   结果:
   info: |-
   address: beijing
   age: 18
   name: test
   sex: boy
   2.helm3中的声明变量的实际案例使用
   1).环境准备 k8s集群
   # kubectl get node
   NAME STATUS ROLES AGE VERSION
   m1 Ready control-plane,master 252d v1.20.4
   m2 Ready control-plane,master 252d v1.20.4
   m3 Ready control-plane,master 252d v1.20.4
   n1 Ready <none> 251d v1.20.4
   2).创建一个chart包 (用helm3发布创建一个configmap,创建的k8s集群中,发布其他应用也一样)
   # helm create mychart #创建一个chart包，chart包名为： mychart
   # cd mychart/
   # ls
   charts Chart.yaml templates values.yaml
   # cd templates/
   # ls
   deployment.yaml _helpers.tpl hpa.yaml ingress.yaml NOTES.txt serviceaccount.yaml service.yaml tests
   # rm -rf * #全部删除
   3).编写自己需要的yaml文件，使用上面的变量演示
   (1).使用变量解决对象作用域问题的演示
   变量的定义格式如下： $name := value （ := 称为赋值运算符，将后面值赋值给前面的变量:name）
   因为使用with语句时，里面不能调用父级别的变量,所以如果需要调用父级别的变量,需要声明一个变量名,将父级别的变量值赋值给声明的变量
   # vim /root/mychart/values.yaml #定义变量和赋值
   people:
   info:
   name: test
   age: 18
   sex: boy
   # vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件，调用values.yaml的变量
   apiVersion: v1
   kind: ConfigMap
   metadata:
   name: {{ .Release.Name }}-configmap
   namespace: {{ .Release.Namespace }}
   data:
   #通过with语句,效果和上面一样,引用很多重复的变量对象时,可用with语句将重复的路径作用域设置过来
   #但是with语句里不能调用父级别的变量,所以如果需要调用父级别的变量,需要声明一个变量名,将父级别的变量值赋值给声明的变量
   {{ $releasename := .Release.Name }} #声明一个变量releasename，将父级别的变量值赋值给该变量
   {{ $sex := .Values.people.info.sex }} #声明一个变量sex，将父级别的变量值赋值给该变量
   {{- with .Values.people.info }}
   Name: {{ .name }} #with语句中正常调用变量值
   Age: {{ .age }} #with语句中正常调用变量值
   Sex: {{ $sex }} #with语句中通过变量解决调用父级别的变量
   Release2: {{ $releasename }} #with语句中通过变量解决调用父级别的变量
   #Release4: {{ .Release.Name }} #with语句中不能直接调用父级别的变量,会报错，注释都会报错
   {{- end }}
   Release3: {{ .Release.Name }} #不在with语句中可以直接调用父级别的变量
   # helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
   ...
   # Source: mychart/templates/configmap.yaml
   apiVersion: v1
   kind: ConfigMap
   metadata:
   name: myconfigmap1-configmap
   namespace: default
   data:
   #通过with语句,效果和上面一样,引用很多重复的变量对象时,可用with语句将重复的路径作用域设置过来
   #但是with语句里不能调用父级别的变量,所以如果需要调用父级别的变量,需要声明一个变量名,将父级别的变量值赋值给声明的变量
   #声明一个变量releasename，将父级别的变量值赋值给该变量
   #声明一个变量sex，将父级别的变量值赋值给该变量
   Name: test #with语句中正常调用变量值
   Age: 18 #with语句中正常调用变量值
   Sex: boy #with语句中通过变量解决调用父级别的变量
   Release2: myconfigmap1 #with语句中通过变量解决调用父级别的变量
   Release3: myconfigmap1 #不在with语句中可以直接调用父级别的变量
   (2).变量在列表或元组中的使用 变量也常用在遍历列表或元组中，可以获取到索引和值（索引号和值都可以打印出来）
   apiVersion: v1
   kind: ConfigMap
   metadata:
   name: {{ .Release.Name }}-configmap
   data:
   address: |-
   {{- range $index, $add := .Values.address }} #range遍历对象,将后面遍历到的对象赋值给前面两个变量,分别得到索引号和对应的值
   {{ $index }}: {{ $add }} #依次输出索引号和对应的值
   {{- end }}
   # vim /root/mychart/values.yaml #定义变量和赋值
   address:
   - beijing
   - shanghai
   - xian
   # vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件，调用values.yaml的变量
   apiVersion: v1
   kind: ConfigMap
   metadata:
   name: {{ .Release.Name }}-configmap
   namespace: {{ .Release.Namespace }}
   data:
   address: |-
   {{- range $index, $add := .Values.address }} #range遍历对象,将后面遍历到的对象赋值给前面两个变量,分别得到索引号和对应的值
   {{ $index }}: {{ $add }} #依次输出索引号和对应的值
   {{- end }}
   # helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
   ...
   # Source: mychart/templates/configmap.yaml
   apiVersion: v1
   kind: ConfigMap
   metadata:
   name: myconfigmap1-configmap
   namespace: default
   data:
   address: |- #range遍历对象,将后面遍历到的对象赋值给前面两个变量,分别得到索引号和对应的值
   0: beijing #依次输出索引号和对应的值 #range遍历对象,将后面遍历到的对象赋值给前面两个变量,分别得到索引号和对应的值
   1: shanghai #依次输出索引号和对应的值 #range遍历对象,将后面遍历到的对象赋值给前面两个变量,分别得到索引号和对应的值
   2: xian #依次输出索引号和对应的值
   (3).变量在字典中的使用 变量也能用于变量字典，获取每个键值对（k和v)
   对于字典类型的结构，可以使用 range 获取到每个键值对的 key 和 value（注意，字典是无序的，所以遍历出来的结果也是无序的。）
   示例：
   apiVersion: v1
   kind: ConfigMap
   metadata:
   name: {{ .Release.Name }}-configmap
   data:
   info: |-
   {{- range $key, $value := .Values.person.info }} #range遍历,将后面遍历出来的字典对象的值赋值给前面两个变量,分别对应key和value
   {{ $key }}: {{ $value }} #将两个变量的值进行依次输出（key和value)
   {{- end }}
   # vim /root/mychart/values.yaml #定义变量和赋值
   person:
   info:
   name: test
   sex: boy
   address: beijing
   age: 18
   # vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件，调用values.yaml的变量
   apiVersion: v1
   kind: ConfigMap
   metadata:
   name: {{ .Release.Name }}-configmap
   data:
   info: |-
   {{- range $key, $value := .Values.person.info }} #range遍历,将后面遍历出来的字典对象的值赋值给前面两个变量,分别对应key和value
   {{ $key }}: {{ $value }} #将两个变量的值进行依次输出（key和value)
   {{- end }}
   # helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
   ...
   # Source: mychart/templates/configmap.yaml
   apiVersion: v1
   kind: ConfigMap
   metadata:
   name: myconfigmap1-configmap
   data:
   info: |- #range遍历,将后面遍历出来的字典对象的值赋值给前面两个变量,分别对应key和value
   address: beijing #将两个变量的值进行依次输出（key和value) #range遍历,将后面遍历出来的字典对象的值赋值给前面两个变量
   age: 18 #将两个变量的值进行依次输出（key和value) #range遍历,将后面遍历出来的字典对象的值赋值给前面两个变量
   name: test #将两个变量的值进行依次输出（key和value) #range遍历,将后面遍历出来的字典对象的值赋值给前面两个变量
   sex: boy #将两个变量的值进行依次输出（key和value)

第七章.helm3中子模板的定义和使用

helm3中define定义子模板、template和include调用

1.定义子模板的两个位置
(1).主模板中
(2)._helpers.tpl文件内
定义子模板，可以在主模板中定义，也可在其他文件中定义（_helpers.tpl 文件内,是专门提供的定义子模板的文件）
实际使用中，这些子模板的内容应当放在单独的文件中，通常是 _helpers.tpl 文件内
2.子模板的定义和调用
定义子模板： 通过define定义
调用子模板： 通过template或include调用(推荐)
template和include,都有用来引用子模板,用法一样，稍微有点区别，下面详细介绍
演示案例：（下面详细介绍）
(1).使用define在主模板中定义子模板的，使用template进行调用子模板
(2).使用define在_helpers.tpl文件中定义子模板，使用template进行调用子模板
(3).向子模板中传入对象，使用template进行调用子模板（以上面其中一种定义子模板方式演示,以define在_helpers.tpl文件中定义子模板为例)
(4).向子模板中传入对象，使用include进行调用子模板（以上面其中一种定义子模板方式演示,以define在_helpers.tpl文件中定义子模板为例)
3.helm3中定义和使用子模板的实际案例使用
1).环境准备 k8s集群
# kubectl get node
NAME STATUS ROLES AGE VERSION
m1 Ready control-plane,master 252d v1.20.4
m2 Ready control-plane,master 252d v1.20.4
m3 Ready control-plane,master 252d v1.20.4
n1 Ready <none> 251d v1.20.4
2).创建一个chart包 (用helm3发布创建一个configmap,创建的k8s集群中,发布其他应用也一样)
# helm create mychart #创建一个chart包，chart包名为： mychart
# cd mychart/
# ls
charts Chart.yaml templates values.yaml
# cd templates/
# ls
deployment.yaml _helpers.tpl hpa.yaml ingress.yaml NOTES.txt serviceaccount.yaml service.yaml tests
# rm -rf * #全部删除
3).编写自己需要的yaml文件
(1).使用define在主模板中定义子模板的演示，使用template进行调用子模板 
注意： define定义的子模板，需要通过调用才能输出，如果不调用是不会有输出的。
格式:
{{- define "mychart.labels" }}
labels:
author: test
date: {{ now | htmlDate }}
{{- end }}
# vim /root/mychart/values.yaml #定义变量和赋值,此处values.yaml文件没用上
xxx
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
{{- define "mychart.labels" }}
labels:
author: test
date: {{ now | htmlDate }}
{{- end }}
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
{{- template "mychart.labels" }}
data:
data1: "hello"
#define 定义一个子模板,子模板的名称是: mychart.labels
#template 调用子模板,通过子模板的名称调用,输出子模板的内容
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
labels:
author: test
date: 2022-11-27
data:
data1: "hello"
#define 定义一个子模板,子模板的名称是: mychart.labels
#template 调用子模板,通过子模板的名称调用,输出子模板的内容
(2).使用define在_helpers.tpl文件中定义子模板的演示，使用template进行调用子模板
注意： define定义的子模板，需要通过调用才能输出，如果不调用是不会有输出的。
# vim /root/mychart/values.yaml #定义变量和赋值,此处values.yaml文件没用上
xxx
# vim /root/mychart/templates/_helpers.tpl #在_helpers.tpl中定义子模板, 原文件以清空,换成下面模板内容
{{/* 注释 */}}
{{- define "mychart.labels" }}
labels:
author: test
date: {{ now | htmlDate }}
{{- end }}
#define 定义一个子模板,子模板的名称是: mychart.labels
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
{{- template "mychart.labels" }}
data:
data1: "hello"
#template 调用子模板,通过子模板的名称调用,输出子模板的内容
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
labels:
author: test
date: 2022-11-27
data:
data1: "hello"
#template 调用子模板,通过子模板的名称调用,输出子模板的内容
(3).向子模板中传入对象，使用template进行调用子模板的演示（以上面其中一种定义子模板方式演示,以define在_helpers.tpl文件中定义子模板为例)
注意： define定义的子模板，需要通过调用才能输出，如果不调用是不会有输出的。
# vim /root/mychart/values.yaml #定义变量和赋值
person:
info:
name: test
sex: boy
address: beijing
age: 18
# vim /root/mychart/templates/_helpers.tpl #在_helpers.tpl中定义子模板, 原文件以清空,换成下面模板内容
{{/* 注释 */}}
{{- define "mychart.labels" }}
labels:
Author: {{ .Values.person.info.name }}
Address: {{ .Values.person.info.address }}
{{- end }}
{{/* 在子模板中,如果引用了对象,那么渲染的时候子模板中是无法获取到对象的信息的,所以如果直接调用子模板会报错.解决这个问题需要在引用子模板的同时,将对象的位置传递进去即可*/}}
{{/*define 定义一个子模板,子模板的名称是: mychart.labels*/}}
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
{{- template "mychart.labels" . }}
data:
data1: "hello"
#template 调用子模板,通过子模板的名称调用,输出子模板的内容
#在子模板中,如果引用了对象,那么渲染的时候子模板中是无法获取到对象的信息的,所以如果直接调用子模板会报错
#解决这个问题需要在引用子模板的同时,将对象的位置传递进去即可
#主模板引用子模板时候需要指定对象的位置信息,这个"点".表示在顶层作用域中寻找子模板中指定的对象
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
labels:
Author: test
Address: beijing
data:
data1: "hello"
#template 调用子模板,通过子模板的名称调用,输出子模板的内容
#在子模板中,如果引用了对象,那么渲染的时候子模板中是无法获取到对象的信息的,所以如果直接调用子模板会报错
#解决这个问题需要在引用子模板的同时,将对象的位置传递进去即可
#主模板引用子模板时候需要指定对象的位置信息,.表示在顶层作用域中寻找子模板中指定的对象
指定对象的位置信息，除了用.在顶层作用域寻找，也可用下面形式:
# vim /root/mychart/values.yaml #定义变量和赋值
person:
info:
name: test
sex: boy
address: beijing
age: 18
# vim /root/mychart/templates/_helpers.tpl #在_helpers.tpl中定义子模板, 原文件以清空,换成下面模板内容
{{/* 注释 */}}
{{- define "mychart.labels" }}
labels:
Author: {{ .name }}
Address: {{ .address }}
{{- end }}
{{/* 在子模板中,如果引用了对象,那么渲染的时候子模板中是无法获取到对象的信息的,所以如果直接调用子模板会报错.解决这个问题需要在引用子模板的同时,将对象的位置传递进去即可*/}}
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
{{- template "mychart.labels" .Values.person.info }}
data:
data1: "hello"
#template 调用子模板,通过子模板的名称调用,输出子模板的内容
#在子模板中,如果引用了对象,那么渲染的时候子模板中是无法获取到对象的信息的,所以如果直接调用子模板会报错
#解决这个问题需要在引用子模板的同时,将对象的位置传递进去即可
#主模板引用子模板时候需要指定对象的位置信息,.表示在顶层作用域中寻找子模板中指定的对象
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
labels:
Author: test
Address: beijing
data:
data1: "hello"
#template 调用子模板,通过子模板的名称调用,输出子模板的内容
#在子模板中,如果引用了对象,那么渲染的时候子模板中是无法获取到对象的信息的,所以如果直接调用子模板会报错
#解决这个问题需要在引用子模板的同时,将对象的位置传递进去即可
#主模板引用子模板时候需要指定对象的位置信息,.表示在顶层作用域中寻找子模板中指定的对象
(4).向子模板中传入对象，使用include进行调用子模板（以上面其中一种定义子模板方式演示,以define在_helpers.tpl文件中定义子模板为例)
template和include,都有用来引用子模板,用法一样,template不能被其他函数修饰,include可以
常见缩进时候,如果想要自定义修饰缩进的字符,template因不能被其他函数修饰而会报错
include可以被其他函数修饰,推荐使用include,上面如果换成template会报错
# vim /root/mychart/values.yaml #定义变量和赋值
person:
info:
name: test
sex: boy
address: beijing
age: 18
# vim /root/mychart/templates/_helpers.tpl #在_helpers.tpl中定义子模板, 原文件以清空,换成下面模板内容
{{/* 注释 */}}
{{- define "mychart.labels" }}
Author: {{ .Values.person.info.name }}
Address: {{ .Values.person.info.address }}
{{- end }}
{{/* 在子模板中,如果引用了对象,那么渲染的时候子模板中是无法获取到对象的信息的,所以如果直接调用子模板会报错.解决这个问题需要在引用子模板的同时,将对象的位置传递进去即可，将所有的缩进都删除*/}}
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
labels:
{{- include "mychart.labels" . | toString |indent 4 }}
data:
{{- include "mychart.labels" . | toString |indent 2 }}
#template和include,都有用来引用子模板,用法一样,template不能被其他函数修饰,include可以
#常见缩进时候,如果想要自定义修饰缩进的字符,template因不能被其他函数修饰而会报错
#include可以被其他函数修饰,推荐使用include,上面如果换成template会报错
#为了防止干扰,将两个定义不同缩进的引用都顶格写,查看自定义缩进的效果
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
labels:
Author: test
Address: beijing
data:
Author: test
Address: beijing
#template和include,都有用来引用子模板,用法一样,template不能被其他函数修饰,include可以
#常见缩进时候,如果想要自定义修饰缩进的字符,template因不能被其他函数修饰而会报错
#include可以被其他函数修饰,推荐使用include,上面如果换成template会报错
#为了防止干扰,将两个定义不同缩进的引用都顶格写,查看自定义缩进的效果

第八章.helm3获取其他文件内容

helm3中获取其他文件的内容或文件名

1.helm3中获取其他文件的内容或文件名
(1).使用Get方法获取其他文件的内容
(2).使用Glob方法获取文件名和内容
(3).使用lines方法循环遍历并逐行读取文件中的内容
2.helm3中的获取其他文件的内容或文件名的实际案例使用
1).环境准备 k8s集群
# kubectl get node
NAME STATUS ROLES AGE VERSION
m1 Ready control-plane,master 252d v1.20.4
m2 Ready control-plane,master 252d v1.20.4
m3 Ready control-plane,master 252d v1.20.4
n1 Ready <none> 251d v1.20.4
2).创建一个chart包 (用helm3发布创建一个configmap,创建的k8s集群中,发布其他应用也一样)
# helm create mychart #创建一个chart包，chart包名为： mychart
# cd mychart/
# ls
charts Chart.yaml templates values.yaml
# cd templates/
# ls
deployment.yaml _helpers.tpl hpa.yaml ingress.yaml NOTES.txt serviceaccount.yaml service.yaml tests
# rm -rf * #全部删除
3).编写自己需要的yaml文件
(1).使用Get方法获取其他文件的内容 
前面的文章讲到了如何定义多个模板以及导入另一个模板。但是有的时候我们需要导入的是一个普通的文件内容而不是模板文件。
所以Helm 提供了 .Files 对象用于访问文件，其中包含了一些方法用于处理文件中的内容。
示例:
token2: {{ .Files.Get "config/test.txt" | quote }}
# vim /root/mychart/values.yaml #定义变量和赋值,此处values.yaml文件没用上
xxx
# mkdir /root/mychart/config/ #自定义一个目录，该目录下自定义一个其他文件
# echo "test message" > /root/mychart/config/test.txt
# cat /root/mychart/config/test.txt
test message
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
data:
token1:
{{ .Files.Get "config/test.txt" | b64enc | indent 4 }}
token2: {{ .Files.Get "config/test.txt" | quote }}
#token1使用.Files对象中的Get方法获取其他文件的内容,这里写的其他文件路径是相对路径,再使用b64enc进行编码,再缩进4个字符
#token2不做任何处理,只讲获取的内容用quote加上双引号
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
data:
token1:
dGVzdCBtZXNzYWdlCg==
token2: "test message\n"
#token1使用.Files对象中的Get方法获取其他文件的内容,这里写的其他文件路径是相对路径,再使用b64enc进行编码,再缩进4个字符
#token2不做任何处理,只讲获取的内容用quote加上双引号
(2).使用Glob方法获取文件名(带路径)和内容 
# vim /root/mychart/values.yaml #定义变量和赋值,此处values.yaml文件没用上
xxx
# mkdir /root/mychart/config1 #自定义两个目录，该目录下自定义一个其他文件
# mkdir /root/mychart/config2
# echo "nginx conf" > /root/mychart/config1/nginx.conf
# echo "httpd conf" > /root/mychart/config1/httpd.conf
# echo "mysql conf" > /root/mychart/config2/mysql.conf
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
data:
{{- range $path, $_ := .Files.Glob "**.conf" }}
path: {{ $path }}
{{- end }}
{{ (.Files.Glob "config1/*").AsConfig | indent 2 }}
{{ (.Files.Glob "config2/*").AsSecrets | indent 2 }}
#上面:声明了两个变量$path和$_, 将.Files对象中的Glob方法匹配到的文件名赋值给前面变量$path, **代表匹配任意字符
#$_是一个占位符,必须要存在,但是会获取一个空
#中间:将Files对象中使用Glob方法匹配的文件名,使用AsConfig方法显示文件内容(以configmap形式显示) 缩进2字符
#下面:将Files对象中使用Glob方法匹配的文件名,使用AsSecrets方法显示文件内容(以secret形式显示) 缩进2字符
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
data:
path: config1/httpd.conf
path: config1/nginx.conf
path: config2/mysql.conf
httpd.conf: |
httpd conf
nginx.conf: |
nginx conf
mysql.conf: bXlzcWwgY29uZgo=
#上面:声明了两个变量$path和$_, 将.Files对象中的Glob方法匹配到的文件名赋值给前面变量$path, **代表匹配任意字符
#$_是一个占位符,必须要存在,但是会获取一个空
#中间:将Files对象中使用Glob方法匹配的文件名,使用AsConfig方法显示文件内容(以configmap形式显示) 缩进2字符
#下面:将Files对象中使用Glob方法匹配的文件名,使用AsSecrets方法显示文件内容(以secret形式显示) 缩进2字符
(3).使用lines方法循环遍历并逐行读取文件中的内容
# vim /root/mychart/values.yaml #定义变量和赋值,此处values.yaml文件没用上
xxx
# mkdir /root/mychart/config/ #自定义一个目录，该目录下自定义一个其他文件
# echo "the line1" >> /root/mychart/config/test.txt
# echo "the line2" >> /root/mychart/config/test.txt
# echo "the line3" >> /root/mychart/config/test.txt
# cat /root/mychart/config/test.txt
the line1
the line2
the line3
# vim /root/mychart/templates/configmap.yaml #编写一个自己需要的模板文件
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Release.Name }}-configmap
data:
{{- range $index, $line := .Files.Lines "config/test.txt" }}
{{- if $line }}
{{ $index }}: {{ $line | quote }}
{{- end }}
{{- end }}
#前面定义两个变量index和line,后面使用.Files对象中的Lines方法循环遍历后面文件中的每行内容赋值给line变量,将每行索引赋值给index变量#Lines方法通常和range一起使用,可以遍历文件中的每一行并输出.
#Lines方法遍历行的时,最后会输出一个空行,对于这个问题,可使用if语句来解决,判断当前行的内容是否为空,如果不为空则输出
#{{- if $line }} 如果为真,则是true,就输出下面的内容
# helm install myconfigmap1 ./mychart/ --debug --dry-run #不真正执行，只是试运行看是否能运行
...
# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: myconfigmap1-configmap
data:
0: "the line1"
1: "the line2"
2: "the line3"