• Kubernetes实战(一)-二进制部署Kubernetes集群

    1 组件版本和配置策略

    1.1 组件版本

    组件版本发布时间
    kubernetes1.16.62020-01-22
    etcd3.4.32019-10-24
    containerd1.3.32020-02-07
    runc1.0.0-rc102019-12-23
    calico3.12.02020-01-27
    coredns1.6.62019-12-20
    dashboardv2.0.0-rc42020-02-06
    k8s-prometheus-adapter0.5.02019-04-03
    prometheus-operator0.35.02020-01-13
    prometheus2.15.22020-01-06
    elasticsearch、kibana7.2.02019-06-25
    cni-plugins0.8.52019-12-20
    metrics-server0.3.62019-10-15

    1.2 主要配置策略

    1.2.1 kube-apiserver：

    • 使用节点本地 nginx 4 层透明代理实现高可用；
    • 关闭非安全端口 8080 和匿名访问；
    • 在安全端口 6443 接收 https 请求；
    • 严格的认证和授权策略 (x509、token、RBAC)；
    • 开启 bootstrap token 认证，支持 kubelet TLS bootstrapping；
    • 使用 https 访问 kubelet、etcd，加密通信；

    1.2.2 kube-controller-manager：

    • 3 节点高可用；
    • 关闭非安全端口，在安全端口 10252 接收 https 请求；
    • 使用 kubeconfig 访问 apiserver 的安全端口；
    • 自动 approve kubelet 证书签名请求 (CSR)，证书过期后自动轮转；
    • 各 controller 使用自己的 ServiceAccount 访问 apiserver；

    1.2.3 kube-scheduler：

    • 3 节点高可用；
    • 使用 kubeconfig 访问 apiserver 的安全端口；

    1.2.4 kubelet：

    • 使用 kubeadm 动态创建 bootstrap token，而不是在 apiserver 中静态配置；
    • 使用 TLS bootstrap 机制自动生成 client 和 server 证书，过期后自动轮转；
    • 在 KubeletConfiguration 类型的 JSON 文件配置主要参数；
    • 关闭只读端口，在安全端口 10250 接收 https 请求，对请求进行认证和授权，拒绝匿名访问和非授权访问；
    • 使用 kubeconfig 访问 apiserver 的安全端口；

    1.2.5 kube-proxy：

    • 使用 kubeconfig 访问 apiserver 的安全端口；
    • 在 KubeProxyConfiguration 类型的 JSON 文件配置主要参数；
    • 使用 ipvs 代理模式；

    1.2.6 集群插件：

    • DNS：使用功能、性能更好的 coredns；
    • Dashboard：支持登录认证；
    • Metric：metrics-server，使用 https 访问 kubelet 安全端口；
    • Log：Elasticsearch、Fluend、Kibana；
    • Registry 镜像库：docker-registry、harbor；

    2 初始化系统和全局变量

    2.1 集群规划

    • sre-master-node：10.12.5.60
    • sre-worker-node-1：10.12.5.61
    • sre-worker-node-2：10.12.5.62

    三台机器混合部署本文档的 etcd、master 集群和 woker 集群。

    2.2 设置主机名

    1. # master node主机名设置为sre-master-node
    2. $ hostnamectl set-hostname sre-master-node
    3. # worker node 1主机名设置为sre-worker-node-1
    4. $ hostnamectl set-hostname sre-worker-node-1
    5. # worker node 2主机名设置为sre-worker-node-2
    6. $ hostnamectl set-hostname sre-worker-node-2

    如果 DNS 不支持主机名称解析，还需要在每台机器的 /etc/hosts 文件中添加主机名和 IP 的对应关系：

    本操作所有节点均需要执行。

    1. $ cat >> /etc/hosts <
    2. 10.12.5.60 sre-master-node
    3. 10.12.5.61 sre-worker-node-1
    4. 10.12.5.62 sre-worker-node-2
    5. EOF

    退出，重新登录 root 账号，可以看到主机名生效。

    2.3 添加节点信任关系

    本操作只需要在sre-master-node节点上进行。

    设置 root 账户可以无密码登录所有节点：

    1. $ ssh-keygen -t rsa 
    2. $ ssh-copy-id root@sre-master-node
    3. $ ssh-copy-id root@sre-worker-node-1
    4. $ ssh-copy-id root@sre-worker-node-2

    2.4 更新 PATH 变量

    本操作所有节点均需要执行。

    1. $ echo 'PATH=/opt/k8s/bin:$PATH' >>/root/.bashrc
    2. $ source /root/.bashrc

    /opt/k8s/bin 目录保存本文档下载安装的程序。 

    2.5 安装依赖包

    本操作所有节点均需要执行。

    1. $ yum install -y epel-release
    2. $ yum install -y chrony conntrack ipvsadm ipset jq iptables curl sysstat libseccomp wget socat git
    • 本文档的 kube-proxy 使用 ipvs 模式，ipvsadm 为 ipvs 的管理工具；
    • etcd 集群各机器需要时间同步，chrony 用于系统时间同步；

    2.6 关闭防火墙

    本操作所有节点均需要执行。

    关闭防火墙，清理防火墙规则，设置默认转发策略：

    1. $ systemctl stop firewalld
    2. $ systemctl disable firewalld
    3. $ iptables -F && iptables -X && iptables -F -t nat && iptables -X -t nat
    4. $ iptables -P FORWARD ACCEPT

    2.7 关闭 swap 分区

    本操作所有节点均需要执行。

    关闭 swap 分区，否则kubelet 会启动失败(可以设置 kubelet 启动参数 --fail-swap-on 为 false 关闭 swap 检查)：

    1. $ swapoff -a
    2. $ sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

    2.8 关闭 SELinux

    本操作所有节点均需要执行。

    关闭 SELinux，否则 kubelet 挂载目录时可能报错 Permission denied：

    1. $ setenforce 0
    2. $ sed -i 's/^SELINUX=.*/SELINUX=disabled/' /etc/selinux/config

    2.9 优化内核参数

    本操作所有节点均需要执行。

    1. $ cat > kubernetes.conf <<EOF
    2. net.bridge.bridge-nf-call-iptables=1
    3. net.bridge.bridge-nf-call-ip6tables=1
    4. net.ipv4.ip_forward=1
    5. net.ipv4.tcp_tw_recycle=0
    6. net.ipv4.neigh.default.gc_thresh1=1024
    7. net.ipv4.neigh.default.gc_thresh2=2048
    8. net.ipv4.neigh.default.gc_thresh3=4096
    9. vm.swappiness=0
    10. vm.overcommit_memory=1
    11. vm.panic_on_oom=0
    12. fs.inotify.max_user_instances=8192
    13. fs.inotify.max_user_watches=1048576
    14. fs.file-max=52706963
    15. fs.nr_open=52706963
    16. net.ipv6.conf.all.disable_ipv6=1
    17. net.netfilter.nf_conntrack_max=2310720
    18. EOF
    19. $ cp kubernetes.conf  /etc/sysctl.d/kubernetes.conf
    20. $ sysctl -p /etc/sysctl.d/kubernetes.conf
    • 关闭 tcp_tw_recycle，否则与 NAT 冲突，可能导致服务不通；

    2.10 设置系统时区

    本操作所有节点均需要执行。

    $ timedatectl set-timezone Asia/Shanghai

    2.11 设置系统时钟同步

    本操作所有节点均需要执行。

    1. $ systemctl enable chronyd
    2. $ systemctl start chronyd

    查看同步状态：

    $ timedatectl status

    输出：

    1. System clock synchronized: yes
    2.               NTP service: active
    3.           RTC in local TZ: no
    • System clock synchronized: yes，表示时钟已同步；
    • NTP service: active，表示开启了时钟同步服务；
    # 将当前的 UTC 时间写入硬件时钟

    $ timedatectl set-local-rtc 0
    # 重启依赖于系统时间的服务

    1. $ systemctl restart rsyslog 
    2. $ systemctl restart crond

    2.12 关闭无关的服务

    本操作所有节点均需要执行。

    $ systemctl stop postfix && systemctl disable postfix

    2.13 创建相关目录

    本操作所有节点均需要执行。

    创建目录：

    $ mkdir -p /opt/k8s/{bin,work} /etc/{kubernetes,etcd}/cert

    2.14 分发集群配置参数脚本

    本操作所有节点均需要执行。

    后续使用的环境变量都定义在文件 environment.sh 中，请根据自己的机器、网络情况修改。然后拷贝到所有节点：

    environment.sh

    1. $ vim environment.sh
    2. #!/usr/bin/bash
    3.  
    4. # 生成 EncryptionConfig 所需的加密 key
    5. export ENCRYPTION_KEY=$(head -c 32 /dev/urandom | base64)
    6.  
    7. # 集群各机器 IP 数组
    8. export NODE_IPS=(10.12.5.60 10.12.5.61 10.12.5.62)
    9.  
    10. # 集群各 IP 对应的主机名数组
    11. export NODE_NAMES=(sre-master-node sre-worker-node-1 sre-worker-node-2)
    12.  
    13. # etcd 集群服务地址列表
    14. export ETCD_ENDPOINTS="https://10.12.5.60:2379,https://10.12.5.61:2379,https://10.12.5.62:2379"
    15.  
    16. # etcd 集群间通信的 IP 和端口
    17. export ETCD_NODES="sre-master-node=https://10.12.5.60:2380,sre-worker-node-1=https://10.12.5.61:2380,sre-worker-node-1=https://10.12.5.62:2380"
    18.  
    19. # kube-apiserver 的反向代理(kube-nginx)地址端口
    20. export KUBE_APISERVER="https://127.0.0.1:8443"
    21.  
    22. # 节点间互联网络接口名称
    23. export IFACE="eth0"
    24.  
    25. # etcd 数据目录
    26. export ETCD_DATA_DIR="/data/k8s/etcd/data"
    27.  
    28. # etcd WAL 目录，建议是 SSD 磁盘分区，或者和 ETCD_DATA_DIR 不同的磁盘分区
    29. export ETCD_WAL_DIR="/data/k8s/etcd/wal"
    30.  
    31. # k8s 各组件数据目录
    32. export K8S_DIR="/data/k8s/k8s"
    33.  
    34. ## DOCKER_DIR 和 CONTAINERD_DIR 二选一
    35. # docker 数据目录
    36. export DOCKER_DIR="/data/k8s/docker"
    37.  
    38. # containerd 数据目录
    39. export CONTAINERD_DIR="/data/k8s/containerd"
    40.  
    41. ## 以下参数一般不需要修改
    42.  
    43. # TLS Bootstrapping 使用的 Token，可以使用命令 head -c 16 /dev/urandom | od -An -t x | tr -d ' ' 生成
    44. BOOTSTRAP_TOKEN="502c6e11a65946e3064e7a4b4658ec29"
    45.  
    46. # 最好使用 当前未用的网段 来定义服务网段和 Pod 网段
    47.  
    48. # 服务网段，部署前路由不可达，部署后集群内路由可达(kube-proxy 保证)
    49. SERVICE_CIDR="192.168.0.0/16"
    50.  
    51. # Pod 网段，建议 /16 段地址，部署前路由不可达，部署后集群内路由可达(flanneld 保证)
    52. CLUSTER_CIDR="172.16.0.0/16"
    53.  
    54. # 服务端口范围 (NodePort Range)
    55. export NODE_PORT_RANGE="30000-32767"
    56.  
    57. # kubernetes 服务 IP (一般是 SERVICE_CIDR 中第一个IP)
    58. export CLUSTER_KUBERNETES_SVC_IP="192.168.0.1"
    59.  
    60. # 集群 DNS 服务 IP (从 SERVICE_CIDR 中预分配)
    61. export CLUSTER_DNS_SVC_IP="192.168.0.2"
    62.  
    63. # 集群 DNS 域名（末尾不带点号）
    64. export CLUSTER_DNS_DOMAIN="cluster.local"
    65.  
    66. # 将二进制目录 /opt/k8s/bin 加到 PATH 中
    67. export PATH=/opt/k8s/bin:$PATH
    68.  
    69. $ source environment.sh # 先修改
    70. $ vim deploy-k8s.sh
    71. #!/bin/bash
    72. for node_ip in ${NODE_IPS[@]}
    73.   do
    74.     echo ">>> ${node_ip}"
    75.     scp environment.sh root@${node_ip}:/opt/k8s/bin/
    76.     ssh root@${node_ip} "chmod +x /opt/k8s/bin/*"
    77.   done
    78. $ sh deploy-k8s.sh

    2.15 升级内核

    本操作所有节点均需要执行。

    CentOS 7.x 系统自带的 3.10.x 内核存在一些 Bugs，导致运行的 Docker、Kubernetes 不稳定，例如：

    1. 高版本的 docker(1.13 以后) 启用了 3.10 kernel 实验支持的 kernel memory account 功能(无法关闭)，当节点压力大如频繁启动和停止容器时会导致 cgroup memory leak；
    2. 网络设备引用计数泄漏，会导致类似于报错："kernel:unregister_netdevice: waiting for eth0 to become free. Usage count = 1";

    解决方案如下：

    1. 升级内核到 4.4.X 以上；
    2. 或者，手动编译内核，disable CONFIG_MEMCG_KMEM 特性；
    3. 或者，安装修复了该问题的 Docker 18.09.1 及以上的版本。但由于 kubelet 也会设置 kmem（它 vendor 了 runc），所以需要重新编译 kubelet 并指定 GOFLAGS="-tags=nokmem"；
    1. $ git clone --branch v1.14.1 --single-branch --depth 1 https://github.com/kubernetes/kubernetes
    2. $ cd kubernetes
    3. $ KUBE_GIT_VERSION=v1.14.1 ./build/run.sh make kubelet GOFLAGS="-tags=nokmem"

    这里采用升级内核的解决办法：

    1. $ rpm -Uvh http://www.elrepo.org/elrepo-release-7.0-3.el7.elrepo.noarch.rpm
    2. # 安装完成后检查 /boot/grub2/grub.cfg 中对应内核 menuentry 中是否包含 initrd16 配置，如果没有，再安装一次！
    3. $ yum --enablerepo=elrepo-kernel install -y kernel-lt
    4. # 设置开机从新内核启动
    5. $ grub2-set-default 0

    重启机器：

    1. $ sync
    2. $ reboot

    3 创建 CA 根证书和秘钥

    为确保安全，kubernetes 系统各组件需要使用 x509 证书对通信进行加密和认证。

    CA (Certificate Authority) 是自签名的根证书，用来签名后续创建的其它证书。

    CA 证书是集群所有节点共享的，只需要创建一次，后续用它签名其它所有证书。

    本章节使用 CloudFlare 的 PKI 工具集 cfssl 创建所有证书。

    如果没有特殊指明，本文档的所有操作均在 sre-master-node节点上执行。

    3.1 安装 cfssl 工具集

    1. $ sudo mkdir -p /opt/k8s/cert && cd /opt/k8s/work
    2.  
    3. $ wget https://github.com/cloudflare/cfssl/releases/download/v1.4.1/cfssl_1.4.1_linux_amd64
    4. $ mv cfssl_1.4.1_linux_amd64 /opt/k8s/bin/cfssl
    5.  
    6. $ wget https://github.com/cloudflare/cfssl/releases/download/v1.4.1/cfssljson_1.4.1_linux_amd64
    7. $ mv cfssljson_1.4.1_linux_amd64 /opt/k8s/bin/cfssljson
    8.  
    9. $ wget https://github.com/cloudflare/cfssl/releases/download/v1.4.1/cfssl-certinfo_1.4.1_linux_amd64
    10. $ mv cfssl-certinfo_1.4.1_linux_amd64 /opt/k8s/bin/cfssl-certinfo
    11.  
    12. $ chmod +x /opt/k8s/bin/*
    13. $ export PATH=/opt/k8s/bin:$PATH

    3.2 创建配置文件

    CA 配置文件用于配置根证书的使用场景 (profile) 和具体参数 (usage，过期时间、服务端认证、客户端认证、加密等)：

    1. $ cd /opt/k8s/work
    2. $ cat > ca-config.json <<EOF
    3. {
    4.   "signing": {
    5.     "default": {
    6.       "expiry": "87600h"
    7.     },
    8.     "profiles": {
    9.       "kubernetes": {
    10.         "usages": [
    11.             "signing",
    12.             "key encipherment",
    13.             "server auth",
    14.             "client auth"
    15.         ],
    16.         "expiry": "876000h"
    17.       }
    18.     }
    19.   }
    20. }
    21. EOF
    • signing：表示该证书可用于签名其它证书（生成的 ca.pem 证书中 CA=TRUE）；
    • server auth：表示 client 可以用该该证书对 server 提供的证书进行验证；
    • client auth：表示 server 可以用该该证书对 client 提供的证书进行验证；
    • "expiry": "876000h"：证书有效期设置为 100 年；

    3.3 创建证书签名请求文件

    1. $ cd /opt/k8s/work
    2. $ cat > ca-csr.json <<EOF
    3. {
    4.   "CN": "kubernetes-ca",
    5.   "key": {
    6.     "algo": "rsa",
    7.     "size": 2048
    8.   },
    9.   "names": [
    10.     {
    11.       "C": "CN",
    12.       "ST": "ShangHai",
    13.       "L": "ShangHai",
    14.       "O": "k8s",
    15.       "OU": "opsnull"
    16.     }
    17.   ],
    18.   "ca": {
    19.     "expiry": "876000h"
    20.  }
    21. }
    22. EOF
    • CN：Common Name：kube-apiserver 从证书中提取该字段作为请求的用户名 (User Name)，浏览器使用该字段验证网站是否合法；
    • O：Organization：kube-apiserver 从证书中提取该字段作为请求用户所属的组 (Group)；
    • kube-apiserver 将提取的 User、Group 作为 RBAC 授权的用户标识；

    注意：

    1. 不同证书 csr 文件的 CN、C、ST、L、O、OU 组合必须不同，否则可能出现 PEER'S CERTIFICATE HAS AN INVALID SIGNATURE 错误；
    2. 后续创建证书的 csr 文件时，CN 都不相同（C、ST、L、O、OU 相同），以达到区分的目的；

    3.4 生成 CA 证书和私钥

    1. $ cd /opt/k8s/work
    2. $ cfssl gencert -initca ca-csr.json | cfssljson -bare ca
    3. $ ls ca*

    3.5 分发证书文件

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim deploy-ca.sh
    4. #!/bin/bash
    5. for node_ip in ${NODE_IPS[@]}
    6.   do
    7.     echo ">>> ${node_ip}"
    8.     ssh root@${node_ip} "mkdir -p /etc/kubernetes/cert"
    9.     scp ca*.pem ca-config.json root@${node_ip}:/etc/kubernetes/cert
    10.   done
    11. $ sh deploy-ca.sh

    4 安装和配置 kubectl

    • 如果没有特殊指明，本文档的所有操作均在sre-master-node节点上执行；
    • 本文档只需要部署一次，生成的 kubeconfig 文件是通用的，可以拷贝到需要执行 kubectl 命令的机器的 ~/.kube/config 位置；

    4.1 下载和分发 kubectl 二进制文件

    1. $ cd /opt/k8s/work
    2. $ wget https://dl.k8s.io/v1.16.6/kubernetes-client-linux-amd64.tar.gz # 自行解决翻墙下载问题
    3. $ tar -xzvf kubernetes-client-linux-amd64.tar.gz

    分发到所有使用 kubectl 工具的节点：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim deploy-kubectl.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     scp kubernetes/client/bin/kubectl root@${node_ip}:/opt/k8s/bin/
    8.     ssh root@${node_ip} "chmod +x /opt/k8s/bin/*"
    9.   done
    10. $ sh deploy-kubectl.sh

    4.2  创建 admin 证书和私钥

    kubectl 使用 https 协议与 kube-apiserver 进行安全通信，kube-apiserver 对 kubectl 请求包含的证书进行认证和授权。

    kubectl 后续用于集群管理，所以这里创建具有最高权限的 admin 证书。

    创建证书签名请求：

    1. $ cd /opt/k8s/work
    2. $ cat > admin-csr.json <<EOF
    3. {
    4.   "CN": "admin",
    5.   "hosts": [],
    6.   "key": {
    7.     "algo": "rsa",
    8.     "size": 2048
    9.   },
    10.   "names": [
    11.     {
    12.       "C": "CN",
    13.       "ST": "BeiJing",
    14.       "L": "BeiJing",
    15.       "O": "system:masters",
    16.       "OU": "opsnull"
    17.     }
    18.   ]
    19. }
    20. EOF
    • O: system:masters：kube-apiserver 收到使用该证书的客户端请求后，为请求添加组（Group）认证标识 system:masters；
    • 预定义的 ClusterRoleBinding cluster-admin 将 Group system:masters 与 Role cluster-admin 绑定，该 Role 授予操作集群所需的最高权限；
    • 该证书只会被 kubectl 当做 client 证书使用，所以 hosts 字段为空；

    生成证书和私钥：

    1. $ cd /opt/k8s/work
    2. $ cfssl gencert -ca=/opt/k8s/work/ca.pem \
    3.   -ca-key=/opt/k8s/work/ca-key.pem \
    4.   -config=/opt/k8s/work/ca-config.json \
    5.   -profile=kubernetes admin-csr.json | cfssljson -bare admin
    6. $ ls admin*
    • 忽略警告消息 [WARNING] This certificate lacks a "hosts" field.；

    4.3 创建 kubeconfig 文件

    kubectl 使用 kubeconfig 文件访问 apiserver，该文件包含 kube-apiserver 的地址和认证信息（CA 证书和客户端证书）：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3.  
    4. # 设置集群参数
    5. $ kubectl config set-cluster kubernetes \
    6.   --certificate-authority=/opt/k8s/work/ca.pem \
    7.   --embed-certs=true \
    8.   --server=https://${NODE_IPS[0]}:6443 \
    9.   --kubeconfig=kubectl.kubeconfig
    10.  
    11. # 设置客户端认证参数
    12. $ kubectl config set-credentials admin \
    13.   --client-certificate=/opt/k8s/work/admin.pem \
    14.   --client-key=/opt/k8s/work/admin-key.pem \
    15.   --embed-certs=true \
    16.   --kubeconfig=kubectl.kubeconfig
    17.  
    18. # 设置上下文参数
    19. $ kubectl config set-context kubernetes \
    20.   --cluster=kubernetes \
    21.   --user=admin \
    22.   --kubeconfig=kubectl.kubeconfig
    23.  
    24.  
    25.  
    26. # 设置默认上下文
    27. $ kubectl config use-context kubernetes --kubeconfig=kubectl.kubeconfig
    • --certificate-authority：验证 kube-apiserver 证书的根证书；
    • --client-certificate、--client-key：刚生成的 admin 证书和私钥，与 kube-apiserver https 通信时使用；
    • --embed-certs=true：将 ca.pem 和 admin.pem 证书内容嵌入到生成的 kubectl.kubeconfig 文件中(否则，写入的是证书文件路径，后续拷贝 kubeconfig 到其它机器时，还需要单独拷贝证书文件，不方便。)；
    • --server：指定 kube-apiserver 的地址，这里指向第一个节点上的服务；

    4.4 分发 kubeconfig 文件

    分发到所有使用 kubectl 命令的节点：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim deploy-kubeconfig.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     ssh root@${node_ip} "mkdir -p ~/.kube"
    8.     scp kubectl.kubeconfig root@${node_ip}:~/.kube/config
    9.   done
    10. $ sh deploy-kubeconfig.sh

    5 部署 etcd 集群

    etcd 是基于 Raft 的分布式 KV 存储系统，由 CoreOS 开发，常用于服务发现、共享配置以及并发控制（如 leader 选举、分布式锁等）。

    kubernetes 使用 etcd 集群持久化存储所有 API 对象、运行数据。

    本章节介绍部署一个三节点高可用 etcd 集群的步骤：

    • 下载和分发 etcd 二进制文件；
    • 创建 etcd 集群各节点的 x509 证书，用于加密客户端(如 etcdctl) 与 etcd 集群、etcd 集群之间的通信；
    • 创建 etcd 的 systemd unit 文件，配置服务参数；
    • 检查集群工作状态；

    etcd 集群节点名称和 IP 如下：

    • sre-master-node：10.12.5.60
    • sre-worker-node-1：10.12.5.61
    • sre-worker-node-2：10.12.5.62
    1. 如果没有特殊指明，本文档的所有操作均在sre-master-node节点上执行；
    2. flanneld 与本文档安装的 etcd v3.4.x 不兼容，如果要安装 flanneld（本文档使用 calio），则需要将 etcd 降级到 v3.3.x 版本；

    5.1 下载和分发 etcd 二进制文件

    到 etcd 的 release 页面 下载最新版本的发布包：

    1. $ cd /opt/k8s/work
    2. $ wget https://github.com/coreos/etcd/releases/download/v3.4.3/etcd-v3.4.3-linux-amd64.tar.gz
    3. $ tar -xvf etcd-v3.4.3-linux-amd64.tar.gz

    分发二进制文件到集群所有节点：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim deploy-etcd.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     scp etcd-v3.4.3-linux-amd64/etcd* root@${node_ip}:/opt/k8s/bin
    8.     ssh root@${node_ip} "chmod +x /opt/k8s/bin/*"
    9.   done
    10. $ sh deploy-etcd.sh

    5.2 创建 etcd 证书和私钥

    创建证书签名请求：

    1. $ cd /opt/k8s/work
    2. $ cat > etcd-csr.json <<EOF
    3. {
    4.   "CN": "etcd",
    5.   "hosts": [
    6.     "127.0.0.1",
    7.     "172.27.138.251",
    8.     "172.27.137.229",
    9.     "172.27.138.239"
    10.   ],
    11.   "key": {
    12.     "algo": "rsa",
    13.     "size": 2048
    14.   },
    15.   "names": [
    16.     {
    17.       "C": "CN",
    18.       "ST": "BeiJing",
    19.       "L": "BeiJing",
    20.       "O": "k8s",
    21.       "OU": "opsnull"
    22.     }
    23.   ]
    24. }
    25. EOF
    • hosts：指定授权使用该证书的 etcd 节点 IP 列表，需要将 etcd 集群所有节点 IP 都列在其中；

    生成证书和私钥：

    1. $ cd /opt/k8s/work
    2. $ cfssl gencert -ca=/opt/k8s/work/ca.pem \
    3.     -ca-key=/opt/k8s/work/ca-key.pem \
    4.     -config=/opt/k8s/work/ca-config.json \
    5.     -profile=kubernetes etcd-csr.json | cfssljson -bare etcd
    6. $ ls etcd*pem

    分发生成的证书和私钥到各 etcd 节点：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim deploy-etcd-pem.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     ssh root@${node_ip} "mkdir -p /etc/etcd/cert"
    8.     scp etcd*.pem root@${node_ip}:/etc/etcd/cert/
    9.   done
    10. $ sh deploy-etcd-pem.sh

    5.3 创建 etcd 的 systemd unit 模板文件

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ cat > etcd.service.template <<EOF
    4. [Unit]
    5. Description=Etcd Server
    6. After=network.target
    7. After=network-online.target
    8. Wants=network-online.target
    9. Documentation=https://github.com/coreos
    10.  
    11. [Service]
    12. Type=notify
    13. WorkingDirectory=${ETCD_DATA_DIR}
    14. ExecStart=/opt/k8s/bin/etcd \\
    15.   --data-dir=${ETCD_DATA_DIR} \\
    16.   --wal-dir=${ETCD_WAL_DIR} \\
    17.   --name=##NODE_NAME## \\
    18.   --cert-file=/etc/etcd/cert/etcd.pem \\
    19.   --key-file=/etc/etcd/cert/etcd-key.pem \\
    20.   --trusted-ca-file=/etc/kubernetes/cert/ca.pem \\
    21.   --peer-cert-file=/etc/etcd/cert/etcd.pem \\
    22.   --peer-key-file=/etc/etcd/cert/etcd-key.pem \\
    23.   --peer-trusted-ca-file=/etc/kubernetes/cert/ca.pem \\
    24.   --peer-client-cert-auth \\
    25.   --client-cert-auth \\
    26.   --listen-peer-urls=https://##NODE_IP##:2380 \\
    27.   --initial-advertise-peer-urls=https://##NODE_IP##:2380 \\
    28.   --listen-client-urls=https://##NODE_IP##:2379,http://127.0.0.1:2379 \\
    29.   --advertise-client-urls=https://##NODE_IP##:2379 \\
    30.   --initial-cluster-token=etcd-cluster-0 \\
    31.   --initial-cluster=${ETCD_NODES} \\
    32.   --initial-cluster-state=new \\
    33.   --auto-compaction-mode=periodic \\
    34.   --auto-compaction-retention=1 \\
    35.   --max-request-bytes=33554432 \\
    36.   --quota-backend-bytes=6442450944 \\
    37.   --heartbeat-interval=250 \\
    38.   --election-timeout=2000
    39. Restart=on-failure
    40. RestartSec=5
    41. LimitNOFILE=65536
    42.  
    43. [Install]
    44. WantedBy=multi-user.target
    45. EOF
    • WorkingDirectory、--data-dir：指定工作目录和数据目录为 ${ETCD_DATA_DIR}，需在启动服务前创建这个目录；
    • --wal-dir：指定 wal 目录，为了提高性能，一般使用 SSD 或者和 --data-dir 不同的磁盘；
    • --name：指定节点名称，当 --initial-cluster-state 值为 new 时，--name 的参数值必须位于 --initial-cluster 列表中；
    • --cert-file、--key-file：etcd server 与 client 通信时使用的证书和私钥；
    • --trusted-ca-file：签名 client 证书的 CA 证书，用于验证 client 证书；
    • --peer-cert-file、--peer-key-file：etcd 与 peer 通信使用的证书和私钥；
    • --peer-trusted-ca-file：签名 peer 证书的 CA 证书，用于验证 peer 证书；

    5.3 为各节点创建和分发 etcd systemd unit 文件

    替换模板文件中的变量，为各节点创建 systemd unit 文件：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim modify-env.sh
    4. for (( i=0; i < 3; i++ ))
    5.   do
    6.     sed -e "s/##NODE_NAME##/${NODE_NAMES[i]}/" -e "s/##NODE_IP##/${NODE_IPS[i]}/" etcd.service.template > etcd-${NODE_IPS[i]}.service 
    7.   done
    8. $ sh modify-env.sh
    • NODE_NAMES 和 NODE_IPS 为相同长度的 bash 数组，分别为节点名称和对应的 IP；

    分发生成的 systemd unit 文件：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim set-system-service.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     scp etcd-${node_ip}.service root@${node_ip}:/etc/systemd/system/etcd.service
    8.   done
    9. $ sh set-system-service.sh

    5.4 启动 etcd 服务

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim start-system-etcd.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     ssh root@${node_ip} "mkdir -p ${ETCD_DATA_DIR} ${ETCD_WAL_DIR}"
    8.     ssh root@${node_ip} "systemctl daemon-reload && systemctl enable etcd && systemctl restart etcd " &
    9.   done
    10. $ sh start-system-etcd.sh
    • 必须先创建 etcd 数据目录和工作目录;
    • etcd 进程首次启动时会等待其它节点的 etcd 加入集群，命令 systemctl start etcd 会卡住一段时间，为正常现象；

    5.5 检查启动结果

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim get-etcd-status.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     ssh root@${node_ip} "systemctl status etcd|grep Active"
    8.   done
    9. $ sh get-etcd-status.sh

    确保状态为 active (running)，否则查看日志，确认原因：

    $ journalctl -u etcd

    5.6 验证服务状态

    部署完 etcd 集群后，在任一 etcd 节点上执行如下命令：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim check-etcd-health.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     /opt/k8s/bin/etcdctl \
    8.     --endpoints=https://${node_ip}:2379 \
    9.     --cacert=/etc/kubernetes/cert/ca.pem \
    10.     --cert=/etc/etcd/cert/etcd.pem \
    11.     --key=/etc/etcd/cert/etcd-key.pem endpoint health
    12.   done
    13. $ sh check-etcd-health.sh
    • 3.4.3 版本的 etcd/etcdctl 默认启用了 V3 API，所以执行 etcdctl 命令时不需要再指定环境变量 ETCDCTL_API=3；
    • 从 K8S 1.13 开始，不再支持 v2 版本的 etcd；

    预期输出：

    1. >>> 10.12.5.60
    2. https://10.12.5.60:2379 is healthy: successfully committed proposal: took = 2.756451ms
    3. >>> 10.12.5.61
    4. https://10.12.5.61:2379 is healthy: successfully committed proposal: took = 2.025018ms
    5. >>> 10.12.5.62
    6. https://10.12.5.62:2379 is healthy: successfully committed proposal: took = 2.335097ms

    输出均为 healthy 时表示集群服务正常。

    5.7 查看当前的 leader

    1. $ source /opt/k8s/bin/environment.sh
    2. $ vim get-etcd-leader.sh
    3. /opt/k8s/bin/etcdctl \
    4.   -w table --cacert=/etc/kubernetes/cert/ca.pem \
    5.   --cert=/etc/etcd/cert/etcd.pem \
    6.   --key=/etc/etcd/cert/etcd-key.pem \
    7.   --endpoints=${ETCD_ENDPOINTS} endpoint status 
    8. $ sh get-etcd-leader.sh

    输出：

    1. +-------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
    2. |        ENDPOINT         |        ID        | VERSION | DB SIZE | IS LEADER | IS LEARNER | RAFT TERM | RAFT INDEX | RAFT APPLIED INDEX | ERRORS |
    3. +-------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
    4. | https://10.12.5.60:2379 |  8e3b68d01403704 |   3.4.3 |   20 kB |      true |      false |        44 |          9 |                  9 |        |
    5. | https://10.12.5.61:2379 | c93b34cd00fd858b |   3.4.3 |   20 kB |     false |      false |        44 |          9 |                  9 |        |
    6. | https://10.12.5.62:2379 | cb9f139b0cd73f5f |   3.4.3 |   16 kB |     false |      false |        44 |          9 |                  9 |        |
    • 可见，当前的 leader 为 10.12.5.60。

    6 部署 master 节点

    kubernetes master 节点运行如下组件：

    • kube-apiserver
    • kube-scheduler
    • kube-controller-manager

    kube-apiserver、kube-scheduler 和 kube-controller-manager 均以多实例模式运行：

    1. kube-scheduler 和 kube-controller-manager 会自动选举产生一个 leader 实例，其它实例处于阻塞模式，当 leader 挂了后，重新选举产生新的 leader，从而保证服务可用性；
    2. kube-apiserver 是无状态的，可以通过 kube-nginx 进行代理访问，从而保证服务可用性；

    如果没有特殊指明，本文档的所有操作均在 sre-master-node节点上执行。

    6.1 下载最新版本二进制文件

    从 CHANGELOG 页面 下载二进制 tar 文件并解压：

    1. $ cd /opt/k8s/work
    2. $ wget https://dl.k8s.io/v1.16.6/kubernetes-server-linux-amd64.tar.gz  # 自行解决翻墙问题
    3. $ tar -xzvf kubernetes-server-linux-amd64.tar.gz
    4. $ cd kubernetes
    5. $ tar -xzvf  kubernetes-src.tar.gz

    将二进制文件拷贝到所有节点：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim scp-k8s.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     scp kubernetes/server/bin/{apiextensions-apiserver,kube-apiserver,kube-controller-manager,kube-proxy,kube-scheduler,kubeadm,kubectl,kubelet,mounter} root@${node_ip}:/opt/k8s/bin/
    8.     ssh root@${node_ip} "chmod +x /opt/k8s/bin/*"
    9.   done
    10. $ sh scp-k8s.sh

     6.2 部署 kube-apiserver 集群

    本章节讲解部署一个三实例 kube-apiserver 集群的步骤.

    如果没有特殊指明，本文档的所有操作均在sre-master-node节点上执行。

    6.2.1 创建 kubernetes-master 证书和私钥

    创建证书签名请求：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ cat > kubernetes-csr.json <<EOF
    4. {
    5.   "CN": "kubernetes-master",
    6.   "hosts": [
    7.     "10.12.5.60",
    8.     "10.12.5.61",
    9.     "10.12.5.62",
    10.     "${CLUSTER_KUBERNETES_SVC_IP}",
    11.     "kubernetes",
    12.     "kubernetes.default",
    13.     "kubernetes.default.svc",
    14.     "kubernetes.default.svc.cluster",
    15.     "kubernetes.default.svc.cluster.local.",
    16.     "kubernetes.default.svc.${CLUSTER_DNS_DOMAIN}."
    17.   ],
    18.   "key": {
    19.     "algo": "rsa",
    20.     "size": 2048
    21.   },
    22.   "names": [
    23.     {
    24.       "C": "CN",
    25.       "ST": "BeiJing",
    26.       "L": "BeiJing",
    27.       "O": "k8s",
    28.       "OU": "opsnull"
    29.     }
    30.   ]
    31. }
    32. EOF
    • hosts 字段指定授权使用该证书的 IP 和域名列表，这里列出了 master 节点 IP、kubernetes 服务的 IP 和域名；

    生成证书和私钥：

    1. $ cfssl gencert -ca=/opt/k8s/work/ca.pem \
    2.   -ca-key=/opt/k8s/work/ca-key.pem \
    3.   -config=/opt/k8s/work/ca-config.json \
    4.   -profile=kubernetes kubernetes-csr.json | cfssljson -bare kubernetes
    5. $ ls kubernetes*pem

    将生成的证书和私钥文件拷贝到所有 master 节点：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim k8s_cert.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     ssh root@${node_ip} "mkdir -p /etc/kubernetes/cert"
    8.     scp kubernetes*.pem root@${node_ip}:/etc/kubernetes/cert/
    9.   done
    10. $ sh k8s_cert.sh

    6.2.2 创建加密配置文件

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ cat > encryption-config.yaml <<EOF
    4. kind: EncryptionConfig
    5. apiVersion: v1
    6. resources:
    7.   - resources:
    8.       - secrets
    9.     providers:
    10.       - aescbc:
    11.           keys:
    12.             - name: key1
    13.               secret: ${ENCRYPTION_KEY}
    14.       - identity: {}
    15. EOF

    将加密配置文件拷贝到 master 节点的 /etc/kubernetes 目录下：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim encryption-config.sh 
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     scp encryption-config.yaml root@${node_ip}:/etc/kubernetes/
    8.   done
    9. $ sh encryption-config.sh

    6.2.3 创建审计策略文件

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ cat > audit-policy.yaml <<EOF
    4. apiVersion: audit.k8s.io/v1beta1
    5. kind: Policy
    6. rules:
    7.   # The following requests were manually identified as high-volume and low-risk, so drop them.
    8.   - level: None
    9.     resources:
    10.       - group: ""
    11.         resources:
    12.           - endpoints
    13.           - services
    14.           - services/status
    15.     users:
    16.       - 'system:kube-proxy'
    17.     verbs:
    18.       - watch
    19.  
    20.   - level: None
    21.     resources:
    22.       - group: ""
    23.         resources:
    24.           - nodes
    25.           - nodes/status
    26.     userGroups:
    27.       - 'system:nodes'
    28.     verbs:
    29.       - get
    30.  
    31.   - level: None
    32.     namespaces:
    33.       - kube-system
    34.     resources:
    35.       - group: ""
    36.         resources:
    37.           - endpoints
    38.     users:
    39.       - 'system:kube-controller-manager'
    40.       - 'system:kube-scheduler'
    41.       - 'system:serviceaccount:kube-system:endpoint-controller'
    42.     verbs:
    43.       - get
    44.       - update
    45.  
    46.   - level: None
    47.     resources:
    48.       - group: ""
    49.         resources:
    50.           - namespaces
    51.           - namespaces/status
    52.           - namespaces/finalize
    53.     users:
    54.       - 'system:apiserver'
    55.     verbs:
    56.       - get
    57.  
    58.   # Don't log HPA fetching metrics.
    59.   - level: None
    60.     resources:
    61.       - group: metrics.k8s.io
    62.     users:
    63.       - 'system:kube-controller-manager'
    64.     verbs:
    65.       - get
    66.       - list
    68.   # Don't log these read-only URLs.
    69.   - level: None
    70.     nonResourceURLs:
    71.       - '/healthz*'
    72.       - /version
    73.       - '/swagger*'
    74.  
    75.   # Don't log events requests.
    76.   - level: None
    77.     resources:
    78.       - group: ""
    79.         resources:
    80.           - events
    82.   # node and pod status calls from nodes are high-volume and can be large, don't log responses
    83.   # for expected updates from nodes
    84.   - level: Request
    85.     omitStages:
    86.       - RequestReceived
    87.     resources:
    88.       - group: ""
    89.         resources:
    90.           - nodes/status
    91.           - pods/status
    92.     users:
    93.       - kubelet
    94.       - 'system:node-problem-detector'
    95.       - 'system:serviceaccount:kube-system:node-problem-detector'
    96.     verbs:
    97.       - update
    98.       - patch
    99.  
    100.   - level: Request
    101.     omitStages:
    102.       - RequestReceived
    103.     resources:
    104.       - group: ""
    105.         resources:
    106.           - nodes/status
    107.           - pods/status
    108.     userGroups:
    109.       - 'system:nodes'
    110.     verbs:
    111.       - update
    112.       - patch
    113.  
    114.   # deletecollection calls can be large, don't log responses for expected namespace deletions
    115.   - level: Request
    116.     omitStages:
    117.       - RequestReceived
    118.     users:
    119.       - 'system:serviceaccount:kube-system:namespace-controller'
    120.     verbs:
    121.       - deletecollection
    123.   # Secrets, ConfigMaps, and TokenReviews can contain sensitive & binary data,
    124.   # so only log at the Metadata level.
    125.   - level: Metadata
    126.     omitStages:
    127.       - RequestReceived
    128.     resources:
    129.       - group: ""
    130.         resources:
    131.           - secrets
    132.           - configmaps
    133.       - group: authentication.k8s.io
    134.         resources:
    135.           - tokenreviews
    136.   # Get repsonses can be large; skip them.
    137.   - level: Request
    138.     omitStages:
    139.       - RequestReceived
    140.     resources:
    141.       - group: ""
    142.       - group: admissionregistration.k8s.io
    143.       - group: apiextensions.k8s.io
    144.       - group: apiregistration.k8s.io
    145.       - group: apps
    146.       - group: authentication.k8s.io
    147.       - group: authorization.k8s.io
    148.       - group: autoscaling
    149.       - group: batch
    150.       - group: certificates.k8s.io
    151.       - group: extensions
    152.       - group: metrics.k8s.io
    153.       - group: networking.k8s.io
    154.       - group: policy
    155.       - group: rbac.authorization.k8s.io
    156.       - group: scheduling.k8s.io
    157.       - group: settings.k8s.io
    158.       - group: storage.k8s.io
    159.     verbs:
    160.       - get
    161.       - list
    162.       - watch
    164.   # Default level for known APIs
    165.   - level: RequestResponse
    166.     omitStages:
    167.       - RequestReceived
    168.     resources:
    169.       - group: ""
    170.       - group: admissionregistration.k8s.io
    171.       - group: apiextensions.k8s.io
    172.       - group: apiregistration.k8s.io
    173.       - group: apps
    174.       - group: authentication.k8s.io
    175.       - group: authorization.k8s.io
    176.       - group: autoscaling
    177.       - group: batch
    178.       - group: certificates.k8s.io
    179.       - group: extensions
    180.       - group: metrics.k8s.io
    181.       - group: networking.k8s.io
    182.       - group: policy
    183.       - group: rbac.authorization.k8s.io
    184.       - group: scheduling.k8s.io
    185.       - group: settings.k8s.io
    186.       - group: storage.k8s.io
    187.       
    188.   # Default level for all other requests.
    189.   - level: Metadata
    190.     omitStages:
    191.       - RequestReceived
    192. EOF

    分发审计策略文件：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim audit-policy.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     scp audit-policy.yaml root@${node_ip}:/etc/kubernetes/audit-policy.yaml
    8.   done
    9. $ sh audit-policy.sh

    6.2.4 创建后续访问 metrics-server 或 kube-prometheus 使用的证书

    创建证书签名请求:

    1. $ cd /opt/k8s/work
    2. $ cat > proxy-client-csr.json <<EOF
    3. {
    4.   "CN": "aggregator",
    5.   "hosts": [],
    6.   "key": {
    7.     "algo": "rsa",
    8.     "size": 2048
    9.   },
    10.   "names": [
    11.     {
    12.       "C": "CN",
    13.       "ST": "BeiJing",
    14.       "L": "BeiJing",
    15.       "O": "k8s",
    16.       "OU": "opsnull"
    17.     }
    18.   ]
    19. }
    20. EOF
    • CN 名称需要位于 kube-apiserver 的 --requestheader-allowed-names 参数中，否则后续访问 metrics 时会提示权限不足。

    生成证书和私钥：

    1. $ cfssl gencert -ca=/etc/kubernetes/cert/ca.pem \
    2.   -ca-key=/etc/kubernetes/cert/ca-key.pem  \
    3.   -config=/etc/kubernetes/cert/ca-config.json  \
    4.   -profile=kubernetes proxy-client-csr.json | cfssljson -bare proxy-client
    5. $ ls proxy-client*.pem

    将生成的证书和私钥文件拷贝到所有 master 节点：

    1. $ source /opt/k8s/bin/environment.sh
    2. $ vim proxy-client.sh
    3. for node_ip in ${NODE_IPS[@]}
    4.   do
    5.     echo ">>> ${node_ip}"
    6.     scp proxy-client*.pem root@${node_ip}:/etc/kubernetes/cert/
    7.   done
    8. $ sh proxy-client.sh

    6.2.5 创建 kube-apiserver systemd unit 模板文件

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ cat > kube-apiserver.service.template <<EOF
    4. [Unit]
    5. Description=Kubernetes API Server
    6. Documentation=https://github.com/GoogleCloudPlatform/kubernetes
    7. After=network.target
    8.  
    9. [Service]
    10. WorkingDirectory=${K8S_DIR}/kube-apiserver
    11. ExecStart=/opt/k8s/bin/kube-apiserver \\
    12.   --advertise-address=##NODE_IP## \\
    13.   --default-not-ready-toleration-seconds=360 \\
    14.   --default-unreachable-toleration-seconds=360 \\
    15.   --feature-gates=DynamicAuditing=true \\
    16.   --max-mutating-requests-inflight=2000 \\
    17.   --max-requests-inflight=4000 \\
    18.   --default-watch-cache-size=200 \\
    19.   --delete-collection-workers=2 \\
    20.   --encryption-provider-config=/etc/kubernetes/encryption-config.yaml \\
    21.   --etcd-cafile=/etc/kubernetes/cert/ca.pem \\
    22.   --etcd-certfile=/etc/kubernetes/cert/kubernetes.pem \\
    23.   --etcd-keyfile=/etc/kubernetes/cert/kubernetes-key.pem \\
    24.   --etcd-servers=${ETCD_ENDPOINTS} \\
    25.   --bind-address=##NODE_IP## \\
    26.   --secure-port=6443 \\
    27.   --tls-cert-file=/etc/kubernetes/cert/kubernetes.pem \\
    28.   --tls-private-key-file=/etc/kubernetes/cert/kubernetes-key.pem \\
    29.   --insecure-port=0 \\
    30.   --audit-dynamic-configuration \\
    31.   --audit-log-maxage=15 \\
    32.   --audit-log-maxbackup=3 \\
    33.   --audit-log-maxsize=100 \\
    34.   --audit-log-truncate-enabled \\
    35.   --audit-log-path=${K8S_DIR}/kube-apiserver/audit.log \\
    36.   --audit-policy-file=/etc/kubernetes/audit-policy.yaml \\
    37.   --profiling \\
    38.   --anonymous-auth=false \\
    39.   --client-ca-file=/etc/kubernetes/cert/ca.pem \\
    40.   --enable-bootstrap-token-auth \\
    41.   --requestheader-allowed-names="aggregator" \\
    42.   --requestheader-client-ca-file=/etc/kubernetes/cert/ca.pem \\
    43.   --requestheader-extra-headers-prefix="X-Remote-Extra-" \\
    44.   --requestheader-group-headers=X-Remote-Group \\
    45.   --requestheader-username-headers=X-Remote-User \\
    46.   --service-account-key-file=/etc/kubernetes/cert/ca.pem \\
    47.   --authorization-mode=Node,RBAC \\
    48.   --runtime-config=api/all=true \\
    49.   --enable-admission-plugins=NodeRestriction \\
    50.   --allow-privileged=true \\
    51.   --apiserver-count=3 \\
    52.   --event-ttl=168h \\
    53.   --kubelet-certificate-authority=/etc/kubernetes/cert/ca.pem \\
    54.   --kubelet-client-certificate=/etc/kubernetes/cert/kubernetes.pem \\
    55.   --kubelet-client-key=/etc/kubernetes/cert/kubernetes-key.pem \\
    56.   --kubelet-https=true \\
    57.   --kubelet-timeout=10s \\
    58.   --proxy-client-cert-file=/etc/kubernetes/cert/proxy-client.pem \\
    59.   --proxy-client-key-file=/etc/kubernetes/cert/proxy-client-key.pem \\
    60.   --service-cluster-ip-range=${SERVICE_CIDR} \\
    61.   --service-node-port-range=${NODE_PORT_RANGE} \\
    62.   --logtostderr=true \\
    63.   --v=2
    64. Restart=on-failure
    65. RestartSec=10
    66. Type=notify
    67. LimitNOFILE=65536
    68.  
    69. [Install]
    70. WantedBy=multi-user.target
    71. EOF
    • --advertise-address：apiserver 对外通告的 IP（kubernetes 服务后端节点 IP）；
    • --default-*-toleration-seconds：设置节点异常相关的阈值；
    • --max-*-requests-inflight：请求相关的最大阈值；
    • --etcd-*：访问 etcd 的证书和 etcd 服务器地址；
    • --bind-address： https 监听的 IP，不能为 127.0.0.1，否则外界不能访问它的安全端口 6443；
    • --secret-port：https 监听端口；
    • --insecure-port=0：关闭监听 http 非安全端口(8080)；
    • --tls-*-file：指定 apiserver 使用的证书、私钥和 CA 文件；
    • --audit-*：配置审计策略和审计日志文件相关的参数；
    • --client-ca-file：验证 client (kue-controller-manager、kube-scheduler、kubelet、kube-proxy 等)请求所带的证书；
    • --enable-bootstrap-token-auth：启用 kubelet bootstrap 的 token 认证；
    • --requestheader-*：kube-apiserver 的 aggregator layer 相关的配置参数，proxy-client & HPA 需要使用；
    • --requestheader-client-ca-file：用于签名 --proxy-client-cert-file 和 --proxy-client-key-file 指定的证书；在启用了 metric aggregator 时使用；
    • --requestheader-allowed-names：不能为空，值为逗号分割的 --proxy-client-cert-file 证书的 CN 名称，这里设置为 "aggregator"；
    • --service-account-key-file：签名 ServiceAccount Token 的公钥文件，kube-controller-manager 的 --service-account-private-key-file 指定私钥文件，两者配对使用；
    • --runtime-config=api/all=true： 启用所有版本的 APIs，如 autoscaling/v2alpha1；
    • --authorization-mode=Node,RBAC、--anonymous-auth=false： 开启 Node 和 RBAC 授权模式，拒绝未授权的请求；
    • --enable-admission-plugins：启用一些默认关闭的 plugins；
    • --allow-privileged：运行执行 privileged 权限的容器；
    • --apiserver-count=3：指定 apiserver 实例的数量；
    • --event-ttl：指定 events 的保存时间；
    • --kubelet-*：如果指定，则使用 https 访问 kubelet APIs；需要为证书对应的用户(上面 kubernetes*.pem 证书的用户为 kubernetes) 用户定义 RBAC 规则，否则访问 kubelet API 时提示未授权；
    • --proxy-client-*：apiserver 访问 metrics-server 使用的证书；
    • --service-cluster-ip-range： 指定 Service Cluster IP 地址段；
    • --service-node-port-range： 指定 NodePort 的端口范围；

    如果 kube-apiserver 机器没有运行 kube-proxy，则还需要添加 --enable-aggregator-routing=true 参数；

    关于 --requestheader-XXX 相关参数，参考：

    1. --requestheader-client-ca-file 指定的 CA 证书，必须具有 client auth and server auth；
    2. 如果 --requestheader-allowed-names 不为空,且 --proxy-client-cert-file 证书的 CN 名称不在 allowed-names 中，则后续查看 node 或 pods 的 metrics 失败，提示：
    1. $ kubectl top nodes
    2. Error from server (Forbidden): nodes.metrics.k8s.io is forbidden: User "aggregator" cannot list resource "nodes" in API group "metrics.k8s.io" at the cluster scope

    6.2.6 为各节点创建和分发 kube-apiserver systemd unit 文件

    替换模板文件中的变量，为各节点生成 systemd unit 文件：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim modify-kube-apiserver.sh
    4. for (( i=0; i < 3; i++ ))
    5.   do
    6.     sed -e "s/##NODE_NAME##/${NODE_NAMES[i]}/" -e "s/##NODE_IP##/${NODE_IPS[i]}/" kube-apiserver.service.template > kube-apiserver-${NODE_IPS[i]}.service 
    7.   done
    8. ls kube-apiserver*.service
    9. $ sh modify-kube-apiserver.sh
    • NODE_NAMES 和 NODE_IPS 为相同长度的 bash 数组，分别为节点名称和对应的 IP；

    分发生成的 systemd unit 文件：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim scp-kube-apiserver.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     scp kube-apiserver-${node_ip}.service root@${node_ip}:/etc/systemd/system/kube-apiserver.service
    8.   done
    9. $ sh scp-kube-apiserver.sh

    6.2.7 启动 kube-apiserver 服务

    1. $ vim source /opt/k8s/bin/environment.sh
    2. $ vim start-k8s-apiserver.sh
    3. for node_ip in ${NODE_IPS[@]}
    4.   do
    5.     echo ">>> ${node_ip}"
    6.     ssh root@${node_ip} "mkdir -p ${K8S_DIR}/kube-apiserver"
    7.     ssh root@${node_ip} "systemctl daemon-reload && systemctl enable kube-apiserver && systemctl restart kube-apiserver"
    8.   done
    9. $ sh start-k8s-apiserver.sh

    6.2.8 检查 kube-apiserver 运行状态

    1. $ source /opt/k8s/bin/environment.sh
    2. $ vim check-spiserver.sh
    3. for node_ip in ${NODE_IPS[@]}
    4.   do
    5.     echo ">>> ${node_ip}"
    6.     ssh root@${node_ip} "systemctl status kube-apiserver |grep 'Active:'"
    7.   done
    8. $ sh check-spiserver.sh

    确保状态为 active (running)，否则查看日志，确认原因：

    $ journalctl -u kube-apiserver

    6.2.9 检查集群状态

    1. $ kubectl cluster-info
    2. Kubernetes master is running at https://10.12.5.60:6443
    3.  
    4. To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.
    5.  
    6. $ kubectl get all --all-namespaces
    7. NAMESPACE   NAME                 TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)   AGE
    8. default     service/kubernetes   ClusterIP   192.168.0.1   <none>        443/TCP   22s
    9.  
    10. $ kubectl get componentstatuses
    11. NAME                 AGE
    12. controller-manager   <unknown>
    13. scheduler            <unknown>
    14. etcd-1               <unknown>
    15. etcd-0               <unknown>
    16. etcd-2               <unknown>
    • Kubernetes 1.16.6 存在 Bugs 导致返回结果一直为 ，但 kubectl get cs -o yaml 可以返回正确结果；

    6.2.10 检查 kube-apiserver 监听的端口

    1. $ sudo netstat -lnpt|grep kube
    2. tcp        0      0 10.12.5.60:6443         0.0.0.0:*               LISTEN      14747/kube-apiserve 
    • 6443: 接收 https 请求的安全端口，对所有请求做认证和授权；
    • 由于关闭了非安全端口，故没有监听 8080；

    6.3 部署高可用 kube-controller-manager 集群

    本章节介绍部署高可用 kube-controller-manager 集群的步骤。

    该集群包含 3 个节点，启动后将通过竞争选举机制产生一个 leader 节点，其它节点为阻塞状态。当 leader 节点不可用时，阻塞的节点将再次进行选举产生新的 leader 节点，从而保证服务的可用性。

    为保证通信安全，本章节先生成 x509 证书和私钥，kube-controller-manager 在如下两种情况下使用该证书：

    1. 与 kube-apiserver 的安全端口通信;
    2. 在安全端口(https，10252) 输出 prometheus 格式的 metrics；

    如果没有特殊指明，本文档的所有操作均在 sre-master-node节点上执行。

    6.3.1 创建 kube-controller-manager 证书和私钥

    创建证书签名请求：

    1. $ cd /opt/k8s/work
    2. $ cat > kube-controller-manager-csr.json <<EOF
    3. {
    4.     "CN": "system:kube-controller-manager",
    5.     "key": {
    6.         "algo": "rsa",
    7.         "size": 2048
    8.     },
    9.     "hosts": [
    10.       "10.12.5.60",
    11.       "10.12.5.61",
    12.       "10.12.5.62"
    13.     ],
    14.     "names": [
    15.       {
    16.         "C": "CN",
    17.         "ST": "BeiJing",
    18.         "L": "BeiJing",
    19.         "O": "system:kube-controller-manager",
    20.         "OU": "opsnull"
    21.       }
    22.     ]
    23. }
    24. EOF
    • hosts 列表包含所有 kube-controller-manager 节点 IP；
    • CN 和 O 均为 system:kube-controller-manager，kubernetes 内置的 ClusterRoleBindings system:kube-controller-manager 赋予 kube-controller-manager 工作所需的权限。

    生成证书和私钥：

    1. $ cd /opt/k8s/work
    2. $ cfssl gencert -ca=/opt/k8s/work/ca.pem \
    3.   -ca-key=/opt/k8s/work/ca-key.pem \
    4.   -config=/opt/k8s/work/ca-config.json \
    5.   -profile=kubernetes kube-controller-manager-csr.json | cfssljson -bare kube-controller-manager
    6. $ ls kube-controller-manager*pem

    将生成的证书和私钥分发到所有 master 节点：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim kube-controller-manager.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     scp kube-controller-manager*.pem root@${node_ip}:/etc/kubernetes/cert/
    8.   done
    9. $ sh kube-controller-manager.sh

    6.3.2 创建和分发 kubeconfig 文件

    kube-controller-manager 使用 kubeconfig 文件访问 apiserver，该文件提供了 apiserver 地址、嵌入的 CA 证书和 kube-controller-manager 证书等信息：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3.  
    4. $ kubectl config set-cluster kubernetes \
    5.   --certificate-authority=/opt/k8s/work/ca.pem \
    6.   --embed-certs=true \
    7.   --server="https://10.12.5.60:6443" \
    8.   --kubeconfig=kube-controller-manager.kubeconfig
    9.  
    10. $ kubectl config set-credentials system:kube-controller-manager \
    11.   --client-certificate=kube-controller-manager.pem \
    12.   --client-key=kube-controller-manager-key.pem \
    13.   --embed-certs=true \
    14.   --kubeconfig=kube-controller-manager.kubeconfig
    15.  
    16. $ kubectl config set-context system:kube-controller-manager \
    17.   --cluster=kubernetes \
    18.   --user=system:kube-controller-manager \
    19.   --kubeconfig=kube-controller-manager.kubeconfig
    20.  
    21. $ kubectl config use-context system:kube-controller-manager --kubeconfig=kube-controller-manager.kubeconfig
    • kube-controller-manager 与 kube-apiserver 混布，故直接通过节点 IP 访问 kube-apiserver；

    分发 kubeconfig 到所有 master 节点：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. # vim kube-controller-manager.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     sed -e "s/##NODE_IP##/${node_ip}/" kube-controller-manager.kubeconfig > kube-controller-manager-${node_ip}.kubeconfig
    8.     scp kube-controller-manager-${node_ip}.kubeconfig root@${node_ip}:/etc/kubernetes/kube-controller-manager.kubeconfig
    9.   done
    10. $ sh kube-controller-manager.sh

    6.3.3 创建 kube-controller-manager systemd unit 模板文件 

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ cat > kube-controller-manager.service.template <<EOF
    4. [Unit]
    5. Description=Kubernetes Controller Manager
    6. Documentation=https://github.com/GoogleCloudPlatform/kubernetes
    7.  
    8. [Service]
    9. WorkingDirectory=${K8S_DIR}/kube-controller-manager
    10. ExecStart=/opt/k8s/bin/kube-controller-manager \\
    11.   --profiling \\
    12.   --cluster-name=kubernetes \\
    13.   --controllers=*,bootstrapsigner,tokencleaner \\
    14.   --kube-api-qps=1000 \\
    15.   --kube-api-burst=2000 \\
    16.   --leader-elect \\
    17.   --use-service-account-credentials\\
    18.   --concurrent-service-syncs=2 \\
    19.   --bind-address=10.12.5.60 \\
    20.   --secure-port=10252 \\
    21.   --tls-cert-file=/etc/kubernetes/cert/kube-controller-manager.pem \\
    22.   --tls-private-key-file=/etc/kubernetes/cert/kube-controller-manager-key.pem \\
    23.   --port=0 \\
    24.   --authentication-kubeconfig=/etc/kubernetes/kube-controller-manager.kubeconfig \\
    25.   --client-ca-file=/etc/kubernetes/cert/ca.pem \\
    26.   --requestheader-allowed-names="aggregator" \\
    27.   --requestheader-client-ca-file=/etc/kubernetes/cert/ca.pem \\
    28.   --requestheader-extra-headers-prefix="X-Remote-Extra-" \\
    29.   --requestheader-group-headers=X-Remote-Group \\
    30.   --requestheader-username-headers=X-Remote-User \\
    31.   --authorization-kubeconfig=/etc/kubernetes/kube-controller-manager.kubeconfig \\
    32.   --cluster-signing-cert-file=/etc/kubernetes/cert/ca.pem \\
    33.   --cluster-signing-key-file=/etc/kubernetes/cert/ca-key.pem \\
    34.   --experimental-cluster-signing-duration=876000h \\
    35.   --horizontal-pod-autoscaler-sync-period=10s \\
    36.   --concurrent-deployment-syncs=10 \\
    37.   --concurrent-gc-syncs=30 \\
    38.   --node-cidr-mask-size=24 \\
    39.   --service-cluster-ip-range=${SERVICE_CIDR} \\
    40.   --pod-eviction-timeout=6m \\
    41.   --terminated-pod-gc-threshold=10000 \\
    42.   --root-ca-file=/etc/kubernetes/cert/ca.pem \\
    43.   --service-account-private-key-file=/etc/kubernetes/cert/ca-key.pem \\
    44.   --kubeconfig=/etc/kubernetes/kube-controller-manager.kubeconfig \\
    45.   --logtostderr=true \\
    46.   --v=2
    47. Restart=on-failure
    48. RestartSec=5
    49.  
    50. [Install]
    51. WantedBy=multi-user.target
    52. EOF
    • --port=0：关闭监听非安全端口（http），同时 --address 参数无效，--bind-address 参数有效；
    • --secure-port=10252、--bind-address=0.0.0.0: 在所有网络接口监听 10252 端口的 https /metrics 请求；
    • --kubeconfig：指定 kubeconfig 文件路径，kube-controller-manager 使用它连接和验证 kube-apiserver；
    • --authentication-kubeconfig 和 --authorization-kubeconfig：kube-controller-manager 使用它连接 apiserver，对 client 的请求进行认证和授权。kube-controller-manager 不再使用 --tls-ca-file 对请求 https metrics 的 Client 证书进行校验。如果没有配置这两个 kubeconfig 参数，则 client 连接 kube-controller-manager https 端口的请求会被拒绝(提示权限不足)。
    • --cluster-signing-*-file：签名 TLS Bootstrap 创建的证书；
    • --experimental-cluster-signing-duration：指定 TLS Bootstrap 证书的有效期；
    • --root-ca-file：放置到容器 ServiceAccount 中的 CA 证书，用来对 kube-apiserver 的证书进行校验；
    • --service-account-private-key-file：签名 ServiceAccount 中 Token 的私钥文件，必须和 kube-apiserver 的 --service-account-key-file 指定的公钥文件配对使用；
    • --service-cluster-ip-range ：指定 Service Cluster IP 网段，必须和 kube-apiserver 中的同名参数一致；
    • --leader-elect=true：集群运行模式，启用选举功能；被选为 leader 的节点负责处理工作，其它节点为阻塞状态；
    • --controllers=*,bootstrapsigner,tokencleaner：启用的控制器列表，tokencleaner 用于自动清理过期的 Bootstrap token；
    • --horizontal-pod-autoscaler-*：custom metrics 相关参数，支持 autoscaling/v2alpha1；
    • --tls-cert-file、--tls-private-key-file：使用 https 输出 metrics 时使用的 Server 证书和秘钥；
    • --use-service-account-credentials=true: kube-controller-manager 中各 controller 使用 serviceaccount 访问 kube-apiserver；

    6.3.4 为各节点创建和分发 kube-controller-mananger systemd unit 文件

    替换模板文件中的变量，为各节点创建 systemd unit 文件：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim modify-kube-controller-manager.service.sh
    4. for (( i=0; i < 3; i++ ))
    5.   do
    6.     sed -e "s/##NODE_NAME##/${NODE_NAMES[i]}/" -e "s/##NODE_IP##/${NODE_IPS[i]}/" kube-controller-manager.service.template > kube-controller-manager-${NODE_IPS[i]}.service 
    7.   done
    8. $ sh modify-kube-controller-manager.service.sh 
    9. $ ls kube-controller-manager*.service

    分发到所有 master 节点：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim scp-kube-controller-manager.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     scp kube-controller-manager-${node_ip}.service root@${node_ip}:/etc/systemd/system/kube-controller-manager.service
    8.   done
    9. $ sh scp-kube-controller-manager.sh

    6.3.5 启动 kube-controller-manager 服务

    1. $ source /opt/k8s/bin/environment.sh
    2. $ vim start-kube-controller-manager.sh
    3. for node_ip in ${NODE_IPS[@]}
    4.   do
    5.     echo ">>> ${node_ip}"
    6.     ssh root@${node_ip} "mkdir -p ${K8S_DIR}/kube-controller-manager"
    7.     ssh root@${node_ip} "systemctl daemon-reload && systemctl enable kube-controller-manager && systemctl restart kube-controller-manager"
    8.   done
    9. $ sh start-kube-controller-manager.sh

    6.3.6 检查服务运行状态

    1. $ source /opt/k8s/bin/environment.sh
    2. $ vim check-kube-controller-manager.sh
    3. for node_ip in ${NODE_IPS[@]}
    4.   do
    5.     echo ">>> ${node_ip}"
    6.     ssh root@${node_ip} "systemctl status kube-controller-manager|grep Active"
    7.   done
    8. $ sh check-kube-controller-manager.sh

    确保状态为 active (running)，否则查看日志，确认原因：

    $ journalctl -u kube-controller-manager

    kube-controller-manager 监听 10252 端口，接收 https 请求：

    1. $ sudo netstat -lnpt | grep kube-cont
    2. tcp        0      0 172.27.138.251:10252    0.0.0.0:*               LISTEN      108977/kube-control

    6.3.7 查看输出的 metrics

    注意：以下命令在 kube-controller-manager 节点上执行。

    1. $ curl -s --cacert /opt/k8s/work/ca.pem --cert /opt/k8s/work/admin.pem --key /opt/k8s/work/admin-key.pem https://10.12.5.60:10252/metrics |head
    2. # HELP apiserver_audit_event_total [ALPHA] Counter of audit events generated and sent to the audit backend.
    3. # TYPE apiserver_audit_event_total counter
    4. apiserver_audit_event_total 0
    5. # HELP apiserver_audit_requests_rejected_total [ALPHA] Counter of apiserver requests rejected due to an error in audit logging backend.
    6. # TYPE apiserver_audit_requests_rejected_total counter
    7. apiserver_audit_requests_rejected_total 0
    8. # HELP apiserver_client_certificate_expiration_seconds [ALPHA] Distribution of the remaining lifetime on the certificate used to authenticate a request.
    9. # TYPE apiserver_client_certificate_expiration_seconds histogram
    10. apiserver_client_certificate_expiration_seconds_bucket{le="0"} 0
    11. apiserver_client_certificate_expiration_seconds_bucket{le="1800"} 0

    6.3.8 查看当前的 leader

    1. $ kubectl get endpoints kube-controller-manager --namespace=kube-system  -o yaml
    2. apiVersion: v1
    3. kind: Endpoints
    4. metadata:
    5.   annotations:
    6.     control-plane.alpha.kubernetes.io/leader: '{"holderIdentity":"sre-master-node_ee20e02b-4c54-4622-94ff-b4acd7b4ce67","leaseDurationSeconds":15,"acquireTime":"2023-09-18T14:01:07Z","renewTime":"2023-09-18T14:20:22Z","leaderTransitions":1}'
    7.   creationTimestamp: "2023-09-18T13:56:33Z"
    8.   name: kube-controller-manager
    9.   namespace: kube-system
    10.   resourceVersion: "30117"
    11.   selfLink: /api/v1/namespaces/kube-system/endpoints/kube-controller-manager
    12.   uid: b636f6d2-35b9-4951-9fcf-e0bd07c977ff

    可见，当前的 leader 为 sre-master-node节点。

    6.3.9 测试 kube-controller-manager 集群的高可用

    停掉一个或两个节点的 kube-controller-manager 服务，观察其它节点的日志，看是否获取了 leader 权限。

    案例：停掉 sre-master-node节点的 kube-controller-manager 服务，leader转移到sre-worker-node-2节点上。

    1. $ systemctl stop kube-controller-manager
    2. $ kubectl get endpoints kube-controller-manager --namespace=kube-system  -o yaml
    3. apiVersion: v1
    4. kind: Endpoints
    5. metadata:
    6.   annotations:
    7.     control-plane.alpha.kubernetes.io/leader: '{"holderIdentity":"sre-worker-node-2_e50f0e97-7cfb-4dec-9069-aeed6cad7115","leaseDurationSeconds":15,"acquireTime":"2023-09-19T14:40:25Z","renewTime":"2023-09-19T14:40:29Z","leaderTransitions":2}'
    8.   creationTimestamp: "2023-09-18T13:56:33Z"
    9.   name: kube-controller-manager
    10.   namespace: kube-system
    11.   resourceVersion: "100329"
    12.   selfLink: /api/v1/namespaces/kube-system/endpoints/kube-controller-manager
    13.   uid: b636f6d2-35b9-4951-9fcf-e0bd07c977ff

    6.4 部署高可用 kube-scheduler 集群

    本章节介绍部署高可用 kube-scheduler 集群的步骤。

    该集群包含 3 个节点，启动后将通过竞争选举机制产生一个 leader 节点，其它节点为阻塞状态。当 leader 节点不可用后，剩余节点将再次进行选举产生新的 leader 节点，从而保证服务的可用性。

    为保证通信安全，本章节先生成 x509 证书和私钥，kube-scheduler 在如下两种情况下使用该证书：

    1. 与 kube-apiserver 的安全端口通信;
    2. 在安全端口(https，10251) 输出 prometheus 格式的 metrics；

    如果没有特殊指明，本文档的所有操作均在sre-master-node节点上执行

    6.4.1 创建 kube-scheduler 证书和私钥

    创建证书签名请求：

    1. $ cd /opt/k8s/work
    2. $ cat > kube-scheduler-csr.json <
    3. {
    4.     "CN": "system:kube-scheduler",
    5.     "hosts": [
    6.       "10.12.5.60",
    7.       "10.12.5.61",
    8.       "10.12.5.62"
    9.     ],
    10.     "key": {
    11.         "algo": "rsa",
    12.         "size": 2048
    13.     },
    14.     "names": [
    15.       {
    16.         "C": "CN",
    17.         "ST": "BeiJing",
    18.         "L": "BeiJing",
    19.         "O": "system:kube-scheduler",
    20.         "OU": "opsnull"
    21.       }
    22.     ]
    23. }
    24. EOF
    • hosts 列表包含所有 kube-scheduler 节点 IP；
    • CN 和 O 均为 system:kube-scheduler，kubernetes 内置的 ClusterRoleBindings system:kube-scheduler 将赋予 kube-scheduler 工作所需的权限；

    生成证书和私钥：

    1. $ cd /opt/k8s/work
    2. $ cfssl gencert -ca=/opt/k8s/work/ca.pem \
    3.   -ca-key=/opt/k8s/work/ca-key.pem \
    4.   -config=/opt/k8s/work/ca-config.json \
    5.   -profile=kubernetes kube-scheduler-csr.json | cfssljson -bare kube-scheduler
    6. $ ls kube-scheduler*pem

    将生成的证书和私钥分发到所有 master 节点：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim kube-scheduler-pem.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     scp kube-scheduler*.pem root@${node_ip}:/etc/kubernetes/cert/
    8.   done
    9. $ sh kube-scheduler-pem.sh

    6.4.2 创建和分发 kubeconfig 文件

    kube-scheduler 使用 kubeconfig 文件访问 apiserver，该文件提供了 apiserver 地址、嵌入的 CA 证书和 kube-scheduler 证书：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ kubectl config set-cluster kubernetes \
    4.   --certificate-authority=/opt/k8s/work/ca.pem \
    5.   --embed-certs=true \
    6.   --server="https://10.12.5.60:6443" \
    7.   --kubeconfig=kube-scheduler.kubeconfig
    8.  
    9. $ kubectl config set-credentials system:kube-scheduler \
    10.   --client-certificate=kube-scheduler.pem \
    11.   --client-key=kube-scheduler-key.pem \
    12.   --embed-certs=true \
    13.   --kubeconfig=kube-scheduler.kubeconfig
    14.  
    15. $ kubectl config set-context system:kube-scheduler \
    16.   --cluster=kubernetes \
    17.   --user=system:kube-scheduler \
    18.   --kubeconfig=kube-scheduler.kubeconfig
    19.  
    20. $ kubectl config use-context system:kube-scheduler --kubeconfig=kube-scheduler.kubeconfig

    分发 kubeconfig 到所有 master 节点：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim kube-scheduler.kubeconfig.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     sed -e "s/##NODE_IP##/${node_ip}/" kube-scheduler.kubeconfig > kube-scheduler-${node_ip}.kubeconfig
    8.     scp kube-scheduler-${node_ip}.kubeconfig root@${node_ip}:/etc/kubernetes/kube-scheduler.kubeconfig
    9.   done
    10. $ sh kube-scheduler.kubeconfig.sh

    6.4.3 创建 kube-scheduler 配置文件

    1. $ cd /opt/k8s/work
    2. $ cat >kube-scheduler.yaml.template <
    3. apiVersion: kubescheduler.config.k8s.io/v1alpha1
    4. kind: KubeSchedulerConfiguration
    5. bindTimeoutSeconds: 600
    6. clientConnection:
    7.   burst: 200
    8.   kubeconfig: "/etc/kubernetes/kube-scheduler.kubeconfig"
    9.   qps: 100
    10. enableContentionProfiling: false
    11. enableProfiling: true
    12. hardPodAffinitySymmetricWeight: 1
    13. healthzBindAddress: ##NODE_IP##:10251
    14. leaderElection:
    15.   leaderElect: true
    16. metricsBindAddress: ##NODE_IP##:10251
    17. EOF
    • --kubeconfig：指定 kubeconfig 文件路径，kube-scheduler 使用它连接和验证 kube-apiserver；
    • --leader-elect=true：集群运行模式，启用选举功能；被选为 leader 的节点负责处理工作，其它节点为阻塞状态；

    替换模板文件中的变量：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim kube-scheduler.yaml.sh
    4. for (( i=0; i < 3; i++ ))
    5.   do
    6.     sed -e "s/##NODE_IP##/${NODE_IPS[i]}/" kube-scheduler.yaml.template > kube-scheduler-${NODE_IPS[i]}.yaml
    7.   done
    8. $ sh kube-scheduler.yaml.sh
    9. $ ls kube-scheduler*.yaml
    • NODE_NAMES 和 NODE_IPS 为相同长度的 bash 数组，分别为节点名称和对应的 IP；

    分发 kube-scheduler 配置文件到所有 master 节点：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim deploy-kube-scheduler.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     scp kube-scheduler-${node_ip}.yaml root@${node_ip}:/etc/kubernetes/kube-scheduler.yaml
    8.   done
    9. $ sh deploy-kube-scheduler.sh
    • 重命名为 kube-scheduler.yaml;

    6.4.4 创建 kube-scheduler systemd unit 模板文件

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ cat > kube-scheduler.service.template <
    4. [Unit]
    5. Description=Kubernetes Scheduler
    6. Documentation=https://github.com/GoogleCloudPlatform/kubernetes
    7.  
    8. [Service]
    9. WorkingDirectory=${K8S_DIR}/kube-scheduler
    10. ExecStart=/opt/k8s/bin/kube-scheduler \\
    11.   --config=/etc/kubernetes/kube-scheduler.yaml \\
    12.   --bind-address=10.12.5.60 \\
    13.   --secure-port=10259 \\
    14.   --port=0 \\
    15.   --tls-cert-file=/etc/kubernetes/cert/kube-scheduler.pem \\
    16.   --tls-private-key-file=/etc/kubernetes/cert/kube-scheduler-key.pem \\
    17.   --authentication-kubeconfig=/etc/kubernetes/kube-scheduler.kubeconfig \\
    18.   --client-ca-file=/etc/kubernetes/cert/ca.pem \\
    19.   --requestheader-allowed-names="" \\
    20.   --requestheader-client-ca-file=/etc/kubernetes/cert/ca.pem \\
    21.   --requestheader-extra-headers-prefix="X-Remote-Extra-" \\
    22.   --requestheader-group-headers=X-Remote-Group \\
    23.   --requestheader-username-headers=X-Remote-User \\
    24.   --authorization-kubeconfig=/etc/kubernetes/kube-scheduler.kubeconfig \\
    25.   --logtostderr=true \\
    26.   --v=2
    27. Restart=always
    28. RestartSec=5
    29. StartLimitInterval=0
    30.  
    31. [Install]
    32. WantedBy=multi-user.target
    33. EOF

    6.4.5 为各节点创建和分发 kube-scheduler systemd unit 文件

    替换模板文件中的变量，为各节点创建 systemd unit 文件：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim modifyip.sh
    4. for (( i=0; i < 3; i++ ))
    5.   do
    6.     sed -e "s/##NODE_IP##/${NODE_IPS[i]}/g" kube-scheduler.service.template > kube-scheduler-${NODE_IPS[i]}.service 
    7.   done
    8. $ sh modifyip.sh
    9. $ ls kube-scheduler*.service

    分发 systemd unit 文件到所有 master 节点：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim scp_kube_scheduler.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     scp kube-scheduler-${node_ip}.service root@${node_ip}:/etc/systemd/system/kube-scheduler.service
    8.   done
    9. $ sh scp_kube_scheduler.sh

    6.4.6 启动 kube-scheduler 服务

    1. $ source /opt/k8s/bin/environment.sh
    2. $ vim start_kube-scheduler.sh
    3. for node_ip in ${NODE_IPS[@]}
    4.   do
    5.     echo ">>> ${node_ip}"
    6.     ssh root@${node_ip} "mkdir -p ${K8S_DIR}/kube-scheduler"
    7.     ssh root@${node_ip} "systemctl daemon-reload && systemctl enable kube-scheduler && systemctl restart kube-scheduler"
    8.   done
    9. $ sh start_kube-scheduler.sh

    6.4.7 检查服务运行状态

    1. $ source /opt/k8s/bin/environment.sh
    2. $ vim check_kube_scheduler.sh
    3. for node_ip in ${NODE_IPS[@]}
    4.   do
    5.     echo ">>> ${node_ip}"
    6.     ssh root@${node_ip} "systemctl status kube-scheduler|grep Active"
    7.   done
    8. $ sh check_kube_scheduler.sh

    确保状态为 active (running)，否则查看日志，确认原因：

    $ journalctl -u kube-scheduler

    6.4.8 查看输出的 metrics

    以下命令在 kube-scheduler 节点上执行。

    kube-scheduler 监听 10251 和 10259 端口：

    • 10251：接收 http 请求，非安全端口，不需要认证授权；
    • 10259：接收 https 请求，安全端口，需要认证授权；

    两个接口都对外提供 /metrics 和 /healthz 的访问。

    1. $ sudo netstat -lnpt |grep kube-sch
    2. tcp        0      0 172.27.138.251:10251    0.0.0.0:*               LISTEN      114702/kube-schedul
    3. tcp        0      0 172.27.138.251:10259    0.0.0.0:*               LISTEN      114702/kube-schedul
    1. $ curl -s http://10.12.5.60:10251/metrics |head
    2. # HELP apiserver_audit_event_total Counter of audit events generated and sent to the audit backend.
    3. # TYPE apiserver_audit_event_total counter
    4. apiserver_audit_event_total 0
    5. # HELP apiserver_audit_requests_rejected_total Counter of apiserver requests rejected due to an error in audit logging backend.
    6. # TYPE apiserver_audit_requests_rejected_total counter
    7. apiserver_audit_requests_rejected_total 0
    8. # HELP apiserver_client_certificate_expiration_seconds Distribution of the remaining lifetime on the certificate used to authenticate a request.
    9. # TYPE apiserver_client_certificate_expiration_seconds histogram
    10. apiserver_client_certificate_expiration_seconds_bucket{le="0"} 0
    11. apiserver_client_certificate_expiration_seconds_bucket{le="1800"} 0
    1. $ curl -s --cacert /opt/k8s/work/ca.pem --cert /opt/k8s/work/admin.pem --key /opt/k8s/work/admin-key.pem https://10.12.5.60:10259/metrics |head
    2. # HELP apiserver_audit_event_total Counter of audit events generated and sent to the audit backend.
    3. # TYPE apiserver_audit_event_total counter
    4. apiserver_audit_event_total 0
    5. # HELP apiserver_audit_requests_rejected_total Counter of apiserver requests rejected due to an error in audit logging backend.
    6. # TYPE apiserver_audit_requests_rejected_total counter
    7. apiserver_audit_requests_rejected_total 0
    8. # HELP apiserver_client_certificate_expiration_seconds Distribution of the remaining lifetime on the certificate used to authenticate a request.
    9. # TYPE apiserver_client_certificate_expiration_seconds histogram
    10. apiserver_client_certificate_expiration_seconds_bucket{le="0"} 0
    11. apiserver_client_certificate_expiration_seconds_bucket{le="1800"} 0

    6.4.9 查看当前的 leader

    1. $ kubectl get endpoints kube-scheduler --namespace=kube-system  -o yaml
    2. apiVersion: v1
    3. kind: Endpoints
    4. metadata:
    5.   annotations:
    6.     control-plane.alpha.kubernetes.io/leader: '{"holderIdentity":"sre-master-node_db4abcee-ed07-494a-8807-c372614f1166","leaseDurationSeconds":15,"acquireTime":"2023-09-21T14:07:58Z","renewTime":"2023-09-21T14:26:24Z","leaderTransitions":0}'
    7.   creationTimestamp: "2023-09-21T14:07:58Z"
    8.   name: kube-scheduler
    9.   namespace: kube-system
    10.   resourceVersion: "238704"
    11.   selfLink: /api/v1/namespaces/kube-system/endpoints/kube-scheduler
    12.   uid: c842d6a8-79a6-4f4c-8fdc-a9e1514b12c0

    可见，当前的 leader 为sre-master-node节点。

    6.4.10 测试 kube-scheduler 集群的高可用

    随便找一个或两个 master 节点，停掉 kube-scheduler 服务，看其它节点是否获取了 leader 权限。

    1. # 停掉sre-master-node的kube-scheduler
    2. $ systemctl stop kube-scheduler
    3. $ kubectl get endpoints kube-scheduler --namespace=kube-system  -o yaml
    4. apiVersion: v1
    5. kind: Endpoints
    6. metadata:
    7.   annotations:
    8.     control-plane.alpha.kubernetes.io/leader: '{"holderIdentity":"sre-worker-node-1_f56cd8ea-0cab-4f96-90e2-1258422d0a86","leaseDurationSeconds":15,"acquireTime":"2023-09-21T14:27:15Z","renewTime":"2023-09-21T14:27:17Z","leaderTransitions":1}'
    9.   creationTimestamp: "2023-09-21T14:07:58Z"
    10.   name: kube-scheduler
    11.   namespace: kube-system
    12.   resourceVersion: "238768"
    13.   selfLink: /api/v1/namespaces/kube-system/endpoints/kube-scheduler
    14.   uid: c842d6a8-79a6-4f4c-8fdc-a9e1514b12c0
    15. # leader主节点切换到了sre-worker-node-1

    7 部署worker节点

    kubernetes worker 节点运行如下组件：

    • containerd
    • kubelet
    • kube-proxy
    • calico
    • kube-nginx

    如果没有特殊指明，本文档的所有操作均在sre-master-node节点上执行。

    7.1 安装依赖包

    1. $ source /opt/k8s/bin/environment.sh
    2. $ vim install_base_pkg.sh
    3. for node_ip in ${NODE_IPS[@]}
    4.   do
    5.     echo ">>> ${node_ip}"
    6.     ssh root@${node_ip} "yum install -y epel-release" &
    7.     ssh root@${node_ip} "yum install -y chrony conntrack ipvsadm ipset jq iptables curl sysstat libseccomp wget socat git" &
    8.   done
    9. $ sh install_base_pkg.sh

    7.2 apiserver高可用

    本章节讲解使用 nginx 4 层透明代理功能实现 Kubernetes worker 节点组件高可用访问 kube-apiserver 集群的步骤。

    如果没有特殊指明，本文档的所有操作均在sre-master-node节点上执行。

    7.2.1 基于nginx代理的kube-apiserver高可用方案

    • 控制节点的 kube-controller-manager、kube-scheduler 是多实例部署且连接本机的 kube-apiserver，所以只要有一个实例正常，就可以保证高可用；
    • 集群内的 Pod 使用 K8S 服务域名 kubernetes 访问 kube-apiserver， kube-dns 会自动解析出多个 kube-apiserver 节点的 IP，所以也是高可用的；
    • 在每个节点起一个 nginx 进程，后端对接多个 apiserver 实例，nginx 对它们做健康检查和负载均衡；
    • kubelet、kube-proxy 通过本地的 nginx（监听 127.0.0.1）访问 kube-apiserver，从而实现 kube-apiserver 的高可用；

    7.2.2 下载和编译nginx

    下载源码：

    1. $ cd /opt/k8s/work
    2. $ wget http://nginx.org/download/nginx-1.15.3.tar.gz
    3. $ tar -xzvf nginx-1.15.3.tar.gz

    配置编译参数：

    1. $ cd /opt/k8s/work/nginx-1.15.3
    2. $ mkdir -p /opt/k8s/work/nginx
    3. $ yum install -y gcc make
    4. $ ./configure --with-stream --without-http --prefix=/opt/k8s/work/nginx --without-http_uwsgi_module --without-http_scgi_module --without-http_fastcgi_module
    • --with-stream：开启 4 层透明转发(TCP Proxy)功能；
    • --without-xxx：关闭所有其他功能，这样生成的动态链接二进制程序依赖最小；

    输出：

    1. Configuration summary
    2.   + PCRE library is not used
    3.   + OpenSSL library is not used
    4.   + zlib library is not used
    5.  
    6.   nginx path prefix: "/opt/k8s/work/nginx"
    7.   nginx binary file: "/opt/k8s/work/nginx/sbin/nginx"
    8.   nginx modules path: "/opt/k8s/work/nginx/modules"
    9.   nginx configuration prefix: "/opt/k8s/work/nginx/conf"
    10.   nginx configuration file: "/opt/k8s/work/nginx/conf/nginx.conf"
    11.   nginx pid file: "/opt/k8s/work/nginx/logs/nginx.pid"
    12.   nginx error log file: "/opt/k8s/work/nginx/logs/error.log"
    13.   nginx http access log file: "/opt/k8s/work/nginx/logs/access.log"
    14.   nginx http client request body temporary files: "client_body_temp"
    15.   nginx http proxy temporary files: "proxy_temp"

    编译和安装：

    1. cd /opt/k8s/work/nginx-1.15.3
    2. make && make install

    7.2.3 验证编译的nginx

    1. $ cd /opt/k8s/work/nginx
    2. $ ./sbin/nginx -v

    输出：

    nginx version: nginx/1.15.3

    7.2.4 配置nginx

    配置 nginx，开启 4 层透明转发功能：

    1. $ cd /opt/k8s/work/nginx/conf
    2. $ cat > nginx.conf << \EOF
    3. worker_processes 1;
    4.  
    5. events {
    6.     worker_connections  1024;
    7. }
    8.  
    9. stream {
    10.     upstream backend {
    11.         hash $remote_addr consistent;
    12.         server 10.12.5.60:6443        max_fails=3 fail_timeout=30s;
    13.         server 10.12.5.61:6443        max_fails=3 fail_timeout=30s;
    14.         server 10.12.5.62:6443        max_fails=3 fail_timeout=30s;
    15.     }
    16.  
    17.     server {
    18.         listen 127.0.0.1:8443;
    19.         proxy_connect_timeout 1s;
    20.         proxy_pass backend;
    21.     }
    22. }
    23. EOF
    • upstream backend 中的 server 列表为集群中各 kube-apiserver 的节点 IP，需要根据实际情况修改；

    分发配置文件：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim nginx_conf.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     scp nginx.conf  root@${node_ip}:/opt/k8s/nginx/conf/nginx.conf
    8.   done
    9. $ sh nginx_conf.sh

    7.2.5 配置systemd unit 文件，启动服务

    配置 kube-nginx systemd unit 文件：

    1. $ cd /opt/k8s/work
    2. $ cat > nginx.service <<EOF
    3. [Unit]
    4. Description=kube-apiserver nginx proxy
    5. After=network.target
    6. After=network-online.target
    7. Wants=network-online.target
    8.  
    9. [Service]
    10. Type=forking
    11. ExecStartPre=/opt/k8s/work/nginx/sbin/nginx -c /opt/k8s/work/nginx/conf/nginx.conf -p /opt/k8s/work/nginx -t
    12. ExecStart=/opt/k8s/work/nginx/sbin/nginx -c /opt/k8s/work/nginx/conf/nginx.conf -p /opt/k8s/work/nginx
    13. ExecReload=/opt/k8s/work/nginx/sbin/nginx -c /opt/k8s/work/nginx/conf/nginx.conf -p /opt/k8s/work/nginx -s reload
    14. PrivateTmp=true
    15. Restart=always
    16. RestartSec=5
    17. StartLimitInterval=0
    18. LimitNOFILE=65536
    19.  
    20. [Install]
    21. WantedBy=multi-user.target
    22. EOF

    分发 systemd unit 文件：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim scp_kube_nginx.sh 
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     scp nginx.service  root@${node_ip}:/etc/systemd/system/
    8.   done
    9. $ sh scp_kube_nginx.sh

    启动 kube-nginx 服务：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim start_kube_nginx.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     ssh root@${node_ip} "systemctl daemon-reload && systemctl enable nginx && systemctl restart nginx"
    8.   done
    9. $ sh start_kube_nginx.sh

    7.2.6 检查nginx的状态

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim check_nginx.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     ssh root@${node_ip} "systemctl status nginx |grep 'Active:'"
    8.   done
    9. $ sh check_nginx.sh

    确保状态为 active (running)，否则查看日志，确认原因：

    $ journalctl -u kube-nginx

    7.3 部署containerd组件

    containerd 实现了 kubernetes 的 Container Runtime Interface (CRI) 接口，提供容器运行时核心功能，如镜像管理、容器管理等，相比 dockerd 更加简单、健壮和可移植。

    1. 如果没有特殊指明，本章节的所有操作均在节点上sre-master-node执行。
    2. 如果想使用 docker，请参考附件 F.部署docker.md；
    3. docker 需要与 flannel 配合使用，且先安装 flannel；

    7.3.1 下载二进制文件

    下载二进制文件：

    1. $ cd /opt/k8s/work
    2. $ wget https://github.com/kubernetes-sigs/cri-tools/releases/download/v1.17.0/crictl-v1.17.0-linux-amd64.tar.gz \
    3.   https://github.com/opencontainers/runc/releases/download/v1.0.0-rc10/runc.amd64 \
    4.   https://github.com/containernetworking/plugins/releases/download/v0.8.5/cni-plugins-linux-amd64-v0.8.5.tgz \
    5.   https://github.com/containerd/containerd/releases/download/v1.3.3/containerd-1.3.3.linux-amd64.tar.gz

    解压：

    1. $ cd /opt/k8s/work
    2. $ mkdir containerd
    3. $ tar -xvf containerd-1.3.3.linux-amd64.tar.gz -C containerd
    4. $ tar -xvf crictl-v1.17.0-linux-amd64.tar.gz
    5.  
    6. $ mkdir cni-plugins
    7. $ sudo tar -xvf cni-plugins-linux-amd64-v0.8.5.tgz -C cni-plugins
    8.  
    9. $ sudo mv runc.amd64 runc

    7.3.2 分发二进制文件

    分发二进制文件到所有 worker 节点

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim scp_containerd.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     scp containerd/bin/*  crictl  cni-plugins/*  runc  root@${node_ip}:/opt/k8s/bin
    8.     ssh root@${node_ip} "chmod a+x /opt/k8s/bin/* && mkdir -p /etc/cni/net.d"
    9.   done
    10. $ sh scp_containerd.sh

    7.3.2 创建分发containerd配置文件

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ cat << EOF | sudo tee containerd-config.toml
    4. version = 2
    5. root = "${CONTAINERD_DIR}/root"
    6. state = "${CONTAINERD_DIR}/state"
    7. [plugins]
    8.   [plugins."io.containerd.grpc.v1.cri"]
    9.     sandbox_image = "registry.cn-beijing.aliyuncs.com/zhoujun/pause-amd64:3.1"
    10.     [plugins."io.containerd.grpc.v1.cri".cni]
    11.       bin_dir = "/opt/k8s/bin"
    12.       conf_dir = "/etc/cni/net.d"
    13.   [plugins."io.containerd.runtime.v1.linux"]
    14.     shim = "containerd-shim"
    15.     runtime = "runc"
    16.     runtime_root = ""
    17.     no_shim = false
    18.     shim_debug = false
    19. EOF
    20. $ cd /opt/k8s/work
    21. $ source /opt/k8s/bin/environment.sh
    22. $ vim containerd-config.sh 
    23. for node_ip in ${NODE_IPS[@]}
    24.   do
    25.     echo ">>> ${node_ip}"
    26.     ssh root@${node_ip} "mkdir -p /etc/containerd/ ${CONTAINERD_DIR}/{root,state}"
    27.     scp containerd-config.toml root@${node_ip}:/etc/containerd/config.toml
    28.   done
    29. $ sh containerd-config.sh

    7.3.4 创建containerd systemd unit文件 

    1. $ cd /opt/k8s/work
    2. $ cat <<EOF | sudo tee containerd.service
    3. [Unit]
    4. Description=containerd container runtime
    5. Documentation=https://containerd.io
    6. After=network.target
    7. [Service]
    8. Environment="PATH=/opt/k8s/bin:/bin:/sbin:/usr/bin:/usr/sbin"
    9. ExecStartPre=/sbin/modprobe overlay
    10. ExecStart=/opt/k8s/bin/containerd
    11. Restart=always
    12. RestartSec=5
    13. Delegate=yes
    14. KillMode=process
    15. OOMScoreAdjust=-999
    16. LimitNOFILE=1048576
    17. LimitNPROC=infinity
    18. LimitCORE=infinity
    19. [Install]
    20. WantedBy=multi-user.target
    21. EOF

    7.3.5 启动containerd

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim containerd_service.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     scp containerd.service root@${node_ip}:/etc/systemd/system
    8.     ssh root@${node_ip} "systemctl enable containerd && systemctl restart containerd"
    9.   done
    10. $ sh containerd_service.sh

    7.3.6 创建和分发crictl配置文件

    crictl 是兼容 CRI 容器运行时的命令行工具，提供类似于 docker 命令的功能。具体参考官方文档。

    1. $ cd /opt/k8s/work
    2. $ cat << EOF | sudo tee crictl.yaml
    3. runtime-endpoint: unix:///run/containerd/containerd.sock
    4. image-endpoint: unix:///run/containerd/containerd.sock
    5. timeout: 10
    6. debug: false
    7. EOF

    分发到所有 worker 节点：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim crictl_yaml.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     scp crictl.yaml root@${node_ip}:/etc/crictl.yaml
    8.   done
    9. $ sh crictl_yaml.sh

    7.4 部署kubelet

    kubelet 运行在每个 worker 节点上，接收 kube-apiserver 发送的请求，管理 Pod 容器，执行交互式命令，如 exec、run、logs 等。

    kubelet 启动时自动向 kube-apiserver 注册节点信息，内置的 cadvisor 统计和监控节点的资源使用情况。

    为确保安全，部署时关闭了 kubelet 的非安全 http 端口，对请求进行认证和授权，拒绝未授权的访问(如 apiserver、heapster 的请求)。

    如果没有特殊指明，本文档的所有操作均在sre-master-node节点上执行。

    7.4.1 下载和分发kubelet二进制文件

    参考章节6.1-下载最新版本二进制文件。

    7.4.2 创建kubelet bootstrap kubeconfig 文件

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim config_k8s.sh
    4. for node_name in ${NODE_NAMES[@]}
    5.   do
    6.     echo ">>> ${node_name}"
    7.  
    8.     # 创建 token
    9.     export BOOTSTRAP_TOKEN=$(kubeadm token create \
    10.       --description kubelet-bootstrap-token \
    11.       --groups system:bootstrappers:${node_name} \
    12.       --kubeconfig ~/.kube/config)
    13.  
    14.     # 设置集群参数
    15.     kubectl config set-cluster kubernetes \
    16.       --certificate-authority=/etc/kubernetes/cert/ca.pem \
    17.       --embed-certs=true \
    18.       --server=${KUBE_APISERVER} \
    19.       --kubeconfig=kubelet-bootstrap-${node_name}.kubeconfig
    20.  
    21.     # 设置客户端认证参数
    22.     kubectl config set-credentials kubelet-bootstrap \
    23.       --token=${BOOTSTRAP_TOKEN} \
    24.       --kubeconfig=kubelet-bootstrap-${node_name}.kubeconfig
    25.  
    26.     # 设置上下文参数
    27.     kubectl config set-context default \
    28.       --cluster=kubernetes \
    29.       --user=kubelet-bootstrap \
    30.       --kubeconfig=kubelet-bootstrap-${node_name}.kubeconfig
    31.  
    32.     # 设置默认上下文
    33.     kubectl config use-context default --kubeconfig=kubelet-bootstrap-${node_name}.kubeconfig
    34.   done
    35. $ sh config_k8s.sh
    • 向 kubeconfig 写入的是 token，bootstrap 结束后 kube-controller-manager 为 kubelet 创建 client 和 server 证书；

    查看 kubeadm 为各节点创建的 token：

    • token 有效期为 1 天，超期后将不能再被用来 boostrap kubelet，且会被 kube-controller-manager 的 tokencleaner 清理；
    • kube-apiserver 接收 kubelet 的 bootstrap token 后，将请求的 user 设置为 system:bootstrap:，group 设置为 system:bootstrappers，后续将为这个 group 设置 ClusterRoleBinding；

    7.4.3 分发bootstrap kubeconfig 文件到所有worker节点 

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim kubelet_config.sh
    4. for node_name in ${NODE_NAMES[@]}
    5.   do
    6.     echo ">>> ${node_name}"
    7.     scp kubelet-bootstrap-${node_name}.kubeconfig root@${node_name}:/etc/kubernetes/kubelet-bootstrap.kubeconfig
    8.   done
    9. $ sh kubelet_config.sh

    7.4.4 创建和分发kubelet参数配置文件

    从 v1.10 开始，部分 kubelet 参数需在配置文件中配置，kubelet --help 会提示：

    DEPRECATED: This parameter should be set via the config file specified by the Kubelet's --config flag

    创建 kubelet 参数配置文件模板（可配置项参考代码中注释）：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ cat > kubelet-config.yaml.template <<EOF
    4. kind: KubeletConfiguration
    5. apiVersion: kubelet.config.k8s.io/v1beta1
    6. address: "##NODE_IP##"
    7. staticPodPath: ""
    8. syncFrequency: 1m
    9. fileCheckFrequency: 20s
    10. httpCheckFrequency: 20s
    11. staticPodURL: ""
    12. port: 10250
    13. readOnlyPort: 0
    14. rotateCertificates: true
    15. serverTLSBootstrap: true
    16. authentication:
    17.   anonymous:
    18.     enabled: false
    19.   webhook:
    20.     enabled: true
    21.   x509:
    22.     clientCAFile: "/etc/kubernetes/cert/ca.pem"
    23. authorization:
    24.   mode: Webhook
    25. registryPullQPS: 0
    26. registryBurst: 20
    27. eventRecordQPS: 0
    28. eventBurst: 20
    29. enableDebuggingHandlers: true
    30. enableContentionProfiling: true
    31. healthzPort: 10248
    32. healthzBindAddress: "##NODE_IP##"
    33. clusterDomain: "${CLUSTER_DNS_DOMAIN}"
    34. clusterDNS:
    35.   - "${CLUSTER_DNS_SVC_IP}"
    36. nodeStatusUpdateFrequency: 10s
    37. nodeStatusReportFrequency: 1m
    38. imageMinimumGCAge: 2m
    39. imageGCHighThresholdPercent: 85
    40. imageGCLowThresholdPercent: 80
    41. volumeStatsAggPeriod: 1m
    42. kubeletCgroups: ""
    43. systemCgroups: ""
    44. cgroupRoot: ""
    45. cgroupsPerQOS: true
    46. cgroupDriver: cgroupfs
    47. runtimeRequestTimeout: 10m
    48. hairpinMode: promiscuous-bridge
    49. maxPods: 220
    50. podCIDR: "${CLUSTER_CIDR}"
    51. podPidsLimit: -1
    52. resolvConf: /etc/resolv.conf
    53. maxOpenFiles: 1000000
    54. kubeAPIQPS: 1000
    55. kubeAPIBurst: 2000
    56. serializeImagePulls: false
    57. evictionHard:
    58.   memory.available:  "100Mi"
    59.   nodefs.available:  "10%"
    60.   nodefs.inodesFree: "5%"
    61.   imagefs.available: "15%"
    62. evictionSoft: {}
    63. enableControllerAttachDetach: true
    64. failSwapOn: true
    65. containerLogMaxSize: 20Mi
    66. containerLogMaxFiles: 10
    67. systemReserved: {}
    68. kubeReserved: {}
    69. systemReservedCgroup: ""
    70. kubeReservedCgroup: ""
    71. enforceNodeAllocatable: ["pods"]
    72. EOF
    • address：kubelet 安全端口（https，10250）监听的地址，不能为 127.0.0.1，否则 kube-apiserver、heapster 等不能调用 kubelet 的 API；
    • readOnlyPort=0：关闭只读端口(默认 10255)，等效为未指定；
    • authentication.anonymous.enabled：设置为 false，不允许匿名�访问 10250 端口；
    • authentication.x509.clientCAFile：指定签名客户端证书的 CA 证书，开启 HTTP 证书认证；
    • authentication.webhook.enabled=true：开启 HTTPs bearer token 认证；
    • 对于未通过 x509 证书和 webhook 认证的请求(kube-apiserver 或其他客户端)，将被拒绝，提示 Unauthorized；
    • authroization.mode=Webhook：kubelet 使用 SubjectAccessReview API 查询 kube-apiserver 某 user、group 是否具有操作资源的权限(RBAC)；
    • featureGates.RotateKubeletClientCertificate、featureGates.RotateKubeletServerCertificate：自动 rotate 证书，证书的有效期取决于 kube-controller-manager 的 --experimental-cluster-signing-duration 参数；
    • 需要 root 账户运行；

    为各节点创建和分发 kubelet 配置文件：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim kubelet_config_yaml.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do 
    6.     echo ">>> ${node_ip}"
    7.     sed -e "s/##NODE_IP##/${node_ip}/" kubelet-config.yaml.template > kubelet-config-${node_ip}.yaml.template
    8.     scp kubelet-config-${node_ip}.yaml.template root@${node_ip}:/etc/kubernetes/kubelet-config.yaml
    9.   done
    10. # sh kubelet_config_yaml.sh

    7.4.5 创建和分发kubelet systemd unit文件

    创建 kubelet systemd unit 文件模板：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ cat > kubelet.service.template <<EOF
    4. [Unit]
    5. Description=Kubernetes Kubelet
    6. Documentation=https://github.com/GoogleCloudPlatform/kubernetes
    7. After=containerd.service
    8. Requires=containerd.service
    9.  
    10. [Service]
    11. WorkingDirectory=${K8S_DIR}/kubelet
    12. ExecStart=/opt/k8s/bin/kubelet \\
    13.   --bootstrap-kubeconfig=/etc/kubernetes/kubelet-bootstrap.kubeconfig \\
    14.   --cert-dir=/etc/kubernetes/cert \\
    15.   --network-plugin=cni \\
    16.   --cni-conf-dir=/etc/cni/net.d \\
    17.   --container-runtime=remote \\
    18.   --container-runtime-endpoint=unix:///var/run/containerd/containerd.sock \\
    19.   --root-dir=${K8S_DIR}/kubelet \\
    20.   --kubeconfig=/etc/kubernetes/kubelet.kubeconfig \\
    21.   --config=/etc/kubernetes/kubelet-config.yaml \\
    22.   --hostname-override=##NODE_NAME## \\
    23.   --image-pull-progress-deadline=15m \\
    24.   --volume-plugin-dir=${K8S_DIR}/kubelet/kubelet-plugins/volume/exec/ \\
    25.   --logtostderr=true \\
    26.   --v=2
    27. Restart=always
    28. RestartSec=5
    29. StartLimitInterval=0
    30.  
    31. [Install]
    32. WantedBy=multi-user.target
    33. EOF
    • 如果设置了 --hostname-override 选项，则 kube-proxy 也需要设置该选项，否则会出现找不到 Node 的情况；
    • --bootstrap-kubeconfig：指向 bootstrap kubeconfig 文件，kubelet 使用该文件中的用户名和 token 向 kube-apiserver 发送 TLS Bootstrapping 请求；
    • K8S approve kubelet 的 csr 请求后，在 --cert-dir 目录创建证书和私钥文件，然后写入 --kubeconfig 文件；
    • --pod-infra-container-image 不使用 redhat 的 pod-infrastructure:latest 镜像，它不能回收容器的僵尸；

    为各节点创建和分发 kubelet systemd unit 文件：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim kubelet_service.sh
    4. for node_name in ${NODE_NAMES[@]}
    5.   do 
    6.     echo ">>> ${node_name}"
    7.     sed -e "s/##NODE_NAME##/${node_name}/" kubelet.service.template > kubelet-${node_name}.service
    8.     scp kubelet-${node_name}.service root@${node_name}:/etc/systemd/system/kubelet.service
    9.   done
    10. $ sh kubelet_service.sh

    7.4.6 授予kube-apiserver 访问kubelet API的权限

    在执行 kubectl exec、run、logs 等命令时，apiserver 会将请求转发到 kubelet 的 https 端口。这里定义 RBAC 规则，授权 apiserver 使用的证书（kubernetes.pem）用户名（CN：kuberntes-master）访问 kubelet API 的权限：

    $ kubectl create clusterrolebinding kube-apiserver:kubelet-apis --clusterrole=system:kubelet-api-admin --user kubernetes-master

    7.4.7 bootstrap Token Auth和授予权限

    kubelet 启动时查找 --kubeletconfig 参数对应的文件是否存在，如果不存在则使用 --bootstrap-kubeconfig 指定的 kubeconfig 文件向 kube-apiserver 发送证书签名请求 (CSR)。

    kube-apiserver 收到 CSR 请求后，对其中的 Token 进行认证，认证通过后将请求的 user 设置为 system:bootstrap:，group 设置为 system:bootstrappers，这一过程称为 Bootstrap Token Auth。

    默认情况下，这个 user 和 group 没有创建 CSR 的权限，kubelet 启动失败，错误日志如下：

    1. $ sudo journalctl -u kubelet -a |grep -A 2 'certificatesigningrequests'
    2. May 26 12:13:41 zhangjun-k8s-01 kubelet[128468]: I0526 12:13:41.798230  128468 certificate_manager.go:366] Rotating certificates
    3. May 26 12:13:41 zhangjun-k8s-01 kubelet[128468]: E0526 12:13:41.801997  128468 certificate_manager.go:385] Failed while requesting a signed certificate from the master: cannot create certificate signing request: certificatesigningrequests.certificates.k8s.io is forbidden: User "system:bootstrap:82jfrm" cannot create resource "certificatesigningrequests" in API group "certificates.k8s.io" at the cluster scope

    解决办法是：创建一个 clusterrolebinding，将 group system:bootstrappers 和 clusterrole system:node-bootstrapper 绑定：

    $ kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --group=system:bootstrappers

    7.4.8 自动approve  CSR请求，生成kubelet client证书

    kubelet 创建 CSR 请求后，下一步需要创建被 approve，有两种方式：

    1. kube-controller-manager 自动 aprrove；
    2. 手动使用命令 kubectl certificate approve；

    CSR 被 approve 后，kubelet 向 kube-controller-manager 请求创建 client 证书，kube-controller-manager 中的 csrapproving controller 使用 SubjectAccessReview API 来检查 kubelet 请求（对应的 group 是 system:bootstrappers）是否具有相应的权限。

    创建三个 ClusterRoleBinding，分别授予 group system:bootstrappers 和 group system:nodes 进行 approve client、renew client、renew server 证书的权限（server csr 是手动 approve 的，见后文）：

    1. $ cd /opt/k8s/work
    2. $ cat > csr-crb.yaml <<EOF
    3.  # Approve all CSRs for the group "system:bootstrappers"
    4.  kind: ClusterRoleBinding
    5.  apiVersion: rbac.authorization.k8s.io/v1
    6.  metadata:
    7.    name: auto-approve-csrs-for-group
    8.  subjects:
    9.  - kind: Group
    10.    name: system:bootstrappers
    11.    apiGroup: rbac.authorization.k8s.io
    12.  roleRef:
    13.    kind: ClusterRole
    14.    name: system:certificates.k8s.io:certificatesigningrequests:nodeclient
    15.    apiGroup: rbac.authorization.k8s.io
    16. ---
    17.  # To let a node of the group "system:nodes" renew its own credentials
    18.  kind: ClusterRoleBinding
    19.  apiVersion: rbac.authorization.k8s.io/v1
    20.  metadata:
    21.    name: node-client-cert-renewal
    22.  subjects:
    23.  - kind: Group
    24.    name: system:nodes
    25.    apiGroup: rbac.authorization.k8s.io
    26.  roleRef:
    27.    kind: ClusterRole
    28.    name: system:certificates.k8s.io:certificatesigningrequests:selfnodeclient
    29.    apiGroup: rbac.authorization.k8s.io
    30. ---
    31. # A ClusterRole which instructs the CSR approver to approve a node requesting a
    32. # serving cert matching its client cert.
    33. kind: ClusterRole
    34. apiVersion: rbac.authorization.k8s.io/v1
    35. metadata:
    36.   name: approve-node-server-renewal-csr
    37. rules:
    38. - apiGroups: ["certificates.k8s.io"]
    39.   resources: ["certificatesigningrequests/selfnodeserver"]
    40.   verbs: ["create"]
    41. ---
    42.  # To let a node of the group "system:nodes" renew its own server credentials
    43.  kind: ClusterRoleBinding
    44.  apiVersion: rbac.authorization.k8s.io/v1
    45.  metadata:
    46.    name: node-server-cert-renewal
    47.  subjects:
    48.  - kind: Group
    49.    name: system:nodes
    50.    apiGroup: rbac.authorization.k8s.io
    51.  roleRef:
    52.    kind: ClusterRole
    53.    name: approve-node-server-renewal-csr
    54.    apiGroup: rbac.authorization.k8s.io
    55. EOF
    56. kubectl apply -f csr-crb.yaml
    • auto-approve-csrs-for-group：自动 approve node 的第一次 CSR； 注意第一次 CSR 时，请求的 Group 为 system:bootstrappers；
    • node-client-cert-renewal：自动 approve node 后续过期的 client 证书，自动生成的证书 Group 为 system:nodes;
    • node-server-cert-renewal：自动 approve node 后续过期的 server 证书，自动生成的证书 Group 为 system:nodes;

    7.4.9 启动kubelet服务

    1. $ source /opt/k8s/bin/environment.sh
    2. $ vim start_kubelet.sh
    3. for node_ip in ${NODE_IPS[@]}
    4.   do
    5.     echo ">>> ${node_ip}"
    6.     ssh root@${node_ip} "mkdir -p ${K8S_DIR}/kubelet/kubelet-plugins/volume/exec/"
    7.     ssh root@${node_ip} "/usr/sbin/swapoff -a"
    8.     ssh root@${node_ip} "systemctl daemon-reload && systemctl enable kubelet && systemctl restart kubelet"
    9.   done
    10. $ sh start_kubelet.sh
    • 启动服务前必须先创建工作目录；
    • 关闭 swap 分区，否则 kubelet 会启动失败；

    kubelet 启动后使用 --bootstrap-kubeconfig 向 kube-apiserver 发送 CSR 请求，当这个 CSR 被 approve 后，kube-controller-manager 为 kubelet 创建 TLS 客户端证书、私钥和 --kubeletconfig 文件。

    注意

    kube-controller-manager 需要配置 --cluster-signing-cert-file 和 --cluster-signing-key-file 参数，才会为 TLS Bootstrap 创建证书和私钥。

    7.4.10 查看kubelet情况

    稍等一会，三个节点的 CSR 都被自动 approved：

    1. $ kubectl get csr
    2. NAME        AGE   REQUESTOR                     CONDITION
    3. csr-5rwzm   43s   system:node:sre-master-node   Pending
    4. csr-65nms   55s   system:bootstrap:2sb8wy       Approved,Issued
    5. csr-8t5hj   42s   system:node:sre-worker-node-1 Pending
    6. csr-jkhhs   41s   system:node:sre-worker-node-2 Pending
    7. csr-jv7dn   56s   system:bootstrap:ta7onm       Approved,Issued
    8. csr-vb6p5   54s   system:bootstrap:xk27zp       Approved,Issued
    • Pending 的 CSR 用于创建 kubelet server 证书，需要手动 approve，参考后文。

    所有节点均注册（NotReady 状态是预期的，后续安装了网络插件后就好）：

    1. $ kubectl get node
    2. NAME              STATUS     ROLES    AGE   VERSION
    3. sre-master-node   NotReady   <none>   10h   v1.16.6
    4. sre-worker-node-1 NotReady   <none>   10h   v1.16.6
    5. sre-worker-node-2 NotReady   <none>   10h   v1.16.6

    kube-controller-manager 为各 node 生成了 kubeconfig 文件和公私钥：

    1. $ ls -l /etc/kubernetes/kubelet.kubeconfig
    2. -rw------- 1 root root 2246 Feb  7 15:38 /etc/kubernetes/kubelet.kubeconfig
    3.  
    4. $ ls -l /etc/kubernetes/cert/kubelet-client-*
    5. -rw------- 1 root root 1281 Feb  7 15:38 /etc/kubernetes/cert/kubelet-client-2020-02-07-15-38-21.pem
    6. lrwxrwxrwx 1 root root   59 Feb  7 15:38 /etc/kubernetes/cert/kubelet-client-current.pem -> /etc/kubernetes/cert/kubelet-client-2020-02-07-15-38-21.pem
    • 没有自动生成 kubelet server 证书；

    7.4.11 手动approve server cert csr

    基于安全性考虑，CSR approving controllers 不会自动 approve kubelet server 证书签名请求，需要手动 approve：

    1. $ kubectl get csr
    2. NAME        AGE   REQUESTOR                     CONDITION
    3. csr-5rwzm   43s   system:node:sre-master-node   Pending
    4. csr-65nms   55s   system:bootstrap:2sb8wy       Approved,Issued
    5. csr-8t5hj   42s   system:node:sre-worker-node-1 Pending
    6. csr-jkhhs   41s   system:node:sre-worker-node-2 Pending
    7. csr-jv7dn   56s   system:bootstrap:ta7onm       Approved,Issued
    8. csr-vb6p5   54s   system:bootstrap:xk27zp       Approved,Issued
    1. $ # 手动 approve
    2. $ kubectl get csr | grep Pending | awk '{print $1}' | xargs kubectl certificate approve
    3.  
    4. $ # 自动生成了 server 证书
    5. $  ls -l /etc/kubernetes/cert/kubelet-*
    6. -rw------- 1 root root 1281 Feb  7 15:38 /etc/kubernetes/cert/kubelet-client-2020-02-07-15-38-21.pem
    7. lrwxrwxrwx 1 root root   59 Feb  7 15:38 /etc/kubernetes/cert/kubelet-client-current.pem -> /etc/kubernetes/cert/kubelet-client-2020-02-07-15-38-21.pem
    8. -rw------- 1 root root 1330 Feb  7 15:42 /etc/kubernetes/cert/kubelet-server-2020-02-07-15-42-12.pem
    9. lrwxrwxrwx 1 root root   59 Feb  7 15:42 /etc/kubernetes/cert/kubelet-server-current.pem -> /etc/kubernetes/cert/kubelet-server-2020-02-07-15-42-12.pem

    7.4.12 kubelet api 认证和授权 

    kubelet 配置了如下认证参数：

    • authentication.anonymous.enabled：设置为 false，不允许匿名�访问 10250 端口；
    • authentication.x509.clientCAFile：指定签名客户端证书的 CA 证书，开启 HTTPs 证书认证；
    • authentication.webhook.enabled=true：开启 HTTPs bearer token 认证；

    同时配置了如下授权参数：

    • authroization.mode=Webhook：开启 RBAC 授权；

    kubelet 收到请求后，使用 clientCAFile 对证书签名进行认证，或者查询 bearer token 是否有效。如果两者都没通过，则拒绝请求，提示 Unauthorized：

    1. $ curl -s --cacert /etc/kubernetes/cert/ca.pem https://10.12.5.60:10250/metrics
    2. Unauthorized
    3.  
    4. $ curl -s --cacert /etc/kubernetes/cert/ca.pem -H "Authorization: Bearer 123456" https://10.12.5.60:10250/metrics
    5. Unauthorized

    通过认证后，kubelet 使用 SubjectAccessReview API 向 kube-apiserver 发送请求，查询证书或 token 对应的 user、group 是否有操作资源的权限(RBAC)；

    7.4.13 证书认证和授权

    1. $ # 权限不足的证书；
    2. $ curl -s --cacert /etc/kubernetes/cert/ca.pem --cert /etc/kubernetes/cert/kube-controller-manager.pem --key /etc/kubernetes/cert/kube-controller-manager-key.pem https://10.12.5.60:10250/metrics
    3. Forbidden (user=system:kube-controller-manager, verb=get, resource=nodes, subresource=metrics)
    4.  
    5. $ # 使用部署 kubectl 命令行工具时创建的、具有最高权限的 admin 证书；
    6. $ curl -s --cacert /etc/kubernetes/cert/ca.pem --cert /opt/k8s/work/admin.pem --key /opt/k8s/work/admin-key.pem https://10.12.5.60:10250/metrics|head
    7. # HELP apiserver_audit_event_total Counter of audit events generated and sent to the audit backend.
    8. # TYPE apiserver_audit_event_total counter
    9. apiserver_audit_event_total 0
    10. # HELP apiserver_audit_requests_rejected_total Counter of apiserver requests rejected due to an error in audit logging backend.
    11. # TYPE apiserver_audit_requests_rejected_total counter
    12. apiserver_audit_requests_rejected_total 0
    13. # HELP apiserver_client_certificate_expiration_seconds Distribution of the remaining lifetime on the certificate used to authenticate a request.
    14. # TYPE apiserver_client_certificate_expiration_seconds histogram
    15. apiserver_client_certificate_expiration_seconds_bucket{le="0"} 0
    16. apiserver_client_certificate_expiration_seconds_bucket{le="1800"} 0
    • --cacert、--cert、--key 的参数值必须是文件路径，如上面的 ./admin.pem 不能省略 ./，否则返回 401 Unauthorized；

    7.4.13 bear token认证和授权

    创建一个 ServiceAccount，将它和 ClusterRole system:kubelet-api-admin 绑定，从而具有调用 kubelet API 的权限：

    1. kubectl create sa kubelet-api-test
    2. kubectl create clusterrolebinding kubelet-api-test --clusterrole=system:kubelet-api-admin --serviceaccount=default:kubelet-api-test
    3. SECRET=$(kubectl get secrets | grep kubelet-api-test | awk '{print $1}')
    4. TOKEN=$(kubectl describe secret ${SECRET} | grep -E '^token' | awk '{print $2}')
    5. echo ${TOKEN}
    1. $ curl -s --cacert /etc/kubernetes/cert/ca.pem -H "Authorization: Bearer ${TOKEN}" https://10.12.5.60:10250/metrics | head
    2. # HELP apiserver_audit_event_total Counter of audit events generated and sent to the audit backend.
    3. # TYPE apiserver_audit_event_total counter
    4. apiserver_audit_event_total 0
    5. # HELP apiserver_audit_requests_rejected_total Counter of apiserver requests rejected due to an error in audit logging backend.
    6. # TYPE apiserver_audit_requests_rejected_total counter
    7. apiserver_audit_requests_rejected_total 0
    8. # HELP apiserver_client_certificate_expiration_seconds Distribution of the remaining lifetime on the certificate used to authenticate a request.
    9. # TYPE apiserver_client_certificate_expiration_seconds histogram
    10. apiserver_client_certificate_expiration_seconds_bucket{le="0"} 0
    11. apiserver_client_certificate_expiration_seconds_bucket{le="1800"} 0

     7.4.14 cadvisor和metries

    cadvisor 是内嵌在 kubelet 二进制中的，统计所在节点各容器的资源(CPU、内存、磁盘、网卡)使用情况的服务。

    浏览器访问https://10.12.5.60:10250/metries和https://10.12.5.60:10250/metries/cadvisor分别返回 kubelet 和 cadvisor 的 metrics。

    注意：

    • kubelet.config.json 设置 authentication.anonymous.enabled 为 false，不允许匿名证书访问 10250 的 https 服务；
    • 参考A.浏览器访问kube-apiserver安全端口.md，创建和导入相关证书，然后访问上面的 10250 端口；

    7.5 部署kube-proxy组件

    kube-proxy 运行在所有 worker 节点上，它监听 apiserver 中 service 和 endpoint 的变化情况，创建路由规则以提供服务 IP 和负载均衡功能。

    本文档讲解部署 ipvs 模式的 kube-proxy 过程。

    注意：如果没有特殊指明，本文档的所有操作均在sre-master-node节点上执行，然后远程分发文件和执行命令。

    7.5.1 下载和分发kube-proxy二进制文件

    参考 6.1-下载最新版本二进制文件。 

    7.5.2 创建kube-proxy证书

    创建证书签名请求：

    1. $ cd /opt/k8s/work
    2. $ cat > kube-proxy-csr.json <<EOF
    3. {
    4.   "CN": "system:kube-proxy",
    5.   "key": {
    6.     "algo": "rsa",
    7.     "size": 2048
    8.   },
    9.   "names": [
    10.     {
    11.       "C": "CN",
    12.       "ST": "BeiJing",
    13.       "L": "BeiJing",
    14.       "O": "k8s",
    15.       "OU": "opsnull"
    16.     }
    17.   ]
    18. }
    19. EOF
    • CN：指定该证书的 User 为 system:kube-proxy；
    • 预定义的 RoleBinding system:node-proxier 将User system:kube-proxy 与 Role system:node-proxier 绑定，该 Role 授予了调用 kube-apiserver Proxy 相关 API 的权限；
    • 该证书只会被 kube-proxy 当做 client 证书使用，所以 hosts 字段为空；

    生成证书和私钥：

    1. $ cd /opt/k8s/work
    2. $ cfssl gencert -ca=/opt/k8s/work/ca.pem \
    3.   -ca-key=/opt/k8s/work/ca-key.pem \
    4.   -config=/opt/k8s/work/ca-config.json \
    5.   -profile=kubernetes  kube-proxy-csr.json | cfssljson -bare kube-proxy
    6. $ ls kube-proxy*

    7.5.3 创建和分发kubeconfig文件

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ kubectl config set-cluster kubernetes \
    4.   --certificate-authority=/opt/k8s/work/ca.pem \
    5.   --embed-certs=true \
    6.   --server=${KUBE_APISERVER} \
    7.   --kubeconfig=kube-proxy.kubeconfig
    8.  
    9. $ kubectl config set-credentials kube-proxy \
    10.   --client-certificate=kube-proxy.pem \
    11.   --client-key=kube-proxy-key.pem \
    12.   --embed-certs=true \
    13.   --kubeconfig=kube-proxy.kubeconfig
    14.  
    15. $ kubectl config set-context default \
    16.   --cluster=kubernetes \
    17.   --user=kube-proxy \
    18.   --kubeconfig=kube-proxy.kubeconfig
    19.  
    20. $ kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig

    分发 kubeconfig 文件：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim kube-proxy-kubeconfig.sh
    4. for node_name in ${NODE_NAMES[@]}
    5.   do
    6.     echo ">>> ${node_name}"
    7.     scp kube-proxy.kubeconfig root@${node_name}:/etc/kubernetes/
    8.   done
    9. $ sh kube-proxy-kubeconfig.sh

    7.5.4 创建和分发kube-proxy配置文件 

    从 v1.10 开始，kube-proxy 部分参数可以配置文件中配置。可以使用 --write-config-to 选项生成该配置文件，或者参考 源代码的注释。

    创建 kube-proxy config 文件模板：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ cat > kube-proxy-config.yaml.template <<EOF
    4. kind: KubeProxyConfiguration
    5. apiVersion: kubeproxy.config.k8s.io/v1alpha1
    6. clientConnection:
    7.   burst: 200
    8.   kubeconfig: "/etc/kubernetes/kube-proxy.kubeconfig"
    9.   qps: 100
    10. bindAddress: ##NODE_IP##
    11. healthzBindAddress: ##NODE_IP##:10256
    12. metricsBindAddress: ##NODE_IP##:10249
    13. enableProfiling: true
    14. clusterCIDR: ${CLUSTER_CIDR}
    15. hostnameOverride: ##NODE_NAME##
    16. mode: "ipvs"
    17. portRange: ""
    18. iptables:
    19.   masqueradeAll: false
    20. ipvs:
    21.   scheduler: rr
    22.   excludeCIDRs: []
    23. EOF
    • bindAddress: 监听地址；
    • clientConnection.kubeconfig: 连接 apiserver 的 kubeconfig 文件；
    • clusterCIDR: kube-proxy 根据 --cluster-cidr 判断集群内部和外部流量，指定 --cluster-cidr 或 --masquerade-all 选项后 kube-proxy 才会对访问 Service IP 的请求做 SNAT；
    • hostnameOverride: 参数值必须与 kubelet 的值一致，否则 kube-proxy 启动后会找不到该 Node，从而不会创建任何 ipvs 规则；
    • mode: 使用 ipvs 模式；

    为各节点创建和分发 kube-proxy 配置文件：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim kube_proxy_config.sh
    4. for (( i=0; i < 3; i++ ))
    5.   do 
    6.     echo ">>> ${NODE_NAMES[i]}"
    7.     sed -e "s/##NODE_NAME##/${NODE_NAMES[i]}/" -e "s/##NODE_IP##/${NODE_IPS[i]}/" kube-proxy-config.yaml.template > kube-proxy-config-${NODE_NAMES[i]}.yaml.template
    8.     scp kube-proxy-config-${NODE_NAMES[i]}.yaml.template root@${NODE_NAMES[i]}:/etc/kubernetes/kube-proxy-config.yaml
    9.   done
    10. $ sh kube_proxy_config.sh

    7.5.5 创建和分发kube-proxy system unit配置文件

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ cat > kube-proxy.service <<EOF
    4. [Unit]
    5. Description=Kubernetes Kube-Proxy Server
    6. Documentation=https://github.com/GoogleCloudPlatform/kubernetes
    7. After=network.target
    8.  
    9. [Service]
    10. WorkingDirectory=${K8S_DIR}/kube-proxy
    11. ExecStart=/opt/k8s/bin/kube-proxy \\
    12.   --config=/etc/kubernetes/kube-proxy-config.yaml \\
    13.   --logtostderr=true \\
    14.   --v=2
    15. Restart=on-failure
    16. RestartSec=5
    17. LimitNOFILE=65536
    18.  
    19. [Install]
    20. WantedBy=multi-user.target
    21. EOF

    分发 kube-proxy systemd unit 文件：

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim kube_proxy_service.sh
    4. for node_name in ${NODE_NAMES[@]}
    5.   do 
    6.     echo ">>> ${node_name}"
    7.     scp kube-proxy.service root@${node_name}:/etc/systemd/system/
    8.   done
    9. $ sh kube_proxy_service.sh

    7.5.6 启动kube-proxy 

    1. $ cd /opt/k8s/work
    2. $ source /opt/k8s/bin/environment.sh
    3. $ vim start_kube_proxy.sh
    4. for node_ip in ${NODE_IPS[@]}
    5.   do
    6.     echo ">>> ${node_ip}"
    7.     ssh root@${node_ip} "mkdir -p ${K8S_DIR}/kube-proxy"
    8.     ssh root@${node_ip} "modprobe ip_vs_rr"
    9.     ssh root@${node_ip} "systemctl daemon-reload && systemctl enable kube-proxy && systemctl restart kube-proxy"
    10.   done
    11. $ sh start_kube_proxy.sh

    7.5.7 检查启动结果

    1. $ source /opt/k8s/bin/environment.sh
    2. $ vim check_kube_proxy_status.sh
    3. for node_ip in ${NODE_IPS[@]}
    4.   do
    5.     echo ">>> ${node_ip}"
    6.     ssh root@${node_ip} "systemctl status kube-proxy|grep Active"
    7.   done
    8. $ sh check_kube_proxy_status.sh

    确保状态为 active (running)，否则查看日志，确认原因：

    $ journalctl -u kube-proxy

    7.5.8 查看监听端口

    1. $ sudo netstat -lnpt|grep kube-prox
    2. tcp        0      0 10.12.5.61:10256    0.0.0.0:*               LISTEN      30590/kube-proxy
    3. tcp        0      0 10.12.5.62:10249    0.0.0.0:*               LISTEN      30590/kube-proxy
    • 10249：http prometheus metrics port;
    • 10256：http healthz port;

    7.5.9 查看ipvs路由规则

    1. $ source /opt/k8s/bin/environment.sh
    2. $ vim get_ipvs.sh
    3. for node_ip in ${NODE_IPS[@]}
    4.   do
    5.     echo ">>> ${node_ip}"
    6.     ssh root@${node_ip} "/usr/sbin/ipvsadm -ln"
    7.   done
    8. $ sh get_ipvs.sh

    预期输出：

    1. >>> 10.12.5.62
    2. IP Virtual Server version 1.2.1 (size=4096)
    3. Prot LocalAddress:Port Scheduler Flags
    4.   -> RemoteAddress:Port           Forward Weight ActiveConn InActConn
    5. TCP  10.254.0.1:443 rr
    6.   -> 10.12.5.60:6443          Masq    1      0          0         
    7.   -> 10.12.5.61:6443          Masq    1      0          0         
    8.   -> 10.12.5.62:6443          Masq    1      0          0         
    9. >>> 10.12.5.61
    10. IP Virtual Server version 1.2.1 (size=4096)
    11. Prot LocalAddress:Port Scheduler Flags
    12.   -> RemoteAddress:Port           Forward Weight ActiveConn InActConn
    13. TCP  10.254.0.1:443 rr
    14.   -> 10.12.5.60:6443          Masq    1      0          0         
    15.   -> 10.12.5.61:6443          Masq    1      0          0         
    16.   -> 10.12.5.62:6443          Masq    1      0          0         
    17. >>> 10.12.5.62
    18. IP Virtual Server version 1.2.1 (size=4096)
    19. Prot LocalAddress:Port Scheduler Flags
    20.   -> RemoteAddress:Port           Forward Weight ActiveConn InActConn
    21. TCP  10.254.0.1:443 rr
    22.   -> 10.12.5.60:6443          Masq    1      0          0         
    23.   -> 10.12.5.61:6443          Masq    1      0          0         
    24.   -> 10.12.5.62:6443          Masq    1      0          0

    可见所有通过 https 访问 K8S SVC kubernetes 的请求都转发到 kube-apiserver 节点的 6443 端口；

    7.6 部署calico网络插件

    kubernetes 要求集群内各节点(包括 master 节点)能通过 Pod 网段互联互通。

    calico 使用 IPIP 或 BGP 技术（默认为 IPIP）为各节点创建一个可以互通的 Pod 网络。

    如果使用 flannel，请参考附件 E.部署flannel网络.md（flannel 与 docker 结合使用）

    注意：如果没有特殊指明，本文档的所有操作均在sre-master-node 节点上执行。

    7.6.1 安装 calico网络插件

    1. $ cd /opt/k8s/work
    2. $ curl https://docs.projectcalico.org/manifests/calico.yaml -O

    修改配置：

    1. $ cp calico.yaml calico.yaml.orig
    2. $ diff -U 5 calico.yaml.orig calico.yaml
    3. --- calico.yaml.orig    2021-06-02 21:04:31.000000000 +0800
    4. +++ calico.yaml 2021-06-02 21:08:14.000000000 +0800
    5. @@ -3678,12 +3678,14 @@
    6.                    name: calico-config
    7.                    key: veth_mtu
    8.              # The default IPv4 pool to create on startup if none exists. Pod IPs will be
    9.              # chosen from this range. Changing this value after installation will have
    10.              # no effect. This should fall within `--cluster-cidr`.
    11. -            # - name: CALICO_IPV4POOL_CIDR
    12. -            #   value: "192.168.0.0/16"
    13. +            - name: CALICO_IPV4POOL_CIDR
    14. +              value: "172.30.0.0/16"
    15. +            - name: IP_AUTODETECTION_METHOD
    16. +              value: "interface=eth.*"
    17.              # Disable file logging so `kubectl logs` works.
    18.              - name: CALICO_DISABLE_FILE_LOGGING
    19.                value: "true"
    20.              # Set Felix endpoint to host default action to ACCEPT.
    21.              - name: FELIX_DEFAULTENDPOINTTOHOSTACTION
    22. @@ -3759,11 +3761,11 @@
    23.              path: /sys/fs/
    24.              type: DirectoryOrCreate
    25.          # Used to install CNI.
    26.          - name: cni-bin-dir
    27.            hostPath:
    28. -            path: /opt/cni/bin
    29. +            path: /opt/k8s/bin
    30.          - name: cni-net-dir
    31.            hostPath:
    32.              path: /etc/cni/net.d
    33.          # Used to access CNI logs.
    34.          - name: cni-log-dir
    • 将 Pod 网段地址修改为 172.30.0.0/16;
    • calico 自动探查互联网卡，如果有多快网卡，则可以配置用于互联的网络接口命名正则表达式，如上面的 eth.*(根据自己服务器的网络接口名修改)；

    运行 calico 插件：

    $ kubectl apply -f  calico.yaml
    • calico 插架以 daemonset 方式运行在所有的 K8S 节点上。

    7.6.2 查看calico 运行状态

    1. $ kubectl get pods -n kube-system -o wide
    2. NAME                                      READY   STATUS    RESTARTS   AGE     IP               NODE              NOMINATED NODE   READINESS GATES
    3. calico-kube-controllers-77c4b7448-99lfq   1/1     Running   0          2m11s   172.30.184.128   sre-worker-node-2   <none>           <none>
    4. calico-node-dxnjs                         1/1     Running   0          2m11s   10.12.5.60   sre-master-node   <none>           <none>
    5. calico-node-rknzz                         1/1     Running   0          2m11s   10.12.5.61   sre-worker-node-1   <none>           <none>
    6. calico-node-rw84c                         1/1     Running   0          2m11s   10.12.5.62   sre-worker-node-2   <none>           <none>

    使用 crictl 命令查看 calico 使用的镜像：

    1. $ crictl  images
    2. IMAGE                                                     TAG                 IMAGE ID            SIZE
    3. docker.io/calico/cni                                      v3.12.0             cb6799752c46c       66.5MB
    4. docker.io/calico/node                                     v3.12.0             fc05bc4225f39       89.7MB
    5. docker.io/calico/pod2daemon-flexvol                       v3.12.0             98793d0a88c82       37.5MB
    6. registry.cn-beijing.aliyuncs.com/images_k8s/pause-amd64   3.1                 21a595adc69ca       326kB

    • 如果 crictl 输出为空或执行失败，则有可能是缺少配置文件 /etc/crictl.yaml 导致的，该文件的配置如下：

      1. $ cat /etc/crictl.yaml
      2. runtime-endpoint: unix:///run/containerd/containerd.sock
      3. image-endpoint: unix:///run/containerd/containerd.sock
      4. timeout: 10
      5. debug: false

    7.7 验证集群功能

    本文档验证 K8S 集群是否工作正常。

    注意：如果没有特殊指明，本文档的所有操作均在 sre-master-node 节点上执行，然后远程分发文件和执行命令。

    7.7.1 检查节点状态

    1. $ kubectl get nodes
    2. NAME              STATUS   ROLES    AGE   VERSION
    3. sre-master-node   Ready    <none>   15m   v1.16.6
    4. sre-worker-node-1   Ready    <none>   15m   v1.16.6
    5. sre-worker-node-2   Ready    <none>   15m   v1.16.6

    都为 Ready 且版本为 v1.16.6 时正常。 

    7.7.2 创建测试文件

    1. $ cd /opt/k8s/work
    2. $ cat > nginx-ds.yml <<EOF
    3. apiVersion: v1
    4. kind: Service
    5. metadata:
    6.   name: nginx-ds
    7.   labels:
    8.     app: nginx-ds
    9. spec:
    10.   type: NodePort
    11.   selector:
    12.     app: nginx-ds
    13.   ports:
    14.   - name: http
    15.     port: 80
    16.     targetPort: 80
    17. ---
    18. apiVersion: apps/v1
    19. kind: DaemonSet
    20. metadata:
    21.   name: nginx-ds
    22.   labels:
    23.     addonmanager.kubernetes.io/mode: Reconcile
    24. spec:
    25.   selector:
    26.     matchLabels:
    27.       app: nginx-ds
    28.   template:
    29.     metadata:
    30.       labels:
    31.         app: nginx-ds
    32.     spec:
    33.       containers:
    34.       - name: my-nginx
    35.         image: nginx:1.7.9
    36.         ports:
    37.         - containerPort: 80
    38. EOF

    7.7.3 执行测试

    $ kubectl create -f nginx-ds.yml

    7.7.4 检查各节点pod ip连通性

    1. $ kubectl get pods  -o wide -l app=nginx-ds
    2. NAME             READY   STATUS    RESTARTS   AGE   IP               NODE              NOMINATED NODE   READINESS GATES
    3. nginx-ds-j7v5g   1/1     Running   0          61s   172.30.244.1     sre-master-node   <none>           <none>
    4. nginx-ds-js8g8   1/1     Running   0          61s   172.30.82.129    sre-worker-node-1   <none>           <none>
    5. nginx-ds-n2p4x   1/1     Running   0          61s   172.30.184.130   sre-worker-node-2   <none>           <none>

    在所有 Node 上分别 ping 上面三个 Pod IP，看是否连通：

    1. $ source /opt/k8s/bin/environment.sh
    2. $ sh ping_pod.sh
    3. for node_ip in ${NODE_IPS[@]}
    4.   do
    5.     echo ">>> ${node_ip}"
    6.     ssh ${node_ip} "ping -c 1 172.30.244.1"
    7.     ssh ${node_ip} "ping -c 1 172.30.82.129"
    8.     ssh ${node_ip} "ping -c 1 172.30.184.130"
    9.   done
    10. $ sh ping_pod.sh

    7.7.5 检查服务ip和端口和可达性

    1. $ kubectl get svc -l app=nginx-ds                                                                                                                    
    2. NAME       TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
    3. nginx-ds   NodePort   10.254.116.22   <none>        80:30562/TCP   2m7s

    可见：

    • Service Cluster IP：10.254.116.22
    • 服务端口：80
    • NodePort 端口：30562

    在所有 Node 上 curl Service IP：

    1. $ source /opt/k8s/bin/environment.sh
    2. $ vim curl_svc.sh
    3. for node_ip in ${NODE_IPS[@]}
    4.   do
    5.     echo ">>> ${node_ip}"
    6.     ssh ${node_ip} "curl -s 10.254.116.22"
    7.   done
    8. $ sh curl_svc.sh

    预期输出 nginx 欢迎页面内容。

    7.7.6 检查服务的nodeport可达性

    在所有 Node 上执行：

    1. $ source /opt/k8s/bin/environment.sh
    2. $ vim nodeport.sh
    3. for node_ip in ${NODE_IPS[@]}
    4.   do
    5.     echo ">>> ${node_ip}"
    6.     ssh ${node_ip} "curl -s ${node_ip}:30562"
    7.   done
    8. $ sh nodeport.sh

    预期输出 nginx 欢迎页面内容。

    7.8 部署集群插件

    插件是集群的附件组件，丰富和完善了集群的功能。

    • coredns插件
    • Dashboard
    • Kube-Prometheus
    • EFK(ES、fluentd、kibana）

    7.8.1 下载和配置coredns

    如果没有特殊指明，本文档的所有操作均在sre-master-node节点上执行。

    1. $ cd /opt/k8s/work
    2. $ git clone https://github.com/coredns/deployment.git
    3. $ mv deployment coredns-deployment

    7.8.2 创建coredns

    1. $ cd /opt/k8s/work/coredns-deployment/kubernetes
    2. $ source /opt/k8s/bin/environment.sh
    3. $ ./deploy.sh -i ${CLUSTER_DNS_SVC_IP} -d ${CLUSTER_DNS_DOMAIN} | kubectl apply -f -

    7.8.3 检查coredns功能

    1. $ kubectl get all -n kube-system -l k8s-app=kube-dns
    2. NAME                          READY   STATUS    RESTARTS   AGE
    3. pod/coredns-76b74f549-cwm8d   1/1     Running   0          62s
    4.  
    5. NAME               TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)                  AGE
    6. service/kube-dns   ClusterIP   10.254.0.2   <none>        53/UDP,53/TCP,9153/TCP   62s
    7.  
    8. NAME                      READY   UP-TO-DATE   AVAILABLE   AGE
    9. deployment.apps/coredns   1/1     1            1           62s
    10.  
    11. NAME                                DESIRED   CURRENT   READY   AGE
    12. replicaset.apps/coredns-76b74f549   1         1         1       62s

    新建一个 Deployment：

    1. $ cd /opt/k8s/work
    2. $ cat > my-nginx.yaml <<EOF
    3. apiVersion: apps/v1
    4. kind: Deployment
    5. metadata:
    6.   name: my-nginx
    7. spec:
    8.   replicas: 2
    9.   selector:
    10.     matchLabels:
    11.       run: my-nginx
    12.   template:
    13.     metadata:
    14.       labels:
    15.         run: my-nginx
    16.     spec:
    17.       containers:
    18.       - name: my-nginx
    19.         image: nginx:1.7.9
    20.         ports:
    21.         - containerPort: 80
    22. EOF
    23. $ kubectl create -f my-nginx.yaml

    expose 该 Deployment, 生成 my-nginx 服务：

    1. $ kubectl expose deploy my-nginx
    2. service "my-nginx" exposed
    3.  
    4. $ kubectl get services my-nginx -o wide
    5. NAME       TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE   SELECTOR
    6. my-nginx   ClusterIP   10.254.67.218   <none>        80/TCP    5s    run=my-nginx

    创建另一个 Pod，查看 /etc/resolv.conf 是否包含 kubelet 配置的 --cluster-dns 和 --cluster-domain，是否能够将服务 my-nginx 解析到上面显示的 Cluster IP 10.254.40.167.

    1. $ cd /opt/k8s/work
    2. $ cat > dnsutils-ds.yml <<EOF
    3. apiVersion: v1
    4. kind: Service
    5. metadata:
    6.   name: dnsutils-ds
    7.   labels:
    8.     app: dnsutils-ds
    9. spec:
    10.   type: NodePort
    11.   selector:
    12.     app: dnsutils-ds
    13.   ports:
    14.   - name: http
    15.     port: 80
    16.     targetPort: 80
    17. ---
    18. apiVersion: apps/v1
    19. kind: DaemonSet
    20. metadata:
    21.   name: dnsutils-ds
    22.   labels:
    23.     addonmanager.kubernetes.io/mode: Reconcile
    24. spec:
    25.   selector:
    26.     matchLabels:
    27.       app: dnsutils-ds
    28.   template:
    29.     metadata:
    30.       labels:
    31.         app: dnsutils-ds
    32.     spec:
    33.       containers:
    34.       - name: my-dnsutils
    35.         image: tutum/dnsutils:latest
    36.         command:
    37.           - sleep
    38.           - "3600"
    39.         ports:
    40.         - containerPort: 80
    41. EOF
    42. $ kubectl create -f dnsutils-ds.yml
    1. $ kubectl get pods -lapp=dnsutils-ds -o wide 
    2. NAME                READY   STATUS    RESTARTS   AGE   IP               NODE              NOMINATED NODE   READINESS GATES
    3. dnsutils-ds-7h9np   1/1     Running   0          69s   172.30.244.3     sre-master-node   <none>           <none>
    4. dnsutils-ds-fthdl   1/1     Running   0          69s   172.30.82.131    sre-worker-node-1   <none>           <none>
    5. dnsutils-ds-w69zp   1/1     Running   0          69s   172.30.184.132   sre-worker-node-2   <none>           <none>
    1. $ kubectl -it exec dnsutils-ds-7h9np  cat /etc/resolv.conf
    2. search default.svc.cluster.local svc.cluster.local cluster.local 4pd.io
    3. nameserver 10.254.0.2
    4. options ndots:5
    1. $ kubectl -it exec dnsutils-ds-7h9np nslookup kubernetes
    2. Server:         10.254.0.2
    3. Address:        10.254.0.2#53
    4.  
    5. Name:   kubernetes.default.svc.cluster.local
    6. Address: 10.254.0.1
    1. $ kubectl -it exec dnsutils-ds-7h9np nslookup kubernetes
    2. Server:         10.254.0.2
    3. Address:        10.254.0.2#53
    4.  
    5. Name:   kubernetes.default.svc.cluster.local
    6. Address: 10.254.0.1
    1. $ kubectl -it exec dnsutils-ds-7h9np nslookup www.baidu.com
    2. Server:         10.254.0.2
    3. Address:        10.254.0.2#53
    4.  
    5. Non-authoritative answer:
    6. *** Can't find www.baidu.com: No answer
    1. $ kubectl -it exec dnsutils-ds-7h9np nslookup www.baidu.com.
    2. Server:         10.254.0.2
    3. Address:        10.254.0.2#53
    4.  
    5. Non-authoritative answer:
    6. www.baidu.com   canonical name = www.a.shifen.com.
    7. Name:   www.a.shifen.com
    8. Address: 220.181.38.150
    9. Name:   www.a.shifen.com
    10. Address: 220.181.38.149
    1. $ kubectl -it exec dnsutils-ds-7h9np nslookup my-nginx
    2. Server:         10.254.0.2
    3. Address:        10.254.0.2#53
    4.  
    5. Name:   my-nginx.default.svc.cluster.local
    6. Address: 10.254.67.218

    7.9 部署dashboard插件

    如果没有特殊指明，本文档的所有操作均在sre-master-node节点上执行；

    7.9.1 下载和修改配置文件

    1. $ cd /opt/k8s/work
    2. $ wget https://raw.githubusercontent.com/kubernetes/dashboard/v2.0.0-rc4/aio/deploy/recommended.yaml
    3. $ mv  recommended.yaml dashboard-recommended.yaml

    7.9.2 执行定义文件 

    1. $ cd /opt/k8s/work
    2. $ kubectl apply -f  dashboard-recommended.yaml

    7.9.3 查看运行状态

    1. $ kubectl get pods -n kubernetes-dashboard 
    2. NAME                                         READY   STATUS    RESTARTS   AGE
    3. dashboard-metrics-scraper-7b8b58dc8b-dlk5t   1/1     Running   0          70s
    4. kubernetes-dashboard-6cfc8c4c9-j8vcm         1/1     Running   0          70s

    7.9.4 访问dashboard

    从 1.7 开始，dashboard 只允许通过 https 访问，如果使用 kube proxy 则必须监听 localhost 或 127.0.0.1。对于 NodePort 没有这个限制，但是仅建议在开发环境中使用。对于不满足这些条件的登录访问，在登录成功后浏览器不跳转，始终停在登录界面。

    7.9.4.1 通过port forward方式访问dashboard

    启动端口转发：

    $ kubectl port-forward -n kubernetes-dashboard  svc/kubernetes-dashboard 4443:443 --address 0.0.0.0

    浏览器访问 URL：https://10.12.5.60:4443.

    7.9.5 创建登录dashboard的token和kubeconfig配置文件

    dashboard 默认只支持 token 认证（不支持 client 证书认证），所以如果使用 Kubeconfig 文件，需要将 token 写入到该文件。

    7.9.5.1 创建登录token
    1. $ kubectl create sa dashboard-admin -n kube-system
    2. $ kubectl create clusterrolebinding dashboard-admin --clusterrole=cluster-admin --serviceaccount=kube-system:dashboard-admin
    3. $ ADMIN_SECRET=$(kubectl get secrets -n kube-system | grep dashboard-admin | awk '{print $1}')
    4. $ DASHBOARD_LOGIN_TOKEN=$(kubectl describe secret -n kube-system ${ADMIN_SECRET} | grep -E '^token' | awk '{print $2}')
    5. $ echo ${DASHBOARD_LOGIN_TOKEN}

    使用输出的 token 登录 Dashboard。

    7.9.5.2 创建使用token的kubeconfig文件
    1. $ source /opt/k8s/bin/environment.sh
    2. # 设置集群参数
    3. $ kubectl config set-cluster kubernetes \
    4.   --certificate-authority=/etc/kubernetes/cert/ca.pem \
    5.   --embed-certs=true \
    6.   --server=${KUBE_APISERVER} \
    7.   --kubeconfig=dashboard.kubeconfig
    8.  
    9. # 设置客户端认证参数，使用上面创建的 Token
    10. $ kubectl config set-credentials dashboard_user \
    11.   --token=${DASHBOARD_LOGIN_TOKEN} \
    12.   --kubeconfig=dashboard.kubeconfig
    13.  
    14. # 设置上下文参数
    15. $ kubectl config set-context default \
    16.   --cluster=kubernetes \
    17.   --user=dashboard_user \
    18.   --kubeconfig=dashboard.kubeconfig
    19.  
    20. # 设置默认上下文
    21. $ kubectl config use-context default --kubeconfig=dashboard.kubeconfig

    用生成的 dashboard.kubeconfig 登录 Dashboard。

    7.10 部署kube-prometheus插件

    kube-prometheus 是一整套监控解决方案，它使用 Prometheus 采集集群指标，Grafana 做展示，包含如下组件：

    • The Prometheus Operator
    • Highly available Prometheus
    • Highly available Alertmanager
    • Prometheus node-exporter
    • Prometheus Adapter for Kubernetes Metrics APIs （k8s-prometheus-adapter）
    • kube-state-metrics
    • Grafana

    其中 k8s-prometheus-adapter 使用 Prometheus 实现了 metrics.k8s.io 和 custom.metrics.k8s.io API，所以不需要再部署 metrics-server。 如果要单独部署 metrics-server，请参考：C.metrics-server插件.md

    如果没有特殊指明，本文档的所有操作均在sre-master-node节点上执行； 

    7.10.1 下载和安装

    1. $ cd /opt/k8s/work
    2. $ git clone https://github.com/coreos/kube-prometheus.git
    3. $ cd kube-prometheus/
    4. $ sed -i -e 's_quay.io_quay.mirrors.ustc.edu.cn_' manifests/*.yaml manifests/setup/*.yaml # 使用中科大的 Registry
    5. $ kubectl apply -f manifests/setup # 安装 prometheus-operator
    6. $ kubectl apply -f manifests/ # 安装 promethes metric adapter

    7.10.2 查看运行状态

    1. $ kubectl get pods -n monitoring
    2. NAME                                   READY   STATUS    RESTARTS   AGE
    3. alertmanager-main-0                    2/2     Running       0          63s
    4. alertmanager-main-1                    2/2     Running       0          63s
    5. alertmanager-main-2                    2/2     Running       0          63s
    6. grafana-76b8d59b9b-nd6gk               1/1     Running       0          11m
    7. kube-state-metrics-67b7c5dc78-sktzg    3/3     Running       0          73s
    8. node-exporter-prsvf                    2/2     Running       0          34s
    9. node-exporter-qdh6n                    2/2     Running       0          71s
    10. node-exporter-z6h4z                    2/2     Running       0          69s
    11. prometheus-adapter-5f46ccd66d-bbsns    1/1     Running       0          73s
    12. prometheus-k8s-0                       3/3     Running       1          53s
    13. prometheus-k8s-1                       3/3     Running       1          53s
    14. prometheus-operator-6d8b95b467-htx56   1/1     Running       0          74s
    1. $ kubectl top pods -n monitoring
    2. NAME                                  CPU(cores)   MEMORY(bytes)   
    3. alertmanager-main-0                    0m           18Mi            
    4. alertmanager-main-1                    2m           20Mi            
    5. alertmanager-main-2                    0m           19Mi            
    6. grafana-76b8d59b9b-nd6gk               4m           49Mi            
    7. kube-state-metrics-67b7c5dc78-sktzg    11m          29Mi            
    8. kube-state-metrics-959876458-cjtr5     9m           37Mi            
    9. node-exporter-prsvf                    4m           11Mi            
    10. node-exporter-qdh6n                    1m           20Mi            
    11. node-exporter-z6h4z                    5m           11Mi            
    12. prometheus-adapter-5f46ccd66d-bbsns    0m           17Mi            
    13. prometheus-k8s-0                       15m          190Mi           
    14. prometheus-k8s-1                       6m           199Mi           
    15. prometheus-operator-6d8b95b467-htx56   0m           20Mi

    7.10.3 查看Prometheus UI

    启动服务代理：

    1. $ kubectl port-forward --address 0.0.0.0 pod/prometheus-k8s-0 -n monitoring 9090:9090
    2. Forwarding from 0.0.0.0:9090 -> 9090
    • port-forward 依赖 socat。

    浏览器访问：http://10.12.5.60:9090/new/graph？g0.expr=&g0.tab=1&g0.stacked=0&g0.range_input=1h

    7.10.4 查看Grafana UI

    启动代理：

    1. $ kubectl port-forward --address 0.0.0.0 svc/grafana -n monitoring 3000:3000 
    2. Forwarding from 0.0.0.0:3000 -> 3000

    浏览器访问：http://10.12.5.60:3000/,用 admin/admin 登录。 

    然后，就可以看到各种预定义的 dashboard 了： 

    7.11 部署EFK插件

    注意：

    1. 如果没有特殊指明，本文档的所有操作均在sre-master-node节点上执行。
    2. kuberntes 自带插件的 manifests yaml 文件使用 gcr.io 的 docker registry，国内被墙，需要手动替换为其它 registry 地址；
    3. 可以从微软中国提供的 gcr.io 免费代理下载被墙的镜像；

    7.11.1 修改配置文件

    将下载的 kubernetes-server-linux-amd64.tar.gz 解压后，再解压其中的 kubernetes-src.tar.gz 文件。

    1. $ cd /opt/k8s/work/kubernetes/
    2. $ tar -xzvf kubernetes-src.tar.gz

    EFK 目录是 kubernetes/cluster/addons/fluentd-elasticsearch。

    1. $ cd /opt/k8s/work/kubernetes/cluster/addons/fluentd-elasticsearch
    2. $ sed -i -e 's_quay.io_quay.mirrors.ustc.edu.cn_' es-statefulset.yaml # 使用中科大的 Registry
    3. $ sed -i -e 's_quay.io_quay.mirrors.ustc.edu.cn_' fluentd-es-ds.yaml # 使用中科大的 Registry

    7.11.2 执行定义文件

    1. $ cd /opt/k8s/work/kubernetes/cluster/addons/fluentd-elasticsearch
    2. $ kubectl apply -f .

    7.11.3 执行检查结果

    1. $ kubectl get all -n kube-system |grep -E 'elasticsearch|fluentd|kibana'
    2. pod/elasticsearch-logging-0                   1/1     Running   0          15m
    3. pod/elasticsearch-logging-1                   1/1     Running   0          14m
    4. pod/fluentd-es-v2.7.0-98slb                   1/1     Running   0          15m
    5. pod/fluentd-es-v2.7.0-v25tz                   1/1     Running   0          15m
    6. pod/fluentd-es-v2.7.0-zngpm                   1/1     Running   0          15m
    7. pod/kibana-logging-75888755d6-nw6bc           1/1     Running   0          5m40s
    8. service/elasticsearch-logging   ClusterIP   10.254.11.19     <none>        9200/TCP                 15m
    9. service/kibana-logging          ClusterIP   10.254.207.146   <none>        5601/TCP                 15m
    10. daemonset.apps/fluentd-es-v2.7.0   3         3         3       3            3           <none>                   15m
    11. deployment.apps/kibana-logging            1/1     1            1           15m
    12. replicaset.apps/kibana-logging-75888755d6           1         1         1       15m
    13. statefulset.apps/elasticsearch-logging   2/2     15m

    kibana Pod 第一次启动时会用**较长时间(0-20分钟)**来优化和 Cache 状态页面，可以 tailf 该 Pod 的日志观察进度：

    $ kubectl logs kibana-logging-75888755d6-nw6bc -n kube-system -f

    注意：只有当 Kibana pod 启动完成后，浏览器才能查看 kibana dashboard，否则会被拒绝。

    7.11.4 通过kube-proxy访问kinaba

    创建代理：

    1. $ kubectl proxy --address='10.12.5.60' --port=8086 --accept-hosts='^*$'
    2. Starting to serve on 10.12.5.60:8086

    浏览器访问 URL：http://10.12.5.60:8086/api/v1/namespaces/kube-system/services/kibana-logging/proxy

    在 Management -> Indices 页面创建一个 index（相当于 mysql 中的一个 database），选中 Index contains time-based events，使用默认的 logstash-* pattern，点击 Create ;

    创建 Index 后，稍等几分钟就可以在 Discover 菜单下看到 ElasticSearch logging 中汇聚的日志；

    8 部署docker registry

    本文档介绍使用 docker 官方的 registry v2 镜像部署私有仓库的步骤。

    本文档讲解部署一个 TLS 加密、HTTP Basic 认证、用 ceph rgw 做后端存储的私有 docker registry 步骤，如果使用其它类型的后端存储，则可以从 “创建 docker registry” 节开始；

    示例两台机器 IP 如下：

    • ceph rgw: 172.27.132.66
    • docker registry: 172.27.132.67

    8.1 部署ceph RGW节点

    $ ceph-deploy rgw create 172.27.132.66 # rgw 默认监听7480端口

    8.2 创建测试账号demo

    $ radosgw-admin user create --uid=demo --display-name="ceph rgw demo user"

    8.3 创建demo账号的子账号swift

    当前 registry 只支持使用 swift 协议访问 ceph rgw 存储，暂时不支持 s3 协议；

    $ radosgw-admin subuser create --uid demo --subuser=demo:swift --access=full --secret=secretkey --key-type=swift

    8.4 创建demo:swift子账号的secret key

    1. $ radosgw-admin key create --subuser=demo:swift --key-type=swift --gen-secret
    2. {
    3.     "user_id": "demo",
    4.     "display_name": "ceph rgw demo user",
    5.     "email": "",
    6.     "suspended": 0,
    7.     "max_buckets": 1000,
    8.     "auid": 0,
    9.     "subusers": [
    10.         {
    11.             "id": "demo:swift",
    12.             "permissions": "full-control"
    13.         }
    14.     ],
    15.     "keys": [
    16.         {
    17.             "user": "demo",
    18.             "access_key": "5Y1B1SIJ2YHKEHO5U36B",
    19.             "secret_key": "nrIvtPqUj7pUlccLYPuR3ntVzIa50DToIpe7xFjT"
    20.         }
    21.     ],
    22.     "swift_keys": [
    23.         {
    24.             "user": "demo:swift",
    25.             "secret_key": "ttQcU1O17DFQ4I9xzKqwgUe7WIYYX99zhcIfU9vb"
    26.         }
    27.     ],
    28.     "caps": [],
    29.     "op_mask": "read, write, delete",
    30.     "default_placement": "",
    31.     "placement_tags": [],
    32.     "bucket_quota": {
    33.         "enabled": false,
    34.         "max_size_kb": -1,
    35.         "max_objects": -1
    36.     },
    37.     "user_quota": {
    38.         "enabled": false,
    39.         "max_size_kb": -1,
    40.         "max_objects": -1
    41.     },
    42.         "temp_url_keys": []
    43. }
    • ttQcU1O17DFQ4I9xzKqwgUe7WIYYX99zhcIfU9vb 为子账号 demo:swift 的 secret key；

    8.5 创建docker registry

    创建 registry 使用的 x509 证书：

    1. $ mkdir -p registry/{auth,certs}
    2. $ cat > registry-csr.json <<EOF
    3. {
    4.   "CN": "registry",
    5.   "hosts": [
    6.       "127.0.0.1",
    7.       "172.27.132.67"
    8.   ],
    9.   "key": {
    10.     "algo": "rsa",
    11.     "size": 2048
    12.   },
    13.   "names": [
    14.     {
    15.       "C": "CN",
    16.       "ST": "BeiJing",
    17.       "L": "BeiJing",
    18.       "O": "k8s",
    19.       "OU": "opsnull"
    20.     }
    21.   ]
    22. }
    23. EOF
    24. $ cfssl gencert -ca=/etc/kubernetes/cert/ca.pem \
    25.     -ca-key=/etc/kubernetes/cert/ca-key.pem \
    26.     -config=/etc/kubernetes/cert/ca-config.json \
    27.     -profile=kubernetes registry-csr.json | cfssljson -bare registry
    28. $ cp registry.pem registry-key.pem registry/certs
    • 这里复用以前创建的 CA 证书和秘钥文件；
    • hosts 字段指定 registry 的 NodeIP；

    创建 HTTP Baisc 认证文件

    1. $ docker run --entrypoint htpasswd registry:2 -Bbn foo foo123  > registry/auth/htpasswd
    2. $ cat  registry/auth/htpasswd
    3. foo:$2y$05$iZaM45Jxlcg0DJKXZMggLOibAsHLGybyU.CgU9AHqWcVDyBjiScN.

    配置 registry 参数

    1. $ export RGW_AUTH_URL="http://172.27.132.66:7480/auth/v1"
    2. $ export RGW_USER="demo:swift"
    3. $ export RGW_SECRET_KEY="ttQcU1O17DFQ4I9xzKqwgUe7WIYYX99zhcIfU9vb"
    4. $ cat > config.yml << EOF
    5. # https://docs.docker.com/registry/configuration/#list-of-configuration-options
    6. version: 0.1
    7. log:
    8.   level: info
    9.   fromatter: text
    10.   fields:
    11.     service: registry
    12.  
    13. storage:
    14.   cache:
    15.     blobdescriptor: inmemory
    16.   delete:
    17.     enabled: true
    18.   swift:
    19.     authurl: ${RGW_AUTH_URL}
    20.     username: ${RGW_USER}
    21.     password: ${RGW_SECRET_KEY}
    22.     container: registry
    23.  
    24. auth:
    25.   htpasswd:
    26.     realm: basic-realm
    27.     path: /auth/htpasswd
    28.  
    29. http:
    30.   addr: 0.0.0.0:8000
    31.   headers:
    32.     X-Content-Type-Options: [nosniff]
    33.   tls:
    34.     certificate: /certs/registry.pem
    35.     key: /certs/registry-key.pem
    36.  
    37. health:
    38.   storagedriver:
    39.     enabled: true
    40.     interval: 10s
    41.     threshold: 3
    42. EOF
    43. [k8s@sre-master-node cert]$ cp config.yml registry
    44. [k8s@sre-master-node cert]$ scp -r registry 172.27.132.67:/opt/k8s
    • storage.swift 指定后端使用 swfit 接口协议的存储，这里配置的是 ceph rgw 存储参数；
    • auth.htpasswd 指定了 HTTP Basic 认证的 token 文件路径；
    • http.tls 指定了 registry http 服务器的证书和秘钥文件路径； 

    创建 docker registry：

    1. $ ssh k8s@172.27.132.67
    2. $ docker run -d -p 8000:8000 --privileged \
    3.     -v /opt/k8s/registry/auth/:/auth \
    4.     -v /opt/k8s/registry/certs:/certs \
    5.     -v /opt/k8s/registry/config.yml:/etc/docker/registry/config.yml \
    6.     --name registry registry:2
    • 执行该 docker run 命令的机器 IP 为 172.27.132.67；

    8.6 向registry push image

    将签署 registry 证书的 CA 证书拷贝到 /etc/docker/certs.d/172.27.132.67:8000 目录下

    1. [k8s@sre-master-node cert]$ sudo mkdir -p /etc/docker/certs.d/172.27.132.67:8000
    2. [k8s@sre-master-node cert]$ sudo cp /etc/kubernetes/cert/ca.pem /etc/docker/certs.d/172.27.132.67:8000/ca.crt

    登陆私有 registry：

    1. $ docker login 172.27.132.67:8000
    2. Username: foo
    3. Password:
    4. Login Succeeded

    登陆信息被写入 ~/.docker/config.json 文件：

    1. $ cat ~/.docker/config.json
    2. {
    3.         "auths": {
    4.                 "172.27.132.67:8000": {
    5.                         "auth": "Zm9vOmZvbzEyMw=="
    6.                 }
    7.         }
    8. }

    将本地的 image 打上私有 registry 的 tag：

    1. $ docker tag prom/node-exporter:v0.16.0 172.27.132.67:8000/prom/node-exporter:v0.16.0
    2. $ docker images |grep pause
    3. prom/node-exporter:v0.16.0                            latest              f9d5de079539        2 years ago         239.8 kB
    4. 172.27.132.67:8000/prom/node-exporter:v0.16.0                        latest              f9d5de079539        2 years ago         239.8 kB

    将 image push 到私有 registry：

    1. $ docker push 172.27.132.67:8000/prom/node-exporter:v0.16.0
    2. The push refers to a repository [172.27.132.67:8000/prom/node-exporter:v0.16.0]
    3. 5f70bf18a086: Pushed
    4. e16a89738269: Pushed
    5. latest: digest: sha256:9a6b437e896acad3f5a2a8084625fdd4177b2e7124ee943af642259f2f283359 size: 916

    查看 ceph 上是否已经有 push 的 pause 容器文件：

    1. $ rados lspools
    2. rbd
    3. cephfs_data
    4. cephfs_metadata
    5. .rgw.root
    6. k8s
    7. default.rgw.control
    8. default.rgw.meta
    9. default.rgw.log
    10. default.rgw.buckets.index
    11. default.rgw.buckets.data
    12.  
    13. $  rados --pool default.rgw.buckets.data ls|grep node-exporter
    14. 1f3f02c4-fe58-4626-992b-c6c0fe4c8acf.34107.1_files/docker/registry/v2/repositories/prom/node-exporter/_layers/sha256/cdb7590af5f064887f3d6008d46be65e929c74250d747813d85199e04fc70463/link
    15. 1f3f02c4-fe58-4626-992b-c6c0fe4c8acf.34107.1_files/docker/registry/v2/repositories/prom/node-exporter/_manifests/revisions/sha256/55302581333c43d540db0e144cf9e7735423117a733cdec27716d87254221086/link
    16. 1f3f02c4-fe58-4626-992b-c6c0fe4c8acf.34107.1_files/docker/registry/v2/repositories/prom/node-exporter/_manifests/tags/v0.16.0/current/link
    17. 1f3f02c4-fe58-4626-992b-c6c0fe4c8acf.34107.1_files/docker/registry/v2/repositories/prom/node-exporter/_manifests/tags/v0.16.0/index/sha256/55302581333c43d540db0e144cf9e7735423117a733cdec27716d87254221086/link
    18. 1f3f02c4-fe58-4626-992b-c6c0fe4c8acf.34107.1_files/docker/registry/v2/repositories/prom/node-exporter/_layers/sha256/224a21997e8ca8514d42eb2ed98b19a7ee2537bce0b3a26b8dff510ab637f15c/link
    19. 1f3f02c4-fe58-4626-992b-c6c0fe4c8acf.34107.1_files/docker/registry/v2/repositories/prom/node-exporter/_layers/sha256/528dda9cf23d0fad80347749d6d06229b9a19903e49b7177d5f4f58736538d4e/link
    20. 1f3f02c4-fe58-4626-992b-c6c0fe4c8acf.34107.1_files/docker/registry/v2/repositories/prom/node-exporter/_layers/sha256/188af75e2de0203eac7c6e982feff45f9c340eaac4c7a0f59129712524fa2984/link

    8.7 私有registry的运维操作

    8.7.1 查询私有仓库中的images

    1. $ curl  --user foo:foo123 --cacert /etc/docker/certs.d/172.27.132.67\:8000/ca.crt https://172.27.132.67:8000/v2/_catalog
    2. {"repositories":["prom/node-exporter"]}

    8.7.2 查询某个镜像的tags列表

    1. $  curl  --user foo:foo123 --cacert /etc/docker/certs.d/172.27.132.67\:8000/ca.crt https://172.27.132.67:8000/v2/prom/node-exporter/tags/list
    2. {"name":"prom/node-exporter","tags":["v0.16.0"]}

    8.7.3 获取image或layer的digest

    向 v2//manifests/ 发 GET 请求，从响应的头部 Docker-Content-Digest 获取 image digest，从响应的 body 的 fsLayers.blobSum 中获取 layDigests;

    注意，必须包含请求头：Accept: application/vnd.docker.distribution.manifest.v2+json：

    1. $ curl -v -H "Accept: application/vnd.docker.distribution.manifest.v2+json" --user foo:foo123 --cacert /etc/docker/certs.d/172.27.132.67\:8000/ca.crt https://172.27.132.67:8000/v2/prom/node-exporter/manifests/v0.16.0
    2. * About to connect() to 172.27.132.67 port 8000 (#0)
    3. *   Trying 172.27.132.67...
    4. * Connected to 172.27.132.67 (172.27.132.67) port 8000 (#0)
    5. * Initializing NSS with certpath: sql:/etc/pki/nssdb
    6. *   CAfile: /etc/docker/certs.d/172.27.132.67:8000/ca.crt
    7.   CApath: none
    8. * SSL connection using TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
    9. * Server certificate:
    10. *       subject: CN=registry,OU=4Paradigm,O=k8s,L=BeiJing,ST=BeiJing,C=CN
    11. *       start date: Jul 05 12:52:00 2018 GMT
    12. *       expire date: Jul 02 12:52:00 2028 GMT
    13. *       common name: registry
    14. *       issuer: CN=kubernetes,OU=4Paradigm,O=k8s,L=BeiJing,ST=BeiJing,C=CN
    15. * Server auth using Basic with user 'foo'
    16. > GET /v2/prom/node-exporter/manifests/v0.16.0 HTTP/1.1
    17. > Authorization: Basic Zm9vOmZvbzEyMw==
    18. > User-Agent: curl/7.29.0
    19. > Host: 172.27.132.67:8000
    20. > Accept: application/vnd.docker.distribution.manifest.v2+json
    21. >
    22. < HTTP/1.1 200 OK
    23. < Content-Length: 949
    24. < Content-Type: application/vnd.docker.distribution.manifest.v2+json
    25. < Docker-Content-Digest: sha256:55302581333c43d540db0e144cf9e7735423117a733cdec27716d87254221086
    26. < Docker-Distribution-Api-Version: registry/2.0
    27. < Etag: "sha256:55302581333c43d540db0e144cf9e7735423117a733cdec27716d87254221086"
    28. < X-Content-Type-Options: nosniff
    29. < Date: Fri, 06 Jul 2018 06:18:41 GMT
    30. <
    31. {
    32.    "schemaVersion": 2,
    33.    "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
    34.    "config": {
    35.       "mediaType": "application/vnd.docker.container.image.v1+json",
    36.       "size": 3511,
    37.       "digest": "sha256:188af75e2de0203eac7c6e982feff45f9c340eaac4c7a0f59129712524fa2984"
    38.    },
    39.    "layers": [
    40.       {
    41.          "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip",
    42.          "size": 2392417,
    43.          "digest": "sha256:224a21997e8ca8514d42eb2ed98b19a7ee2537bce0b3a26b8dff510ab637f15c"
    44.       },
    45.       {
    46.          "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip",
    47.          "size": 560703,
    48.          "digest": "sha256:cdb7590af5f064887f3d6008d46be65e929c74250d747813d85199e04fc70463"
    49.       },
    50.       {
    51.          "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip",
    52.          "size": 5332460,
    53.          "digest": "sha256:528dda9cf23d0fad80347749d6d06229b9a19903e49b7177d5f4f58736538d4e"
    54.       }
    55.    ]

    8.7.4 删除image

    向 /v2//manifests/ 发送 DELETE 请求，reference 为上一步返回的 Docker-Content-Digest 字段内容：

    $ curl -X DELETE  --user foo:foo123 --cacert /etc/docker/certs.d/172.27.132.67\:8000/ca.crt https://172.27.132.67:8000/v2/prom/node-exporter/manifests/sha256:68effe31a4ae8312e47f54bec52d1fc925908009ce7e6f734e1b54a4169081c5

    8.7.5 删除layer

    向 /v2//blobs/发送 DELETE 请求，其中 digest 是上一步返回的 fsLayers.blobSum 字段内容：

    1. $ curl -X DELETE  --user foo:foo123 --cacert /etc/docker/certs.d/172.27.132.67\:8000/ca.crt https://172.27.132.67:8000/v2/prom/node-exporter/blobs/sha256:a3ed95caeb02ffe68cdd9fd84406680ae93d633cb16422d00e8a7c22955b46d4
    2. $ curl -X DELETE  --cacert /etc/docker/certs.d/172.27.132.67\:8000/ca.crt https://172.27.132.67:8000/v2/prom/node-exporter/blobs/sha256:04176c8b224aa0eb9942af765f66dae866f436e75acef028fe44b8a98e045515
    3. $

    8.7.6 常见问题

    8.7.6.1 login失败416

    执行 http://docs.ceph.com/docs/master/install/install-ceph-gateway/ 里面的 s3 test.py 程序失败：

    1. [k8s@sre-master-node cert]$ python s3test.py 
    2. Traceback (most recent call last): 
    3. File "s3test.py", line 12, in bucket = conn.create_bucket('my-new-bucket') 
    4. File "/usr/lib/python2.7/site-packages/boto/s3/connection.py", line 625, in create_bucket response.status, response.reason, body) boto.exception.S3ResponseError: S3ResponseError: 416 Requested Range Not Satisfiable

    解决版办法：

    For anyone who is hitting this issue set default pg_num and pgp_num to lower value(8 for example), or set mon_max_pg_per_osd to a high value in ceph.conf radosgw-admin doesn' throw proper error when internal pool creation fails, hence the upper level error which is very confusing.

    Bug #21497: boto.exception.S3ResponseError: S3ResponseError: 416 Requested Range Not Satisfiable - rgw - Ceph

    8.7.6.2  login失败503
    1. ​[root@sre-master-node ~]# docker login 172.27.132.67:8000 
    2. Username: foo 
    3. Password: 
    4. Error response from daemon: login attempt to https://172.27.132.67:8000/v2/ failed with status: 503 Service Unavailable

    原因： docker run 缺少 --privileged 参数；

    9 清理集群

    9.1 清理Node

    停相关进程：

    1. $ sudo systemctl stop kubelet kube-proxy kube-nginx
    2. $ sudo systemctl disable kubelet kube-proxy kube-nginx

    停容器进程：

    1. $ crictl ps -q | xargs crictl stop
    2. $ killall -9 containerd-shim-runc-v1 pause

    停 containerd 服务：

    $ systemctl stop containerd && systemctl disable containerd

    清理文件：

    1. $ source /opt/k8s/bin/environment.sh
    2. $ # umount k8s 挂载的目录
    3. $ mount |grep -E 'kubelet|cni|containerd' | awk '{print $3}'|xargs umount
    4. $ # 删除 kubelet 目录
    5. $ sudo rm -rf ${K8S_DIR}/kubelet
    6. $ # 删除 docker 目录
    7. $ sudo rm -rf ${DOCKER_DIR}
    8. $ # 删除 containerd 目录
    9. $ sudo rm -rf ${CONTAINERD_DIR}
    10. $ # 删除 systemd unit 文件
    11. $ sudo rm -rf /etc/systemd/system/{kubelet,kube-proxy,containerd,kube-nginx}.service
    12. $ # 删除程序文件
    13. $ sudo rm -rf /opt/k8s/bin/*
    14. $ # 删除证书文件
    15. $ sudo rm -rf /etc/flanneld/cert /etc/kubernetes/cert

    清理 kube-proxy 和 calico 创建的 iptables：

    $ sudo iptables -F && sudo iptables -X && sudo iptables -F -t nat && sudo iptables -X -t nat

    9.2 清理master节点

    停相关进程：

    $ sudo systemctl stop kube-apiserver kube-controller-manager kube-scheduler

    清理文件：

    1. $ # 删除 systemd unit 文件
    2. $ sudo rm -rf /etc/systemd/system/{kube-apiserver,kube-controller-manager,kube-scheduler}.service
    3. $ # 删除程序文件
    4. $ sudo rm -rf /opt/k8s/bin/{kube-apiserver,kube-controller-manager,kube-scheduler}
    5. $ # 删除证书文件
    6. $ sudo rm -rf /etc/flanneld/cert /etc/kubernetes/cert

    9.3 清理etcd集群

    停相关进程：

    $ sudo systemctl stop etcd
    清理文件：
    1. $ source /opt/k8s/bin/environment.sh
    2. $ # 删除 etcd 的工作目录和数据目录
    3. $ sudo rm -rf ${ETCD_DATA_DIR} ${ETCD_WAL_DIR}
    4. $ # 删除 systemd unit 文件
    5. $ sudo rm -rf /etc/systemd/system/etcd.service
    6. $ # 删除程序文件
    7. $ sudo rm -rf /opt/k8s/bin/etcd
    8. $ # 删除 x509 证书文件
    9. $ sudo rm -rf /etc/etcd/cert/*

  • 相关阅读:
    第10章 MyBatisPlus实现分页检索
    matlab simulink响应谱计算
    如何让一颗芯片提前出厂打工
    Oracle-truncate误删数据恢复
    怎么样把下载到的补丁集成到Win10 ISO镜像中？
    C语言，关于字节对齐的一些问题
    好用的云笔记具备哪些特点，这3款云笔记亲测好用
    ChatGPT AIGC 完成各省份销售动态可视化分析
    i2c驱动扫描注册
    ROS2与turtlebot4仿真入门教程-turtlebot4异步建图
  • 原文地址：https://blog.csdn.net/ygq13572549874/article/details/132782080