文章目录

前言
一、APIServer Yaml文件解析
- APIServer证书文件
- APIServer三种探针
- - 启动探针
  - 可读性探针
  - 生存性探针
- APIServer其他参数
- APIServer其他配置项
二、Scheduler Yaml文件解析
- Scheduler证书配置
- Scheduler两个探针
- - 启动探针
  - 生存性探针
- Scheduler其他参数
- Scheduler其他配置项
三、Controller-Manager Yaml文件解析
- Controller-Manager 证书配置
- Controller-Manager 两种探针
- - 启动探针
  - 生存性探针
- Controller-Manager其他参数
- Controller-Manager其他配置项
四、Etcd Yaml文件解析
- Etcd证书文件
- Etcd两种探针
- - 启动探针
  - 生存性探针
- Etcd其他参数
- Etcd其他配置项
- Etcd 进程
尾声

前言

kubectl get nodes 可以看到node有不同的role，一种是master，一种是node，role类型为master就是主节点，有四个静态Pod

一、APIServer Yaml文件解析

/etc/kubernetes/manifest/kube-apiserver.yaml 文件运行成为 apiserver 这个 Pod

整个文件 = apiVersion + kind + metadata + spec

结构和功能相适应：
apiserver的功能：

apiVersion: v1 
kind: Pod      # 类型是Pod，而不是控制器controller，所以副本数就是一个
metadata:
  annotations:
    kubeadm.kubernetes.io/kube-apiserver.advertise-address.endpoint: 192.168.100.155:6443
  creationTimestamp: null
  labels:
    component: kube-apiserver
    tier: control-plane
  name: kube-apiserver
  namespace: kube-system
spec:
  containers:
  - command:
    - kube-apiserver
    - --advertise-address=192.168.100.155
    - --allow-privileged=true 
    - --authorization-mode=Node,RBAC   # 使用 rbac 授权
    - --client-ca-file=/etc/kubernetes/pki/ca.crt
    - --enable-admission-plugins=NodeRestriction  # 准入控制器
    - --enable-bootstrap-token-auth=true
    - --etcd-cafile=/etc/kubernetes/pki/etcd/ca.crt
    - --etcd-certfile=/etc/kubernetes/pki/apiserver-etcd-client.crt
    - --etcd-keyfile=/etc/kubernetes/pki/apiserver-etcd-client.key
    - --etcd-servers=https://127.0.0.1:2379   # apiserver需要的访问的etcd的地址(如果etcd不运行或连不上，apiserver也启动不了)
    - --insecure-port=0    
    - --kubelet-client-certificate=/etc/kubernetes/pki/apiserver-kubelet-client.crt
    - --kubelet-client-key=/etc/kubernetes/pki/apiserver-kubelet-client.key
    - --kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname
    - --proxy-client-cert-file=/etc/kubernetes/pki/front-proxy-client.crt
    - --proxy-client-key-file=/etc/kubernetes/pki/front-proxy-client.key
    - --requestheader-allowed-names=front-proxy-client
    - --requestheader-client-ca-file=/etc/kubernetes/pki/front-proxy-ca.crt
    - --requestheader-extra-headers-prefix=X-Remote-Extra-
    - --requestheader-group-headers=X-Remote-Group
    - --requestheader-username-headers=X-Remote-User
    - --secure-port=6443   
    - --service-account-issuer=https://kubernetes.default.svc.cluster.local
    - --service-account-key-file=/etc/kubernetes/pki/sa.pub
    - --service-account-signing-key-file=/etc/kubernetes/pki/sa.key
    - --service-cluster-ip-range=10.96.0.0/12    # service子网段，这个是
    - --tls-cert-file=/etc/kubernetes/pki/apiserver.crt
    - --tls-private-key-file=/etc/kubernetes/pki/apiserver.key
    image: k8s.gcr.io/kube-apiserver:v1.21.0   # 镜像
    imagePullPolicy: IfNotPresent  # 镜像拉取策略，如果本地不存在就拉取  IfNotPresent Always Never
    livenessProbe:      # 生存性探针(生存性探针和可读性探针整个过程中运行，启动探针仅仅启动的时候用到)
      failureThreshold: 8
      httpGet:
        host: 192.168.100.155
        path: /livez
        port: 6443
        scheme: HTTPS
      initialDelaySeconds: 10
      periodSeconds: 10
      timeoutSeconds: 15
    name: kube-apiserver   # pod的名称
    readinessProbe:    # 可读性探针(生存性探针和可读性探针整个过程中运行，启动探针仅仅启动的时候用到)
      failureThreshold: 3
      httpGet:
        host: 192.168.100.155
        path: /readyz
        port: 6443
        scheme: HTTPS
      periodSeconds: 1
      timeoutSeconds: 15
    resources:   # 资源请求量，request下限，limit上限，scheduler根据request对比机器上的free来调度，hpa根据 top metrics 自动扩缩容
      requests:
        cpu: 250m
    startupProbe:   # 启动探针(生存性探针和可读性探针整个过程中运行，启动探针仅仅启动的时候用到)  
      failureThreshold: 24
      httpGet:
        host: 192.168.100.155
        path: /livez
        port: 6443
        scheme: HTTPS
      initialDelaySeconds: 10
      periodSeconds: 10
      timeoutSeconds: 15
    volumeMounts:  # 目录挂载
    - mountPath: /etc/ssl/certs
      name: ca-certs
      readOnly: true
    - mountPath: /etc/pki
      name: etc-pki
      readOnly: true
    - mountPath: /etc/kubernetes/pki   # 所有的证书，都从宿主机读入到apiserver容器里面去
      name: k8s-certs
      readOnly: true
  hostNetwork: true   
  priorityClassName: system-node-critical
  volumes:
  - hostPath:
      path: /etc/ssl/certs   #  这个目录不存在
      type: DirectoryOrCreate
    name: ca-certs
  - hostPath:
      path: /etc/pki     #  这个目录不存在
      type: DirectoryOrCreate
    name: etc-pki
  - hostPath:
      path: /etc/kubernetes/pki   #  这个目录存在，所有的证书，都从宿主机读入到apiserver容器里面去
      type: DirectoryOrCreate
    name: k8s-certs
status: {}

APIServer证书文件

对于apisever的所有arg参数来说，证书占了很多一部分，看一下和apiserver相关的所有证书(结构和功能相适应的原则)

通过磁盘映射将宿主机m 的 /etc/kubernetes/pki 下面的所有证书文件，映射到容器里面去了，看一下所有的证书相关的 arg 参数

cat /etc/kubernetes/manifests/kube-apiserver.yaml  # 所需要在证书都在 /etc/kubernetes/pki 目录下

# client-ca-file用于验证客户端证书，集群里用的ca是同一个，才不用为不同组件配置不同ca
- --client-ca-file=/etc/kubernetes/pki/ca.crt
- --etcd-cafile=/etc/kubernetes/pki/etcd/ca.crt  # 用来生成apiserver访问etcd的密钥和证书

- --etcd-certfile=/etc/kubernetes/pki/apiserver-etcd-client.crt # apiserver访问etcd的证书
- --etcd-keyfile=/etc/kubernetes/pki/apiserver-etcd-client.key # apiserver访问etcd的密钥

- --kubelet-client-certificate=/etc/kubernetes/pki/apiserver-kubelet-client.crt # apiserver访问kubelet的证书
- --kubelet-client-key=/etc/kubernetes/pki/apiserver-kubelet-client.key # apiserver访问kubelet的密钥

- --proxy-client-cert-file=/etc/kubernetes/pki/front-proxy-client.crt  # 代理根证书签发的客户端证书
- --proxy-client-key-file=/etc/kubernetes/pki/front-proxy-client.key  # 代理根证书签发的客户端密钥
- --requestheader-client-ca-file=/etc/kubernetes/pki/front-proxy-ca.crt  # 代理根证书

- --service-account-key-file=/etc/kubernetes/pki/sa.pub  # sa公钥
- --service-account-signing-key-file=/etc/kubernetes/pki/sa.key  # sa私钥

- --tls-cert-file=/etc/kubernetes/pki/apiserver.crt  # apiserver证书
- --tls-private-key-file=/etc/kubernetes/pki/apiserver.key # apiserver密钥

这些证书都是在宿主机 /etc/kubernetes/pki 目录下，是通过 volumeMount 挂盘的方式映射到容器里面，然后 apiserver 启动的时候才可以使用的

    volumeMounts:  # 容器目录
    - mountPath: /etc/ssl/certs
      name: ca-certs
      readOnly: true
    - mountPath: /etc/pki
      name: etc-pki
      readOnly: true
    - mountPath: /etc/kubernetes/pki   # 所有的证书，都从宿主机读入到apiserver容器里面去
      name: k8s-certs
      readOnly: true
  volumes: # 宿主机目录
  - hostPath:
      path: /etc/ssl/certs   #  这个目录是linux机器的ssl认证 (http+ssl/tls=https)
      type: DirectoryOrCreate
    name: ca-certs
  - hostPath:
      path: /etc/pki     #  这个目录是linux机器的证书
      type: DirectoryOrCreate
    name: etc-pki
  - hostPath:
      path: /etc/kubernetes/pki   #  这个目录存在，所有的证书，都从宿主机读入到apiserver容器里面去
      type: DirectoryOrCreate
    name: k8s-certs

在linux中与CA相关的信息在/etc/pki目录下，里面有CA，nssdb，rpm-gpg，tls 目录。其中，CA目录就是我们在当前创建CA所要依赖的目录，tls目录是openssL的配置文件存放目录，要在此文件中修改CA的相对路径为绝对路径。

在这里插入图片描述

APIServer三种探针

启动探针

startupProbe:   # 启动探针(生存性探针和可读性探针整个过程中运行，启动探针仅仅启动的时候用到)  
  failureThreshold: 24
  httpGet:
    host: 192.168.100.155
    path: /livez
    port: 6443
    scheme: HTTPS # 指定协议是https，因为是探针访问apiserver，需要双向认证，所以是https
  initialDelaySeconds: 10
  periodSeconds: 10
  timeoutSeconds: 15

启动探针含义解释：通过发送 https://192.168.100.155:6443/livez 来验证 apiserver 是否已经启动了，启动探针仅仅启动的时候用到

可读性探针

readinessProbe:    # 可读性探针(生存性探针和可读性探针整个过程中运行，启动探针仅仅启动的时候用到)
  failureThreshold: 3
  httpGet:
    host: 192.168.100.155
    path: /readyz
    port: 6443
    scheme: HTTPS # 指定协议是https，因为是探针访问apiserver，需要双向认证，所以是https
  periodSeconds: 1
  timeoutSeconds: 15

可读性探针含义解释：通过发送 https://192.168.100.155:6443/readyz 来验证 apiserver 是否可读，apiserver 运行时使用，如果失败，报错 unready 当前不可读，可以使用 kubectl describe pod pod-name 看到

生存性探针

livenessProbe:      # 生存性探针(生存性探针和可读性探针整个过程中运行，启动探针仅仅启动的时候用到)
  failureThreshold: 8
  httpGet:
    host: 192.168.100.155
    path: /livez
    port: 6443
    scheme: HTTPS # 指定协议是https，因为是探针访问apiserver，需要双向认证，所以是https
  initialDelaySeconds: 10
  periodSeconds: 10
  timeoutSeconds: 15

生存性探针含义解释：通过发送 https://192.168.100.155:6443/livez 来验证 apiserver 是否存活，apiserver 运行时使用，如果失败，报错 unlive 当前不可活，可以使用 kubectl describe pod pod-name 看到

APIServer其他参数

  - command:
    - kube-apiserver
    - --advertise-address=192.168.100.155
    - --allow-privileged=true 
    - --authorization-mode=Node,RBAC   # 使用 rbac 授权
    - --enable-admission-plugins=NodeRestriction  # 准入控制器
    - --enable-bootstrap-token-auth=true
    - --etcd-servers=https://127.0.0.1:2379   # apiserver需要的访问的etcd的地址(如果etcd不运行或连不上，apiserver也启动不了)
    - --insecure-port=0    
    - --kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname
    - --requestheader-allowed-names=front-proxy-client  # 请求头
    - --requestheader-extra-headers-prefix=X-Remote-Extra-  # 请求头
    - --requestheader-group-headers=X-Remote-Group  # 请求头
    - --requestheader-username-headers=X-Remote-User  # 请求头
    - --secure-port=6443   
    - --service-account-issuer=https://kubernetes.default.svc.cluster.local
    - --service-cluster-ip-range=10.96.0.0/12    # service子网段，这个是

command 表示命令，就是镜像启动命令，执行的是 kube-apiserver 二进制文件，后面的都是这个 kube-apiserver 二进制文件的启动参数。

要想知道这些参数每个代表什么意思，可以查看 k8s 官网 K8S官网APIServer介绍

APIServer其他配置项

    resources:   # 资源请求量，request下限，limit上限，scheduler根据request对比机器上的free来调度，hpa根据 top metrics 自动扩缩容
      requests:
        cpu: 250m  # cpu：250m，表示0.25个cpu，单位是container，表示每个container请求0.25个cpu
  hostNetwork: true   
  priorityClassName: system-node-critical # 这个Pod优先调度，因为是kube-system里面的静态Pod

解释 hostNetwork: true
(1) hostNetwork: true 这种网络模式，相当于 docker run --net=host，采用宿主机的网络命名空间。此时，对于 IP , Pod 的 ip 为 node 节点的ip，即静态Pod；对于 Port 端口，Pod的端口需要保持不与宿主机上的port 端口发生冲突，就是Pod的端口直接映射到宿主机上面去了，需要通过 Service NodePort .
(2) dnsPolicy: ClusterFirst 等效于 hostNetwork: true && dnsPolicy: ClusterFirstWithHostNet，因为当设置了 hostNetwork:true 之后，容器不仅使用宿主机的IP、端口，还是用宿主机的DNS域名解析，dnsPolicy缺省默认值为ClusterFirst，只有在额外设置一下 dnsPolicy: ClusterFirstWithHostNet，才能让POD使用k8s的dns，dns配置在/etc/resolv.conf文件中，如果不加，pod默认使用所在宿主主机使用的DNS，这样会导致容器内不能通过 serviceName.namespace 访问k8s集群中其他 Pod

参考资料：kubernetes中的Cpu和Memory
循序渐进地学习kubernetes网络
k8s-"hostNetwork: true"网络

二、Scheduler Yaml文件解析

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    component: kube-scheduler
    tier: control-plane
  name: kube-scheduler
  namespace: kube-system
spec:
  containers:
  - command:
    - kube-scheduler
    - --authentication-kubeconfig=/etc/kubernetes/scheduler.conf
    - --authorization-kubeconfig=/etc/kubernetes/scheduler.conf
    - --bind-address=127.0.0.1
    - --kubeconfig=/etc/kubernetes/scheduler.conf
    - --leader-elect=true
    - --port=0
    image: k8s.gcr.io/kube-scheduler:v1.21.0
    imagePullPolicy: IfNotPresent
    livenessProbe:
      failureThreshold: 8
      httpGet:
        host: 127.0.0.1
        path: /healthz
        port: 10259
        scheme: HTTPS
      initialDelaySeconds: 10
      periodSeconds: 10
      timeoutSeconds: 15
    name: kube-scheduler
    resources:
      requests:
        cpu: 100m
    startupProbe:
      failureThreshold: 24
      httpGet:
        host: 127.0.0.1
        path: /healthz
        port: 10259
        scheme: HTTPS
      initialDelaySeconds: 10
      periodSeconds: 10
      timeoutSeconds: 15
    volumeMounts:
    - mountPath: /etc/kubernetes/scheduler.conf
      name: kubeconfig
      readOnly: true
  hostNetwork: true
  priorityClassName: system-node-critical
  volumes:
  - hostPath:
      path: /etc/kubernetes/scheduler.conf
      type: FileOrCreate
    name: kubeconfig
status: {}

Scheduler证书配置

kube-scheduler证书配置：scheduler唯一和其他打交道的就是 scheduler Pod 访问 APIServer，因为Scheduler是静态Pod，是稳定的，所以不需要使用 sa 访问，而是使用 scheduler.conf 这种 x509 客户端证书访问，直接使用了预生成的kubeconfig【涉及文件：/etc/kubernetes/scheduler.conf】

cat /etc/kubernetes/manifests/kube-scheduler.yaml  所需要在证书都在 /etc/kubernetes/scheduler.conf

 - command:
    - kube-scheduler
    - --kubeconfig=/etc/kubernetes/scheduler.conf  # kubeconfig就是scheduler.conf文件
    - --authentication-kubeconfig=/etc/kubernetes/scheduler.conf  # 认证使用的kubeconfig也是scheduler.conf文件
    - --authorization-kubeconfig=/etc/kubernetes/scheduler.conf  # 授权使用的kubeconfig也是scheduler.conf文件

涉及的文件

    volumeMounts: # 容器中目录
    - mountPath: /etc/kubernetes/scheduler.conf  # 启动的时候，宿主机 -> 容器
      name: kubeconfig
      readOnly: true
  volumes: # 宿主机中目录
  - hostPath:
      path: /etc/kubernetes/scheduler.conf
      type: FileOrCreate
    name: kubeconfig

Scheduler两个探针

启动探针

startupProbe:
  failureThreshold: 24
  httpGet:
    host: 127.0.0.1
    path: /healthz
    port: 10259
    scheme: HTTPS  # 指定协议是https，因为是探针访scheduler，需要双向认证，所以是https
  initialDelaySeconds: 10
  periodSeconds: 10
  timeoutSeconds: 15

启动探针含义解释：通过发送 https://127.0.0.1:10259/health 来验证 scheduler 是否已经启动了，启动探针仅仅启动的时候用到

生存性探针

livenessProbe:
  failureThreshold: 8
  httpGet:
    host: 127.0.0.1
    path: /healthz
    port: 10259
    scheme: HTTPS   # 指定协议是https，因为是探针访scheduler，需要双向认证，所以是https
  initialDelaySeconds: 10
  periodSeconds: 10
  timeoutSeconds: 15

生存性探针含义解释：通过发送 https://127.0.0.1:10259/health 来验证 scheduler 是否存活，因为这个探针是配置在 yaml 文件中，yaml 是容器化启动，就是访问容器内的启动进程的 10259 的 health 接口。整个探针 scheduler 运行长时间生效，如果失败，报错 unlive 当前不可活，可以使用 kubectl describe pod pod-name 看到

Scheduler其他参数

  - command:
    - kube-scheduler
    - --bind-address=127.0.0.1
    - --leader-elect=true
    - --port=0

command 表示命令，就是镜像启动命令，执行的是 kube-scheduler 二进制文件，后面的都是这个 kube-scheduler 二进制文件的启动参数。

要想知道这些参数每个代表什么意思，可以查看 k8s 官网 K8S官网Scheduler介绍

Scheduler其他配置项

    resources:
      requests:
        cpu: 100m   # 每个Container至少需要 0.1 个CPU
  hostNetwork: true  # ip为Pod所在宿主机IP,容器端口直接映射到宿主机
  priorityClassName: system-node-critical  # 这个Pod优先调度，因为是kube-system里面的静态Pod

三、Controller-Manager Yaml文件解析

[root@w1 ~]# cat /etc/kubernetes/manifests/kube-controller-manager.yaml 
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    component: kube-controller-manager
    tier: control-plane
  name: kube-controller-manager
  namespace: kube-system
spec:
  containers:
  - command:
    - kube-controller-manager
    - --allocate-node-cidrs=true
    - --authentication-kubeconfig=/etc/kubernetes/controller-manager.conf
    - --authorization-kubeconfig=/etc/kubernetes/controller-manager.conf
    - --bind-address=127.0.0.1
    - --client-ca-file=/etc/kubernetes/pki/ca.crt
    - --cluster-cidr=10.244.0.0/16
    - --cluster-name=kubernetes
    - --cluster-signing-cert-file=/etc/kubernetes/pki/ca.crt
    - --cluster-signing-key-file=/etc/kubernetes/pki/ca.key
    - --controllers=*,bootstrapsigner,tokencleaner
    - --kubeconfig=/etc/kubernetes/controller-manager.conf
    - --leader-elect=true
    - --port=0
    - --requestheader-client-ca-file=/etc/kubernetes/pki/front-proxy-ca.crt
    - --root-ca-file=/etc/kubernetes/pki/ca.crt
    - --service-account-private-key-file=/etc/kubernetes/pki/sa.key
    - --service-cluster-ip-range=10.96.0.0/12
    - --use-service-account-credentials=true
    image: k8s.gcr.io/kube-controller-manager:v1.21.0
    imagePullPolicy: IfNotPresent
    livenessProbe:
      failureThreshold: 8
      httpGet:
        host: 127.0.0.1
        path: /healthz
        port: 10257
        scheme: HTTPS
      initialDelaySeconds: 10
      periodSeconds: 10
      timeoutSeconds: 15
    name: kube-controller-manager
    resources:
      requests:
        cpu: 200m
    startupProbe:
      failureThreshold: 24
      httpGet:
        host: 127.0.0.1
        path: /healthz
        port: 10257
        scheme: HTTPS
      initialDelaySeconds: 10
      periodSeconds: 10
      timeoutSeconds: 15
    volumeMounts:
    - mountPath: /etc/ssl/certs
      name: ca-certs
      readOnly: true
    - mountPath: /etc/pki
      name: etc-pki
      readOnly: true
    - mountPath: /usr/libexec/kubernetes/kubelet-plugins/volume/exec
      name: flexvolume-dir
    - mountPath: /etc/kubernetes/pki
      name: k8s-certs
      readOnly: true
    - mountPath: /etc/kubernetes/controller-manager.conf
      name: kubeconfig
      readOnly: true
  hostNetwork: true
  priorityClassName: system-node-critical
  volumes:
  - hostPath:
      path: /etc/ssl/certs
      type: DirectoryOrCreate
    name: ca-certs
  - hostPath:
      path: /etc/pki
      type: DirectoryOrCreate
    name: etc-pki
  - hostPath:
      path: /usr/libexec/kubernetes/kubelet-plugins/volume/exec
      type: DirectoryOrCreate
    name: flexvolume-dir
  - hostPath:
      path: /etc/kubernetes/pki
      type: DirectoryOrCreate
    name: k8s-certs
  - hostPath:
      path: /etc/kubernetes/controller-manager.conf
      type: FileOrCreate
    name: kubeconfig
status: {}

Controller-Manager 证书配置

cat /etc/kubernetes/manifests/kube-controller-manager.yaml  # 所需要在证书都在 /etc/kubernetes/controller-manager.conf

  - command:
    - kube-controller-manager
    - --kubeconfig=/etc/kubernetes/controller-manager.conf  # kubeconfig
    - --authentication-kubeconfig=/etc/kubernetes/controller-manager.conf  # 认证使用的kubeconfig
    - --authorization-kubeconfig=/etc/kubernetes/controller-manager.conf # 授权使用的kubeconfig

    - --root-ca-file=/etc/kubernetes/pki/ca.crt  # 根 ca 证书
    - --client-ca-file=/etc/kubernetes/pki/ca.crt # 客户端 ca 证书 

    - --cluster-signing-cert-file=/etc/kubernetes/pki/ca.crt # 集群签名证书
    - --cluster-signing-key-file=/etc/kubernetes/pki/ca.key  # 集群签名密钥

    - --requestheader-client-ca-file=/etc/kubernetes/pki/front-proxy-ca.crt # 请求头，代理根证书
    - --service-account-private-key-file=/etc/kubernetes/pki/sa.key  # control-manager使用sa.key,kube-apiserver使用sa.pub

controller-manager.conf文件: controller-manager用来访问apiserver，内容包括 client.crt client.key
sa.key文件:

涉及的文件

    volumeMounts: # 容器目录
    - mountPath: /etc/ssl/certs  # 步骤5：这个目录是linux机器的ssl认证 (http+ssl/tls=https)
      name: ca-certs
      readOnly: true
    - mountPath: /etc/pki   # 步骤4：这个目录是linux机器的证书
      name: etc-pki
      readOnly: true
    - mountPath: /usr/libexec/kubernetes/kubelet-plugins/volume/exec # 步骤3：宿主机->容器，/nodeagent~uds/uds文件
      name: flexvolume-dir
    - mountPath: /etc/kubernetes/pki  # 步骤2：宿主机 -> 容器
      name: k8s-certs
      readOnly: true
    - mountPath: /etc/kubernetes/controller-manager.conf  # 步骤1:宿主机 -> 容器, controller-manager访问apiserver
      name: kubeconfig
      readOnly: true
  volumes: # 宿主机目录
  - hostPath:
      path: /etc/ssl/certs
      type: DirectoryOrCreate
    name: ca-certs
  - hostPath:
      path: /etc/pki   
      type: DirectoryOrCreate
    name: etc-pki
  - hostPath:
      path: /usr/libexec/kubernetes/kubelet-plugins/volume/exec
      type: DirectoryOrCreate
    name: flexvolume-dir
  - hostPath:
      path: /etc/kubernetes/pki
      type: DirectoryOrCreate
    name: k8s-certs
  - hostPath:
      path: /etc/kubernetes/controller-manager.conf
      type: FileOrCreate
    name: kubeconfig

Controller-Manager 两种探针

启动探针

startupProbe:
  failureThreshold: 24
  httpGet:
    host: 127.0.0.1
    path: /healthz
    port: 10257
    scheme: HTTPS # 
  initialDelaySeconds: 10
  periodSeconds: 10
  timeoutSeconds: 15

启动探针含义解释：通过发送 https://127.0.0.1:10257/health 来验证 controller-manager 是否已经启动了，启动探针仅仅启动的时候用到

生存性探针

livenessProbe:
  failureThreshold: 8
  httpGet:
    host: 127.0.0.1
    path: /healthz
    port: 10257
    scheme: HTTPS # 
  initialDelaySeconds: 10
  periodSeconds: 10
  timeoutSeconds: 15

生存性探针含义解释：通过发送 https://127.0.0.1:10257/health 来验证 controller-manager 是否存活，因为这个探针是配置在 yaml 文件中，yaml 是容器化启动，就是访问容器内的启动进程的 10257 的 health 接口。整个探针 controller-manager 运行长时间生效，如果失败，报错 unlive 当前不可活，可以使用 kubectl describe pod pod-name 看到

Controller-Manager其他参数

  - command:
    - kube-controller-manager
    - --allocate-node-cidrs=true
    - --bind-address=127.0.0.1
    - --cluster-cidr=10.244.0.0/16
    - --cluster-name=kubernetes
    - --controllers=*,bootstrapsigner,tokencleaner
    - --leader-elect=true
    - --port=0
    - --service-cluster-ip-range=10.96.0.0/12
    - --use-service-account-credentials=true

command 表示命令，就是镜像启动命令，执行的是 kube-controller-manager 二进制文件，后面的都是这个 kube-controller-manager 二进制文件的启动参数。

要想知道这些参数每个代表什么意思，可以查看 k8s 官网 K8S官网ControllerManager介绍

Controller-Manager其他配置项

    name: kube-controller-manager
    resources:
      requests:
        cpu: 200m   # 每个Container至少需要 0.2 个CPU
  hostNetwork: true   # ip为Pod所在宿主机IP,容器端口直接映射到宿主机
  priorityClassName: system-node-critical  # 这个Pod优先调度，因为是kube-system里面的静态Pod

四、Etcd Yaml文件解析

Etcd证书文件

Etcd 组件两个数据交互：
(1) Etcd对外提供服务，其实就是 Kube-APIserver访问Etcd，要有一套etcd server证书和apiserver访问etcd的客户端证书【涉及文件：etcd server.key server.crt，apiserver 的 apiserver-etcd-client.key 和 apiserver-etcd-client.crt 】
(2) Etcd各主节点之间进行通信，要有一套etcd peer证书【涉及文件：peer.key peer.crt 】

cat /etc/kubernetes/manifests/etcd.yaml  所需要在证书都在 /etc/kubernetes/pki/etcd 目录下

  - command:
    - etcd
    - --cert-file=/etc/kubernetes/pki/etcd/server.crt  # etcd唯一的对外提供服务, apiserver访问etcd
    - --key-file=/etc/kubernetes/pki/etcd/server.key # etcd唯一的对外提供服务, apiserver访问etcd
    - --trusted-ca-file=/etc/kubernetes/pki/etcd/ca.crt # # 用来验证etcd服务端证书的ca证书

    - --peer-client-cert-auth=true  # etcd各主节点之间相互通信 true
    - --peer-cert-file=/etc/kubernetes/pki/etcd/peer.crt  # etcd各主节点之间相互通信
    - --peer-key-file=/etc/kubernetes/pki/etcd/peer.key  # etcd各主节点之间相互通信
    - --peer-trusted-ca-file=/etc/kubernetes/pki/etcd/ca.crt  # 用来验证etcd各主节点之间相互通信证书的ca证书 peer.key peer.crt

涉及的文件

    volumeMounts:
    - mountPath: /var/lib/etcd   # 步骤2：运行过程中，将 etcd 的数据持久化到磁盘
      name: etcd-data
    - mountPath: /etc/kubernetes/pki/etcd   # 步骤1：启动的时候，将etcd需要的证书刷入的容器里
      name: etcd-certs
  volumes:
  - hostPath:
      path: /etc/kubernetes/pki/etcd
      type: DirectoryOrCreate
    name: etcd-certs
  - hostPath:
      path: /var/lib/etcd
      type: DirectoryOrCreate
    name: etcd-data

Etcd两种探针

启动探针

startupProbe:
  failureThreshold: 24
  httpGet:
    host: 127.0.0.1
    path: /health
    port: 2381
    scheme: HTTP  # 指定协议为http，自己访问自己 127.0.0.1，这里不是 https 了
  initialDelaySeconds: 10
  periodSeconds: 10
  timeoutSeconds: 15

启动探针含义解释：通过发送 http://127.0.0.1:2381/health 来验证 etcd 是否已经启动了，启动探针仅仅启动的时候用到

生存性探针

livenessProbe:
  failureThreshold: 8
  httpGet:
    host: 127.0.0.1
    path: /health
    port: 2381
    scheme: HTTP  # 指定协议为http，自己访问自己 127.0.0.1，这里不是 https 了
  initialDelaySeconds: 10
  periodSeconds: 10
  timeoutSeconds: 15

生存性探针含义解释：通过发送 http://127.0.0.1:2381/health 来验证 etcd 是否存活，因为这个探针是配置在 yaml 文件中，yaml 是容器化启动，就是访问容器内的启动进程的 2381 的 health 接口。整个探针 etcd 运行长时间生效，如果失败，报错 unlive 当前不可活，可以使用 kubectl describe pod pod-name 看到

Etcd其他参数

  - command:   # 启动命令
    - etcd  # 二进制文件
    - --advertise-client-urls=https://192.168.100.151:2379
    - --client-cert-auth=true
    - --data-dir=/var/lib/etcd
    - --initial-advertise-peer-urls=https://192.168.100.151:2380
    - --initial-cluster=w1=https://192.168.100.151:2380
    - --listen-client-urls=https://127.0.0.1:2379,https://192.168.100.151:2379
    - --listen-metrics-urls=http://127.0.0.1:2381
    - --listen-peer-urls=https://192.168.100.151:2380
    - --name=w1
    - --snapshot-count=10000

command 表示命令，就是镜像启动命令，执行的是 etcd 二进制文件，后面的都是这个 etcd 二进制文件的启动参数。

要想知道这些参数每个代表什么意思，可以查看 k8s 官网

Etcd其他配置项

    name: etcd
    resources:  # 资源
      requests: # 下限
        cpu: 100m   # 每个Container至少需要 0.1 个CPU
        ephemeral-storage: 100Mi  # 每个container至少100Mi磁盘        memory: 100Mi   # 内存为100M
  hostNetwork: true  # ip为Pod所在宿主机IP,容器端口直接映射到宿主机
  priorityClassName: system-node-critical # 这个Pod优先调度，因为是kube-system里面的静态Pod

ephemeral-storage: 100Mi

每个container至少100Mi磁盘，因为etcd是分布式数据库，存储configmap和secret 到 /var/lib/etcd 目录，存储会被持久化到宿主机，所以需要定义一个磁盘空间下限，其他三个 apiserver scheduler kube-controller-manager 都是因为不需要存储数据，所以不定义磁盘空间

参考资料：ephemeral-storage 介绍

Etcd 进程

上面是 etcd 的证书，我们现在来看一下 etcd 的进程， etcd 作为四个静态Pod之一，是运行在 master 节点之上的，我们在 master 节点的宿主机上执行 ps -ef | grep etcd，如下：

在这里插入图片描述

如上图，执行 ps -ef | grep etcd 之后，打印出来不止一条，其中有些不是etcd的，只是包含 etcd 关键字，解释一下找到的四条包含 etcd 关键字的进程：
第一个是 etcd Pod Container对应的进程 (只有这条是 etcd 进程本身)，
第二个是 apiserver Pod Container对应的进程，
第三个是 kuboard Pod Container对应的进程，
第四个就是 ps -ef|grep etcd 这行命令本身。

知识点(上图中四行输出怎么看出来的)：
(1) 对于 k8s Pod Container 容器化程序启动的，使用 ps -ef 也是可以在Pod 所在 linux 上看到yaml里面的参数和启动命令，至于到底是哪个，直接查看输出的 CMD 列第一个二进制文件名或者最后一个 xxx.yaml 名基本就可以判断出了
(2) ps -ef|grep xxx 查看到的结果，其中有一个就是 ps -ef | grep xxx 这条命令本身

尾声

对于四个静态Pod，每个静态Pod，分别介绍了证书和组件交互、探针、其他参数、其他配置项。

证书方面：基本是按照 k8s 内部组件交互图来的

探针方面：除了apiserver使用 192.168.100.151 宿主机上的 6443 为探针，其他三个静态Pod都使用自己访问自己 127.0.0.1:port/health 作为探针.

其他参数方面：基本查看 k8s 官网就可以了，见组件工具

在这里插入图片描述

其他配置项方面：
(1) 资源下限方面，只有 etcd 为了给宿主机持久化 /var/lib/etcd 目录下的数据，对磁盘做了下限要求，其他三个静态Pod仅仅对cpu和内存要求
(2) hostNetwork: true 表示Pod IP使用宿主机IP, 端口直接映射到Pod所在宿主机的端口，DNS也是使用宿主机的DNS解析，为了让能够同时解析 serviceName.ns d需要设置为 dnsPolicy: ClusterFirstWithHost
(3) priorityClassName: system-node-critical 将四个静态Pod都设置为优先调度，因为是kube-system里面的静态Pod