[Cloud Native] Explication de l'architecture Helm et de la grammaire de base

I. Aperçu

Nous pouvons considérer Helm comme apt-get/yum sous Kubernetes. Helm est le gestionnaire de packages de Kubernetes. Il n'y a que des fichiers de liste de configuration dans l'entrepôt helm, mais pas d'images miroir. Les images miroir sont toujours fournies par des entrepôts miroir, tels que hub.docker.com et des entrepôts privés.

Documentation officielle : https://v3.helm.sh/zh/docs/

En fait, j'ai écrit un article sur helm avant [ Kubernetes (k8s) package manager Helm (Helm3) introduction & Helm3 installation Harbor ], il n'est peut-être pas assez détaillé, ici j'expliquerai helm plus en détail.

2. Architecture de barre

3. Installation de la barre

Adresse de téléchargement : https://github.com/helm/helm/releases

# 下载包
$  wget https://get.helm.sh/helm-v3.9.4-linux-amd64.tar.gz
# 解压压缩包
$ tar -xf helm-v3.9.4-linux-amd64.tar.gz
# 制作软连接
$ ln -s /opt/helm/linux-amd64/helm /usr/local/bin/helm
# 验证
$ helm version
$ helm help

4. Composants Helm et termes associés

• Helm——Helm est un outil client sous la ligne de commande . Il est principalement utilisé pour la création, le packaging et la publication de l'application Kubernetes Chart, ainsi que pour la création et la gestion d'entrepôts Chart locaux et distants.
• Chart- Le graphique représente un package Helm . Il contient toutes les définitions de ressources nécessaires pour exécuter une application, un outil ou un service dans un cluster Kubernetes. Vous pouvez le considérer comme l'équivalent Kubernetes de la formule Homebrew, Apt dpkg ou Yum RPM.
• Release——Release est l'instance du graphique exécuté dans le cluster Kubernetes . Un graphique peut généralement être installé plusieurs fois dans le même cluster. Chaque installation crée une nouvelle version.
• Repoistory——Le référentiel ( entrepôt ) est un endroit pour stocker et partager des graphiques. C'est comme le réseau d'archives CPAN de Perl ou le référentiel de packages de Fedora, sauf que c'est pour les packages Kubernetes.

5. Explication détaillée de Helm Chart

1) Structure du répertoire des cartes

# 通过helm create命令创建一个新的chart包
helm create nginx
tree nginx

nginx/
├── charts  #依赖其他包的charts文件
├── Chart.yaml # 该chart的描述文件,包括ico地址,版本信息等
├── templates  # #存放k8s模板文件目录
│   ├── deployment.yaml # 创建k8s资源的yaml 模板
│   ├── _helpers.tpl # 下划线开头的文件,可以被其他模板引用
│   ├── hpa.yaml # 弹性扩缩容，配置服务资源CPU 内存
│   ├── ingress.yaml # ingress 配合service域名访问的配置
│   ├── NOTES.txt # 说明文件,helm install之后展示给用户看的内容
│   ├── serviceaccount.yaml # 服务账号配置
│   ├── service.yaml # kubernetes Serivce yaml 模板
│   └── tests # 测试模块
│       └── test-connection.yaml 
└── values.yaml # 给模板文件使用的变量

Il peut y avoir des packages d'écriture et les répertoires suivants :

wordpress/
...
  LICENSE             # 可选: 包含chart许可证的纯文本文件
  README.md           # 可选: 可读的README文件
  values.schema.json  # 可选: 一个使用JSON结构的values.yaml文件
  charts/             # 包含chart依赖的其他chart
  crds/               # 自定义资源的定义
...

2) Fichier graphique.yaml

apiVersion: chart API 版本 （必需）
name: chart名称 （必需）
version: chart 版本，语义化2 版本（必需）
kubeVersion: 兼容Kubernetes版本的语义化版本（可选）
description: 一句话对这个项目的描述（可选）
type: chart类型 （可选）
keywords:
  - 关于项目的一组关键字（可选）
home: 项目home页面的URL （可选）
sources:
  - 项目源码的URL列表（可选）
dependencies: # chart 必要条件列表 （可选）
  - name: chart名称 (nginx)
    version: chart版本 ("1.2.3")
    repository: （可选）仓库URL ("https://example.com/charts") 或别名 ("@repo-name")
    condition: （可选） 解析为布尔值的yaml路径，用于启用/禁用chart (e.g. subchart1.enabled )
    tags: # （可选）
      - 用于一次启用/禁用 一组chart的tag
    import-values: # （可选）
      - ImportValue 保存源值到导入父键的映射。每项可以是字符串或者一对子/父列表项
    alias: （可选） chart中使用的别名。当你要多次添加相同的chart时会很有用
maintainers: # （可选）
  - name: 维护者名字 （每个维护者都需要）
    email: 维护者邮箱 （每个维护者可选）
    url: 维护者URL （每个维护者可选）
icon: 用做icon的SVG或PNG图片URL （可选）
appVersion: 包含的应用版本（可选）。不需要是语义化，建议使用引号
deprecated: 不被推荐的chart （可选，布尔值）
annotations:
  example: 按名称输入的批注列表 （可选）.

• À partir de la v3.3.2, les champs supplémentaires ne sont plus autorisés. La méthode recommandée consiste à ajouter des métadonnées personnalisées annotationsdans .
• Chaque graphique doit avoir un numéro de version ( version). Les versions doivent suivre la norme SemanticVersion 2. Contrairement à Helm classique, Helm v2 et versions ultérieures utilisent les numéros de version comme marqueurs de version. Les packages d'un référentiel sont identifiés par leur nom suivi d'un numéro de version.

Par exemple, le champ de version version : 1.2.3 du graphique nginx est défini sur :

nginx-1.2.3.tgz

[Rappel] appVersionLes champs ne sont pas liés aux versionchamps. C'est une façon de spécifier la version de l'application. Par exemple, ce graphique Drupal peut avoir une appVersion : "8.2.1", indiquant que la version de Drupal incluse dans le graphique (par défaut) est 8.2.1.

3) Gestion des dépendances graphiques (dépendances)

Les autres graphiques dont dépend le graphique actuel seront définis sous forme de liste dans le champ des dépendances.

dependencies:
  - name: apache
    version: 1.2.3
    repository: https://example.com/charts
  - name: mysql
    version: 3.2.1
    repository: https://another.example.com/charts

• Le champ de nom est le nom du graphique dont vous avez besoin
• Le champ version est la version du graphique dont vous avez besoin
• Le champ de référentiel est l'URL complète du référentiel de cartes. Notez que vous devez ajouter le référentiel localement à l'aide de helm repo add
• Vous pouvez utiliser le nom du référentiel au lieu de l'URL

Exemple de démo :

helm repo add bitnami https://charts.bitnami.com/bitnami
helm pull bitnami/wordpress
tar -xf wordpress
cat wordpress/Chart.yaml

Une fois que vous avez défini vos dépendances, l'exécution helm dependency updateutilisera vos dépendances pour télécharger tous les graphiques que vous spécifiez dans votre répertoire charts/ .

helm dependency update ./wordpress

Lorsque la mise à jour de la dépendance helm récupère le graphique, un package de graphique sera formé dans le répertoire charts/ . Ainsi, pour l'exemple ci-dessus, vous vous attendez à voir les fichiers suivants dans le répertoire du graphique :

wordpress/charts/
├── common
├── common-2.0.1.tgz
├── mariadb
├── mariadb-11.2.2.tgz
├── memcached
└── memcached-6.2.3.tgz

champs de balise et de condition dans les dépendances

En plus des autres champs ci-dessus, chaque élément d'exigence peut contenir des champs facultatifs tagset condition. Tous les graphiques seront chargés par défaut . Si des balises ou des champs de condition sont présents, ils seront évalués et utilisés pour contrôler le chargement du graphique auquel ils s'appliquent.

• Condition--Condition field field contient un ou plusieurs chemins YAML (séparés par des virgules). Si ce chemin existe déjà dans les valeurs de niveau supérieur et se résout en une valeur booléenne, le graphique activera ou désactivera le graphique en fonction de la valeur booléenne. Seul le premier chemin valide trouvé dans la liste sera utilisé, si le chemin n'est pas trouvé, la condition n'a aucun effet.

• Tags - tagLes champs sont une liste au format YAML d'étiquettes associées au graphique. Dans la valeur de niveau supérieur, tous les graphiques balisés peuvent être activés ou désactivés en spécifiant une balise et une valeur booléenne.

# parentchart/Chart.yaml

dependencies:
  - name: subchart1
    repository: http://localhost:10191
    version: 0.1.0
    condition: subchart1.enabled, global.subchart1.enabled
    tags:
      - front-end
      - subchart1
  - name: subchart2
    repository: http://localhost:10191
    version: 0.1.0
    condition: subchart2.enabled,global.subchart2.enabled
    tags:
      - back-end
      - subchart2

# parentchart/values.yaml

subchart1:
  enabled: true
tags:
  front-end: false
  back-end: true

• Dans l'exemple ci-dessus, tous les graphiques avec la balise frontale seront désactivés, mais tant que subchart1.enabledle chemin défini sur 'true', la condition remplacera la balise frontale et subchart1 sera activé .
• Une fois que subchart2 utilise la balise back-end et est défini sur true, subchart2 sera activé. Notez également que bien que subchart2 spécifie un champ de condition, la valeur de niveau supérieur n'a pas de chemin et de valeur correspondants, donc cette condition ne prendra pas effet.

--setLes paramètres peuvent être utilisés pour définir des étiquettes et des valeurs conditionnelles.

helm install --set tags.front-end=true --set subchart2.enabled=false

Analyse des balises et des conditions :

• La condition (lorsqu'elle est définie dans la valeur) remplacera toujours l'étiquette. Le premier chemin de condition du graphique ignorera le chemin suivant s'il existe.
• Les drapeaux sont définis comme "le graphique peut être activé si l'un des drapeaux du graphique est vrai".
• Les étiquettes et les valeurs conditionnelles doivent être définies dans la valeur de niveau supérieur.
• Les balises : key in value doivent être une clé de niveau supérieur.

4) Importer la valeur enfant via la dépendance

• Dans certains cas, il est utile d'autoriser le passage des valeurs du graphique enfant dans le graphique parent en tant que valeurs publiques par défaut . Un avantage supplémentaire de l'utilisation exportsdu format est qu'il permet aux futurs outils d'introspecter les valeurs définissables par l'utilisateur.
• Les clés importées contenant des valeurs peuvent être spécifiées sous forme de listes YAML dans le import-valueschamp . Chaque élément de la liste est une clé importée du champ des exportations dans le sous-graphique.
• Pour importer des valeurs non incluses dans la clé exports, utilisez le format enfant -parent . Des exemples des deux formats sont décrits ci-dessous.

Utiliser le format d'export :
Si le fichier values.yaml du graphe enfant contient le champ exports dans le noeud racine, son contenu peut être directement importé dans la valeur du graphe parent en précisant comme suit :

# parent's Chart.yaml file

dependencies:
  - name: subchart
    repository: http://localhost:10191
    version: 0.1.0
    import-values:
      - data

# child's values.yaml file

exports:
  data:
    myint: 99

Tant que nous spécifions les données clés dans la liste d'importation, Helm recherchera la clé de données dans le champ d'exportation du sous-diagramme et importera son contenu.

La valeur parent finale contiendra nos champs exportés :

# parent's values

myint: 99

[Remarque] Les données de la clé parent ne sont pas incluses dans la valeur finale du parent. Si vous souhaitez spécifier cette clé parent, vous devez l'utiliser '子-父' 格式.

Le dans l'exemple ci-dessous import-valuesdemande à Helm de prendre n'importe quelle valeur trouvée dans l'enfant : chemin et de la copier dans le parent : chemin spécifié.

# parent's Chart.yaml file

dependencies:
  - name: subchart1
    repository: http://localhost:10191
    version: 0.1.0
    ...
    import-values:
      - child: default.data
        parent: myimports

Dans l'exemple ci-dessus, la valeur de default.data trouvée dans subchart1 sera importée dans la clé myimports du graphique parent, les détails sont les suivants :

# parent's values.yaml file

myimports:
  myint: 0
  mybool: false
  mystring: "helm rocks!"

# subchart1's values.yaml file

default:
  data:
    myint: 999
    mybool: true

La valeur résultante du graphique parent ressemblera à ceci :

# parent's final values

myimports:
  myint: 999
  mybool: true
  mystring: "helm rocks!"

六、Modèles et valeurs

1) Introduction aux modèles et aux valeurs

• Le modèle Helm Chart est écrit selon le langage de modèle Go, ajoutant environ 50 fonctions de modèle supplémentaires de la bibliothèque Sprig et quelques autres fonctions spécifiées.
• Tous les fichiers de modèle sont stockés dans le templates/dossier . Lorsque Helm affiche un graphique, il parcourt chaque fichier du répertoire via le moteur de création de modèles.

La valeur du modèle est fournie de deux manières :

• Les développeurs de graphiques peuvent fournir un fichier values.yamlnommé . Ce fichier contient des valeurs par défaut.
• Les utilisateurs de graphiques peuvent fournir un fichier YAML contenant des valeurs. Vous pouvez spécifier le fichier de valeurs lors de l'utilisation de la commande helm install sur la ligne de commande -f.

exemple de modèle

apiVersion: v1
kind: ReplicationController
metadata:
  name: deis-database
  namespace: deis
  labels:
    app.kubernetes.io/managed-by: deis
spec:
  replicas: 1
  selector:
    app.kubernetes.io/name: deis-database
  template:
    metadata:
      labels:
        app.kubernetes.io/name: deis-database
    spec:
      serviceAccount: deis-database
      containers:
        - name: deis-database
          image: {
    
    {
    
     .Values.imageRegistry }}/postgres:{
    
    {
    
     .Values.dockerTag }}
          imagePullPolicy: {
    
    {
    
     .Values.pullPolicy }}
          ports:
            - containerPort: 5432
          env:
            - name: DATABASE_STORAGE
              value: {
    
    {
    
     default "minio" .Values.storage }}

L'exemple ci-dessus, vaguement basé sur https://github.com/deis/charts , est un modèle pour un contrôleur de réplication Kubernetes. Les quatre valeurs de modèle suivantes peuvent être utilisées (généralement définies dans le fichier values.yaml) :

• imageRegistry : le registre source de l'image Docker
• dockerTag : le tag de l'image Docker
• pullPolicy : règle d'extraction de Kubernetes
• stockage : stockage en arrière-plan, la valeur par défaut est "minio"

2) Valeurs prédéfinies

Les valeurs sont fournies via le fichier values.yaml (ou via le paramètre --set) accessible par l'objet .Values ​​dans le modèle, mais d'autres fragments de données prédéfinis sont accessibles dans le modèle.

Les valeurs suivantes sont prédéfinies, valides pour chaque modèle et peuvent être remplacées. Comme toutes les valeurs, les noms sont sensibles à la casse.

• Release.Name: nom de la version (hors graphique)
• Release.Namespace: espace de noms de la version publiée du graphique
• Release.Service: version d'organisation du service
• Release.IsUpgrade: défini sur vrai si l'opération en cours est une mise à niveau ou une restauration
• Release.IsInstall: défini sur vrai si l'opération en cours est une installation
• Chart: Chart.yamlcontenu. Par conséquent, la version du graphique peut être obtenue à partir de Chart.Version et le responsable se trouve dans Chart.Maintainers.
• Files: un objet de diagramme de classes qui contient des fichiers non spéciaux dans le graphique. Cela ne vous permettra pas d'accéder aux modèles, mais à d'autres fichiers existants (sauf s'ils sont exclus par .helmignore). Utilisez { { index .Files "file.name" }} pour accéder aux fichiers ou utilisez la fonction { { .Files.Get name }}. Vous pouvez également utiliser { { .Files.GetBytes }} pour accéder au contenu du fichier en tant que [] octet.
• Capabilities : un objet de diagramme de classes contenant des informations sur la version de Kubernetes. ({ { .Capabilities.KubeVersion }}) et versions d'API Kubernetes prises en charge ({ { .Capabilities.APIVersions.Has "batch/v1" }})

Compte tenu du modèle de la section précédente, values.yamlles valeurs nécessaires fournies par le fichier sont les suivantes :

imageRegistry: "quay.io/deis"
dockerTag: "latest"
pullPolicy: "Always"
storage: "s3"

Le fichier de valeurs est défini au format YAML. Le graphique contiendra un fichier values.yaml par défaut. La commande d'installation Helm permet aux utilisateurs de remplacer cette valeur par des valeurs YAML supplémentaires :

helm install --generate-name --values=myvals.yaml wordpress

3) Portée, dépendances et valeurs

Un fichier de valeurs peut déclarer des valeurs pour le graphique de niveau supérieur, ainsi que pour charts/tout autre graphique contenu dans le répertoire. Ou pour le dire autrement, le fichier de valeurs peut fournir des valeurs pour le graphique et l'une de ses dépendances . Par exemple, le graphique WordPress présenté ci-dessus a à la fois mysql et apache comme dépendances. Le fichier de valeurs peut fournir des dépendances pour l'ensemble de ces composants :

title: "My WordPress Site" # Sent to the WordPress template

mysql:
  max_connections: 100 # Sent to MySQL
  password: "secret"

apache:
  port: 8080 # Passed to Apache

Les graphiques d'ordre supérieur ont accès à toutes les variables définies ci-dessous . Ainsi, le graphique WordPress peut accéder au mot de passe MySQL avec .Values.mysql.password . Mais les graphiques de niveau inférieur ne peuvent pas accéder au parent chart , donc MySQL ne peut pas accéder à l'attribut title . Impossible également d'accéder à apache.port.

4) Valeurs globales

Depuis 2.0.0-Alpha.2, Helm prend en charge une valeur "globale" spéciale. Prenons une version modifiée de l'exemple précédent :

title: "My WordPress Site" # Sent to the WordPress template

global:
  app: MyWordPress

mysql:
  max_connections: 100 # Sent to MySQL
  password: "secret"

apache:
  port: 8080 # Passed to Apache

Ajout de la section globale et d'une application de valeur : MyWordPress. Cette valeur est valable .Values.global.appdans tous les graphiques .

Par exemple, le modèle mysql peut { {.Values.global.app}}accéder à l'application, et le graphique apache peut également y accéder. En fait, le fichier de valeurs ci-dessus sera régénéré comme ceci :

title: "My WordPress Site" # Sent to the WordPress template

global:
  app: MyWordPress

mysql:
  global:
    app: MyWordPress
  max_connections: 100 # Sent to MySQL
  password: "secret"

apache:
  global:
    app: MyWordPress
  port: 8080 # Passed to Apache

7. Ordre d'installation des ressources Helm

• Espace de noms
• NetworkPolicy
• Quota de ressources
• LimitRange
• SubSecurityPolicy
• PodDisruptionBudget
• Compte de service
• Secret
• ListeSecrète
• ConfigMap
• Classe de stockage
• Volume persistant
• PersistentVolumeClaim
• CustomResourceDefinitionCustomResourceDefinition
• Rôle de cluster
• ClusterRoleList
• ClusterRoleBindingClusterRoleBinding
• ClusterRoleBindingListClusterRoleBindingList
• Rôle
• Liste de rôles
• Liaison de rôle
• RoleBindingListRoleBindingList
• Service
• Ensemble de démons
• Cosse
• Contrôleur de réplication
• Jeu de répliques
• Déploiement
• HorizontalPodAutoscaler
• StatefulSet
• Emploi
• Tâche planifiée
• Entrée
• APIService

8. Trois façons pour Helm d'installer le package Chart

Helm est livré avec une puissante commande de recherche qui peut être utilisée pour rechercher à partir de deux sources :

• helm search hubTrouvez et répertoriez les cartes de barre d' Artifact Hub . Artifact Hub héberge un grand nombre de référentiels différents.
• helm search repohelm repo addRecherches à partir des référentiels que vous ajoutez (utilisez ) à votre client helm local. Cette commande effectue une recherche basée sur des données locales et ne nécessite pas de connexion Internet.

# 添加bitnami仓库源
helm repo add bitnami https://charts.bitnami.com/bitnami
# 从bitnami源查找所有chart包，不指定具体源的话，会查找本地添加的所有源地址的所有chart包
helm search repo bitnami

1) paramètre de valeurs passant

Il existe deux manières de transmettre les données de configuration lors de l'installation :

• --values (或 -f) : Remplacez la configuration à l'aide d'un fichier YAML. Il peut être spécifié plusieurs fois et le fichier le plus à droite est utilisé en premier.
• --set: remplacez l'élément spécifié via la ligne de commande.

Si les deux méthodes sont utilisées en même temps, la valeur dans --set sera fusionnée dans --values, mais la valeur --set dans prioritaire . Les remplacements dans --set seront enregistrés dans ConfigMap. Vous pouvez afficher la valeur définie par --set dans la version spécifiéehelm get values <release-name> via . Les valeurs définies dans --set peuvent également être effacées en exécutant helm upgrade et en spécifiant le champ --reset-values ​​​​. Les exemples sont les suivants :

echo '{mariadb.auth.database: user0db, mariadb.auth.username: user0}' > values.yaml
helm install -f values.yaml bitnami/wordpress --generate-name

2) [La première méthode] L'installation directe en ligne n'a pas besoin de télécharger d'abord le package sur le site local

helm install mysql bitnami/mysql
helm list

3) [Deuxième méthode] Installation hors ligne directement via le package d'installation

# 先删除
helm uninstall mysql
# 拉包到本地
helm pull bitnami/mysql
# 不解压直接安装
helm install mysql ./mysql-9.3.1.tgz
helm list

4) [Troisième méthode] Installez le package décompressé hors ligne et réinstallez-le

# 拉包到本地
helm pull bitnami/mysql
# 解压安装
tar -xf mysql-9.3.1.tgz

# 开始安装
helm install mysql ./mysql \
--namespace=mysql \
--create-namespace \
--set image.registry=myharbor.com \
--set image.repository=bigdata/mysql \
--set image.tag=8.0.30 \
--set primary.service.type=NodePort \
--set service.nodePorts.mysql=30306

# 查看在运行的Release
helm list

# 卸载
helm uninstall mysql -n mysql 

Neuf, grammaire de base de Helm

1) variables

Les variablestemplates/ du modèle ( ) sont toutes placées dans , par exemple : représentant le champ images sous . Les valeurs proviennent de fichiers ou de fichiers yaml spécifiés, ou définissent des variables.{ {}}{ { .Values.images }}Values 对象values.yaml-f--set

【Rappel】 Utilisez pour supprimer des espaces et des sauts de ligne, si vous souhaitez supprimer d'autres espaces et sauts de -ligne dans cette ligne, vous pouvez utiliser { {-ou -}}, l'un consiste à supprimer la somme à gauche 空格et l'autre à supprimer 换行符la somme sur le à droite空格换行符 .

2) Objets intégrés

• Release: L'objet Release décrit la version elle-même. Contient les objets suivants :
  • Release.Name: nom de la version ;
  • Release.Namespace: l'espace de noms inclus dans la version (s'il n'est pas couvert par le manifeste) ;
  • Release.IsUpgrade : Si l'opération en cours est une mise à niveau ou une restauration, cette valeur sera définie sur true
  • Release.IsInstall: Si l'opération en cours consiste à installer, la valeur sera définie sur true
  • Release.Revision: Le numéro de version de cette révision. Il est égal à 1 lors de l'installation et sera incrémenté à chaque mise à niveau ou restauration ;
  • Release.Service: Ce service est utilisé pour afficher le modèle actuel. Helm est toujours Helm.
• Valuesvalues.yaml: L'objet Values ​​​​est passé dans le modèle à partir de fichiers et de fichiers fournis par l'utilisateur. vide par défaut
• Chart: Chart.yamlcontenu du fichier. Toutes les données de Chart.yaml sont accessibles ici. Par exemple { { .Chart.Name }}-{ { .Chart.Version }} imprimera mychart-0.1.0.
• Template: Contient des informations sur le modèle en cours d'exécution
  • Template.Name: chemin du fichier d'espace de noms du modèle actuel (par exemple mychart/templates/mytemplate.yaml) ;
  • Template.BasePath: Le chemin du répertoire du modèle de graphique actuel (par exemple mychart/templates).

3) Fonctions intégrées couramment utilisées

1, citation et citation

Cette fonction convertit en une chaîne entre guillemets doubles ( quote) ou ** guillemets simples ( squote) **. Les exemples sont les suivants :

apiVersion: v1
kind: ConfigMap
metadata:
  name: {
    
    {
    
     .Release.Name }}-configmap
data:
  myvalue: "Hello World"
  drink: {
    
    {
    
     .Values.favorite.drink | quote }}
  food: {
    
    {
    
     .Values.favorite.food | upper | quote }}

L'inversion des commandes est une pratique courante dans les modèles. peut souvent être vu .val | quoteà la place de quote .val. En fait, les deux opérations sont possibles.

2、par défaut

Cette fonction vous permet de spécifier une valeur par défaut dans le modèle, au cas où la valeur serait ignorée.

# 如果.Values.favorite.drink是非空值，则使用它，否则会返回tea。
drink: {
    
    {
    
     .Values.favorite.drink | default "tea" | quote }}

# 还可以这样写，如果.Bar是非空值，则使用它，否则会返回foo。
default "foo" .Bar

La définition "vide" dépend des types suivants :

整型: 0
字符串: ""
列表: []
字典: {
    
    }
布尔: false
以及所有的nil (或 null)

3、imprimer

Renvoie la chaîne combinée de chaque partie, et les types non-chaîne seront convertis en chaînes.

print "Matt has " .Dogs " dogs"

[Rappel] Lorsque deux paramètres adjacents ne sont pas des chaînes, un espace sera ajouté entre eux.

4、println

Même effet que l'impression, mais ajoute une nouvelle ligne à la fin.

5、printf

Renvoie la chaîne formatée passée par les paramètres dans l'ordre.

printf "%s has %d dogs." .Name .NumberDogs
{
    
    {
    
    - printf "%d" (.Values.externalCache.port | int ) -}}
{
    
    {
    
    - printf "%s" .Values.existingSecret -}}

{
    
    {
    
    - printf "%v" .context.Values.redis.enabled -}}

# %s 字符串占位符，未解析的二进制字符串或切片
# %d 数字占位符，十进制
# %v 默认格式的值，当打印字典时，加号参数(%+v)可以添加字段名称

Pour plus d'utilisation des espaces réservés, veuillez vous référer à la documentation officielle : https://helm.sh/zh/docs/chart_template_guide/function_list/

6, garniture

Le numéro de ligne de coupe supprime les espaces des deux côtés de la chaîne :

trim "   hello    "

7、trimAll

Supprimer les caractères donnés d'une chaîne :

trimAll "$" "$5.00"

Le résultat de ce qui précède est : 5,00 (sous forme de chaîne).

8、inférieur

Convertissez la chaîne entière en minuscules :

lower "HELLO"

Le résultat ci-dessus est : bonjour

9、supérieur

Convertissez la chaîne entière en majuscule :

upper "hello"

Le résultat ci-dessus est : BONJOUR

10、titre

Convertissez la première lettre en majuscule :

title "hello world"

Le résultat de ce qui précède est : Hello World

11、substr

Obtenez la sous-chaîne de la chaîne, il y a trois paramètres :

• début (entier)
• fin (entier)
• chaîne (chaîne)

substr 0 5 "hello world"

Le résultat ci-dessus est : bonjour

12. abréviation

Tronquer une chaîne avec des points de suspension (...)

abbrev 5 "hello world"
# 第一个参数：最大长度
# 第二个参数：字符串

Le résultat de ce qui précède est : il..., car les points de suspension sont comptés dans la longueur.

13、contient

Teste si une chaîne est contenue dans une autre chaîne :

contains "cat" "catch"

14, chat

La fonction cat combine plusieurs chaînes en une seule, séparées par des espaces :

cat "hello" "beautiful" "world"

Le résultat de ce qui précède est : bonjour beau monde

15、retrait

indent indente la ligne de la chaîne donnée de la longueur spécifiée , utile lors de l'alignement de chaînes multilignes :

indent 4 $lots_of_text

Le résultat ci-dessus indentera chaque ligne de 4 espaces.

16

La fonction nindent est identique à la fonction indent, mais peut ajouter une nouvelle ligne au début de la chaîne.

nindent 4 $lots_of_text

Le résultat ci-dessus mettra en retrait 4 caractères sur la ligne où se trouve la chaîne et ajoutera une nouvelle ligne au début.

17、remplacer

Effectuez des remplacements de chaînes simples.

# 下面两行等价
replace " " "-" "I Am Henry VIII" 
"I Am Henry VIII" | replace " " "-"

# 参数1：待替换字符串
# 参数2：要替换字符串
# 参数3：源字符串

Le résultat de ce qui précède est : je-suis-Henry-VIII

18、rendez-vous

La fonction date formate la date, et la date est formatée comme ANNÉE-MOIS-JOUR :

now | date "2006-01-02"

Pour plus de fonctions intégrées, veuillez vous référer à la documentation officielle : https://helm.sh/zh/docs/chart_template_guide/function_list/

4) Fonction de conversion de type

Helm fournit les fonctions de conversion de type suivantes :

• atoi: Convertit une chaîne en entier.
• float64: Convertir en float64.
• int: Convertir en entier selon la largeur de l'entier système.
• int64: Convertir en int64.
• toDecimal: Convertit unix octal en int64.
• toString: Convertir en chaîne.
• toStrings: convertit une liste, une tranche ou un tableau en une liste de chaînes.
• toJson (mustToJson): convertissez une liste, une tranche, un tableau, un dictionnaire ou un objet en JSON.
• toPrettyJson (mustToPrettyJson): convertissez une liste, une tranche, un tableau, un dictionnaire ou un objet en JSON formaté.
• toRawJson (mustToRawJson): convertit une liste, une tranche, un tableau, un dictionnaire ou un objet en JSON avec des caractères HTML sans échappement.

5) Expressions régulières

Helm inclut les fonctions d'expression régulière suivantes

• regexFind(noirRegexFind)
• regexFindAll(mustRegexFindAll)
• regexMatch (mustRegexMatch)
• regexReplaceAll (mustRegexReplaceAll)
• regexReplaceAllLiteral(mustRegexReplaceAllLiteral)
• regexSplit (noirRegexSplit)

6) Fonctions d'encodage et de décodage

Helm possède les fonctions d'encodage et de décodage suivantes :

• b64enc/b64dec : Encoder ou décoder Base64
• b32enc/b32dec : Encoder ou décoder Base32

7）Dictionnaires et fonctions Dict

Helm fournit un type de stockage clé/valeur appelé dict (abréviation de "dictionnaire", également disponible en Python). dict est un type non ordonné. Les clés de dictionnaire doivent être des chaînes . Mais la valeur peut être de n'importe quel type, même un autre dict ou list .

1. Créer un dictionnaire (dict)

Ce qui suit crée un dictionnaire de trois paires clé-valeur :

$myDict := dict "name1" "value1" "name2" "value2" "name3" "value 3"

2. Obtenir la valeur (obtenir)

Étant donné une carte et une clé, obtenez la valeur de la carte.

get $myDict "name1"

Le résultat de ce qui précède est : "valeur1"

Notez qu'il renvoie simplement "" s'il n'est pas trouvé. Aucune erreur ne sera générée.

3. Ajouter des paires clé-valeur (ensemble)

Utilisez set pour ajouter une paire clé-valeur au dictionnaire.

$_ := set $myDict "name4" "value4"

Notez que set renvoie un dictionnaire (une exigence des fonctions de modèle Go), vous devrez donc peut-être utiliser $_l'affectation comme ci-dessus pour obtenir la valeur.

4. Supprimer (non défini)

Étant donné une carte et une clé, retirez la clé de la carte.

$_ := unset $myDict "name4"

Comme set, un dictionnaire doit être renvoyé.

5. Clé de jugement (hasKey)

La fonction hasKey renvoie true si la clé donnée est contenue dans le dictionnaire donné.

hasKey $myDict "name1"

Si la clé n'est pas trouvée, false sera renvoyé.

6、cueillir

La fonction pluck reçoit une clé et plusieurs mappages et obtient une liste de toutes les correspondances :

pluck "name1" $myDict $myOtherDict

Ce qui précède renverra une liste contenant chaque valeur trouvée ([value1 otherValue1]).

7. Fusionner dict (merge, mustMerge)

Fusionnez deux ou plusieurs dictionnaires en un seul, le dictionnaire de destination en premier :

$newdict := merge $dest $source1 $source2

8. Obtenez toutes les clés

La fonction keys renvoie une liste de toutes les clés dans un ou plusieurs types de dict. Comme les dictionnaires ne sont pas ordonnés, les clés ne seront pas dans un ordre prévisible. Peut utiliser le stockage sortAlpha.

keys $myDict | sortAlpha

Lorsque plusieurs dictionnaires sont fournis, les clés sont concaténées. Utilisez uniqla fonction et sortAlphapour obtenir une liste ordonnée unique de clés.

keys $myDict $myOtherDict | uniq | sortAlpha

9. Obtenez toutes les valeurs

La fonction de valeurs est similaire aux clés, renvoyant une nouvelle liste contenant toutes les valeurs du dictionnaire source (un seul dictionnaire est pris en charge).

$vals := values $myDict

Le résultat de ce qui précède est : list["value1", "value2", "value 3"].

Notez que les valeurs ne garantissent pas l'ordre des résultats ; si vous avez besoin d'ordre, utilisez sortAlpha.

8）Listes et fonctions de liste

Helm fournit un type de liste simple qui contient des listes dans n'importe quel ordre. Semblable aux tableaux ou aux tranches, mais les listes sont conçues pour des types de données immuables.

1. Créez une liste

$myList := list 1 2 3 4 5

Ce qui précède générerait une liste [1 2 3 4 5].

2. Obtenir le premier élément de la liste (first, mustFirst)

Pour obtenir le premier élément de la liste, utilisez d'abord.

first $myList
# 返回 1

Une erreur se produira s'il y a un problème avec first, et une erreur sera renvoyée au moteur de modèle s'il y a un problème avec mustFirst.

3. Obtenir le contenu final de la liste (rest, mustRest)

Obtenez le contenu final de la liste (tout sauf le premier élément), en utilisant rest.

rest $myList
# 返回 [2 3 4 5]

Une erreur se produit lorsqu'il y a un problème avec rest, et une erreur est renvoyée au moteur de template lorsqu'il y a un problème avec mustRest.

4. Obtenir le dernier élément de la liste (last, mustLast)

Utilisez last pour obtenir le dernier élément d'une liste :

last $myList 
# 返回 5。这大致类似于反转列表然后调用first。

5. Obtenir tout le contenu de la liste (initial, mustInitial)

En retournant tous les éléments sauf le dernier.

 initial $myList
 # 返回 [1 2 3 4]。

Une erreur se produira s'il y a un problème avec initial, mais une erreur sera renvoyée au moteur de modèle s'il y a un problème avec mustInitial.

6. Ajouter des éléments à la fin (append, mustAppend)

Ajoute un élément à une liste existante, créant une nouvelle liste.

$new = append $myList 6

L'instruction ci-dessus définira $new sur [1 2 3 4 5 6]. $myList restera inchangé.

Une erreur se produit lorsque l'ajout échoue, mais mustAppend renvoie une erreur au moteur de modèle en cas de problème.

7. Ajouter des éléments devant (prepend, mustPrepend)

Ajoute des éléments au début de la liste, produisant une nouvelle liste.

prepend $myList 0

La déclaration ci-dessus générerait [0 1 2 3 4 5]. $myList restera inchangé.

prepend renverra une erreur, mais mustPrepend renverra une erreur au moteur de template en cas de problème.

8. Connexion multi-liste (concat)

Concaténer n'importe quel nombre de listes en une seule.

concat $myList ( list 6 7 ) ( list 8 )

La déclaration ci-dessus produit [1 2 3 4 5 6 7 8]. $myList restera inchangé.

9. Inverser (inverser, mustReverse)

Inverser la liste donnée pour produire une nouvelle liste.

reverse $myList

La déclaration ci-dessus produit une liste : [5 4 3 2 1].

reverse renverra une erreur, mais mustReverse renverra une erreur au moteur de template.

10. Déduplication (uniq, mustUniq)

Générez une liste avec les doublons supprimés.

list 1 1 1 2 | uniq

La déclaration ci-dessus générerait [1 2]

uniq renverra une erreur en cas de problème, mais mustUniq renverra une erreur au moteur de modèle en cas de problème.

11. Filtrage (sans, doitSans)

La fonction sans filtre le contenu de la liste.

without $myList 3
# 上述语句会生成 [1 2 4 5]

Un filtre peut filtrer plusieurs éléments :

without $myList 1 3 5
# 这样会得到： [2 4]

Without renverra une erreur, mais mustWithout renverra une erreur au moteur de template.

12. Déterminer si un élément existe (has, mustHas)

Vérifiez qu'une liste contient un élément spécifique.

has 4 $myList

L'instruction ci-dessus renverra vrai, mais a "hello" $myList renverra faux.

Has renverra une erreur, mais mustHas renverra une erreur au moteur de template.

13. Supprimer les éléments vides (compact, mustCompact)

Prend une liste et supprime les éléments nuls.

$list := list 1 "a" "foo" ""
$copy := compact $list

compact renvoie une nouvelle liste avec les valeurs nulles (par exemple, "") supprimées.

compact renverra une erreur, mais mustCompact renverra une erreur au moteur de template.

14、index

Utilisez index list[n] pour obtenir le nième élément de la liste. Utilisez la liste d'index [n] [m] ... pour obtenir des éléments de liste multi-bits.

• index $myList 0 renvoie 1, identique à myList[0]
• index $maListe 0 1 同 maListe[0][1]

15. Obtenir des éléments (slice, mustSlice)

Pour obtenir des éléments d'une liste, utilisez slice list[n][m]. Équivalent à liste[n:m].

• slice $myList renvoie [1 2 3 4 5]. Équivalent à maListe[:].
• slice $myList 3 renvoie [4 5] qui équivaut à myList[3:].
• slice $myList 1 3 renvoie [2 3] qui équivaut à myList[1:3].
• slice $myList 0 3 renvoie [1 2 3] qui équivaut à myList[:3].

slice renverra une erreur, mais mustSlice renverra une erreur au moteur de template en cas de problème.

16. Construire une liste d'entiers (jusqu'à)

La fonction until construit une plage d'entiers.

until 5

L'instruction ci-dessus produit une liste : [0, 1, 2, 3, 4].

Utile pour les boucles : plage $i, $e := jusqu'à 5.

17、seq

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

9) Fonctions mathématiques

1. Somme (addition)

Utilisez ajouter à la somme. Accepte deux entrées ou plus.

add 1 2 3

2. Ajouter 1 (add1)

Pour incrémenter de 1, utilisez add1.

3. Soustraction (sous)

La soustraction utilise sub.

4. Diviser (div)

Divisible en utilisant div.

5. Modulo (mod)

Prenez le mod en utilisant mod.

6. Multiplier (mul)

Pour multiplier, utilisez mul. Accepte deux entrées ou plus.

mul 1 2 3

7. Obtenir la valeur maximale (max)

Renvoie le plus grand entier d'un ensemble d'entiers.

max 1 2 3
# 返回 3

8. Obtenir la valeur minimale (min)

Renvoie le plus petit nombre d'un ensemble de nombres.

min 1 2 3 
# 会返回 1。

9. Obtenir la longueur (len)

Renvoie la longueur de l'argument sous la forme d'un entier.

len .Arg

10）Fonctions réseau

Helm fournit plusieurs fonctions de mise en réseau :

• getHostByNameRecevez un nom de domaine et renvoyez une adresse IP.

• getHostByName"www.google.com" renverra l'adresse correspondante de www.google.com.

10) Instruction conditionnelle

opérateur:

eq: 等于（equal to）
ne: 不等于（not equal to）
lt: 小于（less than）
le: 小于等于（less than or equal to）
gt: 大于（greater than）
ge: 大于等于（greater than or equal to）

si/sinon utilisation :

{
    
    {
    
    if 命令}}
…
{
    
    {
    
    else if 命令}}
…
{
    
    {
    
    else}}
…
{
    
    {
    
    end}}

Pipeline sera défini sur false si :

布尔false
数字0
空字符串
nil (空或null)
空集合(map, slice, tuple, dict, array)

【Exemple】

apiVersion: v1
kind: ConfigMap
metadata:
  name: {
    
    {
    
     .Release.Name }}-configmap
data:
  myvalue: "Hello World"
  drink: {
    
    {
    
     .Values.favorite.drink | default "tea" | quote }}
  food: {
    
    {
    
     .Values.favorite.food | upper | quote }}
  {
    
    {
    
     if eq .Values.favorite.drink "coffee" }}mug: "true"{
    
    {
    
     end }}

11) Modifier la portée avec

La prochaine structure de contrôle est withl'opération. Ceci est utilisé pour contrôler la portée de la variable . Rappelez-vous qu'il .s'agit d'une référence à la portée actuelle. Cela indique donc .Valuesau modèle de rechercher l'objet Values ​​​​dans la portée actuelle.

La syntaxe de with est similaire à l'instruction if :

{
    
    {
    
     with PIPELINE }}
  # restricted scope
{
    
    {
    
     end }}

La portée peut être modifiée. avec vous permet de définir la portée actuelle ( .) pour un objet spécifique. Par exemple, nous utilisons déjà .Values.favorite. Modifiez la portée de . dans la carte de configuration pour pointer vers .Values.favorite :

apiVersion: v1
kind: ConfigMap
metadata:
  name: {
    
    {
    
     .Release.Name }}-configmap
data:
  myvalue: "Hello World"
  {
    
    {
    
    - with .Values.favorite }}
  drink: {
    
    {
    
     .drink | default "tea" | quote }}
  food: {
    
    {
    
     .food | upper | quote }}
  {
    
    {
    
    - end }}

Mais il y a une mise en garde ici. Dans une portée limitée, vous ne pouvez pas utiliser . pour accéder aux objets de la portée parent. Voici des exemples d'erreurs :

{
    
    {
    
    - with .Values.favorite }}
drink: {
    
    {
    
     .drink | default "tea" | quote }}
food: {
    
    {
    
     .food | upper | quote }}
release: {
    
    {
    
     .Release.Name }}
{
    
    {
    
    - end }}

Cela signalera une erreur car Release.Nameil n'est pas .dans la portée limitée . Mais c'est normal si les deux dernières lignes sont inversées, car la portée est réinitialisée après { { end }}.

{
    
    {
    
    - with .Values.favorite }}
drink: {
    
    {
    
     .drink | default "tea" | quote }}
food: {
    
    {
    
     .food | upper | quote }}
{
    
    {
    
    - end }}
release: {
    
    {
    
     .Release.Name }}

Alternativement, nous pouvons utiliser $l'objet Release.Name pour être accessible à partir de la portée parent . Lorsqu'un modèle commence à s'exécuter, $il est mappé à la portée racine et ne change pas pendant l'exécution. L'approche suivante fonctionne également très bien :

{
    
    {
    
    - with .Values.favorite }}
drink: {
    
    {
    
     .drink | default "tea" | quote }}
food: {
    
    {
    
     .food | upper | quote }}
release: {
    
    {
    
     $.Release.Name }}
{
    
    {
    
    - end }}

Les variables peuvent également être définies à l'extérieur, en suivant $name变量le format et en spécifiant un opérateur d'affectation spécial : :=. Nous pouvons réécrire ce qui précède avec une variable pour Release.Name.

apiVersion: v1
kind: ConfigMap
metadata:
  name: {
    
    {
    
     .Release.Name }}-configmap
data:
  myvalue: "Hello World"
  {
    
    {
    
    - $relname := .Release.Name -}}
  {
    
    {
    
    - with .Values.favorite }}
  drink: {
    
    {
    
     .drink | default "tea" | quote }}
  food: {
    
    {
    
     .food | upper | quote }}
  release: {
    
    {
    
     $relname }}
  {
    
    {
    
    - end }}

Notez l'affectation avant le début du bloc with $relname := .Release.Name. Maintenant, dans le bloc with, la variable $relname exécute toujours le nom de la version.

12) déclaration de boucle de rang

De nombreux langages de programmation prennent en charge l'utilisation de boucles for, de boucles foreach ou de mécanismes de méthode similaires. Dans le langage de template de Helm, la façon d'itérer sur une collection consiste à utiliser rangedes opérateurs.

définir des valeurs

favorite:
  drink: coffee
  food: pizza
pizzaToppings:
  - mushrooms
  - cheese
  - peppers
  - onions

Nous avons maintenant une liste de pizzaToppings (appelées tranches dans le modèle). Modifiez le modèle pour imprimer cette liste dans la carte de configuration :

apiVersion: v1
kind: ConfigMap
metadata:
  name: {
    
    {
    
     .Release.Name }}-configmap
data:
  myvalue: "Hello World"
  {
    
    {
    
    - with .Values.favorite }}
  drink: {
    
    {
    
     .drink | default "tea" | quote }}
  food: {
    
    {
    
     .food | upper | quote }}
  {
    
    {
    
    - end }}
  toppings: |-
    {
    
    {
    
    - range .Values.pizzaToppings }}
    - {
    
    {
    
     . | title | quote }}
    {
    
    {
    
    - end }}    

Parfois, il est utile de pouvoir créer rapidement une liste dans un modèle, puis de l'itérer, et les tuples de modèle Helm facilitent cette tâche. En informatique, un tuple représente une collection de type liste de taille fixe, mais peut être de n'importe quel type de données. Cela exprime à peu près tuplel'utilisation de .

  sizes: |-
    {
    
    {
    
    - range tuple "small" "medium" "large" }}
    - {
    
    {
    
     . }}
    {
    
    {
    
    - end }}    

Le modèle ci-dessus générerait ce qui suit :

  sizes: |-
    - small
    - medium
    - large    

13) Nommez le modèle

À ce stade, vous devez dépasser le modèle et commencer à créer d'autres contenus. Dans cette section, nous verrons comment définir des modèles nommés dans un fichier et les utiliser ailleurs. Un modèle nommé (parfois appelé une section ou un sous-modèle) est simplement un modèle défini à l'intérieur d'un fichier avec un nom. Il existe deux manières de le créer et plusieurs manières de l'utiliser.

• Trois méthodes de déclaration et de gestion des modèles : define, template, et block, Dans cette section, nous allons utiliser ces trois opérations et introduire une includeméthode , similaire à l'opération de modèle.
• Il y a un détail important à garder à l'esprit lorsque vous nommez des modèles : les noms de modèles sont globaux . Si vous souhaitez déclarer deux modèles avec le même nom, celui qui est chargé en dernier sera utilisé . Étant donné que les modèles des graphiques enfants sont compilés avec le modèle de niveau supérieur, faites attention aux noms spécifiques aux graphiques lorsque vous les nommez.
• Une convention de dénomination courante consiste à préfixer le modèle avec le nom du graphique : { { define "mychart.labels" }}. Le préfixe avec un nom de graphique spécifique évite les conflits qui pourraient survenir si deux graphiques différents utilisent des modèles portant le même nom.

Avant d'écrire les détails du modèle, la convention de nommage du fichier nécessite une attention :

• La plupart des fichiers dans templates/ sont considérés comme contenant des manifestes Kubernetes
• NOTES.txt est une exception
• Les fichiers dont les noms commencent par un trait de soulignement ( _) sont supposés ne contenir aucun contenu manifeste. Ces fichiers ne sont pas rendus en tant que définitions d'objet Kubernetes, mais sont disponibles dans d'autres modèles de graphique.

Ces fichiers sont utilisés pour stocker des objets locaux et auxiliaires. En fait, lorsque nous créons mychart pour la première fois, nous verrons un _helpers.tplfichier nommé . Ce fichier est l'emplacement par défaut du modèle local .

1. Déclarer et utiliser des modèles avec define et template

L'opération de définition nous permet de créer un modèle nommé dans le fichier de modèle, la syntaxe est la suivante :

{
    
    {
    
    - define "MY.NAME" }}
  # body of template here
{
    
    {
    
    - end }}

Par exemple, nous pouvons définir un modèle pour encapsuler les balises Kubernetes :

{
    
    {
    
    - define "mychart.labels" }}
  labels:
    generator: helm
    date: {
    
    {
    
     now | htmlDate }}
{
    
    {
    
    - end }}

Maintenant, nous intégrons le modèle dans la carte de configuration existante et l'incluons en utilisanttemplate :

{
    
    {
    
    - define "mychart.labels" }}
  labels:
    generator: helm
    date: {
    
    {
    
     now | htmlDate }}
{
    
    {
    
    - end }}
apiVersion: v1
kind: ConfigMap
metadata:
  name: {
    
    {
    
     .Release.Name }}-configmap
  {
    
    {
    
    - template "mychart.labels" }}
data:
  myvalue: "Hello World"
  {
    
    {
    
    - range $key, $val := .Values.favorite }}
  {
    
    {
    
     $key }}: {
    
    {
    
     $val | quote }}
  {
    
    {
    
    - end }}

Lorsque le moteur de modèle lit ce fichier, il stocke une référence à mychart.labels jusqu'à ce que le modèle "mychart.labels" soit appelé. Le modèle est ensuite rendu ligne par ligne, donc le résultat ressemble à ceci :

# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: running-panda-configmap
  labels:
    generator: helm
    date: 2022-09-04
data:
  myvalue: "Hello World"
  drink: "coffee"
  food: "pizza"

Remarque : définir n'aura pas de sortie à moins qu'il ne soit appelé avec un modèle comme cet exemple.

Par convention, les chartes Helm placent ces modèles dans des fichiers partiels, généralement _helpers.tpl. Déplacez cette méthode ici :

{
    
    {
    
    /* Generate basic labels */}}
{
    
    {
    
    - define "mychart.labels" }}
  labels:
    generator: helm
    date: {
    
    {
    
     now | htmlDate }}
{
    
    {
    
    - end }}

2. Définir la plage de modèles

Dans le modèle défini ci-dessus, nous n'avons utilisé aucun objet, uniquement des méthodes. Modifiez le modèle défini pour inclure le nom du graphique et le numéro de version :

{
    
    {
    
    /* Generate basic labels */}}
{
    
    {
    
    - define "mychart.labels" }}
  labels:
    generator: helm
    date: {
    
    {
    
     now | htmlDate }}
    chart: {
    
    {
    
     .Chart.Name }}
    version: {
    
    {
    
     .Chart.Version }}
{
    
    {
    
    - end }}

3, inclure la méthode

Supposons qu'un modèle simple soit défini comme suit :

{
    
    {
    
    - define "mychart.app" -}}
app_name: {
    
    {
    
     .Chart.Name }}
app_version: "{
    
    { .Chart.Version }}"
{
    
    {
    
    - end -}}

Supposons maintenant que je veuille insérer ceci dans les sections étiquettes : et données : du modèle :

apiVersion: v1
kind: ConfigMap
metadata:
  name: {
    
    {
    
     .Release.Name }}-configmap
  labels:
    {
    
    {
    
     template "mychart.app" . }}
data:
  myvalue: "Hello World"
  {
    
    {
    
    - range $key, $val := .Values.favorite }}
  {
    
    {
    
     $key }}: {
    
    {
    
     $val | quote }}
  {
    
    {
    
    - end }}
{
    
    {
    
     template "mychart.app" . }}

Si je rends ceci, j'obtiens l'erreur suivante :

$ helm install --dry-run measly-whippet ./mychart
Error: unable to build kubernetes objects from release manifest: error validating "": error validating data: [ValidationError(ConfigMap): unknown field "app_name" in io.k8s.api.core.v1.ConfigMap, ValidationError(ConfigMap): unknown field "app_version" in io.k8s.api.core.v1.ConfigMap]

Pour voir ce qui est rendu, --disable-openapi-validationré-exécutez avec des arguments : helm install --dry-run --disable-openapi-validation measly-whippet ./mychart. L'entrée n'est pas ce que nous voulons:

# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: measly-whippet-configmap
  labels:
    app_name: mychart
app_version: "0.1.0"
data:
  myvalue: "Hello World"
  drink: "coffee"
  food: "pizza"
app_name: mychart
app_version: "0.1.0"

Notez que l'indentation de app_version aux deux endroits est incorrecte , pourquoi ? Parce que le texte du modèle remplacé est aligné à gauche. Puisqu'il templates'agit d'un comportement et non d'une méthode , la sortie de l'appel ne peut pas êtretemplate transmise à d'autres méthodes et les données sont simplement insérées ligne par ligne .

Pour gérer cela, Helm fournit un includecontenu de modèle qui peut être importé dans le pipeline actuel, puis transmis à d'autres méthodes du pipeline. Voici un exemple utilisant indentle modèle mychart.app correctement indenté :

apiVersion: v1
kind: ConfigMap
metadata:
  name: {
    
    {
    
     .Release.Name }}-configmap
  labels:
{
    
    {
    
     include "mychart.app" . | indent 4 }}
data:
  myvalue: "Hello World"
  {
    
    {
    
    - range $key, $val := .Values.favorite }}
  {
    
    {
    
     $key }}: {
    
    {
    
     $val | quote }}
  {
    
    {
    
    - end }}
{
    
    {
    
     include "mychart.app" . | indent 2 }}

Désormais, chaque partie du YAML généré est correctement indentée :

# Source: mychart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: edgy-mole-configmap
  labels:
    app_name: mychart
    app_version: "0.1.0"
data:
  myvalue: "Hello World"
  drink: "coffee"
  food: "pizza"
  app_name: mychart
  app_version: "0.1.0"

includePar rapport à l'utilisation de template, l'utilisation d'include dans helm est considérée comme un meilleur moyen de mieux gérer le format de sortie des documents YAML.

14) Fichier NOTES.txt

Cette section présente l'outil Helm qui fournit des instructions aux utilisateurs de graphiques . À la fin de la commande helm install ou helm upgrade, Helm imprimera des informations utiles à l'utilisateur . Cette section d'informations peut être hautement personnalisée à l'aide de modèles.

Pour ajouter des instructions d'installation à un tableau, créez simplement templates/NOTES.txtun fichier. Le fichier est en texte brut, mais il est traité comme un modèle , et toutes les fonctions et tous les objets de modèle normaux sont disponibles. Créons un simple fichier NOTES.txt :

Thank you for installing {
    
    {
    
     .Chart.Name }}.

Your release is named {
    
    {
    
     .Release.Name }}.

To learn more about the release, try:

  $ helm status {
    
    {
    
     .Release.Name }}
  $ helm get all {
    
    {
    
     .Release.Name }}

Maintenant, si nous exécutons helm install rude-cardinal ./mychart, nous verrons en bas :

RESOURCES:
==> v1/Secret
NAME                   TYPE      DATA      AGE
rude-cardinal-secret   Opaque    1         0s

==> v1/ConfigMap
NAME                      DATA      AGE
rude-cardinal-configmap   3         0s


NOTES:
Thank you for installing mychart.

Your release is named rude-cardinal.

To learn more about the release, try:

  $ helm status rude-cardinal
  $ helm get all rude-cardinal

L'utilisation de NOTES.txt de cette manière est un excellent moyen de fournir aux utilisateurs des informations détaillées sur l'utilisation d'un graphique nouvellement installé. Bien que non obligatoire, la création d'un fichier est fortement recommandéeNOTES.txt .

15) Débogage des modèles

Le débogage des modèles peut être délicat, car les modèles rendus sont envoyés au serveur d'API Kubernetes, qui peut rejeter le fichier YAML pour des raisons autres que le formatage. Les commandes suivantes sont utiles pour le débogage :

• helm lintest l'outil de choix pour vérifier que les graphiques suivent les meilleures pratiques
• helm install --dry-run --debugOuhelm template --debug : nous avons déjà vu cette astuce, et c'est un excellent moyen pour que le serveur rende un modèle, puis renvoie le fichier manifeste résultant.
• helm get manifest: C'est un excellent moyen de visualiser les modèles installés sur le serveur.

Lorsque l'analyse de votre fichier YAML échoue, mais que vous souhaitez savoir ce qui a été généré, un moyen simple de récupérer le YAML consiste à commenter la partie incriminée du modèle , puis à relancerhelm install --dry-run --debug :

apiVersion: v2
# some: problem section
# {
    
    { .Values.foo | quote }}

Ce qui précède sera rendu et renverra le commentaire complet :

apiVersion: v2
# some: problem section
#  "bar"

En fait, il s'agit principalement de trier les documents officiels, et répertorie la syntaxe d'usage courant. Si vous voulez en savoir plus, vous pouvez vous référer aux documents officiels. Les documents officiels sont très détaillés. Si vous avez des questions, veuillez laisser Envoyez-moi un message. Je continuerai à partager à l'avenir. 【Cloud Native et Big Data】 Articles connexes, veuillez patienter ~