Kubernetes

Kubernetes Node

下面是 Kubernetes 的架构图,用户交互部分是 UI 和 CLI,这两个不需要监控,关键是 Control plane(控制面)和 Worker node(工作负载节点)。控制面的组件提供了管理和调度能力,如果控制面组件出了问题,我们就没法给 Kubernetes 下发指令了。工作负载节点运行了容器,以及管理这些容器的运行时引擎(图上的 Docker)、管理 Pod 的 Kubelet,以及转发规则的 Kube-Proxy。工作负载节点如果出问题,可能会直接影响业务流量,所以对这类节点的监控就显得更为重要了。

当然,除了控制面组件和工作负载节点的监控,整个 Kubernetes 监控体系还应该包含另外三部分,一个是 Kubernetes 所在宿主的监控,一个是 Kubernetes 上面运行对象的监控,还有一个是 Pod 内业务的监控。宿主的监控就是机器的监控。Kubernetes 的对象监控,使用 kube-state-metrics(简称KSM) 监控。Pod 内的业务的监控,已经超过了组件监控的范畴。

所以 Kubernetes 组件监控,需要重点关注控制面、工作负载、KSM三个方面的监控。随着越来越多公司选择公有云的 Kubernetes 托管服务,控制面的组件直接交给云厂商来托管了,我们只需要关注工作负载节点,所以这一讲我们先来介绍工作负载节点的监控。

工作负载节点我们重点关注两部分,一个是容器负载,一个是组件,组件又包括 Kube-Proxy、Kubelet、容器引擎。容器引擎一般不会出问题,所以我们重点关注 Kubernetes 的两个组件 Kube-Proxy 和 Kubelet。按照先易后难,循序渐进的顺序,我们先来看一下 Kube-Proxy 的监控方案。

监控 Kube-Proxy

所有的 Kubernetes 组件,都提供了 /metrics 接口用来暴露监控数据,Kube-Proxy 也不例外。通过 ss 或者 netstat 命令可以看到 Kube-Proxy 监听的端口,一个是 10249,用来暴露监控指标,一个是 10256 ,作为健康检查的端口,一般我们只关注前一个端口。下面我来测试一下。

[root@tt-fc-dev01.nj ~]# curl -s localhost:10249/metrics | head -n 6
# HELP apiserver_audit_event_total [ALPHA] Counter of audit events generated and sent to the audit backend.
# TYPE apiserver_audit_event_total counter
apiserver_audit_event_total 0
# HELP apiserver_audit_requests_rejected_total [ALPHA] Counter of apiserver requests rejected due to an error in audit logging backend.
# TYPE apiserver_audit_requests_rejected_total counter
apiserver_audit_requests_rejected_total 0

不需要认证直接就可以拿到指标,很简单,我们只要有个采集器能够抓取这个数据就可以了。支持 Prometheus 协议数据抓取的采集器挺多的,这里我还是使用 Categraf 给你演示,相信通过前面几讲的演示,你对 Categraf 已经很熟悉了。

配置采集规则

抓取 Prometheus 协议的数据,使用 Categraf 的 input.prometheus 插件,配置文件在 conf/input.prometheus/prometheus.toml,要抓取哪个目标地址,就直接把 URL 配置到抓取地址中,可以参考下面的样例。

interval = 15
[[instances]]
urls = [
     "http://localhost:10249/metrics"
]
labels = { job="kube-proxy" }

之后我们就可以使用 ./categraf --test --inputs prometheus 测试了,如果一切正常,在控制台就能看到采集到的 Kube-Proxy 相关的指标,具体哪些指标比较关键呢?先不急,后面我会谈到。

Kube-Proxy 在 Kubernetes 集群的所有节点上部署,如果使用上面的采集规则配置方式,就需要在所有 Kubernetes 节点的 Categraf 上配置采集规则,未来扩容节点的时候,也要记得在新节点配置采集规则。如果机器初始化流程做得不错,也还好,否则的话就会比较麻烦。我更推荐的方式,是把 Categraf 作为 Daemonset 部署,这样每次新节点扩容,Kubernetes 会自动调度,省事不少。下面我来演示一下如何部署 Categraf Daemonset。

使用 Daemonset 部署采集器

要把 Categraf 部署为 Daemonset,需要先创建一个 namespace,然后把相关的配置做成 ConfigMap,下面我做一个演示,先创建 namespace。

# 创建 namespace
$ kubectl create namespace flashcat
namespace/flashcat created

# 查询刚刚创建的namespace,看是否创建成功
$ kubectl get ns | grep flashcat
flashcat                                 Active   29s

然后创建 ConfigMap,ConfigMap 用来放置 Categraf 的主配置 config.toml,以及 input.prometheus 插件的配置 prometheus.toml,你可以看一下相关的 YAML 内容。

---
kind: ConfigMap
metadata:
  name: categraf-config
apiVersion: v1
data:
  config.toml: |
    [global]
    hostname = "$HOSTNAME"
    interval = 15
    providers = ["local"]
    [writer_opt]
    batch = 2000
    chan_size = 10000
    [[writers]]
    url = "http://10.206.0.16:19000/prometheus/v1/write"
    timeout = 5000
    dial_timeout = 2500
    max_idle_conns_per_host = 100
---
kind: ConfigMap
metadata:
  name: categraf-input-prometheus
apiVersion: v1
data:
  prometheus.toml: |
    [[instances]]
    urls = ["http://127.0.0.1:10249/metrics"]
    labels = { job="kube-proxy" }

上例中的 http://10.206.0.16:19000/prometheus/v1/write 是一个支持 Prometheus Remote Write 协议的数据接收地址,可以使用你的 n9e-server,也可以使用 vminsert、prometheus 等其他支持 RemoteWrite 协议的地址。 hostname = "$HOSTNAME" 这个配置用了 $ 符号,后面创建 Daemonset 的时候会注入 HOSTNAME 这个环境变量,让 Categraf 自动拿到。

prometheus.toml 的配置中,除了给出 Kube-Proxy 的抓取地址,还手工指定了一个 job 标签,用来标识这个数据来自哪个组件。如果公司有多套 Kubernetes 集群,所有监控数据都会进到一个时序库,为了区分不同的集群,我建议你在标签里再加一个 cluster 的标签。

比如:

labels = { job="kube-proxy", cluster="beijing01" }

下面我们把 ConfigMap 创建出来。

[work@tt-fc-dev01.nj yamls]$ kubectl apply -f categraf-configmap-v1.yaml -n flashcat
configmap/categraf-config created
configmap/categraf-input-prometheus created

[work@tt-fc-dev01.nj yamls]$ kubectl get configmap -n flashcat
NAME                        DATA   AGE
categraf-config             1      19s
categraf-input-prometheus   1      19s
kube-root-ca.crt            1      22m

配置文件准备好了,接下来就可以创建 Daemonset 了。这里要注意,把 HOSTNAME 作为环境变量注入进去,你可以参考我给出的这个 Daemonset 的 YAML 文件。

apiVersion: apps/v1
kind: DaemonSet
metadata:
  labels:
    app: categraf-daemonset
  name: categraf-daemonset
spec:
  selector:
    matchLabels:
      app: categraf-daemonset
  template:
    metadata:
      labels:
        app: categraf-daemonset
    spec:
      containers:
      - env:
        - name: TZ
          value: Asia/Shanghai
        - name: HOSTNAME
          valueFrom:
            fieldRef:
              apiVersion: v1
              fieldPath: spec.nodeName
        - name: HOSTIP
          valueFrom:
            fieldRef:
              apiVersion: v1
              fieldPath: status.hostIP
        image: flashcatcloud/categraf:v0.2.18
        imagePullPolicy: IfNotPresent
        name: categraf
        volumeMounts:
        - mountPath: /etc/categraf/conf
          name: categraf-config
        - mountPath: /etc/categraf/conf/input.prometheus
          name: categraf-input-prometheus
      hostNetwork: true
      restartPolicy: Always
      tolerations:
      - effect: NoSchedule
        operator: Exists
      volumes:
      - configMap:
          name: categraf-config
        name: categraf-config
      - configMap:
          name: categraf-input-prometheus
        name: categraf-input-prometheus

最后一步,apply 一下这个 Daemonset 的 YAML 文件。

[work@tt-fc-dev01.nj yamls]$ kubectl apply -f categraf-daemonset-v1.yaml -n flashcat
daemonset.apps/categraf-daemonset created

[work@tt-fc-dev01.nj yamls]$ kubectl get ds -o wide -n flashcat
NAME                 DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE     CONTAINERS   IMAGES                           SELECTOR
categraf-daemonset   6         6         6       6            6           <none>          2m20s   categraf     flashcatcloud/categraf:v0.2.17   app=categraf-daemonset

[work@tt-fc-dev01.nj yamls]$ kubectl get pods -o wide -n flashcat
NAME                       READY   STATUS    RESTARTS   AGE     IP            NODE          NOMINATED NODE   READINESS GATES
categraf-daemonset-4qlt9   1/1     Running   0          2m10s   10.206.0.7    10.206.0.7    <none>           <none>
categraf-daemonset-s9bk2   1/1     Running   0          2m10s   10.206.0.11   10.206.0.11   <none>           <none>
categraf-daemonset-w77lt   1/1     Running   0          2m10s   10.206.16.3   10.206.16.3   <none>           <none>
categraf-daemonset-xgwf5   1/1     Running   0          2m10s   10.206.0.16   10.206.0.16   <none>           <none>
categraf-daemonset-z9rk5   1/1     Running   0          2m10s   10.206.16.8   10.206.16.8   <none>           <none>
categraf-daemonset-zdp8v   1/1     Running   0          2m10s   10.206.0.17   10.206.0.17   <none>           <none>

看起来一切正常,去监控服务端查询一下 kubeproxy 打头的指标,理论上就能看到采集到的数据了。Kube-Proxy 暴露了不少指标,下面我挑选一些关键指标稍作解释。

Kube-Proxy 指标解释

  1. 通用的 Go 程序相关的指标
通用的 Go 程序相关的指标 解释
go_gc_duration_seconds GC 时间
go_goroutines Gorountine 数量
go_threads 线程数量
process_max_fds 进程可以打开的最大文件句柄数量
process_open_fds 进程当前可以打开了多少文件句柄
process_resident_memory_bytes 内存使用大小
process_cpu_seconds_total 进程使用的 CPU 时间
process_start_time_seconds 进程启动时间戳

以上指标,只要是通过 Prometheus Go SDK 埋点的程序都会有,除了 Kube-Proxy,后面介绍的 Kubelet、APIServer、Scheduler 等,也全部都有,这里你记住了,后面我就不会重复介绍了。

  1. 请求 APIServer 的指标

Kubernetes 中多个组件都要调用 APIServer 的接口,每秒调用多少次、有多少成功多少失败、耗时情况如何,这些指标也比较关键。

比如:

  1. 规则同步类指标

Kube-Proxy 的核心职能,就是去 APIServer 获取转发规则,修改本地的 iptables 或者 ipvs 的规则,所以这些规则同步相关的指标,就至关重要了。这里列出几个核心指标。

Categraf 内置了 Kube-Proxy 的 监控大盘,关键的核心指标都已经做到监控大盘里了,导入夜莺就能使用。

监控 Kubelet

Kubelet 也是在所有 Kubernetes 节点上部署的,理论上可以采用和 Kube-Proxy 完全一样的监控方法,但是 Kubelet 的接口需要认证,我们来测试一下。

$ ps aux|grep kubelet
root      163490  0.0  0.0  12136  1064 pts/1    S+   13:34   0:00 grep --color=auto kubelet
root      166673  3.2  1.0 3517060 81336 ?       Ssl  Aug16 4176:52 /usr/bin/kubelet --bootstrap-kubeconfig=/etc/kubernetes/bootstrap-kubelet.conf --kubeconfig=/etc/kubernetes/kubelet.conf --config=/var/lib/kubelet/config.yaml --hostname-override=10.206.0.16 --network-plugin=cni --pod-infra-container-image=registry.aliyuncs.com/google_containers/pause:3.6

$ cat /var/lib/kubelet/config.yaml | grep 102
healthzPort: 10248

$ curl localhost:10248/healthz
ok

$ curl localhost:10250/metrics
Client sent an HTTP request to an HTTPS server.

$ curl https://localhost:10250/metrics
curl: (60) SSL certificate problem: self signed certificate in certificate chain
More details here: https://curl.haxx.se/docs/sslcerts.html

curl failed to verify the legitimacy of the server and therefore could not
establish a secure connection to it. To learn more about this situation and
how to fix it, please visit the web page mentioned above.
$ curl -k https://localhost:10250/metrics
Unauthorized

这几条测试命令可以说明很多问题,首先是Kubelet 监听了两个端口,一个是 10248,是个健康检查端口,另一个是 10250,暴露 metrics 指标,但是访问这个接口需要传入 Authorization 的 Token,下面我们就来创建 ServiceAccount。Kubernetes 会为 ServiceAccount 自动分配 Token。

引入认证信息

只创建 ServiceAccount 没什么用,还需要为这个账号绑定权限,Kubernetes 中使用 ClusterRole 来定义权限,使用 ClusterRoleBinding 来绑定 ClusterRole 和 ServiceAccount,下面是相关 YAML 定义。

---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: categraf-daemonset
rules:
- apiGroups:
  - ""
  resources:
  - nodes/metrics
  - nodes/stats
  - nodes/proxy
  verbs:
  - get
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: categraf-daemonset
  namespace: flashcat
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: categraf-daemonset
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: categraf-daemonset
subjects:
- kind: ServiceAccount
  name: categraf-daemonset
  namespace: flashcat

把上面的内容保存为 auth.yaml,apply 一下,然后我们从 ServiceAccount 中提取 Token,做一下 metrics 接口的请求测试。

[work@tt-fc-dev01.nj yamls]$ kubectl apply -f auth.yaml
clusterrole.rbac.authorization.k8s.io/categraf-daemonset created
serviceaccount/categraf-daemonset created
clusterrolebinding.rbac.authorization.k8s.io/categraf-daemonset created

[work@tt-fc-dev01.nj yamls]$ kubectl get sa -n flashcat
NAME                 SECRETS   AGE
categraf-daemonset   1         90m
default              1         4d23h

[root@tt-fc-dev01.nj qinxiaohui]# kubectl get sa categraf-daemonset -n flashcat -o yaml
apiVersion: v1
kind: ServiceAccount
metadata:
  annotations:
    kubectl.kubernetes.io/last-applied-configuration: |
      {"apiVersion":"v1","kind":"ServiceAccount","metadata":{"annotations":{},"name":"categraf-daemonset","namespace":"flashcat"}}
  creationTimestamp: "2022-11-14T03:53:54Z"
  name: categraf-daemonset
  namespace: flashcat
  resourceVersion: "120570510"
  uid: 22f5a785-871c-4454-b82e-12bf104450a0
secrets:
- name: categraf-daemonset-token-7mccq

[root@tt-fc-dev01.nj qinxiaohui]# token=`kubectl get secret categraf-daemonset-token-7mccq -n flashcat -o jsonpath={.data.token} | base64 -d`
[root@tt-fc-dev01.nj qinxiaohui]# curl -s -k -H "Authorization: Bearer $token" https://localhost:10250/metrics > aaaa
[root@tt-fc-dev01.nj qinxiaohui]# head -n 5 aaaa
# HELP apiserver_audit_event_total [ALPHA] Counter of audit events generated and sent to the audit backend.
# TYPE apiserver_audit_event_total counter
apiserver_audit_event_total 0
# HELP apiserver_audit_requests_rejected_total [ALPHA] Counter of apiserver requests rejected due to an error in audit logging backend.
# TYPE apiserver_audit_requests_rejected_total counter
apiserver_audit_requests_rejected_total 0

这几个命令看起来比较清晰了,创建的 ServiceAccount 名为 categraf-daemonset,导出为 YAML 之后,看到 secret 的 name 是 categraf-daemonset-token-7mccq,然后从这个 secret 中解出 Token,放到 Header 里,请求 Kubelet 的 metrics 接口,最终拿到了数据,搞定收工。

后面我们把 Categraf 作为采集器做成 Daemonset,再为 Categraf 这个 Daemonset 指定 ServiceAccountName,Kubernetes就会自动把 Token 的内容挂到 Daemonset 的目录里,下面我们开始实操。

升级 Categraf Daemonset

采集 Kube-Proxy 的时候,我们已经准备好了 Categraf Daemonset 用到的 ConfigMap,当时只是抓取了 Kube-Proxy 的 metrics 数据,下面我们升级一下这个 ConfigMap 的内容,加上对 Kubelet 的数据抓取规则。

---
kind: ConfigMap
metadata:
  name: categraf-config
apiVersion: v1
data:
  config.toml: |
    [global]
    hostname = "$HOSTNAME"
    interval = 15
    providers = ["local"]
    [writer_opt]
    batch = 2000
    chan_size = 10000
    [[writers]]
    url = "http://10.206.0.16:19000/prometheus/v1/write"
    timeout = 5000
    dial_timeout = 2500
    max_idle_conns_per_host = 100
---
kind: ConfigMap
metadata:
  name: categraf-input-prometheus
apiVersion: v1
data:
  prometheus.toml: |
    [[instances]]
    urls = ["http://127.0.0.1:10249/metrics"]
    labels = { job="kube-proxy" }
    [[instances]]
    urls = ["https://127.0.0.1:10250/metrics"]
    bearer_token_file = "/var/run/secrets/kubernetes.io/serviceaccount/token"
    use_tls = true
    insecure_skip_verify = true
    labels = { job="kubelet" }
    [[instances]]
    urls = ["https://127.0.0.1:10250/metrics/cadvisor"]
    bearer_token_file = "/var/run/secrets/kubernetes.io/serviceaccount/token"
    use_tls = true
    insecure_skip_verify = true
    labels = { job="cadvisor" }

Kubelet 在 10250 端口暴露了两类 metrics 数据,一个是 /metrics,暴露的是 Kubelet 自身的监控数据,另一个是 /metrics/cadvisor,暴露的是容器的监控数据。

然后修改一下之前的 Daemonset 的 yaml 文件,在 hostNetwork 这一行下面增加 ServiceAccountName 配置,你可以看下示例。

hostNetwork: true
serviceAccountName: categraf-daemonset
restartPolicy: Always

我们可以把之前的 Daemonset 直接删除,使用新的 yaml 重新创建,稍等片刻,就能在服务端查询到 Kubelet 和容器的监控数据了。

Kubelet 关键指标

Kubelet 也会吐出 Go 进程相关的通用指标以及和 APIServer 通信相关的度量指标,和 Kube-Proxy 类似。Kubelet 核心职能是管理 Pod,操作各种 CNI、CSI 相关的接口,和容器引擎打交道,度量这类操作的指标就显得尤为关键。

比如:

Categraf 内置了 Kubelet 的 监控大盘,关键的核心指标都已经做到监控大盘里了,导入夜莺就能使用。

刚才我们在升级 Categraf Daemonset 的 ConfigMap 的时候,不只采集了 Kubelet 的指标,还一并采集了容器的指标,Categraf 也提供了容器的 监控大盘。关于容器,我这里也选几个核心的指标给你解释一下。

容器负载指标

容器负载主要是关心 CPU、内存、网络、IO,尤其是 CPU 和内存,我们一起看一下相关指标的说明。

CPU指标

sum(irate(container_cpu_usage_seconds_total[3m])) by (pod,id,namespace,container,ident,image)/sum(container_spec_cpu_quota/container_spec_cpu_period) by (pod,id,namespace,container,ident,image)

这是计算CPU使用率,整体是一个除法运算,分子部分是容器每秒耗费的CPU时间,分母部分是每秒分配给容器的CPU时间。里边的 ident 标签是 Categraf 采集时自动加的,如果你的采集方式和我演示的不同,可能要适当调整 by 后面的标签集。

increase(container_cpu_cfs_throttled_periods_total[1m])/increase(container_cpu_cfs_periods_total[1m]) * 100

这是在计算CPU被限制的时间比例,如果这个值很高,说明容器在使用CPU资源的时候经常被限制,需要提高这个容器的CPU Quota。延迟敏感型的应用,需要特别关注这个指标。

内存指标

container_memory_working_set_bytes
/
container_spec_memory_limit_bytes
and
container_spec_memory_limit_bytes != 0

计算内存使用率的时候,核心也是一个除法运算,分子是容器的内存占用,分母是内存Limit大小。当然,有些容器没有指定内存Limit,所以还需要有个 and 语句来做限制,只有 limit_bytes 不等于 0,这个除法运算才有意义。

Pod 网络流量

irate(container_network_transmit_bytes_total[1m]) * 8
irate(container_network_receive_bytes_total[1m]) * 8

这个指标名字非常清晰,transmit 是出向,receive 是入向,这两个指标都是 Counter 类型的值,单调递增,所以使用 irate 计算每秒速率。因为网络流量一般都是用 bit 作为单位,所以最后乘以 8,把 byte 换算成 bit。

Pod 硬盘IO读写流量

irate(container_fs_reads_bytes_total[1m])
irate(container_fs_writes_bytes_total[1m])

这个指标名字一看就知道是 Counter 类型,我们不关心当前值是多少,而是关心最近一段时间每秒的速率是多少,所以使用 irate 做了二次计算。

刚刚我们说的这些就是容器负载相关的关键指标。到这里,我们就介绍完工作负载节点的核心知识点了,下面我们对整体内容做一个小结。

Kubernetes 控制面组件

控制面组件 的监控,包括 APIServer、Controller-manager(简称CM)、Scheduler、etcd 四个组件。此外,我们还会学习如何使用 kube-state-metrics(简称KSM)来监控Kubernetes 的各类对象。

数据采集

自行搭建 Kubernetes 控制面的朋友,大都是选择 Kubeadm 这样的工具,Kubeadm 会把控制面的组件以静态容器的方式放到容器里运行,之后我会重点给你演示在这种部署方式下如何采集监控数据。

不过很多大一些的互联网公司会选择直接使用二进制的方式来部署,因为二进制的方式对于监控数据采集来说其实更简单,直接在采集器里配置要抓取的这几个组件的目标地址就可以了。

如果想要调用 Kubernetes 服务端 APIServer、Controller-manager、Scheduler 这三个组件的 /metrics 接口,需要有 Token 做鉴权,我们还是通过创建 ServiceAccount 的方式拿到 Token,后面也会把采集器直接部署到 Kubernetes 容器里,这样 Token 信息就可以自动 mount 到容器里,比较方便。

创建认证信息

相比前面为 Categraf 准备的 ServiceAccount,用于访问控制面组件的 ServiceAccount 会要求更多权限,这里我重新给出一个升级后的 YAML 文件,供你参考。

---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: categraf
rules:
  - apiGroups: [""]
    resources:
      - nodes
      - nodes/metrics
      - nodes/stats
      - nodes/proxy
      - services
      - endpoints
      - pods
    verbs: ["get", "list", "watch"]
  - apiGroups:
      - extensions
      - networking.k8s.io
    resources:
      - ingresses
    verbs: ["get", "list", "watch"]
  - nonResourceURLs: ["/metrics", "/metrics/cadvisor"]
    verbs: ["get"]
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: categraf
  namespace: flashcat
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: categraf
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: categraf
subjects:
- kind: ServiceAccount
  name: categraf
  namespace: flashcat

使用 kubectl apply 一下这个YAML 文件即可。有了认证信息,后面就是选型并部署采集器了。

部署采集器

我们希望能够自动感知到组件实例的变化,也就是要抓取的目标地址的变化。毫无疑问要读取 Kubernetes 的元信息,就需要具备类似 Prometheus 的 Kubernetes 服务发现能力。支持这个服务发现能力的采集器,比较常用的是 Telegraf、Prometheus、Categraf、Grafana-agent、vmagent 等,这里最原汁原味的显然是 Prometheus 自身。

Prometheus 从 v2.32.0 开始支持 agent mode 模式,相当于把 Prometheus 当做一个采集 agent 来使用,只负责采集数据,这个玩法最为简便清晰,我们就使用这个方式来采集数据。

agent mode 模式的 Prometheus,重点要配置 scrape 规则和 remote write 地址,我们把配置文件做成 ConfigMap,你可以看一下具体的 YAML 文件。

apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-agent-conf
  labels:
    name: prometheus-agent-conf
  namespace: flashcat
data:
  prometheus.yml: |-
    global:
      scrape_interval: 15s
      evaluation_interval: 15s

    scrape_configs:
      - job_name: 'apiserver'
        kubernetes_sd_configs:
        - role: endpoints
        scheme: https
        tls_config:
          insecure_skip_verify: true
        authorization:
          credentials_file: /var/run/secrets/kubernetes.io/serviceaccount/token
        relabel_configs:
        - source_labels: [__meta_kubernetes_namespace, __meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name]
          action: keep
          regex: default;kubernetes;https

      - job_name: 'controller-manager'
        kubernetes_sd_configs:
        - role: endpoints
        scheme: https
        tls_config:
          insecure_skip_verify: true
        authorization:
          credentials_file: /var/run/secrets/kubernetes.io/serviceaccount/token
        relabel_configs:
        - source_labels: [__meta_kubernetes_namespace, __meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name]
          action: keep
          regex: kube-system;kube-controller-manager;https

      - job_name: 'scheduler'
        kubernetes_sd_configs:
        - role: endpoints
        scheme: https
        tls_config:
          insecure_skip_verify: true
        authorization:
          credentials_file: /var/run/secrets/kubernetes.io/serviceaccount/token
        relabel_configs:
        - source_labels: [__meta_kubernetes_namespace, __meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name]
          action: keep
          regex: kube-system;kube-scheduler;https

      - job_name: 'etcd'
        kubernetes_sd_configs:
        - role: endpoints
        scheme: http
        relabel_configs:
        - source_labels: [__meta_kubernetes_namespace, __meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name]
          action: keep
          regex: kube-system;etcd;http

      - job_name: 'kube-state-metrics'
        kubernetes_sd_configs:
        - role: endpoints
        scheme: http
        relabel_configs:
        - source_labels: [__meta_kubernetes_namespace, __meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name]
          action: keep
          regex: kube-system;kube-state-metrics;http-metrics

    remote_write:
    - url: 'http://10.206.0.16:19000/prometheus/v1/write'

我来简单介绍一下,这段代码中包含了 5 个抓取 job,分别是 APIServer、Controller-manager、Scheduler、ectd、KSM。前面 3 个走的是 HTTPS ,后面两个走的是 HTTP,重点关注 relabel 规则。keep 的规则实际就是在做过滤,只过滤自己 job 感兴趣的那些 endpoint。最后两行配置了 remote write 地址,采集到的数据通过 remote write 协议推给远端,我这里是推给了 n9e-server,n9e-server 后面是 VictoriaMetrics 集群。

准备好配置文件之后,接下来部署 Prometheus。因为只是抓取几个服务端组件,抓取量不大,不用做分片,我这里把 Prometheus agent mode 做成单副本的 Deployment,你可以看一下我给出的 YAML 文件。

apiVersion: apps/v1
kind: Deployment
metadata:
  name: prometheus-agent
  namespace: flashcat
  labels:
    app: prometheus-agent
spec:
  replicas: 1
  selector:
    matchLabels:
      app: prometheus-agent
  template:
    metadata:
      labels:
        app: prometheus-agent
    spec:
      serviceAccountName: categraf
      containers:
        - name: prometheus
          image: prom/prometheus
          args:
            - "--config.file=/etc/prometheus/prometheus.yml"
            - "--web.enable-lifecycle"
            - "--enable-feature=agent"
          ports:
            - containerPort: 9090
          resources:
            requests:
              cpu: 500m
              memory: 500M
            limits:
              cpu: 1
              memory: 1Gi
          volumeMounts:
            - name: prometheus-config-volume
              mountPath: /etc/prometheus/
            - name: prometheus-storage-volume
              mountPath: /prometheus/
      volumes:
        - name: prometheus-config-volume
          configMap:
            defaultMode: 420
            name: prometheus-agent-conf
        - name: prometheus-storage-volume
          emptyDir: {}

这里要注意的关键点,一个是 serviceAccountName,配置是 categraf,和前面创建的 ServiceAccount 对应,另一个是 args 部分,给出了相关的启动参数, --enable-feature=agent 就是作为 agent mode 模式运行。

最后,执行 kubectl apply -f prometheus-agent-deployment.yaml,让 Kubernetes 把 Deployment 拉起来就可以了。稍等片刻,去页面上查询一下 APIServer 的监控数据,理论上是可以查到的,但是其他组件的监控数据,大概率是没有的,下面我们来一一修复。

修复Controller-manager和Scheduler

上面的抓取规则走的都是 Kubernetes 服务发现机制,发现 endpoint,然后过滤。我们先通过下面的命令查看一下 kube-system 这个 namespace 下有哪些 endpoint。

kubectl get endpoints -n kube-system

如果有 kube-controller-manager、kube-scheduler 这两个 endpoint,理论上通过上面的抓取规则就可以抓到数据,如果没有的话,我们可以创建相关的 service。

你可以参考我给出的这两个 YAML 文件来创建 service。

另外就是得确保 Controller-manager 和 Scheduler 没有监听在 127.0.0.1,否则采集器落在其他机器上就访问不通了。具体怎么做呢?

在这两个组件的启动参数里加上 --bind-address=0.0.0.0 就可以了。如果是 Kubeadm 安装的,可以在 /etc/kubernetes/manifests/kube-controller-manager.yaml 和 /etc/kubernetes/manifests/kube-scheduler.yaml 里调整参数。调整完之后,理论上就可以抓到数据了。

修复 etcd

etcd 默认端口是 2379,如果从这个端口获取监控数据,就需要有比较复杂的认证鉴权。但其实etcd的监控数据也不是什么太关键的信息,而且是内网,直接开放就可以了。etcd提供了一个启动参数,可以为暴露监控指标单独监听一个地址。

具体参数是:

--listen-metrics-urls=http://0.0.0.0:2381

之后创建相关的 service ,prometheus agent 就可以发现这个 HTTP 的 endpoint 了。

修复 KSM

KSM 是监控各类 Kubernetes 对象的组件,通过 KSM 我们可以知道 Service、Deployment、Statefulset、Node 等组件的各类元信息,比如某个 Deployment 期望有几个副本、实际有几个 Pod 在运行这种问题,就是靠 KSM 来回答的。KSM 是如何知道这些信息的呢?它需要跟 APIServer 通信,订阅各类资源对象的变更。下面我们安装一下 KSM,相关指标就有了。

git clone https://github.com/kubernetes/kube-state-metrics
kubectl apply -f kube-state-metrics/examples/standard/

KSM 在代码仓库里提供了相关的 YAML 文件,我们 clone 下来直接 apply 就可以。KSM 默认暴露了两个端口,8080 用于返回各类 Kubernetes 对象信息,8081 用于返回 KSM 自身的指标,我们在抓取规则里重点抓取的是 8080 的数据。

KSM 要返回所有 Kubernetes 对象的指标,数据量比较大,从 8080 拉取监控数据可能会拉取十几秒甚至几十秒,KSM 为此支持了分片逻辑,examples/standard 下面提供的 YAML 文件是把 KSM 部署为单副本的 Deployment,分片的话使用 Daemonset,每个 Node 上都跑一个 KSM,这个 KSM 只同步与自身节点相关的数据,KSM 的官方 README 里说得很清楚了,你可以看一下Daemonset 样例。

apiVersion: apps/v1
kind: DaemonSet
spec:
  template:
    spec:
      containers:
      - image: registry.k8s.io/kube-state-metrics/kube-state-metrics:IMAGE_TAG
        name: kube-state-metrics
        args:
        - --resource=pods
        - --node=$(NODE_NAME)
        env:
        - name: NODE_NAME
          valueFrom:
            fieldRef:
              apiVersion: v1
              fieldPath: spec.nodeName

另外,KSM 提供了两种方式来过滤要 watch 的对象类型,一个是通过白名单的方式指定具体要 watch 哪类对象,通过命令行启动参数中的 --resources=daemonsets,deployments,表示只 watch daemonsets 和 deployments。虽然已经限制了对象资源类型,但如果采集的某些指标仍然不想要,可以采用黑名单的方式来过滤指标: --metric-denylist=kube_deployment_spec_.*。这个过滤规则支持正则写法,多个正则之间可以使用逗号分隔。

做完这些操作之后,我们就可以采集到这些组件的监控数据了,下面我们继续看哪些指标更为关键。

关键指标

Categraf 的代码仓库里已经内置了 Kubernetes 各个组件的监控大盘,只要是出现在监控大盘上的指标,理论上就是相对比较重要的,要不然也没有必要放到大盘上了。你可以看一下 APIServer、 Controller-manager、 Scheduler、 etcd、 KSM 的大盘。

如果你使用 Grafana 来做可视化,可以参考下面两个项目中提供的 Dashboard。

因为所有组件都是 Go 实现的,都暴露了 Go 程序通用的那些 CPU、内存、Goroutine、句柄等指标,这一部分内容我们在上一讲已经介绍过,这里不再赘述。下面我们分别看一下这几个组件一些其他类型的关键指标。

APIServer

APIServer 的核心职能是 Kubernetes 集群的 API 总入口,Kube-Proxy、Kubelet、Controller-Manager、Scheduler 等都需要调用 APIServer,所以 APIServer 的监控,完全按照 RED 方法论来梳理即可,最核心的就是请求吞吐和延迟。

Controller-manager

Controller-manager 负责监听对象状态,并与期望状态做对比。如果状态不一致则进行调谐,重点关注的是 任务数量、队列深度 等。

Scheduler

Scheduler 在 Kubernetes 架构中负责把对象调度到合适的 Node 上,在这个过程中会有一系列的规则计算和筛选,重点关注 调度 这个动作的相关指标。

etcd

etcd在 Kubernetes 的架构中作用巨大,相对也比较稳定,不过 etcd对硬盘 IO 要求较高,因此需要着重关注 IO 相关的指标,生产环境建议至少使用 SSD 的盘做存储。

KSM

Kube-state-metrics 这个组件,采集的很多指标都只是充当元信息,单独拿出来未必那么有用,但是和其他指标做 group_left、group_right 连接的时候可能又会很有用。下面我挑选一些相对常用的指标解释一下。

基于 KSM 数据的比较典型的告警规则,我也举个例子,让你有一个直观的认识。

# 长时间版本不一致需要告警
kube_deployment_status_observed_generation{job="kube-state-metrics"}
!=
kube_deployment_metadata_generation{job="kube-state-metrics"}

# deployment 副本数不一致
(
kube_deployment_spec_replicas{job="kube-state-metrics"}
!=
kube_deployment_status_replicas_available{job="kube-state-metrics"}
)
and
(
changes(kube_deployment_status_replicas_updated{job="kube-state-metrics"}[5m]) == 0
)

# 容器有 Error 或者 OOM 导致的退出
(sum(kube_pod_container_status_last_terminated_reason{reason=~"Error|OOMKilled"}) by (namespace,pod,container) > 0)
* on(namespace,pod,container)
sum(increase(kube_pod_container_status_restarts_total[10m]) > 0) by(namespace,pod,container)

上面我只是举了Deployment的例子,Statefulset 也是类似的。