第15章 helm prometheus监控redis等组件

第15章-helm-prometheus监控redis等组件

本章所讲内容：

15.1 k8s 包管理器 Helm

15.2 Prometheus 监控 redis、kafka、es 集群

15.1、k8s 包管理工具 Helm

1、Helm 介绍

官网：

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

https://helm.sh/

Helm 是一种 Kubernetes 的包管理工具，用于简化应用程序的部署和管理。它允许用户定义、安装和升级 Kubernetes 应用程序的预定义资源集合，称为 charts。

以下是 Helm 的基本介绍：

Charts：Helm 使用 charts 来打包和组织 Kubernetes 应用程序的部署文件。一个 chart 是一个预定义的目录结构，其中包含了用于创建 Kubernetes 对象的模板文件、参数配置文件和其他相关资源。通过使用 charts，你可以轻松地管理复杂的应用程序部署，并实现可重复性和可移植性。
仓库：Helm 提供了仓库的概念，类似于软件包管理工具中的软件包仓库。你可以将自己的 charts 存储在私有或公共的 Helm 仓库中，并与其他人共享。Helm Hub 是官方的公共仓库，包含了大量常用的 charts。
Tiller（已弃用）：在 Helm v2 中，Tiller 是 Helm 的服务端组件，负责管理 charts 的安装和升级。然而，在 Helm v3 中，Tiller 被移除了，安全性问题也随之解决。Helm v3 直接与 Kubernetes API 交互，不再依赖 Tiller。
Helm CLI：Helm 提供了一个命令行界面（CLI），用于与 Helm 进行交互。通过 Helm CLI，你可以搜索、安装、升级和删除 charts，管理 Helm 仓库，配置部署选项，并执行其他与 Helm 相关的操作。
部署管理：Helm 允许你通过定义 values 文件来配置 charts 的部署选项。这些 values 文件包含了应用程序所需的参数值，如镜像版本、服务端口、环境变量等。通过修改 values 文件，你可以轻松地自定义部署，并支持不同环境（如开发、测试和生产）之间的差异。
社区支持：Helm 是一个活跃的开源项目，拥有庞大的社区支持。这意味着你可以从社区中获取大量的 charts、文档、教程和支持，以加快你的应用程序部署和管理过程。

helm 下载地址：

https://github.com/helm/helm/releases

找到 Linux amd64 这个 checksum 连接，下载之后传到自己的 k8s 控制节点

2、安装 Helm v3

K8s 版本支持的各个 helm 版本对照表：

https://helm.sh/zh/docs/topics/version_skew/

[root@k8s-master01 helm]# tar -xf helm-v3.8.1-linux-amd64.tar.gz 

[root@k8s-master01 helm]# mv linux-amd64/helm /usr/local/bin/

3、配置国内存放 chart 仓库的地址

阿里云仓库:

（https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts）

1）添加阿里云的 chart 仓库

[root@k8s-master01 helm]# helm repo add aliyun https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts

显示如下：

"aliyun" has been added to your repositories

2）添加 bitnami 的 chart 仓库

[root@k8s-master01 helm]# helm repo add bitnami https://charts.bitnami.com/bitnami

3）更新 chart 仓库

[root@k8s-master01 helm]# helm repo update

4）查看当前 chart 仓库有哪些

[root@k8s-master01 helm]# helm repo list
NAME    URL                                                   
aliyun  https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts
bitnami https://charts.bitnami.com/bitnami

5）删除 chart 仓库地址

[root@k8s-master01 helm]# helm repo remove aliyun
"aliyun" has been removed from your repositories

重新添加阿里云的 chart 仓库

$ helm repo add aliyun https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts

更新 chart 仓库

$ helm repo update

6）从指定 chart 仓库地址搜索 chart

$ helm search repo aliyun

4、Helm 基本使用

4.1 搜索和下载 Chart

1）查看阿里云 chart 仓库中的 memcached

[root@k8s-master01 helm]# helm search repo aliyun |grep memcached
aliyun/mcrouter                 0.1.0           0.36.0          Mcrouter is a memcached protocol router for sca...
aliyun/memcached                2.0.1                           Free & open source, high-performance, distribut...

2）查看 chart 信息

[root@k8s-master01 helm]# helm show chart aliyun/memcached
apiVersion: v1
description: Free & open source, high-performance, distributed memory object caching
  system.
home: http://memcached.org/
icon: https://upload.wikimedia.org/wikipedia/en/thumb/2/27/Memcached.svg/1024px-Memcached.svg.png
keywords:
- memcached
- cache
maintainers:
- email: gtaylor@gc-taylor.com
  name: Greg Taylor
name: memcached
sources:
- https://github.com/docker-library/memcached
version: 2.0.1

3）下载 chart 包到本地

[root@k8s-master01 memcache]# helm pull aliyun/memcached

[root@k8s-master01 memcache]# tar -xf memcached-2.0.1.tgz 

[root@k8s-master01 memcache]# cd memcached

[root@k8s-master01 memcached]# ls
Chart.yaml  README.md  templates  values.yaml

文件解释：

Chart.yaml: chart 的基本信息，包括版本名字之类

templates: 存放 k8s 的部署资源模板，通过渲染变量得到部署文件

values.yaml：存放全局变量，templates 下的文件可以调用

[root@k8s-master01 memcached]# cd templates/

[root@k8s-master01 templates]# ls
_helpers.tpl  NOTES.txt  pdb.yaml  statefulset.yaml  svc.yaml

文件解释：

_helpers.tpl     存放能够复用的模板

NOTES.txt       为用户提供一个关于 chart 部署后使用说明的文件

4.2 部署 chart

4.2.1 helm 部署 memcached 服务

1）安装 memcached 的Chart

[root@k8s-node01 ~]# docker load -i memcache_1_4_36.tar.gz
[root@k8s-node02 ~]# docker load -i memcache_1_4_36.tar.gz

2）修改 statefulset.yaml 文件

## 修改文件所在位置
[root@k8s-master01 ~]# tree helm/
helm/
├── helm-v3.8.1-linux-amd64.tar.gz
├── linux-amd64
│   ├── LICENSE
│   └── README.md
└── memcache
    ├── memcached
    │   ├── Chart.yaml
    │   ├── README.md
    │   ├── templates
    │   │   ├── _helpers.tpl
    │   │   ├── NOTES.txt
    │   │   ├── pdb.yaml
    │   │   ├── statefulset.yaml
    │   │   └── svc.yaml
    │   └── values.yaml
    └── memcached-2.0.1.tgz

4 directories, 12 files

$ pwd
/root/helm/memcache/memcached

$ cp templates/statefulset.yaml templates/statefulset.yaml.bak
$ vim templates/statefulset.yaml

apiVersion 后面的 value 值变成 apps/v1

spec 下添加 selector 字段

  selector:
    matchLabels:
      app: {{ template "memcached.fullname" . }}
      chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
      release: "{{ .Release.Name }}"
      heritage: "{{ .Release.Service }}"

删除 affinity 亲和性配置

$ cat templates/statefulset.yaml

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: {{ template "memcached.fullname" . }}
  labels:
    app: {{ template "memcached.fullname" . }}
    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
    release: "{{ .Release.Name }}"
    heritage: "{{ .Release.Service }}"
spec:
  selector:
    matchLabels:
      app: {{ template "memcached.fullname" . }}
      chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
      release: "{{ .Release.Name }}"
      heritage: "{{ .Release.Service }}"
  serviceName: {{ template "memcached.fullname" . }}
  replicas: {{ .Values.replicaCount }}
  template:
    metadata:
      labels:
        app: {{ template "memcached.fullname" . }}
        chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
        release: "{{ .Release.Name }}"
        heritage: "{{ .Release.Service }}"
    spec:
      containers:
      - name: {{ template "memcached.fullname" . }}
        image: {{ .Values.image }}
        imagePullPolicy: {{ default "" .Values.imagePullPolicy | quote }}
        command:
        - memcached
        - -m {{ .Values.memcached.maxItemMemory  }}
        {{- if .Values.memcached.extendedOptions }}
        - -o
        - {{ .Values.memcached.extendedOptions }}
        {{- end }}
        {{- if .Values.memcached.verbosity }}
        - -{{ .Values.memcached.verbosity }}
        {{- end }}
        ports:
        - name: memcache
          containerPort: 11211
        livenessProbe:
          tcpSocket:
            port: memcache
          initialDelaySeconds: 30
          timeoutSeconds: 5
        readinessProbe:
          tcpSocket:
            port: memcache
          initialDelaySeconds: 5
          timeoutSeconds: 1
        resources:
{{ toYaml .Values.resources | indent 10 }}

3）helm 安装 memcached

$ helm install memcached ./

W0918 23:58:25.129203 1852598 warnings.go:70] policy/v1beta1 PodDisruptionBudget is deprecated in v1.21+, unavailable in v1.25+; use policy/v1 PodDisruptionBudget
W0918 23:58:25.193485 1852598 warnings.go:70] policy/v1beta1 PodDisruptionBudget is deprecated in v1.21+, unavailable in v1.25+; use policy/v1 PodDisruptionBudget
NAME: memcached
LAST DEPLOYED: Mon Sep 18 23:58:25 2023
NAMESPACE: default
STATUS: deployed
REVISION: 1
TEST SUITE: None
NOTES:
Memcached can be accessed via port 11211 on the following DNS name from within your cluster:
memcached-memcached.default.svc.cluster.local

If you'd like to test your instance, forward the port locally:

  export POD_NAME=$(kubectl get pods --namespace default -l "app=memcached-memcached" -o jsonpath="{.items[0].metadata.name}")
  kubectl port-forward $POD_NAME 11211

In another tab, attempt to set a key:

  $ echo -e 'set mykey 0 60 5\r\nhello\r' | nc localhost 11211

You should see:

  STORED

4）验证 memcache 是否部署成功：

$ kubectl get statefulset
NAME                  READY   AGE
memcached-memcached   3/3     34s

$ kubectl get pod |grep memcached
memcached-memcached-0         1/1     Running   0          2m1s
memcached-memcached-1         1/1     Running   0          111s
memcached-memcached-2         1/1     Running   0          101s

$ kubectl get svc |grep memcached
memcached-memcached   ClusterIP   None             <none>        11211/TCP      76s

$ export POD_NAME=$(kubectl get pods --namespace default -l "app=memcached-memcached" -o jsonpath="{.items[0].metadata.name}")
$ kubectl port-forward $POD_NAME 11211
Forwarding from 127.0.0.1:11211 -> 11211
Forwarding from [::1]:11211 -> 11211
Handling connection for 11211
Handling connection for 11211

$ echo -e 'set mykey 0 60 5\r\nhello\r' | nc localhost 11211

4.3 release 相关操作

查看 release 发布状态

[root@k8s-master01 memcached]# helm list
NAME        NAMESPACE   REVISION    UPDATED                                 STATUS      CHART           APP VERSION
memcached   default     1           2023-09-18 23:58:25.006706075 +0800 CST deployed    memcached-2.0.1

删除 release

$ helm delete memcached

删除 release 会把 release 下对应的资源也删除，memecached 的 pod 也被删除了

5、自定义 Chart 模板

5.1 自定义一个 Chart

当我们安装好 helm 之后我们可以开始自定义 chart，那么我们需要先创建出一个模板如下：

$ helm create myapp
$ cd myapp/

[root@k8s-master01 myapp]# tree .
.
├── charts                      #用于存放所依赖的子 chart
├── Chart.yaml                  ## 描述这个 Chart 的相关信息、包括名字、描述信息、版本等
├── templates                   #模板目录，保留创建 k8s 的资源清单文件
│   ├── deployment.yaml         #deployment 资源的 go 模板文件
│   ├── _helpers.tpl            ## 模板助手文件，定义的值可在模板中使用
│   ├── hpa.yaml                #水平 pod 自动扩缩容 go 模板文件
│   ├── ingress.yaml            #七层代理 go 模板文件
│   ├── NOTES.txt
│   ├── serviceaccount.yaml
│   ├── service.yaml            #service 的 go 模板文件
│   └── tests
│       └── test-connection.yaml
└── values.yaml                 #模板的值文件，这些值会在安装时应用到 GO 模板生成部署文件

3 directories, 10 files

5.2 Chart.yaml 编写规则

$ cat Chart.yaml 

apiVersion: v2
name: myapp
description: A Helm chart for Kubernetes
version: 0.0.1
appVersion: "latest"
type: application
maintainer:
- name: qingcai
  wechat: xuegod66
appVersion: "1.16.0"

上述的 YAML 文件是一个 Helm chart 的 Chart.yaml 文件，用于描述和定义 Helm chart 的基本信息和元数据。下面是对这个 YAML 文件的解释说明：

apiVersion: v2: 指定 Helm chart 的 API 版本，这里是 v2。
name: myapp: 指定 Helm chart 的名称，这里是 "myapp"。
description: A Helm chart for Kubernetes: 提供了对 Helm chart 的简要描述，说明它是一个用于部署 Kubernetes 资源的 Helm chart。
version: 0.0.1: 指定 Helm chart 的版本号，这里是 "0.0.1"。
appVersion: "latest": 指定应用程序的版本号，这里设置为 "latest"
type: application: 指定 Helm chart 的类型，这里是一个应用程序类型的 chart。应用程序类型的 Helm chart 通常包含了部署一个完整应用程序所需的各种 Kubernetes 资源，如 Deployment、Service、Ingress、ConfigMap、Secret 等。它们定义了应用程序的容器镜像、端口、环境变量、配置文件等信息，并提供了部署所需的模板和默认配置。
maintainer: 维护者的信息列表，包含一个或多个维护者的名称和联系方式。
name: xuegod: 维护者的名称，这里是 "qingcai"。
wechat: xuegod66: 维护者的微信号，这里是 "qingcai"。
appVersion: "1.16.0": 指定应用程序的实际版本号，这里设置为 "1.16.0"。

这个 Chart.yaml 文件提供了对 Helm chart 的基本信息描述，包括名称、描述、版本、应用程序版本等。它是 Helm chart 的核心元数据文件，用于识别和管理 Helm chart。

5.3 go 模板文件渲染

$ cat templates/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ include "myapp.fullname" . }}
  labels:
    {{- include "myapp.labels" . | nindent 4 }}
spec:
  {{- if not .Values.autoscaling.enabled }}
  replicas: {{ .Values.replicaCount }}
  {{- end }}
  selector:
    matchLabels:
      {{- include "myapp.selectorLabels" . | nindent 6 }}
  template:
    metadata:
      {{- with .Values.podAnnotations }}
      annotations:
        {{- toYaml . | nindent 8 }}
      {{- end }}
      labels:
        {{- include "myapp.selectorLabels" . | nindent 8 }}
    spec:
      {{- with .Values.imagePullSecrets }}
      imagePullSecrets:
        {{- toYaml . | nindent 8 }}
      {{- end }}
      serviceAccountName: {{ include "myapp.serviceAccountName" . }}
      securityContext:
        {{- toYaml .Values.podSecurityContext | nindent 8 }}
      containers:
        - name: {{ .Chart.Name }}
          securityContext:
            {{- toYaml .Values.securityContext | nindent 12 }}
          image: "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}"
          imagePullPolicy: {{ .Values.image.pullPolicy }}
          ports:
            - name: http
              containerPort: 80
              protocol: TCP
          livenessProbe:
            httpGet:
              path: /
              port: http
          readinessProbe:
            httpGet:
              path: /
              port: http
          resources:
            {{- toYaml .Values.resources | nindent 12 }}
      {{- with .Values.nodeSelector }}
      nodeSelector:
        {{- toYaml . | nindent 8 }}
      {{- end }}
      {{- with .Values.affinity }}
      affinity:
        {{- toYaml . | nindent 8 }}
      {{- end }}
      {{- with .Values.tolerations }}
      tolerations:
        {{- toYaml . | nindent 8 }}
      {{- end }}

以下是对这个 YAML 文件的解释说明：

apiVersion: apps/v1 : 指定了使用的 Kubernetes API 版本，这里是 apps/v1 版本。
kind: Deployment : 定义了 Kubernetes 对象的类型，这里是一个 Deployment 对象。
metadata : 定义了 Deployment 对象的元数据信息。
name: {{ include "myapp.fullname" . }} : 指定 Deployment 的名称。名称使用了 Helm 中的模板引用 include，引用了名为 "myapp.fullname" 的模板。
```
myapp.fullname 在 templates/_helpers.tpl 文件中定义了 

{{- define "myapp.fullname" -}} 

{{- if .Values.fullnameOverride }}

{{- .Values.fullnameOverride | trunc 63 | trimSuffix "-" }}
{{- else }}
{{- $name := default .Chart.Name .Values.nameOverride }}
{{- if contains $name .Release.Name }}
{{- .Release.Name | trunc 63 | trimSuffix "-" }}
{{- else }}
{{- printf "%s-%s" .Release.Name $name | trunc 63 | trimSuffix "-" }}
{{- end }}
{{- end }}
{{- end }}
```
备注：上述代码解释说明：
- {{- define "myapp.fullname" -}} : 这行代码定义了一个名为 "myapp.fullname" 的模板。
- {{- if .Values.fullnameOverride }} : 这行代码检查是否存在 .Values.fullnameOverride 值。如果存在，则执行下面的逻辑。
- {{- .Values.fullnameOverride | trunc 63 | trimSuffix "-" }} : 这行代码使用 .Values.fullnameOverride 值作为应用程序的完整名称。通过 trunc 函数将名称截断为 63 个字符，并使用 trimSuffix 函数去除尾部的连字符 "- "。
- {{- else }} : 如果 .Values.fullnameOverride 不存在，则执行下面的逻辑。
- {{- $name := default .Chart.Name .Values.nameOverride }} : 这行代码将 .Chart.Name 的值赋给变量 $name。如果存在 .Values.nameOverride 值，则使用该值覆盖 $name。
- {{- if contains $name .Release.Name }} : 这行代码检查 $name 是否包含 .Release.Name 的值。如果是，则执行下面的逻辑。
- {{- .Release.Name | trunc 63 | trimSuffix "-" }} : 这行代码使用 .Release.Name 作为应用程序的完整名称。通过 trunc 函数将名称截断为 63 个字符，并使用 trimSuffix 函数去除尾部的连字符 "- "。
- {{- else }} : 如果 $name 不包含 .Release.Name 的值，则执行下面的逻辑。
- {{- printf "%s-%s" .Release.Name $name | trunc 63 | trimSuffix "-" }} : 这行代码使用 .Release.Name 和 $name 的值生成应用程序的完整名称。通过 printf 函数将两个值连接起来，并使用 trunc 函数将名称截断为 63 个字符，并使用 trimSuffix 函数去除尾部的连字符 "- "。
- {{- end }} : 结束 if 条件判断。
- {{- end }} : 结束模板定义。

上述内容的目的是生成一个唯一且符合命名规范的应用程序完整名称。它考虑了 .Values.fullnameOverride 和 .Values.nameOverride 的设置，优先使用 .Values.fullnameOverride，其次使用 .Values.nameOverride 或者默认的 .Chart.Name 和 .Release.Name 进行名称的生成。生成的名称将截断为 63 个字符，并去除尾部的连字符 "- "。

labels : 定义了 Deployment 对象的标签。这里使用了 Helm 中的模板引用 include，引用了名为 "myapp.labels" 的模板，通过缩进 nindent 设置了标签的格式。
spec : 定义了 Deployment 对象的规格。
replicas: {{ .Values.replicaCount }} : 定义了 Deployment 的副本数量。这里使用了 Helm 中的值引用 .Values.replicaCount ，表示副本数量由 Helm 的值文件定义。
selector : 定义了用于选择 Pods 的标签。
- matchLabels : 指定了用于选择 Pods 的标签。这里使用了 Helm 中的模板引用 include，引用了名为 "myapp.selectorLabels" 的模板，并传递了当前上下文（.）作为参数，通过缩进 nindent 设置了标签的格式。
template : 定义了创建 Pods 的模板。
- metadata : 定义了 Pod 的元数据信息。
- annotations : 定义了 Pod 的注解。这里使用了 Helm 中的值引用 .Values.podAnnotations ，表示注解由 Helm 的值文件定义，通过缩进 nindent 设置了注解的格式。
- labels : 定义了 Pod 的标签。这里使用了 Helm 中的模板引用 include，引用了名为 "myapp.selectorLabels" 的模板，并传递了当前上下文（.）作为参数，通过缩进 nindent 设置了标签的格式。
spec : 定义了 Pod 的规格。
- imagePullSecrets : 定义了使用的镜像拉取凭证。这里使用了 Helm 中的值引用.Values.imagePullSecrets，表示镜像拉取凭证由 Helm 的值文件定义，通过缩进 nindent 设置了凭证的格式。
- serviceAccountName : 指定了 Pod 使用的服务账户名称。这里使用了 Helm 中的模板引用 include，引用了名为 "myapp.serviceAccountName" 的模板，并传递了当前上下文（.）作为参数。
- securityContext : 定义了 Pod 的安全上下文配置。这里使用了 Helm 中的值引用 .Values.podSecurityContext，通过缩进 nindent 设置了安全上下文的格式。
- containers : 定义了 Pod 中的容器。
- name: {{ .Chart.Name }} : 指定容器的名称。名称使用了 Helm 中的值引用 .Chart.Name ，表示容器的名称与 Chart 的名称相同。
- securityContext : 定义了容器的安全上下文配置。这里使用了 Helm 中的值引用 .Values.securityContext ，通过缩进 nindent 设置了安全上下文的格式。
- image : "{{ .Values.image.repository }}:{{ .Values.image.tag |default .Chart.AppVersion }}" : 指定容器使用的镜像。镜像名称使用了 Helm 中的值引用.Values.image.repository 和 .Values.image.tag ，表示镜像由 Helm 的值文件定义，通过缩进 nindent 设置了镜像的格式。
- imagePullPolicy : 定义了容器的镜像拉取策略。这里使用了 Helm 中的值引用 .Values.image.pullPolicy。
- ports : 定义了容器暴露的端口。
  - name: http : 指定端口的名称。
  - containerPort: 80 : 指定容器的端口号。
  - protocol: TCP : 指定端口的协议。
- livenessProbe : 定义了容器的存活探针。
  - livenessProbe : 定义了容器的存活探针。
  - path: / : 指定探针使用的路径。
  - port: http : 指定探针使用的端口。
- readinessProbe : 定义了容器的就绪探针。
  - httpGet : 指定了 HTTP 请求的方式。
  - path: / : 指定探针使用的路径。
  - port: http : 指定探针使用的端口。
- resources : 定义了容器的资源配置。这里使用了 Helm 中的值引用 .Values.resources ，通过缩进 nindent 设置了资源的格式。
- nodeSelector : 定义了 Pod 的节点选择器。这里使用了 Helm 中的值引用 .Values.nodeSelector ，通过缩进 nindent 设置了节点选择器的格式。
- affinity : 定义了 Pod 的亲和性配置。这里使用了 Helm 中的值引用 .Values.affinity ，通过缩进 nindent 设置了亲和性配置的格式。
- tolerations: 定义了 Pod 的容忍性配置。这里使用了 Helm 中的值引用 .Values.tolerations ，通过缩进 nindent 设置了容忍性配置的格式。

5.4 values.yaml 文件编写

[root@k8s-master01 myapp]# cat values.yaml 
## Default values for myapp.
## This is a YAML-formatted file.
## Declare variables to be passed into your templates.

replicaCount: 2

image:
  repository: nginx
  pullPolicy: IfNotPresent
  ## Overrides the image tag whose default is the chart appVersion.
  tag: ""

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

serviceAccount:
  ## Specifies whether a service account should be created
  create: true
  ## Annotations to add to the service account
  annotations: {}
  ## The name of the service account to use.
  ## If not set and create is true, a name is generated using the fullname template
  name: ""

podAnnotations: {}

podSecurityContext: {}
  ## fsGroup: 2000

securityContext: {}
  ## capabilities:
  ##   drop:
  ##   - ALL
  ## readOnlyRootFilesystem: true
  ## runAsNonRoot: true
  ## runAsUser: 1000

service:
  type: ClusterIP
  port: 80

ingress:
  enabled: false
  className: ""
  annotations: {}
    ## kubernetes.io/ingress.class: nginx
    ## kubernetes.io/tls-acme: "true"
  hosts:
    - host: chart-example.local
      paths:
        - path: /
          pathType: ImplementationSpecific
  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

autoscaling:
  enabled: false
  minReplicas: 1
  maxReplicas: 100
  targetCPUUtilizationPercentage: 80
  ## targetMemoryUtilizationPercentage: 80

nodeSelector: {}

tolerations: []

affinity: {}

5.5 部署 release

$ pwd
/root/helm/myapp

$ helm install myapp . 

NAME: myapp
LAST DEPLOYED: Tue Sep 19 00:53:33 2023
NAMESPACE: default
STATUS: deployed
REVISION: 1
NOTES:
1. Get the application URL by running these commands:
  export POD_NAME=$(kubectl get pods --namespace default -l "app.kubernetes.io/name=myapp,app.kubernetes.io/instance=myapp" -o jsonpath="{.items[0].metadata.name}")
  export CONTAINER_PORT=$(kubectl get pod --namespace default $POD_NAME -o jsonpath="{.spec.containers[0].ports[0].containerPort}")
  echo "Visit http://127.0.0.1:8080 to use your application"
  kubectl --namespace default port-forward $POD_NAME 8080:$CONTAINER_PORT

$ kubectl get pod |grep myapp
myapp-7d7647cfcc-p422q        1/1     Running   0          45s
myapp-7d7647cfcc-pd4b2        1/1     Running   0          45s

6. Helm 常用命令演示

6.1 打包 Chart

$ helm package /root/helm/myapp/
Successfully packaged chart and saved it to: /root/myapp-0.0.1.tgz

6.2 和 helm 相关的命令汇总

参考：https://v3.helm.sh/zh/docs/helm/helm/

15.2 、Prometheus 监控 Redis、kafaka、elasticsearch

1、prometheus 监控 redis

配置一个 Redis 的 exporter，我们通过 redis 进行暴露监控

在 Redis 上添加 prometheus.io/scrape=true

$ vim redis.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis
  namespace: kube-system
spec:
  replicas: 1
  selector:
    matchLabels:
      app: redis
  template:
    metadata:
      labels:
        app: redis
    spec:
      containers:
        - name: redis
          image: redis:4
          resources:
            requests:
              cpu: 100m
              memory: 100Mi
          ports:
          - containerPort: 6379
        - name: redis-exporter
          image: oliver006/redis_exporter:latest
          resources:
            requests:
              cpu: 100m
              memory: 100Mi
          ports:
          - containerPort: 9121
---
kind: Service
apiVersion: v1
metadata:
  name: redis
  namespace: kube-system
  annotations:
    prometheus.io/scrape: "true"
    prometheus.io/port: "9121"
spec:
  selector:
    app: redis
  ports:
  - name: redis
    port: 6379
    targetPort: 6379
  - name: prom
    port: 9121
    targetPort: 9121

$ kubectl apply -f redis.yaml

redis 这个 Pod 中包含了两个容器，一个就是 redis 本身的主应用，另外一个容器就是 redis_exporter

由于 Redis 服务的 metrics 接口在 redis-exporter 9121 上，所以我们添加了 prometheus.io/port=9121 这样的 annotation,在 prometheus 就会自动发现 redis 了

刷新一下 Redis 的Service 配置

$ kubectl apply -f redis.yaml

在 grafana 导入 redis 的json 文件 Redis Cluster-1571393212519.json，监控界面如下：

2、prometheus 监控 tomcat

tomcat_exporter 地址:

https://github.com/nlighten/tomcat_exporter

下面在控制节点操作

（1）制作 tomcat 镜像，按如下步骤

mkdir /root/tomcat_image

把上面的 war 包和 jar 包传到这个目录下

$ cat Dockerfile 

FROM tomcat
ADD metrics.war /usr/local/tomcat/webapps/ 
ADD simpleclient-0.8.0.jar /usr/local/tomcat/lib/
ADD simpleclient_common-0.8.0.jar /usr/local/tomcat/lib/
ADD simpleclient_hotspot-0.8.0.jar /usr/local/tomcat/lib/ 
ADD simpleclient_servlet-0.8.0.jar /usr/local/tomcat/lib/
ADD tomcat_exporter_client-0.0.12.jar /usr/local/tomcat/lib/

$ docker build -t "192.168.2.206/library/tomcat_prometheus:v1" .

$ docker login 192.168.2.206

#上传镜像到 hub 仓库
$ docker push 192.168.2.206/library/tomcat_prometheus:v1

#在 k8s 的 node 节点拉取镜像拉取镜像
$ docker pull 192.168.2.206/library/tomcat_prometheus:v1

（2）基于上面的镜像创建一个 tomcat 实例

$ cat deploy.yaml 

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tomcat-deployment
  namespace: default
spec:
  selector:
    matchLabels:
      app: tomcat
  replicas: 2
  template:
    metadata:
      labels:
        app: tomcat
      annotations:
        prometheus.io/scrape: 'true'
    spec:
      containers:
      - name: tomcat
        image: 192.168.2.206/library/tomcat_prometheus:v1
        ports:
        - containerPort: 8080
        securityContext:
          privileged: true

$ kubectl apply -f deploy.yaml

在 promethues 上可以看到监控到 tomcat 的 pod 了

3、prometheus 监控 elasticsearch

1、安装和配置 Elasticsearch Exporter：

Elasticsearch Exporter 是用于收集 Elasticsearch 指标的组件。你可以从 Elasticsearch Exporter 的 GitHub 仓库 https://github.com/justwatchcom/elasticsearch_exporter 获取最新版本的二进制文件。将Elasticsearch Exporter 部署到与 Elasticsearch 集群通信的主机上，并根据需要配置其参数。通常，你需要指定Elasticsearch 节点的地址、索引名称等。

具体配置如下，配置 Elasticsearch Exporter：编辑 Elasticsearch Exporter 的配置文件，通常是 elasticsearch_exporter.yml。

es.uri: http://localhost:9200 ## Elasticsearch 集群的连接地址

es.indices: true ## 监控索引级别的指标

es.cluster_settings: true ## 监控集群级别的指标

es.shards: true ## 监控分片级别的指标

2、配置 Prometheus 与 Elasticsearch Exporter 的关联：

在 Prometheus 的配置文件 prometheus.yml 中，添加以下内容来定义 Elasticsearch Exporter 的目标：

scrape_configs:
  - job_name: 'elasticsearch'
    static_configs:
      - targets: ['localhost:9108'] ## Elasticsearch Exporter 的监听地址

上述配置中，job_name 定义了该监控任务的名称，targets 指定了 Elasticsearch Exporter 的监听地址和端口。

第15章 helm prometheus监控redis等组件