温馨提示×

温馨提示×

您好，登录后才能下订单哦！

密码登录×
登录注册×
获取短信验证码
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》
登 录 注册有礼
云服务器 香港服务器 高防服务器
最新更新 网站标签 地图导航
产品

k8s之helm

发布时间：2020-06-25 01:37:58 来源：网络 阅读：826 作者：wuseeger 栏目：云计算
Kubernetes 的包管理器。

每个成功的软件平台都有一个优秀的打包系统，比如 Debian、Ubuntu 的 apt，Redhat、Centos 的 yum。而 Helm 则是 Kubernetes 上的包管理器。

Helm，架构和组件，以及如何使用 Helm。

Why Helm

Helm 到底解决了什么问题？为什么 Kubernetes 需要 Helm？

答案是：Kubernetes 能够很好地组织和编排容器，但它缺少一个更高层次的应用打包工具，而 Helm 就是来干这件事的。

先来看个例子。
比如对于一个 MySQL 服务， Kubernetes 需要部署下面这些对象：

Service，让外界能够访问到 MySQL。

apiVersion: v1
kind: Service
metadata:
  name: my-mysql
  labels:
    app: my-mysql
spec:
  ports:
  - name: mysql
    port: 3306
    targetPort: mysql
  selector:
    app: my-mysql

Secret，定义 MySQL 的密码。

apiVersion: v1
kind: Secret
metadata:
  name: my-mysql
  labels:
    app: my-mysql
type: Opaque
data:
  mysql-root-password: "M0MzREhRQWRjeQ=="
  mysql-password: "eGNXZkpMNmlkSw=="

PersistentVolumeClaim，为 MySQL 申请持久化存储空间。

kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: my-mysql
  labels:
    app: my-mysql
spec:
  accessModes:
    - "ReadWriteOnce"
  resources:
    requests:
      storage: 8Gi

Deployment，部署 MySQL Pod，并使用上面的这些支持对象。

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: my-mysql
  labels:
    app: my-mysql
spec:
  template:
    metadata:
      labels:
        app: my-mysql
    spec:
      containers:
      - name: my-mysql
        image: mysql:5.7
        env:
        - name: MYSQL_ROOT_PASSWORD
          valueFrom:
            secretKeyRef:
              name: my-mysql
              key: mysql-password
        - name: MYSQL_USER
          value: ""
        - name: MYSQL_DATABASE
          value: ""
        ports:
        - name: mysql
          containerPort: 3306
        volumMounts:
        - name: data
          mountPath: /var/lib/mysql
      volumes:
      - name: data
        persistentVolumeClaim:
          claimName: my-mysql

我们可以将上面这些配置保存到对象各自的文件中，或者集中写进一个配置文件，然后通过 kubectl apply -f 部署。

到目前为止，Kubernetes 对服务的部署支持得都挺好，如果应用只由一个或几个这样的服务组成，上面的部署方式完全足够了。

但是，如果我们开发的是微服务架构的应用，组成应用的服务可能多达十个甚至几十上百个，这种组织和管理应用的方式：

  1. 很难管理、编辑和维护如此多的服务。每个服务都有若干配置，缺乏一个更高层次的工具将这些配置组织起来。
  2. 不容易将这些服务作为一个整体统一发布。部署人员需要首先理解应用都包含哪些服务，然后按照逻辑顺序依次执行 kubectl apply。即缺少一种工具来定义应用与服务，以及服务与服务之间的依赖关系。
  3. 不能高效地共享和重用服务。比如两个应用都要用到 MySQL 服务，但配置的参数不一样，这两个应用只能分别拷贝一套标准的 MySQL 配置文件，修改后通过 kubectl apply 部署。也就是说不支持参数化配置和多环境部署。
  4. 不支持应用级别的版本管理。虽然可以通过 kubectl rollout undo 进行回滚，但这只能针对单个 Deployment，不支持整个应用的回滚。
  5. 不支持对部署的应用状态进行验证。比如是否能通过预定义的账号访问 MySQL。虽然 Kubernetes 有健康检查，但那是针对单个容器，我们需要应用（服务）级别的健康检查。

Helm 能够解决上面这些问题，Helm 帮助 Kubernetes 成为微服务架构应用理想的部署平台。

Helm 的架构。

Helm 的架构。

Helm 有两个重要的概念：chart 和 release。

chart 是创建一个应用的信息集合，包括各种 Kubernetes 对象的配置模板、参数定义、依赖关系、文档说明等。chart 是应用部署的自包含逻辑单元。可以将 chart 想象成 apt、yum 中的软件安装包。

release 是 chart 的运行实例，代表了一个正在运行的应用。当 chart 被安装到 Kubernetes 集群，就生成一个 release。chart 能够多次安装到同一个集群，每次安装都是一个 release。

Helm 是包管理工具，这里的包就是指的 chart。Helm 能够：

  1. 从零创建新 chart。
  2. 与存储 chart 的仓库交互，拉取、保存和更新 chart。
  3. 在 Kubernetes 集群中安装和卸载 release。
  4. 更新、回滚和测试 release。

Helm 包含两个组件：Helm 客户端 和 Tiller 服务器。

Helm 客户端是终端用户使用的命令行工具，用户可以：

  1. 在本地开发 chart。
  2. 管理 chart 仓库。
  3. 与 Tiller 服务器交互。
  4. 在远程 Kubernetes 集群上安装 chart。
  5. 查看 release 信息。
  6. 升级或卸载已有的 release。

Tiller 服务器运行在 Kubernetes 集群中，它会处理 Helm 客户端的请求，与 Kubernetes API Server 交互。Tiller 服务器负责：

  1. 监听来自 Helm 客户端的请求。
  2. 通过 chart 构建 release。
  3. 在 Kubernetes 中安装 chart，并跟踪 release 的状态。
  4. 通过 API Server 升级或卸载已有的 release。

简单的讲：Helm 客户端负责管理 chart；Tiller 服务器负责管理 release。

部署 Helm
安装和部署 Helm 客户端和 Tiller 服务器。 Helm 客户端

通常，我们将 Helm 客户端安装在能够执行 kubectl 命令的节点上，只需要下面一条命令：

curl https://raw.githubusercontent.com/kubernetes/helm/master/scripts/get | bash

执行 helm version 验证。

[root@k8s-master ~]# helm version
Client: &version.Version{SemVer:"v2.14.3", GitCommit:"0e7f3b6637f7af8fcfddb3d2941fcc7cbebb0085", GitTreeState:"clean"}
Error: could not find tiller

目前只能查看到客户端的版本，服务器还没有安装。

helm 有很多子命令和参数，为了提高使用命令行的效率，通常建议安装 helm 的 bash 命令补全脚本，方法如下：

# source <(helm completion bash)
# echo "source <(helm completion bash)" >> ~/.bashrc

重新登录后就可以通过 Tab 键补全 helm 子命令和参数了。

[root@k8s-master ~]# helm 
completion  history     list        search      verify
create      home        package     serve       version
delete      init        plugin      status      
dependency  inspect     repo        template    
fetch       install     reset       test        
get         lint        rollback    upgrade     
[root@k8s-master ~]# helm install --
--atomic                      --render-subchart-notes
--ca-file=                    --replace
--cert-file=                  --repo=
--debug                       --set=
--dep-up                      --set-file=
--description=                --set-string=
--devel                       --tiller-connection-timeout=
--dry-run                     --tiller-namespace=
--home=                       --timeout=
--host=                       --tls
--key-file=                   --tls-ca-cert=
--keyring=                    --tls-cert=
--kubeconfig=                 --tls-hostname=
--kube-context=               --tls-key=
--name=                       --tls-verify
--namespace=                  --username=
--name-template=              --values=
--no-crd-hook                 --verify
--no-hooks                    --version=
--password=                   --wait
[root@k8s-master ~]# helm install --
Tiller 服务器

Tiller 服务器安装非常简单，只需要执行 helm init：

[root@k8s-master ~]# helm init
Creating /root/.helm 
Creating /root/.helm/repository 
Creating /root/.helm/repository/cache 
Creating /root/.helm/repository/local 
Creating /root/.helm/plugins 
Creating /root/.helm/starters 
Creating /root/.helm/cache/archive 
Creating /root/.helm/repository/repositories.yaml 
Adding stable repo with URL: https://kubernetes-charts.storage.googleapis.com 
Adding local repo with URL: http://127.0.0.1:8879/charts 
$HELM_HOME has been configured at /root/.helm.

Tiller (the Helm server-side component) has been installed into your Kubernetes Cluster.

Please note: by default, Tiller is deployed with an insecure 'allow unauthenticated users' policy.
To prevent this, run `helm init` with the --tiller-tls-verify flag.
For more information on securing your installation see: https://docs.helm.sh/using_helm/#securing-your-helm-installation

Tiller 本身也是作为容器化应用运行在 Kubernetes Cluster 中的：

[root@k8s-master ~]# kubectl get --namespace=kube-system svc tiller-deploy 
NAME            TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)     AGE
tiller-deploy   ClusterIP   10.104.165.164   <none>        44134/TCP   30s
# docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/tiller:v2.14.3

# docker tag registry.cn-hangzhou.aliyuncs.com/google_containers/tiller:v2.14.3 gcr.io/kubernetes-helm/tiller:v2.14.3

可以看到 Tiller 的 Service、Deployment 和 Pod。

[root@k8s-master ~]# kubectl get --namespace=kube-system svc tiller-deploy 
NAME            TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)     AGE
tiller-deploy   ClusterIP   10.104.165.164   <none>        44134/TCP   19m
[root@k8s-master ~]# kubectl get -n kube-system deployments. tiller-deploy 
NAME            READY   UP-TO-DATE   AVAILABLE   AGE
tiller-deploy   1/1     1            1           16m
[root@k8s-master ~]# kubectl get -n kube-system pod tiller-deploy-75f6c87b87-qlw4h 
NAME                             READY   STATUS    RESTARTS   AGE
tiller-deploy-75f6c87b87-qlw4h   1/1     Running   0          17m

现在， helm version 已经能够查看到服务器的版本信息了。

[root@k8s-master ~]# helm version 
Client: &version.Version{SemVer:"v2.14.3", GitCommit:"0e7f3b6637f7af8fcfddb3d2941fcc7cbebb0085", GitTreeState:"clean"}
Server: &version.Version{SemVer:"v2.14.3", GitCommit:"0e7f3b6637f7af8fcfddb3d2941fcc7cbebb0085", GitTreeState:"clean"}
使用 Helm

Helm 安装成功后，可执行 helm search 查看当前可安装的 chart。

# helm search

Helm 可以像 apt 和 yum 管理软件包一样管理 chart。apt 和 yum 的软件包存放在仓库中，同样的，Helm 也有仓库。

[root@k8s-master ~]# helm repo list
NAME    URL                                             
stable  https://kubernetes-charts.storage.googleapis.com
local   http://127.0.0.1:8879/charts                    
[root@k8s-master ~]#

Helm 安装时已经默认配置好了两个仓库：stable 和 local。stable 是官方仓库，local 是用户存放自己开发的 chart 的本地仓库。

helm search 会显示 chart 位于哪个仓库，比如 local/cool-chart 和 stable/acs-engine-autoscaler。

用户可以通过 helm repo add 添加更多的仓库，比如企业的私有仓库，仓库的管理和维护方法请参考官网文档 https://docs.helm.sh

与 apt 和 yum 一样，helm 也支持关键字搜索：

[root@k8s-master ~]# helm search mysql
NAME                                    CHART VERSION   APP VERSION     DESCRIPTION                                                 
stable/mysql                            1.4.0           5.7.27          Fast, reliable, scalable, and easy to use open-source rel...
stable/mysqldump                        2.6.0           2.4.1           A Helm chart to help backup MySQL databases using mysqldump 
stable/prometheus-mysql-exporter        0.5.1           v0.11.0         A Helm chart for prometheus mysql exporter with cloudsqlp...
stable/percona                          1.2.0           5.7.17          free, fully compatible, enhanced, open source drop-in rep...
stable/percona-xtradb-cluster           1.0.2           5.7.19          free, fully compatible, enhanced, open source drop-in rep...
stable/phpmyadmin                       3.0.7           4.9.1           phpMyAdmin is an mysql administration frontend              
stable/gcloud-sqlproxy                  0.6.1           1.11            DEPRECATED Google Cloud SQL Proxy                           
stable/mariadb                          6.11.1          10.3.18         Fast, reliable, scalable, and easy to use open-source rel...

包括 DESCRIPTION 在内的所有信息，只要跟关键字匹配，都会显示在结果列表中。

安装 chart 也很简单，执行如下命令可以安装 MySQL。

helm install stable/mysql
如果看到如下报错，通常是因为 Tiller 服务器的权限不足。

[root@k8s-master ~]# helm install stable/mysql
Error: failed to download "stable/mysql" (hint: running `helm repo update` may help)

执行如下命名添加权限：

kubectl create serviceaccount --namespace kube-system tiller
kubectl create clusterrolebinding tiller-cluster-rule --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
kubectl patch deploy --namespace kube-system tiller-deploy -p '{"spec":{"template":{"spec":{"serviceAccount":"tiller"}}}}'
[root@k8s-master ~]# kubectl create serviceaccount -n kube-system tiller
serviceaccount/tiller created
[root@k8s-master ~]# kubectl create clusterrolebinding tille[root@k8s-master ~]# kubectl create clusterrolebinding tiller-cluster-rule --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
clusterrolebinding.rbac.authorization.k8s.io/tiller-cluster-rule created
[root@k8s-master ~]# kubectl patch deploy -n kube-system tiller-deploy -p '{"spec":{"template":{"spec":{"serviceAccount":"tiller"}}}}'
deployment.extensions/tiller-deploy patched

然后再次执行

[root@k8s-master ~]# helm install stable/mysql
NAME:   olfactory-bird
LAST DEPLOYED: Tue Oct 15 17:36:02 2019
NAMESPACE: default
STATUS: DEPLOYED

RESOURCES:
==> v1/ConfigMap
NAME                       DATA  AGE
olfactory-bird-mysql-test  1     0s

==> v1/Deployment
NAME                  READY  UP-TO-DATE  AVAILABLE  AGE
olfactory-bird-mysql  0/1    1           0          0s

==> v1/PersistentVolumeClaim
NAME                  STATUS   VOLUME  CAPACITY  ACCESS MODES  STORAGECLASS  AGE
olfactory-bird-mysql  Pending  0s

==> v1/Pod(related)
NAME                                  READY  STATUS   RESTARTS  AGE
olfactory-bird-mysql-5cd5bc6b7-qmbj6  0/1    Pending  0         0s

==> v1/Secret
NAME                  TYPE    DATA  AGE
olfactory-bird-mysql  Opaque  2     0s

==> v1/Service
NAME                  TYPE       CLUSTER-IP      EXTERNAL-IP  PORT(S)   AGE
olfactory-bird-mysql  ClusterIP  10.102.142.220  <none>       3306/TCP  0s

NOTES:
MySQL can be accessed via port 3306 on the following DNS name from within your cluster:
olfactory-bird-mysql.default.svc.cluster.local

To get your root password run:

    MYSQL_ROOT_PASSWORD=$(kubectl get secret --namespace default olfactory-bird-mysql -o jsonpath="{.data.mysql-root-password}" | base64 --decode; echo)

To connect to your database:

1. Run an Ubuntu pod that you can use as a client:

    kubectl run -i --tty ubuntu --image=ubuntu:16.04 --restart=Never -- bash -il

2. Install the mysql client:

    $ apt-get update && apt-get install mysql-client -y

3. Connect using the mysql cli, then provide your password:
    $ mysql -h olfactory-bird-mysql -p

To connect to your database directly from outside the K8s cluster:
    MYSQL_HOST=127.0.0.1
    MYSQL_PORT=3306

    # Execute the following command to route the connection:
    kubectl port-forward svc/olfactory-bird-mysql 3306

    mysql -h ${MYSQL_HOST} -P${MYSQL_PORT} -u root -p${MYSQL_ROOT_PASSWORD}

输出分为三部分：

① chart 本次部署的描述信息：

NAME 是 release 的名字，因为我们没用 -n 参数指定，Helm 随机生成了一个，这里是 fun-zorse。

NAMESPACE 是 release 部署的 namespace，默认是 default，也可以通过 --namespace 指定。

STATUS 为 DEPLOYED，表示已经将 chart 部署到集群。

② 当前 release 包含的资源：Service、Deployment、Secret 和 PersistentVolumeClaim，其名字都是 fun-zorse-mysql，命名的格式为 ReleasName-ChartName。

③ NOTES 部分显示的是 release 的使用方法。比如如何访问 Service，如何获取数据库密码，以及如何连接数据库等。

通过 kubectl get 可以查看组成 release 的各个对象：

[root@k8s-master ~]# kubectl get service olfactory-bird-mysql 
NAME                   TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)    AGE
olfactory-bird-mysql   ClusterIP   10.102.142.220   <none>        3306/TCP   4m14s
[root@k8s-master ~]# kubectl get deployments. 
nginx-configmap       olfactory-bird-mysql  
[root@k8s-master ~]# kubectl get deployments. olfactory-bird-mysql 
NAME                   READY   UP-TO-DATE   AVAILABLE   AGE
olfactory-bird-mysql   0/1     1            0           4m29s
[root@k8s-master ~]# kubectl get pod olfactory-bird-mysql-5cd5bc6b7-qmbj6 
NAME                                   READY   STATUS    RESTARTS   AGE
olfactory-bird-mysql-5cd5bc6b7-qmbj6   0/1     Pending   0          4m40s
[root@k8s-master ~]# kubectl get pvc olfactory-bird-mysql 
NAME                   STATUS    VOLUME   CAPACITY   ACCESS MODES   STORAGECLASS   AGE
olfactory-bird-mysql   Pending                                                     4m56s

因为我们还没有准备 PersistentVolume，当前 release 还不可用。

helm list 显示已经部署的 release，helm delete 可以删除 release。

[root@k8s-master ~]# helm list
NAME            REVISION        UPDATED                         STATUS        CHART           APP VERSION     NAMESPACE
olfactory-bird  1               Tue Oct 15 17:36:02 2019        DEPLOYED      mysql-1.4.0     5.7.27          default  
[root@k8s-master ~]#

Helm 的使用方法像极了 apt 和 yum，用 Helm 来管理 Kubernetes 应用非常方便。

chart 目录结构

chart 是 Helm 的应用打包格式。chart 由一系列文件组成，这些文件描述了 Kubernetes 部署应用时所需要的资源，比如 Service、Deployment、PersistentVolumeClaim、Secret、ConfigMap 等。

单个的 chart 可以非常简单，只用于部署一个服务，比如 Memcached；chart 也可以很复杂，部署整个应用，比如包含 HTTP Servers、 Database、消息中间件、cache 等。

chart 将这些文件放置在预定义的目录结构中，通常整个 chart 被打成 tar 包，而且标注上版本信息，便于 Helm 部署。

下面我们将详细讨论 chart 的目录结构以及包含的各类文件。

chart 目录结构

以前面 MySQL chart 为例。一旦安装了某个 chart，我们就可以在 ~/.helm/cache/archive 中找到 chart 的 tar 包。

# ls ~/.helm/cache/archive/
mysql-1.4.0.tgz

解压后，MySQL chart 目录结构如下：

[root@k8s-master ~]# tree mysql
mysql
├── Chart.yaml
├── README.md
├── templates
│   ├── configurationFiles-configmap.yaml
│   ├── deployment.yaml
│   ├── _helpers.tpl
│   ├── initializationFiles-configmap.yaml
│   ├── NOTES.txt
│   ├── pvc.yaml
│   ├── secrets.yaml
│   ├── servicemonitor.yaml
│   ├── svc.yaml
│   └── tests
│       ├── test-configmap.yaml
│       └── test.yaml
└── values.yaml

2 directories, 14 files

目录名就是 chart 的名字（不带版本信息），这里是 mysql，包含如下内容：

Chart.yaml

YAML 文件，描述 chart 的概要信息。

apiVersion: v1
appVersion: 5.7.27
description: Fast, reliable, scalable, and easy to use open-source relational database
  system.
engine: gotpl
home: https://www.mysql.com/
icon: https://cache.yisu.com/upload/information/20200309/33/54090.jpg
keywords:
- mysql
- database
- sql
maintainers:
- email: o.with@sportradar.com
  name: olemarkus
- email: viglesias@google.com
  name: viglesiasce
name: mysql
sources:
- https://github.com/kubernetes/charts
- https://github.com/docker-library/mysql
version: 1.4.0

name 和 version 是必填项，其他都是可选。

README.md

Markdown 格式的 README 文件，相当于 chart 的使用文档，此文件为可选。

LICENSE

文本文件，描述 chart 的许可信息，此文件为可选。

requirements.yaml

chart 可能依赖其他的 chart，这些依赖关系可通过 requirements.yaml 指定，比如：

在安装过程中，依赖的 chart 也会被一起安装。

values.yaml
chart 支持在安装的时根据参数进行定制化配置，而 values.yaml 则提供了这些配置参数的默认值。

templates 目录
各类 Kubernetes 资源的配置模板都放置在这里。Helm 会将 values.yaml 中的参数值注入到模板中生成标准的 YAML 配置文件。

模板是 chart 最重要的部分，也是 Helm 最强大的地方。模板增加了应用部署的灵活性，能够适用不同的环境，我们后面会详细讨论。

templates/NOTES.txt
chart 的简易使用文档，chart 安装成功后会显示此文档内容。

与模板一样，可以在 NOTE.txt 中插入配置参数，Helm 会动态注入参数值。

chart 模板

Helm 通过模板创建 Kubernetes 能够理解的 YAML 格式的资源配置文件，我们将通过例子来学习如何使用模板。

以 templates/secrets.yaml 为例：

{{- if not .Values.existingSecret }}
apiVersion: v1
kind: Secret
metadata:
  name: {{ template "mysql.fullname" . }}
  namespace: {{ .Release.Namespace }}
  labels:
    app: {{ template "mysql.fullname" . }}
    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
    release: "{{ .Release.Name }}"
    heritage: "{{ .Release.Service }}"
type: Opaque
data:
  {{ if .Values.mysqlRootPassword }}
  mysql-root-password:  {{ .Values.mysqlRootPassword | b64enc | quote }}
  {{ else }}
  mysql-root-password: {{ randAlphaNum 10 | b64enc | quote }}
  {{ end }}
  {{ if .Values.mysqlPassword }}
  mysql-password:  {{ .Values.mysqlPassword | b64enc | quote }}
  {{ else }}
  mysql-password: {{ randAlphaNum 10 | b64enc | quote }}
  {{ end }}
{{- if .Values.ssl.enabled }}
{{ if .Values.ssl.certificates }}
{{- range .Values.ssl.certificates }}
---
apiVersion: v1
kind: Secret
metadata:
  name: {{ .name }}
  labels:
    app: {{ template "mysql.fullname" $ }}
    chart: "{{ $.Chart.Name }}-{{ $.Chart.Version }}"
    release: "{{ $.Release.Name }}"
    heritage: "{{ $.Release.Service }}"
type: Opaque
data:
  ca.pem: {{ .ca | b64enc }}
  server-cert.pem: {{ .cert | b64enc }}
  server-key.pem: {{ .key | b64enc }}
{{- end }}
{{- end }}
{{- end }}
{{- end }}

从结构看，文件的内容非常像 Secret 配置，只是大部分属性值变成了{{ xxx }}。这些 {{ xxx }} 实际上是模板的语法。Helm 采用了 Go 语言的模板来编写 chart。Go 模板非常强大，支持变量、对象、函数、流控制等功能。下面我们通过解析 templates/secrets.yaml 快速学习模板。

① {{ template "mysql.fullname" . }} 定义 Secret 的 name。
关键字 template 的作用是引用一个子模板 mysql.fullname。这个子模板是在 templates/_helpers.tpl 文件中定义的。

这个定义还是很复杂的，因为它用到了模板语言中的对象、函数、流控制等概念。现在看不懂没关系，这里我们学习的重点是：如果存在一些信息多个模板都会用到，则可在 templates/_helpers.tpl 中将其定义为子模板，然后通过 templates 函数引用。

这里 mysql.fullname 是由 release 与 chart 二者名字拼接组成。

根据 chart 的最佳实践，所有资源的名称都应该保持一致，对于我们这个 chart，无论 Secret 还是 Deployment、PersistentVolumeClaim、Service，它们的名字都是子模板 mysql.fullname 的值。

② Chart 和 Release 是 Helm 预定义的对象，每个对象都有自己的属性，可以在模板中使用。如果使用下面命令安装 chart：

helm install stable/mysql -n my
那么：
{{ .Chart.Name }} 的值为 mysql。
{{ .Chart.Version }} 的值为 0.3.0。
{{ .Release.Name }} 的值为 my。
{{ .Release.Service }} 始终取值为 Tiller。
{{ template "mysql.fullname" . }} 计算结果为 my-mysql。

③ 这里指定 mysql-root-password 的值，不过使用了 if-else 的流控制，其逻辑为：
如果 .Values.mysqlRootPassword 有值，则对其进行 base64 编码；否则随机生成一个 10 位的字符串并编码。

Values 也是预定义的对象，代表的是 values.yaml 文件。而 .Values.mysqlRootPassword 则是 values.yaml 中定义的 mysqlRootPassword 参数：

因为 mysqlRootPassword 被注释掉了，没有赋值，所以逻辑判断会走 else，即随机生成密码。

randAlphaNum、b64enc、quote 都是 Go 模板语言支持的函数，函数之间可以通过管道 | 连接。{{ randAlphaNum 10 | b64enc | quote }} 的作用是首先随机产生一个长度为 10 的字符串，然后将其 base64 编码，最后两边加上双引号。

templates/secrets.yaml 这个例子展示了 chart 模板主要的功能，我们最大的收获应该是：模板将 chart 参数化了，通过 values.yaml 可以灵活定制应用。

无论多复杂的应用，用户都可以用 Go 模板语言编写出 chart。无非是使用到更多的函数、对象和流控制。对于初学者，我的建议是尽量参考官方的 chart。根据二八定律，这些 chart 已经覆盖了绝大部分情况，而且采用了最佳实践。如何遇到不懂的函数、对象和其他语法，可参考官网文档 https://docs.helm.sh

实践 MySQL chart
chart 安装前的准备

作为准备工作，安装之前需要先清楚 chart 的使用方法。这些信息通常记录在 values.yaml 和 README.md 中。除了下载源文件查看，执行 helm inspect values 可能是更方便的方法。

[root@k8s-master ~]# helm inspect values stable/mysql
## mysql image version
## ref: https://hub.docker.com/r/library/mysql/tags/
##
image: "mysql"
imageTag: "5.7.14"

busybox:
  image: "busybox"
  tag: "1.29.3"

testFramework:
  enabled: true
  image: "dduportal/bats"
  tag: "0.4.0"

## Specify password for root user
##
## Default: random 10 character string
# mysqlRootPassword: testing

## Create a database user
##
# mysqlUser:
## Default: random 10 character string
# mysqlPassword:

## Allow unauthenticated access, uncomment to enable
##
# mysqlAllowEmptyPassword: true

## Create a database
##
# mysqlDatabase:

## Specify an imagePullPolicy (Required)
## It's recommended to change this to 'Always' if the image tag is 'latest'
## ref: http://kubernetes.io/docs/user-guide/images/#updating-images
##
imagePullPolicy: IfNotPresent

## Additionnal arguments that are passed to the MySQL container.
## For example use --default-authentication-plugin=mysql_native_password if older clients need to
## connect to a MySQL 8 instance.
args: []

extraVolumes: |
  # - name: extras
  #   emptyDir: {}

extraVolumeMounts: |
  # - name: extras
  #   mountPath: /usr/share/extras
  #   readOnly: true

extraInitContainers: |
  # - name: do-something
  #   image: busybox
  #   command: ['do', 'something']

# Optionally specify an array of imagePullSecrets.
# Secrets must be manually created in the namespace.
# ref: https://kubernetes.io/docs/concepts/containers/images/#specifying-imagepullsecrets-on-a-pod
# imagePullSecrets:
  # - name: myRegistryKeySecretName

## Node selector
## ref: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/#nodeselector
nodeSelector: {}

## Tolerations for pod assignment
## Ref: https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/
##
tolerations: []

livenessProbe:
  initialDelaySeconds: 30
  periodSeconds: 10
  timeoutSeconds: 5
  successThreshold: 1
  failureThreshold: 3

readinessProbe:
  initialDelaySeconds: 5
  periodSeconds: 10
  timeoutSeconds: 1
  successThreshold: 1
  failureThreshold: 3

## Persist data to a persistent volume
persistence:
  enabled: true
  ## database data Persistent Volume Storage Class
  ## If defined, storageClassName: <storageClass>
  ## If set to "-", storageClassName: "", which disables dynamic provisioning
  ## If undefined (the default) or set to null, no storageClassName spec is
  ##   set, choosing the default provisioner.  (gp2 on AWS, standard on
  ##   GKE, AWS & OpenStack)
  ##
  # storageClass: "-"
  accessMode: ReadWriteOnce
  size: 8Gi
  annotations: {}

## Use an alternate scheduler, e.g. "stork".
## ref: https://kubernetes.io/docs/tasks/administer-cluster/configure-multiple-schedulers/
##
# schedulerName:

## Security context
securityContext:
  enabled: false
  runAsUser: 999
  fsGroup: 999

## Configure resource requests and limits
## ref: http://kubernetes.io/docs/user-guide/compute-resources/
##
resources:
  requests:
    memory: 256Mi
    cpu: 100m

# Custom mysql configuration files path
configurationFilesPath: /etc/mysql/conf.d/

# Custom mysql configuration files used to override default mysql settings
configurationFiles: {}
#  mysql.cnf: |-
#    [mysqld]
#    skip-name-resolve
#    ssl-ca=/ssl/ca.pem
#    ssl-cert=/ssl/server-cert.pem
#    ssl-key=/ssl/server-key.pem

# Custom mysql init SQL files used to initialize the database
initializationFiles: {}
#  first-db.sql: |-
#    CREATE DATABASE IF NOT EXISTS first DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_general_ci;
#  second-db.sql: |-
#    CREATE DATABASE IF NOT EXISTS second DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_general_ci;

metrics:
  enabled: false
  image: prom/mysqld-exporter
  imageTag: v0.10.0
  imagePullPolicy: IfNotPresent
  resources: {}
  annotations: {}
    # prometheus.io/scrape: "true"
    # prometheus.io/port: "9104"
  livenessProbe:
    initialDelaySeconds: 15
    timeoutSeconds: 5
  readinessProbe:
    initialDelaySeconds: 5
    timeoutSeconds: 1
  flags: []
  serviceMonitor:
    enabled: false
    additionalLabels: {}

## Configure the service
## ref: http://kubernetes.io/docs/user-guide/services/
service:
  annotations: {}
  ## Specify a service type
  ## ref: https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services---service-types
  type: ClusterIP
  port: 3306
  # nodePort: 32000
  # loadBalancerIP:

ssl:
  enabled: false
  secret: mysql-ssl-certs
  certificates:
#  - name: mysql-ssl-certs
#    ca: |-
#      -----BEGIN CERTIFICATE-----
#      ...
#      -----END CERTIFICATE-----
#    cert: |-
#      -----BEGIN CERTIFICATE-----
#      ...
#      -----END CERTIFICATE-----
#    key: |-
#      -----BEGIN RSA PRIVATE KEY-----
#      ...
#      -----END RSA PRIVATE KEY-----

## Populates the 'TZ' system timezone environment variable
## ref: https://dev.mysql.com/doc/refman/5.7/en/time-zone-support.html
##
## Default: nil (mysql will use image's default timezone, normally UTC)
## Example: 'Australia/Sydney'
# timezone:

# Deployment Annotations
deploymentAnnotations: {}

# To be added to the database server pod(s)
podAnnotations: {}
podLabels: {}

## Set pod priorityClassName
# priorityClassName: {}

## Init container resources defaults
initContainer:
  resources:
    requests:
      memory: 10Mi
      cpu: 10m

输出的实际上是 values.yaml 的内容。阅读注释就可以知道 MySQL chart 支持哪些参数，安装之前需要做哪些准备。其中有一部分是关于存储的：

## Persist data to a persistent volume
persistence:
  enabled: true
  ## database data Persistent Volume Storage Class
  ## If defined, storageClassName: <storageClass>
  ## If set to "-", storageClassName: "", which disables dynamic provisioning
  ## If undefined (the default) or set to null, no storageClassName spec is
  ##   set, choosing the default provisioner.  (gp2 on AWS, standard on
  ##   GKE, AWS & OpenStack)
  ##
  # storageClass: "-"
  accessMode: ReadWriteOnce
  size: 8Gi
  annotations: {}

chart 定义了一个 PersistentVolumeClaim，申请 8G 的 PersistentVolume。由于我们的实验环境不支持动态供给，所以得预先创建好相应的 PV，其配置文件 mysql-pv.yml 内容为：

apiVersion: v1
kind: PersistentVolume
metadata:
  name: mysql-pv
spec:
  accessModes:
    - ReadWriteOnce
  capacity:
    storage: 8Gi
  persistentVolumeReclaimPolicy: Retain
  nfs:
    path: /nfsdata/mysql-pv
    server: 192.168.77.10

创建 PV mysql-pv：

[root@k8s-master ~]# kubectl apply -f mysql-pv.yml
persistentvolume/mysql-pv created
[root@k8s-master ~]# kubectl get pv
NAME       CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS      CLAIM   STORAGECLASS   REASON   AGE
mysql-pv   8Gi        RWO            Retain           Available                                   5s

接下来就可以安装 chart 了。

定制化安装 chart

除了接受 values.yaml 的默认值，我们还可以定制化 chart，比如设置 mysqlRootPassword。

Helm 有两种方式传递配置参数：

  1. 指定自己的 values 文件。
    通常的做法是首先通过 helm inspect values mysql > myvalues.yaml生成 values 文件，然后设置 mysqlRootPassword，之后执行 helm install --values=myvalues.yaml mysql。
  2. 通过 --set 直接传入参数值，比如：
[root@k8s-master ~]# helm install stable/mysql --set mysqlRootPassword=abc123 -n my
NAME:   my
LAST DEPLOYED: Tue Oct 15 21:52:35 2019
NAMESPACE: default
STATUS: DEPLOYED

RESOURCES:
==> v1/ConfigMap
NAME           DATA  AGE
my-mysql-test  1     0s

==> v1/Deployment
NAME      READY  UP-TO-DATE  AVAILABLE  AGE
my-mysql  0/1    1           0          0s

==> v1/PersistentVolumeClaim
NAME      STATUS   VOLUME  CAPACITY  ACCESS MODES  STORAGECLASS  AGE
my-mysql  Pending  0s

==> v1/Pod(related)
NAME                       READY  STATUS   RESTARTS  AGE
my-mysql-6dcc9b7d67-qh7m4  0/1    Pending  0         0s

==> v1/Secret
NAME      TYPE    DATA  AGE
my-mysql  Opaque  2     0s

==> v1/Service
NAME      TYPE       CLUSTER-IP    EXTERNAL-IP  PORT(S)   AGE
my-mysql  ClusterIP  10.105.14.41  <none>       3306/TCP  0s

NOTES:
MySQL can be accessed via port 3306 on the following DNS name from within your cluster:
my-mysql.default.svc.cluster.local

To get your root password run:

    MYSQL_ROOT_PASSWORD=$(kubectl get secret --namespace default my-mysql -o jsonpath="{.data.mysql-root-password}" | base64 --decode; echo)

To connect to your database:

1. Run an Ubuntu pod that you can use as a client:

    kubectl run -i --tty ubuntu --image=ubuntu:16.04 --restart=Never -- bash -il

2. Install the mysql client:

    $ apt-get update && apt-get install mysql-client -y

3. Connect using the mysql cli, then provide your password:
    $ mysql -h my-mysql -p

To connect to your database directly from outside the K8s cluster:
    MYSQL_HOST=127.0.0.1
    MYSQL_PORT=3306

    # Execute the following command to route the connection:
    kubectl port-forward svc/my-mysql 3306

    mysql -h ${MYSQL_HOST} -P${MYSQL_PORT} -u root -p${MYSQL_ROOT_PASSWORD}

mysqlRootPassword 设置为 abc123。另外，-n 设置 release 为 my，各类资源的名称即为my-mysql。

通过 helm list 和 helm status 可以查看 chart 的最新状态。

[root@k8s-master ~]# helm list
NAME                    REVISION        UPDATED                         STATUS     CHART           APP VERSION     NAMESPACE
my                      1               Tue Oct 15 21:52:35 2019        DEPLOYED   mysql-1.4.0     5.7.27          default  

[root@k8s-master ~]# helm status my
LAST DEPLOYED: Tue Oct 15 21:52:35 2019
NAMESPACE: default
STATUS: DEPLOYED

RESOURCES:
==> v1/ConfigMap
NAME           DATA  AGE
my-mysql-test  1     10m

==> v1/Deployment
NAME      READY  UP-TO-DATE  AVAILABLE  AGE
my-mysql  1/1    1           1          10m

==> v1/PersistentVolumeClaim
NAME      STATUS  VOLUME    CAPACITY  ACCESS MODES  STORAGECLASS  AGE
my-mysql  Bound   mysql-pv  8Gi       RWO           10m

==> v1/Pod(related)
NAME                       READY  STATUS   RESTARTS  AGE
my-mysql-6dcc9b7d67-qh7m4  1/1    Running  0         10m

==> v1/Secret
NAME      TYPE    DATA  AGE
my-mysql  Opaque  2     10m

==> v1/Service
NAME      TYPE       CLUSTER-IP    EXTERNAL-IP  PORT(S)   AGE
my-mysql  ClusterIP  10.105.14.41  <none>       3306/TCP  10m

NOTES:
MySQL can be accessed via port 3306 on the following DNS name from within your cluster:
my-mysql.default.svc.cluster.local

To get your root password run:

    MYSQL_ROOT_PASSWORD=$(kubectl get secret --namespace default my-mysql -o jsonpath="{.data.mysql-root-password}" | base64 --decode; echo)

To connect to your database:

1. Run an Ubuntu pod that you can use as a client:

    kubectl run -i --tty ubuntu --image=ubuntu:16.04 --restart=Never -- bash -il

2. Install the mysql client:

    $ apt-get update && apt-get install mysql-client -y

3. Connect using the mysql cli, then provide your password:
    $ mysql -h my-mysql -p

To connect to your database directly from outside the K8s cluster:
    MYSQL_HOST=127.0.0.1
    MYSQL_PORT=3306

    # Execute the following command to route the connection:
    kubectl port-forward svc/my-mysql 3306

    mysql -h ${MYSQL_HOST} -P${MYSQL_PORT} -u root -p${MYSQL_ROOT_PASSWORD}

PVC 已经 Bound，Deployment 也 AVAILABLE。

升级和回滚 release

release 发布后可以执行 helm upgrade 对其升级，通过 --values 或 --set应用新的配置。比如将当前的 MySQL 版本升级到 5.7.15：

[root@k8s-master ~]# helm upgrade --set imageTag=5.7.15 my stable/mysql
Release "my" has been upgraded.
LAST DEPLOYED: Tue Oct 15 22:13:15 2019
NAMESPACE: default
STATUS: DEPLOYED

RESOURCES:
==> v1/ConfigMap
NAME           DATA  AGE
my-mysql-test  1     20m

==> v1/Deployment
NAME      READY  UP-TO-DATE  AVAILABLE  AGE
my-mysql  1/1    1           1          20m

==> v1/PersistentVolumeClaim
NAME      STATUS  VOLUME    CAPACITY  ACCESS MODES  STORAGECLASS  AGE
my-mysql  Bound   mysql-pv  8Gi       RWO           20m

==> v1/Pod(related)
NAME                       READY  STATUS    RESTARTS  AGE
my-mysql-67f47db69b-tx2kt  0/1    Init:0/1  0         0s
my-mysql-6dcc9b7d67-qh7m4  1/1    Running   0         20m

==> v1/Secret
NAME      TYPE    DATA  AGE
my-mysql  Opaque  2     20m

==> v1/Service
NAME      TYPE       CLUSTER-IP    EXTERNAL-IP  PORT(S)   AGE
my-mysql  ClusterIP  10.105.14.41  <none>       3306/TCP  20m

NOTES:
MySQL can be accessed via port 3306 on the following DNS name from within your cluster:
my-mysql.default.svc.cluster.local

To get your root password run:

    MYSQL_ROOT_PASSWORD=$(kubectl get secret --namespace default my-mysql -o jsonpath="{.data.mysql-root-password}" | base64 --decode; echo)

To connect to your database:

1. Run an Ubuntu pod that you can use as a client:

    kubectl run -i --tty ubuntu --image=ubuntu:16.04 --restart=Never -- bash -il

2. Install the mysql client:

    $ apt-get update && apt-get install mysql-client -y

3. Connect using the mysql cli, then provide your password:
    $ mysql -h my-mysql -p

To connect to your database directly from outside the K8s cluster:
    MYSQL_HOST=127.0.0.1
    MYSQL_PORT=3306

    # Execute the following command to route the connection:
    kubectl port-forward svc/my-mysql 3306

    mysql -h ${MYSQL_HOST} -P${MYSQL_PORT} -u root -p${MYSQL_ROOT_PASSWORD}

等待一些时间，升级成功。

[root@k8s-master ~]# kubectl get deployments. my-mysql -o wide
NAME       READY   UP-TO-DATE   AVAILABLE   AGE   CONTAINERS   IMAGES         SELECTOR
my-mysql   1/1     1            1           21m   my-mysql     mysql:5.7.15   app=my-mysql,release=my

helm history 可以查看 release 所有的版本。通过 helm rollback 可以回滚到任何版本。

[root@k8s-master ~]# helm history my
REVISION        UPDATED                         STATUS          CHART           DESCRIPTION     
1               Tue Oct 15 21:52:35 2019        SUPERSEDED      mysql-1.4.0     Install complete
2               Tue Oct 15 22:13:15 2019        DEPLOYED        mysql-1.4.0     Upgrade complete

[root@k8s-master ~]# helm rollback my 1
Rollback was a success.

回滚成功，MySQL 恢复到 5.7.14。

[root@k8s-master ~]# helm history my
REVISION        UPDATED                         STATUS          CHART           DESCRIPTION     
1               Tue Oct 15 21:52:35 2019        SUPERSEDED      mysql-1.4.0     Install complete
2               Tue Oct 15 22:13:15 2019        SUPERSEDED      mysql-1.4.0     Upgrade complete
3               Tue Oct 15 22:16:21 2019        DEPLOYED        mysql-1.4.0     Rollback to 1  

[root@k8s-master ~]# kubectl get deployments. my-mysql -o wide
NAME       READY   UP-TO-DATE   AVAILABLE   AGE   CONTAINERS   IMAGES         SELECTOR
my-mysql   1/1     1            1           24m   my-mysql     mysql:5.7.14   app=my-mysql,release=my
开发自己的 chart

Kubernetes 给我们提供了大量官方 chart，不过要部署微服务应用，还是需要开发自己的 chart。

创建 chart

执行 helm create mychart 的命令创建 chart mychart：

[root@k8s-master ~]# helm create mychart
Creating mychart
[root@k8s-master ~]# tree mychart/
mychart/
├── charts
├── Chart.yaml
├── templates
│   ├── deployment.yaml
│   ├── _helpers.tpl
│   ├── ingress.yaml
│   ├── NOTES.txt
│   ├── service.yaml
│   └── tests
│       └── test-connection.yaml
└── values.yaml

3 directories, 8 files

Helm 会帮我们创建目录 mychart，并生成了各类 chart 文件。这样我们就可以在此基础上开发自己的 chart 了。

新建的 chart 默认包含一个 nginx 应用示例，values.yaml 内容如下：

# Default values for mychart.
# This is a YAML-formatted file.
# Declare variables to be passed into your templates.

replicaCount: 1

image:
  repository: nginx
  tag: stable
  pullPolicy: IfNotPresent

imagePullSecrets: []
nameOverride: ""
fullnameOverride: ""

service:
  type: ClusterIP
  port: 80

ingress:
  enabled: false
  annotations: {}
    # kubernetes.io/ingress.class: nginx
    # kubernetes.io/tls-acme: "true"
  hosts:
    - host: chart-example.local
      paths: []

  tls: []
  #  - secretName: chart-example-tls
  #    hosts:
  #      - chart-example.local

resources: {}
  # We usually recommend not to specify default resources and to leave this as a conscious
  # choice for the user. This also increases chances charts run on environments with little
  # resources, such as Minikube. If you do want to specify resources, uncomment the following
  # lines, adjust them as necessary, and remove the curly braces after 'resources:'.
  # limits:
  #   cpu: 100m
  #   memory: 128Mi
  # requests:
  #   cpu: 100m
  #   memory: 128Mi

nodeSelector: {}

tolerations: []

affinity: {}

开发时建议大家参考官方 chart 中的模板、values.yaml、Chart.yaml，里面包含了大量最佳实践和最常用的函数、流控制。

调试 chart

只要是程序就会有 bug，chart 也不例外。Helm 提供了 debug 的工具：helm lint 和 helm install --dry-run --debug。

helm lint 会检测 chart 的语法，报告错误以及给出建议。

比如我们故意在 values.yaml漏掉了一个 :，

helm lint mychart 会指出这个语法错误。

[root@k8s-master ~]# helm lint mychart
==> Linting mychart
[INFO] Chart.yaml: icon is recommended
[ERROR] values.yaml: unable to parse YAML
        error converting YAML to JSON: yaml: line 12: could not find expected ':'

Error: 1 chart(s) linted, 1 chart(s) failed

mychart 目录被作为参数传递给 helm lint。错误修复后则能通过检测。

helm install --dry-run --debug 会模拟安装 chart，并输出每个模板生成的 YAML 内容。

[root@k8s-master ~]# helm install --dry-run mychart --debug
[debug] Created tunnel using local port: '37754'

[debug] SERVER: "127.0.0.1:37754"

[debug] Original chart version: ""
[debug] CHART PATH: /root/mychart

NAME:   quieting-quetzal
REVISION: 1
RELEASED: Wed Oct 16 23:12:34 2019
CHART: mychart-0.1.0
USER-SUPPLIED VALUES:
{}

COMPUTED VALUES:
affinity: {}
fullnameOverride: ""
image:
  pullPolicy: IfNotPresent
  repository: nginx
  tag: stable
imagePullSecrets: []
ingress:
  annotations: {}
  enabled: false
  hosts:
  - host: chart-example.local
    paths: []
  tls: []
nameOverride: ""
nodeSelector: {}
replicaCount: 1
resources: {}
service:
  externalPort: 80
  internalPort: 80
  type: ClusterIP
tolerations: []

HOOKS:
---
# quieting-quetzal-mychart-test-connection
apiVersion: v1
kind: Pod
metadata:
  name: "quieting-quetzal-mychart-test-connection"
  labels:
    app.kubernetes.io/name: mychart
    helm.sh/chart: mychart-0.1.0
    app.kubernetes.io/instance: quieting-quetzal
    app.kubernetes.io/version: "1.0"
    app.kubernetes.io/managed-by: Tiller
  annotations:
    "helm.sh/hook": test-success
spec:
  containers:
    - name: wget
      image: busybox
      command: ['wget']
      args:  ['quieting-quetzal-mychart:']
  restartPolicy: Never
MANIFEST:

---
# Source: mychart/templates/service.yaml
apiVersion: v1
kind: Service
metadata:
  name: quieting-quetzal-mychart
  labels:
    app.kubernetes.io/name: mychart
    helm.sh/chart: mychart-0.1.0
    app.kubernetes.io/instance: quieting-quetzal
    app.kubernetes.io/version: "1.0"
    app.kubernetes.io/managed-by: Tiller
spec:
  type: ClusterIP
  ports:
    - port: 
      targetPort: http
      protocol: TCP
      name: http
  selector:
    app.kubernetes.io/name: mychart
    app.kubernetes.io/instance: quieting-quetzal
---
# Source: mychart/templates/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: quieting-quetzal-mychart
  labels:
    app.kubernetes.io/name: mychart
    helm.sh/chart: mychart-0.1.0
    app.kubernetes.io/instance: quieting-quetzal
    app.kubernetes.io/version: "1.0"
    app.kubernetes.io/managed-by: Tiller
spec:
  replicas: 1
  selector:
    matchLabels:
      app.kubernetes.io/name: mychart
      app.kubernetes.io/instance: quieting-quetzal
  template:
    metadata:
      labels:
        app.kubernetes.io/name: mychart
        app.kubernetes.io/instance: quieting-quetzal
    spec:
      containers:
        - name: mychart
          image: "nginx:stable"
          imagePullPolicy: IfNotPresent
          ports:
            - name: http
              containerPort: 80
              protocol: TCP
          livenessProbe:
            httpGet:
              path: /
              port: http
          readinessProbe:
            httpGet:
              path: /
              port: http
          resources:
            {}

我们可以检视这些输出，判断是否与预期相符。

同样，mychart 目录作为参数传递给 helm install --dry-run --debug。

管理和安装 chart

安装 chart
当我们觉得准备就绪，就可以安装 chart，Helm 支持四种安装方法：

安装仓库中的 chart，例如：helm install stable/nginx

通过 tar 包安装，例如：helm install ./nginx-1.2.3.tgz

通过 chart 本地目录安装，例如：helm install ./nginx

通过 URL 安装，例如：helm install https://example.com/charts/nginx-1.2.3.tgz

这里我们使用本地目录安装：

[root@k8s-master ~]# helm install mychart
NAME:   exasperated-olm
LAST DEPLOYED: Wed Oct 16 23:49:18 2019
NAMESPACE: default
STATUS: DEPLOYED

RESOURCES:
==> v1/Deployment
NAME                     READY  UP-TO-DATE  AVAILABLE  AGE
exasperated-olm-mychart  0/1    1           0          0s

==> v1/Pod(related)
NAME                                      READY  STATUS             RESTARTS  AGE
exasperated-olm-mychart-6845d8bb6c-mflfj  0/1    ContainerCreating  0         0s

==> v1/Service
NAME                     TYPE       CLUSTER-IP     EXTERNAL-IP  PORT(S)  AGE
exasperated-olm-mychart  ClusterIP  10.109.135.88  <none>       80/TCP   0s

NOTES:
1. Get the application URL by running these commands:
  export POD_NAME=$(kubectl get pods --namespace default -l "app.kubernetes.io/name=mychart,app.kubernetes.io/instance=exasperated-olm" -o jsonpath="{.items[0].metadata.name}")
  echo "Visit http://127.0.0.1:8080 to use your application"
  kubectl port-forward $POD_NAME 8080:80

当 chart 部署到 Kubernetes 集群，便可以对其进行更为全面的测试。

将 chart 添加到仓库

chart 通过测试后可以将其添加到仓库，团队其他成员就能够使用。任何 HTTP Server 都可以用作 chart 仓库，下面在 k8s-node1上搭建仓库。

在 k8s-node1 上启动一个 httpd 容器。

[root@k8s-node1 ~]# mkdir /var/www
[root@k8s-node1 ~]# docker run -d -p 8080:80 -v /var/www:/usr/local/apache2/htdocs/ httpd 
f571b574a59017de31b615402ae7d6886cde18907bb14c22fe82b8a68757e859

通过 helm package 将 mychart 打包。

[root@k8s-master ~]# helm package mychart
Successfully packaged chart and saved it to: /root/mychart-0.1.0.tgz

执行 helm repo index 生成仓库的 index 文件。

[root@k8s-master ~]# mkdir myrepo
[root@k8s-master ~]# mv mychart-0.1.0.tgz myrepo
[root@k8s-master ~]# helm repo index myrepo/ --url http://192.168.77.20:8080/charts
[root@k8s-master ~]# ls myrepo/
index.yaml  mychart-0.1.0.tgz
[root@k8s-master ~]#

Helm 会扫描 myrepo 目录中的所有 tgz 包并生成 index.yaml。--url指定的是新仓库的访问路径。新生成的 index.yaml 记录了当前仓库中所有 chart 的信息：

apiVersion: v1
entries:
  mychart:
  - apiVersion: v1
    appVersion: "1.0"
    created: "2019-10-16T23:58:54.835722169+08:00"
    description: A Helm chart for Kubernetes
    digest: 31c8cc4336c1afd09be0094a6bbb5d4c37abb20bbffbcc0c3e72101f6f0635b6
    name: mychart
    urls:
    - http://192.168.77.20:8080/charts/mychart-0.1.0.tgz
    version: 0.1.0
generated: "2019-10-16T23:58:54.834212265+08:00"

当前只有 mychart 这一个 chart。

将 mychart-0.1.0.tgz 和 index.yaml 上传到 k8s-node1 的 /var/www/charts 目录。

通过 helm repo add 将新仓库添加到 Helm。

[root@k8s-master ~]# helm repo add newrepo http://192.168.77.20:8080/charts
"newrepo" has been added to your repositories
[root@k8s-master ~]# 
[root@k8s-master ~]# helm repo list
NAME    URL                                             
stable  https://kubernetes-charts.storage.googleapis.com
local   http://127.0.0.1:8879/charts                    
newrepo http://192.168.77.20:8080/charts

仓库命名为 newrepo，Helm 会从仓库下载 index.yaml。

现在已经可以 repo search 到 mychart 了。

[root@k8s-master ~]# helm search mychart
NAME            CHART VERSION   APP VERSION     DESCRIPTION                
local/mychart   0.1.0           1.0             A Helm chart for Kubernetes
newrepo/mychart 0.1.0           1.0             A Helm chart for Kubernetes

除了 newrepo/mychart，这里还有一个 local/mychart。这是因为在执行第 2 步打包操作的同时，mychart 也被同步到了 local 的仓库。

已经可以直接从新仓库安装 mychart 了。

[root@k8s-master ~]# helm install newrepo/mychart
NAME:   ardent-pug
LAST DEPLOYED: Thu Oct 17 00:06:23 2019
NAMESPACE: default
STATUS: DEPLOYED

RESOURCES:
==> v1/Deployment
NAME                READY  UP-TO-DATE  AVAILABLE  AGE
ardent-pug-mychart  0/1    1           0          0s

==> v1/Pod(related)
NAME                               READY  STATUS             RESTARTS  AGE
ardent-pug-mychart-7858fd5f-j8mpb  0/1    ContainerCreating  0         0s

==> v1/Service
NAME                TYPE       CLUSTER-IP   EXTERNAL-IP  PORT(S)  AGE
ardent-pug-mychart  ClusterIP  10.98.167.6  <none>       80/TCP   0s

NOTES:
1. Get the application URL by running these commands:
  export POD_NAME=$(kubectl get pods --namespace default -l "app.kubernetes.io/name=mychart,app.kubernetes.io/instance=ardent-pug" -o jsonpath="{.items[0].metadata.name}")
  echo "Visit http://127.0.0.1:8080 to use your application"
  kubectl port-forward $POD_NAME 8080:80

如果以后仓库添加了新的 chart，需要用 helm repo update 更新本地的 index。

[root@k8s-master ~]# helm repo update
Hang tight while we grab the latest from your chart repositories...
...Skip local chart repository
...Successfully got an update from the "newrepo" chart repository
...Successfully got an update from the "stable" chart repository
Update Complete.

这个操作相当于CentOS的yum update。

小结
Helm 让我们能够像 apt 管理 deb 包那样安装、部署、升级和删除容器化应用。
Helm 由客户端和 Tiller 服务器组成。客户端负责管理 chart，服务器负责管理 release。

chart 是 Helm 的应用打包格式，它由一组文件和目录构成。其中最重要的是模板，模板中定义了 Kubernetes 各类资源的配置信息，Helm 在部署时通过 values.yaml 实例化模板。

Helm 允许用户开发自己的 chart，并为用户提供了调试工具。用户可以搭建自己的 chart 仓库，在团队中共享 chart。

Helm 帮助用户在 Kubernetes 上高效地运行和管理微服务架构应用，Helm 非常重要。

向AI问一下细节
推荐阅读：
  1. 玩K8S不得不会的HELM
  2. k8s实践(九)：Helm and Kubeapps UI

免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。

k8s docker linux

猜你喜欢

最新资讯
相关推荐

相关标签

prometheus1-k8s-node 部署k8s集群 k8s集群 k8s多节点部署 docker监控 docker-compose docker 容器 docker私有仓库部署 docker hub docker安全 docker compose docker仓库 dockerfile指令 docker swarm docker网络 dockertoolbox dockerswarm docker容器服务 centos docker DockerHub
AI
助
手
产品服务
地区划分
专题活动
帮助支持
关于我们
售后咨询
7*24小时在线电话：400-100-2938
7*24小时在线 QQ：800811969
关注亿速云

亿速云公众号

手机网站二维码

Copyright © Yisu Cloud Ltd. All Rights Reserved. 2018 版权所有

广州亿速云计算有限公司粤ICP备17096448号-1 粤公网安备 44010402001142号增值电信业务经营许可证编号：B1-20181529