Kubernetes1.11.1集群部署手册

1 环境概述

1.1 操作系统

注意：安装Docker需要内核版本在4.4.x以上。

CentOS系统最好选择7.4-7.7，Centos7.4之前的版本安装docker会无法使用overlay2为docker的默认存储引擎。

1.2组件版本

1.3插件

• Coredns
• Dashboard
• Metrics-server
• EFK (elasticsearch、fluentd、kibana)

1.4镜像仓库

• docker registry
• harbor（两个仓库相互同步，对外提供统一入口VIP地址）

1.5主要配置策略

1.5.1kube-apiserver高可用

• 使用Nginx或Haproxy+Keepalived实现高可用；
• 关闭非安全端口 8080 和匿名访问；
• 在安全端口 6443 接收 https 请求；
• 严格的认证和授权策略 (x509、token、RBAC)；
• 开启 bootstrap token 认证，支持 kubelet TLS bootstrapping；
• 使用 https 访问 kubelet、etcd，加密通信；

1.5.2kube-controller-manager高可用

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

1.5.3kube-scheduler高可用

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

1.5.4kubelet

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

1.5.5kube-proxy

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

1.5.6集群插件

• DNS：使用功能、性能更好的 coredns；
• Dashboard：支持登录认证；
• Metric：metrics-server，使用 https 访问 kubelet 安全端口；
• Log：Elasticsearch、Fluend、Kibana；
• Registry 镜像库：docker-registry、Harbor私有仓库，两个节点相互同步；

2 安装部署

搭建Kubernetes集群环境有以下三种方式：

1. ==Minikube==安装方式 Minikube是一个工具，可以在本地快速运行一个单点的Kubernetes，尝试Kubernetes或日常开发的用户使用。但是这种方式仅可用于学习和测试部署，不能用于生产环境。
2. ==Kubeadm==安装方式 kubeadm是一个kubernetes官方提供的快速安装和初始化拥有最佳实践（best practice）的kubernetes集群的工具，提供kubeadm init和kubeadm join，用于快速部署Kubernetes集群。目前kubeadm还处于beta 和alpha状态，不推荐用在生产环境，但是可以通过学习这种部署方法来体会一些官方推荐的kubernetes最佳实践的设计和思想。

kubeadm的目标是提供一个最小可用的可以通过Kubernetes一致性测试的集群，所以并不会安装任何除此之外的非必须的addon。kubeadm默认情况下并不会安装一个网络解决方案，所以用kubeadm安装完之后，需要自己来安装一个网络的插件。所以说，目前的kubeadm是不能用于生产环境的

3. ==二进制包==安装方式（生产部署的推荐方式） 从官方下载发行版的二进制包，手动部署每个组件，组成Kubernetes集群，这种方式符合企业生产环境标准的Kubernetes集群环境的安装，可用于生产方式部署。

2.1 节点规划

生产环境双master高可用，数据库最少3台，奇数增加。node节点最少2个，可以用云服务器SLB进行负载均衡，也可以使用nginx+keepa高可用。

2.1 OS初始化

2.1.1升级内核

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";

• 更新elrep

rpm -Uvh http://www.elrepo.org/elrepo-release-7.0-4.el7.elrepo.noarch.rpm

• 安装完成后检查 /boot/grub2/grub.cfg 中对应内核 menuentry 中是否包含 initrd16 配置，如果没有，再安装一次！

xxxxxxxxxx
yum -y update
yum --enablerepo=elrepo-kernel install -y kernel-lt

• 设置开机从新内核启动

xxxxxxxxxx
grub2-set-default 0
reboot

2.1.2安装依赖包和repo文件

​x
yum install -y lrzsz vim wget curl curl-devel zip unzip telnet ftp tree screen lsof tcpdump expect expect-devel p7zip p7zip-plugins convmv ntp ntpdate net-tools man.x86_64 man-pages.noarch bash-completion lvm2 conntrack ipvsadm ipset jq iptables sysstat libseccomp yum-utils device-mapper-persistent-data 
​
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
或
wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo -O /etc/yum.repos.d/docker-ce.repo
​
cat > /etc/yum.repos.d/kubernetes.repo <<EOF
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/ 
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg 
https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF

• 执行命令，更新：

xxxxxxxxxx
yum clean all && yum -y makecache && yum -y update

• 验证：

xxxxxxxxxx
yum list | grep kubernetes | sort -r
yum list | grep docker-ce | sort -r 

• 其他配置：

xxxxxxxxxx
cat >> /etc/profile <<EOF
​
alias vi='vim'
alias grep='grep --colour=auto'
EOF
​
source /etc/profile
​
ntpdate 0.centos.pool.ntp.org && hwclock -w && hwclock --systohc
​
sed -i "s/^#UseDNS yes/UseDNS no/" /etc/ssh/sshd_config
systemctl restart sshd
​
useradd ops
passwd ops
mkdir -p /app
chown -R ops.ops /app
sed -i '$a  ops     ALL=(ALL)       ALL\nops     ALL=(ALL)       NOPASSWD: ALL' /etc/sudoers
​

2.1.3 加载ipvs相关内核模块

• 为什么要使用IPVS,从k8s的1.8版本开始，kube-proxy引入了IPVS模式，IPVS模式与iptables同样基于Netfilter，但是采用的hash表，因此当service数量达到一定规模时，hash查表的速度优势就会显现出来，从而提高service的服务性能。
• ipvs依赖于nf_conntrack_ipv4内核模块,4.19包括之后内核里改名为nf_conntrack,1.13.1之前的kube-proxy的代码里没有加判断一直用的nf_conntrack_ipv4,1.13.1后的kube-proxy代码里增加了判断,是会去load nf_conntrack使用ipvs正常。
• 执行如下命令，加载ipvs相关内核模块：
• 临时生效：

xxxxxxxxxx
modprobe -- ip_vs
modprobe -- ip_vs_rr
modprobe -- ip_vs_wrr
modprobe -- ip_vs_sh
modprobe -- nf_conntrack_ipv4

• 永久生效：

xxxxxxxxxx
cat > /etc/sysconfig/modules/ipvs.modules <<EOF
modprobe -- ip_vs
modprobe -- ip_vs_rr
modprobe -- ip_vs_wrr
modprobe -- ip_vs_sh
modprobe -- nf_conntrack_ipv4
EOF

• 执行命令，检验结果：

xxxxxxxxxx
lsmod | grep ip_vs

2.1.4关闭 NUMA

• 在 GRUB_CMDLINE_LINUX 一行添加 `numa=off` 参数

xxxxxxxxxx
cp /etc/default/grub{,.bak} 
sed -i "s/quiet/quiet ipv6.disable=1 numa=off/" /etc/default/grub

• 重新生成grub.cfg

xxxxxxxxxx
cp /boot/grub2/grub.cfg{,.bak}
diff /etc/default/grub.bak /etc/default/grub
grub2-mkconfig -o /boot/grub2/grub.cfg

2.1.5关闭防火墙

• 在所有服务器上执行以下命令，关闭防火墙服务，清理防火墙规则，设置默认转发策略：

xxxxxxxxxx
systemctl stop firewalld.service

• 关闭防火墙服务开机启动：

xxxxxxxxxx
systemctl disable firewalld.service

• 清理防火墙规则：

xxxxxxxxxx
iptables -F && iptables -X && iptables -F -t nat && iptables -X -t nat

• 设置默认转发策略：

xxxxxxxxxx
iptables -P FORWARD ACCEPT

2.1.6 关闭Selinux

• 在所有服务器上执行以下命令，关闭Selinux：

xxxxxxxxxx
setenforce 0

• 永久禁用：编辑配置文件/etc/selinux/config，使SELINUX=disabled

xxxxxxxxxx
sed -i 's/SELINUX=enforcing/SELINUX=disabled/' /etc/selinux/config

2.1.7关闭swap

• 在所有服务器上执行以下命令，关闭swap：

xxxxxxxxxx
swapoff -a

• 永久禁用：编辑文件/etc/fstab，注释所有swap相关行

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

2.1.8优化内核参数

xxxxxxxxxx
​
cp /etc/security/limits.conf{,.org}
cat  >> /etc/security/limits.conf << EOF
​
*    soft    nofile  655350
*    hard    nofile  655350
*    soft    nproc unlimited
*    hard    nproc unlimited
EOF
​
cat >> /etc/rc.local<< EOF
​
ulimit -SHn 655350
ulimit -SHu unlimited
ulimit -SHs unlimited
EOF
​
cp /etc/sysctl.conf{,.org}
cat >> /etc/sysctl.conf << EOF
​
kernel.msgmnb = 65536
kernel.msgmax = 65536
kernel.shmmax = 68719476736
kernel.shmall = 4294967296
EOF
/sbin/sysctl -p
​
cat > /etc/sysctl.d/k8s.conf <<EOF
net.bridge.bridge-nf-call-iptables=1
net.bridge.bridge-nf-call-ip6tables=1
net.ipv4.ip_forward=1
net.ipv4.tcp_tw_recycle=0
vm.swappiness=0
vm.overcommit_memory=1
vm.panic_on_oom=0
fs.inotify.max_user_instances=8192
fs.inotify.max_user_watches=1048576
fs.file-max=52706963
fs.nr_open=52706963
#net.netfilter.nf_conntrack_max=2310720
EOF

xxxxxxxxxx
sysctl -p /etc/sysctl.d/k8s.conf

• 修改完成后，执行命令：
• 必须关闭 tcp_tw_recycle，否则和 NAT 冲突，会导致服务不通；
• 关闭 IPV6，防止触发 docker BUG；

2.1.9关闭无关的服务

xxxxxxxxxx
systemctl stop postfix && systemctl disable postfix

2.1.10设置 rsyslogd 和 systemd journald

journald 默认将日志转发给 rsyslog，这会导致日志写了多份，/var/log/messages 中包含了太多无关日志，不方便后续查看，同时也影响系统性能。

xxxxxxxxxx
mkdir /var/log/journal
mkdir /etc/systemd/journald.conf.d
​
cat > /etc/systemd/journald.conf.d/99-prophet.conf <<EOF
[Journal]
# 持久化保存到磁盘
Storage=persistent
# 压缩历史日志
Compress=yes
SyncIntervalSec=5m
RateLimitInterval=30s
RateLimitBurst=1000
# 最大占用空间 2G
SystemMaxUse=2G
# 单日志文件最大 100M
SystemMaxFileSize=100M
# 日志保存时间 2 周
MaxRetentionSec=2week
# 不将日志转发到 syslog
ForwardToSyslog=no
EOF
​
systemctl restart systemd-journald

2.2k8s通用配置

2.2.1安装CFSSL

• 创建目录

xxxxxxxxxx
mkdir -p /app/{opt,bin,etc,cert,data,logs,wal}
​

• 使用wget下载cfssl包

xxxxxxxxxx
wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64
wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64
wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64

• 移动下载好的包

xxxxxxxxxx
cp cfssl_linux-amd64 /app/bin/cfssl
cp cfssljson_linux-amd64 /app/bin/cfssljson
cp cfssl-certinfo_linux-amd64 /app/bin/cfssl-certinfo
chmod +x /app/bin/*

• 设置系统环境变量

xxxxxxxxxx
cat >> /etc/profile <<EOF
​
export PATH=\$PATH:/app/bin
EOF
​
source /etc/profile

2.2.2创建CA证书和秘钥

为确保安全，kubernetes 系统各组件需要使用 x509 证书对通信进行加密和认证。 CA (Certificate Authority) 是自签名的根证书，用来签名后续创建的其它证书。 本文档使用 CloudFlare 的 PKI 工具集 fssl​创建所有证书。

• 创建根证书 (CA)

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

• 创建用来生成 CA 文件的 JSON 配置文件

CA 配置文件用于配置根证书的使用场景 (profile) 和具体参数 (usage，过期时间、服务端认证、客户端认证、加密等)，后续在签名其它证书时需要指定特定场景。

xxxxxxxxxx
cat > /app/cert/ca-config.json <<EOF
{
  "signing": {
    "default": {
      "expiry": "876000h"
    },
    "profiles": {
      "kubernetes": {
        "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ],
        "expiry": "876000h"
      }
    }
  }
}
EOF

signing：表示该证书可用于签名其它证书，生成的 ca.pem 证书中 CA=TRUE； server auth：表示 client 可以用该该证书对 server 提供的证书进行验证； client auth：表示 server 可以用该该证书对 client 提供的证书进行验证；

• 创建用来生成 CA 证书签名请求（CSR）的 JSON 配置文件

xxxxxxxxxx
cat > /app/cert/ca-csr.json <<EOF
{
  "CN": "kubernetes",
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "k8s",
      "OU": "System"
    }
  ],
  "ca": {
    "expiry": "876000h"
 }
}
EOF

CN：Common Name，kube-apiserver 从证书中提取该字段作为请求的用户名 (User Name)，浏览器使用该字段验证网站是否合法； O：Organization，kube-apiserver 从证书中提取该字段作为请求用户所属的组 (Group)； kube-apiserver 将提取的 User、Group 作为 RBAC 授权的用户标识；

• 生成CA证书（ca.pem）和密钥（ca-key.pem）

xxxxxxxxxx
cd /app/cert
cfssl gencert -initca ca-csr.json | cfssljson -bare ca
​
ll ca*
-rw-r--r-- 1 root root  294 Nov  5 17:23 ca-config.json
-rw-r--r-- 1 root root 1001 Nov  5 17:23 ca.csr
-rw-r--r-- 1 root root  246 Nov  5 17:23 ca-csr.json
-rw------- 1 root root 1679 Nov  5 17:23 ca-key.pem
-rw-r--r-- 1 root root 1363 Nov  5 17:23 ca.pem
​
rm -rf ca.csr ca-csr.json

2.2.3部署 kubectl 命令行工具

kubectl 默认从 ~/.kube/config 文件读取 kube-apiserver 地址和认证信息，如果没有配置，执行 kubectl 命令时可能会出错：

xxxxxxxxxx
$ kubectl get pods
The connection to the server localhost:8080 was refused - did you specify the right host or port?

本文档只需要部署一次，生成的 kubeconfig 文件是通用的，可以拷贝到需要执行 kubectl 命令的机器，重命名为 ~/.kube/config；

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

下载和解压：

xxxxxxxxxx
cd /app/opt
wget https://dl.k8s.io/v1.16.2/kubernetes-client-linux-amd64.tar.gz
tar -xzf kubernetes-client-linux-amd64.tar.gz
cp /app/opt/kubernetes/client/bin/kubectl /app/bin
chmod +x /app/bin/kubectl
kubectl version

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

xxxxxxxxxx
for node_ip in k8s-base-02 k8s-base-03
  do
    echo ">>> ${node_ip}"
    scp /app/opt/kubernetes/client/bin/kubectl root@${node_ip}:/app/bin
    ssh root@${node_ip} "chmod +x /app/bin/kubectl && source /etc/profile && kubectl version && kubectl version"
  done

• 创建 admin 证书和私钥

kubectl 与 apiserver https 安全端口通信，apiserver 对提供的证书进行认证和授权。 kubectl 作为集群的管理工具，需要被授予最高权限，这里创建具有最高权限的 admin 证书。

后面只有apiserver和kubelet这两个服务启动参数会用到admin的ca证书；kubectl工具和kubelet服务不是一回事。

创建证书签名请求：

xxxxxxxxxx
cd /app/cert
cat > /app/cert/admin-csr.json <<EOF
{
  "CN": "admin",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "system:masters",
      "OU": "System"
    }
  ]
}
EOF

O 为 system:masters，kube-apiserver 收到该证书后将请求的 Group 设置为 system:masters；

预定义的 ClusterRoleBinding cluster-admin 将 Group system:masters 与 Role cluster-admin 绑定，该 Role 授予所有 API的权限；

该证书只会被 kubectl 当做 client 证书使用，所以 hosts 字段为空；

生成证书和私钥：

xxxxxxxxxx
cfssl gencert -ca=/app/cert/ca.pem \
  -ca-key=/app/cert/ca-key.pem \
  -config=/app/cert/ca-config.json \
  -profile=kubernetes admin-csr.json | cfssljson -bare admin
​
ls -al admin*
-rw-r--r-- 1 root root 1009 Nov 11 12:12 admin.csr
-rw-r--r-- 1 root root  229 Nov 11 12:12 admin-csr.json
-rw------- 1 root root 1679 Nov 11 12:12 admin-key.pem
-rw-r--r-- 1 root root 1403 Nov 11 12:12 admin.pem
​
rm -rf admin.csr admin-csr.json

• 创建 kubeconfig 文件

kubeconfig 为 kubectl 的配置文件，包含访问 apiserver 的所有信息，如 apiserver 地址、CA 证书和自身使用的证书；

xxxxxxxxxx
cd /app/etc
​
# 设置集群参数
kubectl config set-cluster kubernetes \
  --certificate-authority=/app/cert/ca.pem \
  --embed-certs=true \
  --server=https://192.168.209.100:8443\
  --kubeconfig=kubectl.kubeconfig
​
# 设置客户端认证参数
kubectl config set-credentials admin \
  --client-certificate=/app/cert/admin.pem \
  --client-key=/app/cert/admin-key.pem \
  --embed-certs=true \
  --kubeconfig=kubectl.kubeconfig
​
# 设置上下文参数
kubectl config set-context kubernetes \
  --cluster=kubernetes \
  --user=admin \
  --kubeconfig=kubectl.kubeconfig
​
# 设置默认上下文
kubectl config use-context kubernetes --kubeconfig=kubectl.kubeconfig
​
cp kubectl.kubeconfig  ~/.kube/config

--certificate-authority：验证 kube-apiserver 证书的根证书；

--serve：kube-apiserver的地址，如果apiserer前有负载均衡，则是VIP地址；

--client-certificate、--client-key：刚生成的 admin 证书和私钥，连接 kube-apiserver 时使用；

--embed-certs=true：将 ca.pem 和 admin.pem 证书内容嵌入到生成的 kubectl.kubeconfig 文件中(不加时，写入的是证书文件路径，后续拷贝 kubeconfig 到其它机器时，还需要单独拷贝证书文件，不方便。)；

• 分发 kubeconfig 文件

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

xxxxxxxxxx
for node_ip in k8s-base-02 k8s-base-03
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "mkdir -p ~/.kube"
    scp kubectl.kubeconfig root@${node_ip}:~/.kube/config
  done

保存的文件名为 ~/.kube/config；

2.3部署apiserver高可用

2.3.1基本配置

• k8s-lb-01节点操作

xxxxxxxxxx
hostnamectl --static set-hostname k8s-lb-01
​
cat >> /etc/hosts <<EOF
192.168.209.98 k8s-lb-01
192.168.209.99 k8s-lb-02
EOF
​
mkdir -p /app/{opt,bin,etc,logs}

• 无密码ssh登录其它节点

xxxxxxxxxx
ssh-keygen -t rsa -P "" -f ~/.ssh/id_rsa
​
for  node_ip in k8s-lb-01 k8s-lb-02
do
  expect -c "
  spawn ssh-copy-id -i /root/.ssh/id_rsa.pub root@${node_ip}
        expect {
                \"*yes/no*\" {send \"yes\r\"; exp_continue}
                \"*password*\" {send \"hello\r\"; exp_continue}
                \"*Password*\" {send \"hello\r\";}
        } "
done

• 批量修改主机名

xxxxxxxxxx
ssh k8s-lb-02 "hostnamectl --static set-hostname k8s-lb-02 && mkdir -p /app/{opt,bin,etc,logs}"

• 批量修改hosts

xxxxxxxxxx
ssh k8s-lb-02 "cat >> /etc/hosts <<EOF
192.168.209.98 k8s-lb-01
192.168.209.99 k8s-lb-02
EOF"

2.3.2安装haproxy+keeplived

• 首先所有lb节点安装haproxy+keeplived

xxxxxxxxxx
for node_ip in k8s-lb-01 k8s-lb-02
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "yum -y install haproxy keepalived && rpm -qa|grep haproxy && rpm -qa|grep keepalived"
  done

• 在k8s-lb-01修改配置文件

haproxy配置文件修改：

xxxxxxxxxx
mv /etc/haproxy/haproxy.cfg /etc/haproxy/haproxy.cfg.org
​
cat > /etc/haproxy/haproxy.cfg <<EOF
global
  maxconn  2000
  ulimit-n  16384
  log  127.0.0.1 local0 err
  stats timeout 30s
​
defaults
  log global
  mode  http
  option  httplog
  timeout connect 5000
  timeout client  50000
  timeout server  50000
  timeout http-request 15s
  timeout http-keep-alive 15s
​
frontend monitor-in
  bind *:33305
  mode http
  option httplog
  monitor-uri /monitor
​
listen stats
  bind    *:8006
  mode    http
  stats   enable
  stats   hide-version
  stats   uri       /stats
  stats   refresh   30s
  stats   realm     Haproxy\ Statistics
  stats   auth      admin:admin
​
frontend k8s-api
  bind 0.0.0.0:8443
  bind 127.0.0.1:8443
  mode tcp
  option tcplog
  tcp-request inspect-delay 5s
  default_backend k8s-api
​
backend k8s-api
  mode tcp
  option tcplog
  option tcp-check
  balance roundrobin
  default-server inter 10s downinter 5s rise 2 fall 2 slowstart 60s maxconn 250 maxqueue 256 weight 100
  server k8s-api-1  192.168.209.101:6443  check
  server k8s-api-2  192.168.209.102:6443  check
  server k8s-api-3  192.168.209.103:6443  check
EOF

keeplived配置文件修改：

xxxxxxxxxx
mv /etc/keepalived/keepalived.conf /etc/keepalived/keepalived.conf.org
​
cat > /etc/keepalived/keepalived.conf <<EOF
global_defs {
   notification_email { 
       root@localhost
   }
   notification_email_from keepalived@localhost
   smtp_server 127.0.0.1 
   smtp_connect_timeout 30
   router_id s1.keepalived 
   #vrrp_mcast_group4 224.0.100.19
   vrrp_skip_check_adv_addr
   #vrrp_strict                 #将严格遵守vrrp协议这一项关闭，否则会因为不是组播而无法启动keepalived
   vrrp_iptables
   vrrp_garp_interval 0
   vrrp_gna_interval 0
}
​
vrrp_script haproxy-check {
    script "/bin/bash /app/bin/check_haproxy.sh"
    interval 3
    weight -2
    fall 10
    rise 2
}
​
vrrp_instance haproxy-vip {
    state MASTER
    priority 100
    interface ens32
    virtual_router_id 47
    advert_int 3
    authentication {
        auth_type PASS
        auth_pass 1111
    } 
    
    unicast_src_ip 192.168.209.98 
​
    unicast_peer {
        192.168.209.99
    }
​
    virtual_ipaddress {
        192.168.209.100
    }
​
    track_script {
        haproxy-check
    }
}
EOF

xxxxxxxxxx
cat > /app/bin/check_haproxy.sh <<EOF
#!/bin/bash
​
errorExit() {
    echo "*** $*" 1>&2
    exit 1
}
​
if ip addr | grep -q 192.168.209.100 ; then
    curl -s --max-time 2 --insecure https://192.168.209.100:8443/ -o /dev/null || errorExit "Error GET https://192.168.209.100:8443/"
fi
EOF
​
chmod +x /app/bin/check_haproxy.sh

分发keeplived及haproxy文件给所有lb

xxxxxxxxxx
for node_ip in k8s-lb-02
  do
    echo ">>> ${node_ip}"
    scp /etc/haproxy/haproxy.cfg root@${node_ip}:/etc/haproxy
    scp /etc/keepalived/keepalived.conf root@${node_ip}:/etc/keepalived
    scp /app/bin/check_haproxy.sh root@${node_ip}:/app/bin
    ssh root@${node_ip} "sed -i 's#s1.keepalived#s2.keepalived#g' /etc/keepalived/keepalived.conf"
    ssh root@${node_ip} "sed -i 's#MASTER#BACKUP#g' /etc/keepalived/keepalived.conf"
    ssh root@${node_ip} "sed -i 's#priority 100#priority 80#g' /etc/keepalived/keepalived.conf"
    ssh root@${node_ip} "sed -i 's#virtual_router_id 47#virtual_router_id 27#g' /etc/keepalived/keepalived.conf"
    ssh root@${node_ip} "sed -i 's#192.168.209.99#192.168.209.98#g' /etc/keepalived/keepalived.conf"
    ssh root@${node_ip} "sed -i 's#unicast_src_ip 192.168.209.98#unicast_src_ip 192.168.209.99#g' /etc/keepalived/keepalived.conf"
  done

启动lb节点服务：

xxxxxxxxxx
for node_ip in k8s-lb-01 k8s-lb-02
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "systemctl enable --now haproxy keepalived && systemctl restart haproxy keepalived && systemctl status haproxy keepalived && ps -ef | grep haproxy && ps -ef | grep keepalived && netstat -tnulp"
  done

验证

http://192.168.209.98:33305/monitor

http://192.168.209.99:33305/monitor

http://192.168.209.98:8006/stats

http://192.168.209.99:8006/stats

2.4部署etcd集群

2.4.1基本配置

• k8s-etcd-01节点操作

xxxxxxxxxx
hostnamectl --static set-hostname k8s-etcd-01
​
cat >> /etc/hosts <<EOF
192.168.209.111 k8s-etcd-01
192.168.209.112 k8s-etcd-02
192.168.209.113 k8s-etcd-03
EOF
​

• 无密码ssh登录其它节点

xxxxxxxxxx
ssh-keygen -t rsa -P "" -f ~/.ssh/id_rsa
​
for  node_ip in k8s-etcd-01 k8s-etcd-02 k8s-etcd-03;do
expect -c "
spawn ssh-copy-id -i /root/.ssh/id_rsa.pub root@${node_ip}
        expect {
                \"*yes/no*\" {send \"yes\r\"; exp_continue}
                \"*password*\" {send \"hello\r\"; exp_continue}
                \"*Password*\" {send \"hello\r\";}
        } "
done

• 批量修改主机名

xxxxxxxxxx
ssh k8s-etcd-02 "hostnamectl --static set-hostname k8s-etcd-02" &&
ssh k8s-etcd-03 "hostnamectl --static set-hostname k8s-etcd-03"

• 批量修改hosts

xxxxxxxxxx
ssh k8s-etcd-02 "cat >> /etc/hosts <<EOF
192.168.209.111 k8s-etcd-01
192.168.209.112 k8s-etcd-02
192.168.209.113 k8s-etcd-03
EOF" &&
ssh k8s-etcd-03 "cat >> /etc/hosts <<EOF
192.168.209.111 k8s-etcd-01
192.168.209.112 k8s-etcd-02
192.168.209.113 k8s-etcd-03
EOF"

2.4.2安装etcd

etcd 是基于 Raft 的分布式 key-value 存储系统，由 CoreOS 开发，常用于服务发现、共享配置以及并发控制（如 leader 选举、分布式锁等）。kubernetes 使用 etcd 存储所有运行数据。

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

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

xxxxxxxxxx
cd /app/opt
wget https://github.com/coreos/etcd/releases/download/v3.4.3/etcd-v3.4.3-linux-amd64.tar.gz
tar -xzf etcd-v3.4.3-linux-amd64.tar.gz

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

xxxxxxxxxx
for node_ip in  k8s-etcd-01 k8s-etcd-02 k8s-etcd-03
  do
    echo ">>> ${node_ip}"
    scp etcd-v3.4.3-linux-amd64/etcd* root@${node_ip}:/app/bin
    ssh root@${node_ip} "chmod +x /app/bin/etcd* && source /etc/profile && etcd --version && etcdctl version"
  done

• 创建 etcd 证书和私钥

创建证书签名请求：

xxxxxxxxxx
cat > /app/cert/etcd-csr.json <<EOF
{
  "CN": "etcd",
  "hosts": [
    "127.0.0.1",
    "192.168.209.111",
    "192.168.209.112",
    "192.168.209.113"
  ],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "k8s",
      "OU": "System"
    }
  ]
}
EOF

hosts 字段指定授权使用该证书的 etcd 节点 IP 或域名列表，需要将 etcd 集群的三个节点 IP 都列在其中；

生成证书和私钥：

xxxxxxxxxx
cd /app/cert
cfssl gencert -ca=/app/cert/ca.pem \
    -ca-key=/app/cert/ca-key.pem \
    -config=/app/cert/ca-config.json \
    -profile=kubernetes etcd-csr.json | cfssljson -bare etcd
    
ll etcd*
 -rw-r--r-- 1 root root 1062 Nov  6 10:10 etcd.csr
-rw-r--r-- 1 root root  305 Nov  6 10:10 etcd-csr.json
-rw------- 1 root root 1679 Nov  6 10:10 etcd-key.pem
-rw-r--r-- 1 root root 1436 Nov  6 10:10 etcd.pem
​
rm -rf etcd.csr etcd-csr.json

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

xxxxxxxxxx
for node_ip in   k8s-etcd-02 k8s-etcd-03
  do
    echo ">>> ${node_ip}"
    scp etcd*.pem root@${node_ip}:/app/cert
  done

• 设置etcd配置文件

  配置文件路径为/etc/etcd/etcd.config.yml,参考官方 etcd.conf.yml

xxxxxxxxxx
mkdir /app/wal
cat > /app/etc/etcd.conf.yml <<EOF
name: k8s-etcd-01
data-dir: /app/data
wal-dir: /app/wal
snapshot-count: 10000
heartbeat-interval: 100
election-timeout: 1000
quota-backend-bytes: 0
listen-peer-urls: https://192.168.209.111:2380
listen-client-urls: https://192.168.209.111:2379,http://127.0.0.1:2379
max-snapshots: 5
max-wals: 5
cors: 
initial-advertise-peer-urls: https://192.168.209.111:2380
advertise-client-urls: https://192.168.209.111:2379
discovery: 
discovery-fallback: proxy
discovery-proxy: 
discovery-srv: 
initial-cluster: k8s-etcd-01=https://192.168.209.111:2380,k8s-etcd-02=https://192.168.209.112:2380,k8s-etcd-03=https://192.168.209.113:2380
initial-cluster-token: k8s-etcd-cluster
initial-cluster-state: new
strict-reconfig-check: false
enable-v2: true
enable-pprof: true
client-transport-security: 
  ca-file: /app/cert/ca.pem
  cert-file: /app/cert/etcd.pem
  key-file: /app/cert/etcd-key.pem
  client-cert-auth: true
  trusted-ca-file: /app/cert/ca.pem
  auto-tls: true
peer-transport-security: 
  ca-file: /app/cert/ca.pem
  cert-file: /app/cert/etcd.pem
  key-file: /app/cert/etcd-key.pem
  peer-client-cert-auth: true
  trusted-ca-file: /app/cert/ca.pem
  auto-tls: true
logger: zap
log-output: 
log-level: info
force-new-cluster: false
EOF

data-dir 指定节点的数据存储目录，这些数据包括节点ID，集群ID，集群初始化配置，Snapshot文件，若未指定--wal-dir，还会存储WAL文件；

wal-dir 指定节点的was文件的存储目录，若指定了该参数，wal文件会和其他数据文件分开存储；

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 证书；

• 创建etcd 的systemd unit 文件

xxxxxxxxxx
cat > /usr/lib/systemd/system/etcd.service <<EOF
[Unit]
Description=Etcd Service
After=network.target
 
[Service]
Type=notify
ExecStart=/app/bin/etcd --config-file=/app/etc/etcd.conf.yml
Restart=on-failure
RestartSec=10
 
[Install]
WantedBy=multi-user.target
EOF
​

• 分发systemd和配置文件

xxxxxxxxxx
for node_ip in k8s-etcd-02 k8s-etcd-03
  do
  echo ">>> ${node_ip}"
    scp /app/etc/etcd.conf.yml root@${node_ip}:/app/etc/etcd.conf.yml
    scp /usr/lib/systemd/system/etcd.service root@${node_ip}:/usr/lib/systemd/system/etcd.service
    ssh root@k8s-etcd-02 "sed -i 's#name: k8s-etcd-01#name: k8s-etcd-02#g' /app/etc/etcd.conf.yml"
    ssh root@k8s-etcd-02 "sed -i "s/192.168.209.111/192.168.209.112/g" /app/etc/etcd.conf.yml"
    ssh root@k8s-etcd-02 "sed -i "s#k8s-etcd-01=https:\/\/192.168.209.112#k8s-etcd-01=https:\/\/192.168.209.111#g" /app/etc/etcd.conf.yml"
    ssh root@k8s-etcd-03 "sed -i 's#name: k8s-etcd-01#name: k8s-etcd-03#g' /app/etc/etcd.conf.yml"
    ssh root@k8s-etcd-03 "sed -i "s/192.168.209.111/192.168.209.113/g" /app/etc/etcd.conf.yml"
    ssh root@k8s-etcd-03 "sed -i "s#k8s-etcd-01=https:\/\/192.168.209.113#k8s-etcd-01=https:\/\/192.168.209.111#g" /app/etc/etcd.conf.yml"   
  done

• 启动所有 etcd 服务

xxxxxxxxxx
for node_ip in k8s-etcd-01 k8s-etcd-02 k8s-etcd-03
  do
  echo ">>> ${node_ip}"
  ssh root@${node_ip} "systemctl daemon-reload && systemctl enable etcd && systemctl restart etcd && systemctl status etcd"
  done

• 检查端口进程是否正常

xxxxxxxxxx
for node_ip in k8s-etcd-01 k8s-etcd-02 k8s-etcd-03
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "ps -ef | grep etcd && netstat -tnulp | grep etcd && lsof -i:2379"
  done

• 验证集群服务状态

xxxxxxxxxx
for node_ip in 192.168.209.111 192.168.209.112 192.168.209.113
  do
    echo ">>> ${node_ip}"
    ETCDCTL_API=3 /app/bin/etcdctl \
    --endpoints=https://${node_ip}:2379 \
    --cacert=/app/cert/ca.pem \
    --cert=/app/cert/etcd.pem \
    --key=/app/cert/etcd-key.pem endpoint health
  done 

xxxxxxxxxx
>>> 192.168.209.111
https://192.168.209.111:2379 is healthy: successfully committed proposal: took = 8.18993ms
>>> 192.168.209.112
https://192.168.209.112:2379 is healthy: successfully committed proposal: took = 94.727521ms
>>> 192.168.209.113
https://192.168.209.113:2379 is healthy: successfully committed proposal: took = 55.996259ms

• 查看当前的 leader

xxxxxxxxxx
export etcd_endpoints=https://192.168.209.111:2379,https://192.168.209.112:2379,https://192.168.209.113:2379
​
ETCDCTL_API=3 /app/bin/etcdctl \
  -w table --cacert=/app/cert/ca.pem \
  --cert=/app/cert/etcd.pem \
  --key=/app/cert/etcd-key.pem \
  --endpoints=${etcd_endpoints} endpoint status

+------------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+ |ENDPOINT|ID|VERSION |DB SIZE | IS LEADER | IS LEARNER | RAFT TERM | RAFT INDEX | RAFT APPLIED INDEX | ERRORS | +------------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+ | https://192.168.209.111:2379 | 1f7b20c64341f02d | 3.4.3 | 20 kB | true | false | 301 | 12 | 12 | | | https://192.168.209.112:2379 | 67399fad7b454529 | 3.4.3 | 20 kB | false | false | 301 | 12 | 12 | | | https://192.168.209.113:2379 | 5345e9a1fbc2ee1c | 3.4.3 | 20 kB | false | false | 301 | 12 | 12 | | +------------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+

当前的 leader 为192.168.209.111。

2.5部署master集群

2.5.1基本配置

• k8s-master-01节点操作

xxxxxxxxxx
hostnamectl --static set-hostname k8s-master-01
​
cat >> /etc/hosts <<EOF
192.168.209.101 k8s-master-01
192.168.209.102 k8s-master-02
192.168.209.103 k8s-master-03
EOF

• 无密码ssh登录其它节点

xxxxxxxxxx
ssh-keygen -t rsa -P "" -f ~/.ssh/id_rsa
​
for  node_ip in k8s-master-01 k8s-master-02 k8s-master-03
do
  expect -c "
  spawn ssh-copy-id -i /root/.ssh/id_rsa.pub root@${node_ip}
        expect {
                \"*yes/no*\" {send \"yes\r\"; exp_continue}
                \"*password*\" {send \"hello\r\"; exp_continue}
                \"*Password*\" {send \"hello\r\";}
        } "
done

• 批量修改主机名

xxxxxxxxxx
ssh k8s-master-02 "hostnamectl --static set-hostname k8s-master-02" &&
ssh k8s-master-03 "hostnamectl --static set-hostname k8s-master-03"

• 批量修改hosts

xxxxxxxxxx
ssh k8s-master-02 "cat >> /etc/hosts <<EOF
192.168.209.101 k8s-master-01
192.168.209.102 k8s-master-02
192.168.209.103 k8s-master-03
EOF" &&
ssh k8s-master-03 "cat >> /etc/hosts <<EOF
192.168.209.101 k8s-master-01
192.168.209.102 k8s-master-02
192.168.209.103 k8s-master-03
EOF"

• 下载二进制包并部署组件

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

xxxxxxxxxx
cd  /app/opt
wget https://dl.k8s.io/v1.16.2/kubernetes-server-linux-amd64.tar.gz
tar -xzf kubernetes-server-linux-amd64.tar.gz

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

xxxxxxxxxx
for node_ip in k8s-master-01 k8s-master-02 k8s-master-03
  do
    echo ">>> ${node_ip}"
     scp /app/opt/kubernetes/server/bin/{kube-apiserver,kube-controller-manager,kube-scheduler} root@${node_ip}:/app/bin
     ssh root@${node_ip} "chmod +x /app/bin/kube* && source /etc/profile && kube-apiserver --version && kube-controller-manager --version && kube-scheduler --version"
  done

2.5.2部署kube-apiserver

• 创建 kubernetes 证书和私钥

创建证书签名请求：

xxxxxxxxxx
cat > /app/cert/k8s-csr.json <<EOF
{
  "CN": "kubernetes",
  "hosts": [
    "127.0.0.1",
    "192.168.209.101",
    "192.168.209.102",
    "192.168.209.103",
    "192.168.209.100",
    "192.168.209.98",
    "192.168.209.99",
    "10.254.0.1",
    "kubernetes",
    "kubernetes.default",
    "kubernetes.default.svc",
    "kubernetes.default.svc.cluster",
    "kubernetes.default.svc.cluster.local."
  ],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "k8s",
      "OU": "System"
    }
  ]
}
EOF

hosts 字段指定授权使用该证书的 IP 和域名列表，这里列出了 master 节点 IP、kubernetes 服务的 IP 和域名。如果master做负载均衡，还需增加lb的IP和VIP；

kubernetes 服务 IP 是 apiserver 自动创建的，一般是 --service-cluster-ip-range 参数指定的网段的第一个IP，后续可以通过下面命令获取：

xxxxxxxxxx
$ kubectl get svc kubernetes
NAME         CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
kubernetes   10.254.0.1   <none>        443/TCP   1d

生成证书和私钥：

xxxxxxxxxx
cfssl gencert -ca=/app/cert/ca.pem \
  -ca-key=/app/cert/ca-key.pem \
  -config=/app/cert/ca-config.json \
  -profile=kubernetes k8s-csr.json | cfssljson -bare k8s
  
  rm -rf  k8s.csr k8s-csr.json

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

xxxxxxxxxx
for node_ip in k8s-master-02 k8s-master-03
  do
    echo ">>> ${node_ip}"
     scp /app/cert/k8s*.pem root@${node_ip}:/app/cert
     ssh root@${node_ip} "ls -alh /app/cert/k8s*"
  done

• 创建加密配置文件

xxxxxxxxxx
cat > /app/etc/encryption-config.yaml <<EOF
kind: EncryptionConfig
apiVersion: v1
resources:
  - resources:
      - secrets
    providers:
      - aescbc:
          keys:
            - name: key1
              secret: O92ZTxpbTdkMbdZNt6H7m6befP4EMvkDbNWVQCnIq1c=
      - identity: {}
EOF

secret通过命令：head -c 32 /dev/urandom | base64

将加密配置文件拷贝到 master 节点

xxxxxxxxxx
for node_ip in k8s-master-02 k8s-master-03
  do
    echo ">>> ${node_ip}"
     scp /app/etc/encryption-config.yaml  root@${node_ip}:/app/etc
     ssh root@${node_ip} "ls -alh  /app/etc/encryption-config.yaml"
  done

• 创建审计策略文件

xxxxxxxxxx
cat > /app/etc/audit-policy.yaml <<EOF
apiVersion: audit.k8s.io/v1beta1
kind: Policy
rules:
  # The following requests were manually identified as high-volume and low-risk, so drop them.
  - level: None
    resources:
      - group: ""
        resources:
          - endpoints
          - services
          - services/status
    users:
      - 'system:kube-proxy'
    verbs:
      - watch
​
  - level: None
    resources:
      - group: ""
        resources:
          - nodes
          - nodes/status
    userGroups:
      - 'system:nodes'
    verbs:
      - get
​
  - level: None
    namespaces:
      - kube-system
    resources:
      - group: ""
        resources:
          - endpoints
    users:
      - 'system:kube-controller-manager'
      - 'system:kube-scheduler'
      - 'system:serviceaccount:kube-system:endpoint-controller'
    verbs:
      - get
      - update
​
  - level: None
    resources:
      - group: ""
        resources:
          - namespaces
          - namespaces/status
          - namespaces/finalize
    users:
      - 'system:apiserver'
    verbs:
      - get
​
  # Don't log HPA fetching metrics.
  - level: None
    resources:
      - group: metrics.k8s.io
    users:
      - 'system:kube-controller-manager'
    verbs:
      - get
      - list
​
  # Don't log these read-only URLs.
  - level: None
    nonResourceURLs:
      - '/healthz*'
      - /version
      - '/swagger*'
​
  # Don't log events requests.
  - level: None
    resources:
      - group: ""
        resources:
          - events
​
  # node and pod status calls from nodes are high-volume and can be large, don't log responses for expected updates from nodes
  - level: Request
    omitStages:
      - RequestReceived
    resources:
      - group: ""
        resources:
          - nodes/status
          - pods/status
    users:
      - kubelet
      - 'system:node-problem-detector'
      - 'system:serviceaccount:kube-system:node-problem-detector'
    verbs:
      - update
      - patch
​
  - level: Request
    omitStages:
      - RequestReceived
    resources:
      - group: ""
        resources:
          - nodes/status
          - pods/status
    userGroups:
      - 'system:nodes'
    verbs:
      - update
      - patch
​
  # deletecollection calls can be large, don't log responses for expected namespace deletions
  - level: Request
    omitStages:
      - RequestReceived
    users:
      - 'system:serviceaccount:kube-system:namespace-controller'
    verbs:
      - deletecollection
​
  # Secrets, ConfigMaps, and TokenReviews can contain sensitive & binary data,
  # so only log at the Metadata level.
  - level: Metadata
    omitStages:
      - RequestReceived
    resources:
      - group: ""
        resources:
          - secrets
          - configmaps
      - group: authentication.k8s.io
        resources:
          - tokenreviews
  # Get repsonses can be large; skip them.
  - level: Request
    omitStages:
      - RequestReceived
    resources:
      - group: ""
      - group: admissionregistration.k8s.io
      - group: apiextensions.k8s.io
      - group: apiregistration.k8s.io
      - group: apps
      - group: authentication.k8s.io
      - group: authorization.k8s.io
      - group: autoscaling
      - group: batch
      - group: certificates.k8s.io
      - group: extensions
      - group: metrics.k8s.io
      - group: networking.k8s.io
      - group: policy
      - group: rbac.authorization.k8s.io
      - group: scheduling.k8s.io
      - group: settings.k8s.io
      - group: storage.k8s.io
    verbs:
      - get
      - list
      - watch
​
  # Default level for known APIs
  - level: RequestResponse
    omitStages:
      - RequestReceived
    resources:
      - group: ""
      - group: admissionregistration.k8s.io
      - group: apiextensions.k8s.io
      - group: apiregistration.k8s.io
      - group: apps
      - group: authentication.k8s.io
      - group: authorization.k8s.io
      - group: autoscaling
      - group: batch
      - group: certificates.k8s.io
      - group: extensions
      - group: metrics.k8s.io
      - group: networking.k8s.io
      - group: policy
      - group: rbac.authorization.k8s.io
      - group: scheduling.k8s.io
      - group: settings.k8s.io
      - group: storage.k8s.io
​
  # Default level for all other requests.
  - level: Metadata
    omitStages:
      - RequestReceived
EOF

分发审计策略文件：

xxxxxxxxxx
for node_ip in k8s-master-02 k8s-master-03
  do
    echo ">>> ${node_ip}"
     scp /app/etc/audit-policy.yaml  root@${node_ip}:/app/etc
     ssh root@${node_ip} "ls -alh /app/etc/audit-policy.yaml "
  done

• 创建后续访问 metrics-server 使用的证书

创建证书签名请求：

xxxxxxxxxx
cat > proxy-client-csr.json <<EOF
{
  "CN": "aggregator",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "k8s",
      "OU": "System"
    }
  ]
}
EOF

CN 名称需要位于 kube-apiserver 的 --requestheader-allowed-names 参数中，否则后续访问 metrics 时会提示权限不足。

生成证书和私钥：

xxxxxxxxxx
cfssl gencert -ca=/app/cert/ca.pem \
  -ca-key=/app/cert/ca-key.pem  \
  -config=/app/cert/ca-config.json  \
  -profile=kubernetes proxy-client-csr.json | cfssljson -bare proxy-client

保留pem证书，将其他文件删除或移动

xxxxxxxxxx
rm -rf proxy-client.csr proxy-client-csr.json
ls -alh proxy-client*  

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

xxxxxxxxxx
for node_ip in k8s-master-02 k8s-master-03
  do
    echo ">>> ${node_ip}"
     scp /app/cert/proxy-client*.pem  root@${node_ip}:/app/cert
     ssh root@${node_ip} "ls -alh /app/cert/proxy-client*.pem"
  done

• 复制etcd节点的证书到所有master节点

xxxxxxxxxx
将ca.pem、etcd.pem、etcd-key.pem 上传到master-01节点的 /app/cert目录下。
​
for node_ip in k8s-master-02 k8s-master-03
  do
    echo ">>> ${node_ip}"
     scp /app/cert/etcd*.pem  root@${node_ip}:/app/cert
     ssh root@${node_ip} "ls -alh /app/cert/etcd*.pem"
  done

• 设置kube-apiserver配置文件

xxxxxxxxxx
for node_ip in  k8s-master-01 k8s-master-02 k8s-master-03
  do
    echo ">>> ${node_ip}"
     ssh root@${node_ip} "mkdir -p /app/logs/kube-apiserver"
  done
​
cat  >/app/etc/kube-apiserver <<EOF
KUBE_APISERVER_OPTS="--advertise-address=192.168.209.101 \\
  --default-not-ready-toleration-seconds=360 \\
  --default-unreachable-toleration-seconds=360 \\
  --feature-gates=DynamicAuditing=true \\
  --max-mutating-requests-inflight=2000 \\
  --max-requests-inflight=4000 \\
  --default-watch-cache-size=200 \\
  --delete-collection-workers=2 \\
  --encryption-provider-config=/app/etc/encryption-config.yaml \\
  --etcd-cafile=/app/cert/etcd-ca.pem \\
  --etcd-certfile=/app/cert/etcd.pem \\
  --etcd-keyfile=/app/cert/etcd-key.pem \\
  --etcd-servers=https://192.168.209.111:2379,https://192.168.209.112:2379,https://192.168.209.113:2379 \\
  --bind-address=192.168.209.101 \\
  --secure-port=6443 \\
  --tls-cert-file=/app/cert/k8s.pem \\
  --tls-private-key-file=/app/cert/k8s-key.pem \\
  --insecure-port=0 \\
  --audit-dynamic-configuration \\
  --audit-log-maxage=15 \\
  --audit-log-maxbackup=3 \\
  --audit-log-maxsize=100 \\
  --audit-log-truncate-enabled \\
  --audit-log-path=/app/logs/kube-apiserver/audit.log \\
  --audit-policy-file=/app/etc/audit-policy.yaml \\
  --client-ca-file=/app/cert/ca.pem \\
  --enable-bootstrap-token-auth \\
  --requestheader-allowed-names=aggregator \\
  --requestheader-client-ca-file=/app/cert/ca.pem \\
  --requestheader-extra-headers-prefix=X-Remote-Extra- \\
  --requestheader-group-headers=X-Remote-Group \\
  --requestheader-username-headers=X-Remote-User \\
  --service-account-key-file=/app/cert/ca.pem \\
  --authorization-mode=Node,RBAC \\
  --anonymous-auth=false \\
  --runtime-config=api/all=true \\
  --enable-admission-plugins=NodeRestriction \\
  --allow-privileged=true \\
  --apiserver-count=3 \\
  --event-ttl=168h \\
  --kubelet-certificate-authority=/app/cert/ca.pem \\
  --kubelet-client-certificate=/app/cert/k8s.pem \\
  --kubelet-client-key=/app/cert/k8s-key.pem \\
  --kubelet-https=true \\
  --kubelet-timeout=20s \\
  --proxy-client-cert-file=/app/cert/proxy-client.pem \\
  --proxy-client-key-file=/app/cert/proxy-client-key.pem \\
  --service-cluster-ip-range=10.254.0.0/16 \\
  --enable-aggregator-routing=true  \\
  --log-dir=/app/logs/kube-apiserver \\
  --logtostderr=false \\
  --v=2 "
EOF

--advertise-address：apiserver 对外通告的 IP（kubernetes 服务后端节点 IP）；

--default-*-toleration-seconds：设置节点异常相关的阈值；

--max-*-requests-inflight：请求相关的最大阈值；

--etcd-*：访问 etcd 的证书和 etcd 服务器地址；

--experimental-encryption-provider-config：指定用于加密 etcd 中 secret 的配置；

--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 相关参数，参考：

• https://github.com/kubernetes-incubator/apiserver-builder/blob/master/docs/concepts/auth.md
• https://docs.bitnami.com/kubernetes/how-to/configure-autoscaling-custom-metrics/

注意：

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 失败，提示：

xxxxxxxxxx
[root@zhangjun-k8s01 1.8+]# kubectl top nodes
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

• 创建kube-apiserver 的systemd unit文件

xxxxxxxxxx
cat >/usr/lib/systemd/system/kube-apiserver.service <<EOF
[Unit]
Description=Kubernetes API Server
Documentation=https://github.com/kubernetes/kubernetes
After=network.target
​
[Service]
EnvironmentFile=/app/etc/kube-apiserver
ExecStart=/app/bin/kube-apiserver \$KUBE_APISERVER_OPTS
Restart=on-failure
RestartSec=10
Type=notify
​
[Install]
WantedBy=multi-user.target
EOF

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

xxxxxxxxxx
for node_ip in k8s-master-02 k8s-master-03
  do
    echo ">>> ${node_ip}"
    scp /app/etc/kube-apiserver root@${node_ip}:/app/etc
    scp /usr/lib/systemd/system/kube-apiserver.service root@${node_ip}:/usr/lib/systemd/system
    ssh root@k8s-master-02 "sed -i 's#192.168.209.101#192.168.209.102#g' /app/etc/kube-apiserver"
    ssh root@k8s-master-03 "sed -i 's#192.168.209.101#192.168.209.103#g' /app/etc/kube-apiserver"
  done

• 启动 所有kube-apiserver 服务

xxxxxxxxxx
for node_ip in k8s-master-01 k8s-master-02 k8s-master-03
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "systemctl daemon-reload && systemctl enable kube-apiserver && systemctl restart kube-apiserver"
  done

• 检查服务运行状态

xxxxxxxxxx
for node_ip in k8s-master-01 k8s-master-02 k8s-master-03
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "systemctl status kube-apiserver | grep Active && ps -ef | grep kube-apiserver && netstat -tnulp | grep kube-api"
  done
​
   tcp        0      0 192.168.209.101:6443    0.0.0.0:*               LISTEN      12644/kube-apiserve
​
more /app/logs/kube-apiserver/kube-apiserver.INFO

6443: 接收 https 请求的安全端口，对所有请求做认证和授权。

• 打印 kube-apiserver 写入 etcd 的数据(etcd节点1执行一次)

xxxxxxxxxx
ETCDCTL_API=3 etcdctl \
    --endpoints=https://192.168.209.111:2379,https://192.168.209.112:2379,https://192.168.209.113:2379 \
    --cacert=/app/cert/ca.pem \
    --cert=/app/cert/etcd.pem \
    --key=/app/cert/etcd-key.pem \
    get /registry/ --prefix --keys-only

• 检查集群信息

xxxxxxxxxx
$ kubectl cluster-info
    Kubernetes master is running at https://192.168.209.100:8443
    To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.
    
$ kubectl get all --all-namespaces
    NAMESPACE   NAME                 TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
    default     service/kubernetes   ClusterIP   10.254.0.1   <none>        443/TCP   30h
​
$ kubectl get componentstatuses
    NAME                 AGE
    controller-manager   <unknown>
    scheduler            <unknown>
    etcd-1               <unknown>
    etcd-2               <unknown>
    etcd-0               <unknown>

1. 如果执行 kubectl 命令式时输出如下错误信息，则说明使用的 ~/.kube/config 文件不对，请切换到正确的账户后再执行该命令：

   The connection to the server localhost:8080 was refused - did you specify the right host or port?

2. 执行 kubectl get componentstatuses 命令时，apiserver 默认向 127.0.0.1 发送请求。当 controller-manager、scheduler 以集群模式运行时，有可能和 kube-apiserver 不在一台机器上，这时 controller-manager 或 scheduler 的状态为 Unhealthy，但实际上它们工作正常。

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

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

xxxxxxxxxx
$ kubectl create clusterrolebinding kube-apiserver:kubelet-apis --clusterrole=system:kubelet-api-admin --user kubernetes
clusterrolebinding.rbac.authorization.k8s.io/kube-apiserver:kubelet-apis created

2.5.3部署kube-controller-manager

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

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

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

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

创建证书签名请求：

xxxxxxxxxx
cd /app/cert
​
cat > /app/cert/kube-controller-manager-csr.json <<EOF
{
    "CN": "system:kube-controller-manager",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "hosts": [
      "127.0.0.1",
      "192.168.209.101",
      "192.168.209.102",
      "192.168.209.103"
    ],
    "names": [
      {
        "C": "CN",
        "ST": "BeiJing",
        "L": "BeiJing",
        "O": "system:kube-controller-manager",
        "OU": "System"
      }
    ]
}
EOF

hosts 列表包含所有 kube-controller-manager 节点 IP；

CN 和 O 均为 system:kube-controller-manager，kubernetes 内置的 ClusterRoleBindings system:kube-controller-manager 赋予 kube-controller-manager 工作所需的权限。

生成证书和私钥：

xxxxxxxxxx
cfssl gencert -ca=/app/cert/ca.pem \
  -ca-key=/app/cert/ca-key.pem \
  -config=/app/cert/ca-config.json \
  -profile=kubernetes kube-controller-manager-csr.json | cfssljson -bare kube-controller-manager
  
ls  -alh kube-controller-manager*.pem
rm -rf kube-controller-manager.csr kube-controller-manager-csr.json

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

xxxxxxxxxx
for node_ip in k8s-master-02 k8s-master-03
  do
    echo ">>> ${node_ip}"
     scp /app/cert/kube-controller-manager*.pem root@${node_ip}:/app/cert
     ssh root@${node_ip} "ls -alh /app/cert/kube-controller-manager*.pem"
  done

• 创建和分发 kubeconfig 文件

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

xxxxxxxxxx
cd /app/etc
​
kubectl config set-cluster kubernetes \
  --certificate-authority=/app/cert/ca.pem \
  --embed-certs=true \
  --server=https://192.168.209.100:8443  \
  --kubeconfig=kube-controller-manager.kubeconfig
​
kubectl config set-credentials system:kube-controller-manager \
  --client-certificate=/app/cert/kube-controller-manager.pem \
  --client-key=/app/cert/kube-controller-manager-key.pem \
  --embed-certs=true \
  --kubeconfig=kube-controller-manager.kubeconfig
​
kubectl config set-context system:kube-controller-manager \
  --cluster=kubernetes \
  --user=system:kube-controller-manager \
  --kubeconfig=kube-controller-manager.kubeconfig
​
kubectl config use-context system:kube-controller-manager --kubeconfig=kube-controller-manager.kubeconfig
ls -alh kube-controller-manager.kubeconfig

分发 kubeconfig 到所有 master 节点：

xxxxxxxxxx
for node_ip in k8s-master-02 k8s-master-03
  do
    echo ">>> ${node_ip}"
     scp /app/etc/kube-controller-manager.kubeconfig root@${node_ip}:/app/etc
     ssh root@${node_ip} "ls -alh /app/etc/kube-controller-manager.kubeconfig"
  done

• 设置kube-controller-manager配置文件

xxxxxxxxxx
for node_ip in  k8s-master-01 k8s-master-02 k8s-master-03
  do
    echo ">>> ${node_ip}"
     ssh root@${node_ip} "mkdir -p /app/logs/kube-controller-manager"
  done
  
cat  >/app/etc/kube-controller-manager <<EOF
KUBE_CONTROLLER_MANAGER_OPTS="--cluster-name=kubernetes \\
  --controllers=*,bootstrapsigner,tokencleaner \\
  --kube-api-qps=1000 \\
  --kube-api-burst=2000 \\
  --leader-elect \\
  --use-service-account-credentials=true \\
  --concurrent-service-syncs=2 \\
  --bind-address=192.168.209.101 \\
  --secure-port=10257 \\
  --port=0 \\
  --tls-cert-file=/app/cert/kube-controller-manager.pem \\
  --tls-private-key-file=/app/cert/kube-controller-manager-key.pem \\
   --client-ca-file=/app/cert/ca.pem \\
  --requestheader-allowed-names=  \\
  --requestheader-client-ca-file=/app/cert/ca.pem \\
  --requestheader-extra-headers-prefix=X-Remote-Extra- \\
  --requestheader-group-headers=X-Remote-Group \\
  --requestheader-username-headers=X-Remote-User \\
  --authorization-kubeconfig=/app/etc/kube-controller-manager.kubeconfig \\
  --cluster-signing-cert-file=/app/cert/ca.pem \\
  --cluster-signing-key-file=/app/cert/ca-key.pem \\
  --experimental-cluster-signing-duration=876000h \\
  --horizontal-pod-autoscaler-sync-period=10s \\
  --concurrent-deployment-syncs=10 \\
  --concurrent-gc-syncs=30 \\
  --node-cidr-mask-size=24 \\
  --service-cluster-ip-range=10.254.0.0/16 \\
  --pod-eviction-timeout=6m \\
  --terminated-pod-gc-threshold=10000 \\
  --root-ca-file=/app/cert/ca.pem \\
  --service-account-private-key-file=/app/cert/ca-key.pem \\
  --kubeconfig=/app/etc/kube-controller-manager.kubeconfig \\
  --log-dir=/app/logs/kube-controller-manager \\
  --logtostderr=false \\
  --v=2 "
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；

• 创建kube-controller-manager 的systemd unit文件

xxxxxxxxxx
cat >/usr/lib/systemd/system/kube-controller-manager.service <<EOF
[Unit]
Description=Kubernetes Controller Manager Server
Documentation=https://github.com/kubernetes/kubernetes
After=network.target
​
[Service]
EnvironmentFile=/app/etc/kube-controller-manager
ExecStart=/app/bin/kube-controller-manager \$KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure
RestartSec=5
Type=notify
​
[Install]
WantedBy=multi-user.target
EOF

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

xxxxxxxxxx
for node_ip in k8s-master-02 k8s-master-03
  do
    echo ">>> ${node_ip}"
    scp /app/etc/kube-controller-manager root@${node_ip}:/app/etc
    scp /usr/lib/systemd/system/kube-controller-manager.service root@${node_ip}:/usr/lib/systemd/system
    ssh root@k8s-master-02 "sed -i 's#192.168.209.101#192.168.209.102#g' /app/etc/kube-controller-manager"
    ssh root@k8s-master-03 "sed -i 's#192.168.209.101#192.168.209.103#g' /app/etc/kube-controller-manager"
  done

• 启动 所有kube-controller-manager 服务

xxxxxxxxxx
for node_ip in k8s-master-01 k8s-master-02 k8s-master-03
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "systemctl daemon-reload && systemctl enable kube-controller-manager && systemctl restart kube-controller-manager"
  done

• 检查服务运行状态

xxxxxxxxxx
for node_ip in k8s-master-01 k8s-master-02 k8s-master-03
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "systemctl status kube-controller-manager | grep Active && ps -ef | grep kube-controller-manager && netstat -tnulp | grep kube-con"
  done
​
    tcp        0      0 192.168.209.101:10257   0.0.0.0:*               LISTEN      13058/kube-controll
​
more /app/logs/kube-controller-manager/kube-controller-manager.INFO

kube-controller-manager 监听 10257 端口，接收 https 请求。

• 查看当前的 leader

xxxxxxxxxx
kubectl get endpoints kube-controller-manager --namespace=kube-system  -o yaml
​
apiVersion: v1
kind: Endpoints
metadata:
  annotations:
    control-plane.alpha.kubernetes.io/leader: '{"holderIdentity":"k8s-master-01_cf286549-aea4-4b6c-bf49-77508454458e","leaseDurationSeconds":15,"acquireTime":"2019-11-13T03:56:48Z","renewTime":"2019-11-13T03:57:04Z","leaderTransitions":1019}'
  creationTimestamp: "2019-11-12T09:18:14Z"
  name: kube-controller-manager
  namespace: kube-system
  resourceVersion: "78079"
  selfLink: /api/v1/namespaces/kube-system/endpoints/kube-controller-manager
  uid: 816d3350-3a9b-4432-84e3-4034df954564
​

可见，当前的 leader 为 k8s-master-01 节点。

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

  停掉k8s-master-01节点：

xxxxxxxxxx
systemctl stop kube-controller-manager

查看当前的 leader：

xxxxxxxxxx
kubectl get endpoints kube-controller-manager --namespace=kube-system  -o yaml
​
apiVersion: v1
kind: Endpoints
metadata:
  annotations:
    control-plane.alpha.kubernetes.io/leader: '{"holderIdentity":"k8s-master-02_080e70f8-a6cc-4c4b-9290-abecb65fdf30","leaseDurationSeconds":15,"acquireTime":"2019-11-13T03:58:28Z","renewTime":"2019-11-13T03:58:31Z","leaderTransitions":1021}'
  creationTimestamp: "2019-11-12T09:18:14Z"
  name: kube-controller-manager
  namespace: kube-system
  resourceVersion: "78136"
  selfLink: /api/v1/namespaces/kube-system/endpoints/kube-controller-manager
  uid: 816d3350-3a9b-4432-84e3-4034df954564

可见，当前的 leader 为 k8s-master-02 节点。

• kube-controller-manager 的权限

ClusteRole system:kube-controller-manager 的权限很小，只能创建 secret、serviceaccount 等资源对象，各 controller 的权限分散到 ClusterRole system:controller:XXX 中：

xxxxxxxxxx
kubectl describe clusterrole system:kube-controller-manager
​
Name:         system:kube-controller-manager
Labels:       kubernetes.io/bootstrapping=rbac-defaults
Annotations:  rbac.authorization.kubernetes.io/autoupdate: true
PolicyRule:
  Resources                                  Non-Resource URLs  Resource Names  Verbs
  ---------                                  -----------------  --------------  -----
  secrets                                    []                 []              [create delete get update]
  endpoints                                  []                 []              [create get update]
  serviceaccounts                            []                 []              [create get update]
  events                                     []                 []              [create patch update]
  events.events.k8s.io                       []                 []              [create patch update]
  serviceaccounts/token                      []                 []              [create]
  tokenreviews.authentication.k8s.io         []                 []              [create]
  subjectaccessreviews.authorization.k8s.io  []                 []              [create]
  configmaps                                 []                 []              [get]
  namespaces                                 []                 []              [get]
  *.*                                        []                 []              [list watch]

需要在 kube-controller-manager 的启动参数中添加 --use-service-account-credentials=true 参数，这样 main controller 会为各 controller 创建对应的 ServiceAccount XXX-controller。

内置的 ClusterRoleBinding system:controller:XXX 将赋予各 XXX-controller ServiceAccount 对应的 ClusterRole system:controller:XXX 权限。

xxxxxxxxxx
kubectl get clusterrole | grep controller
​
system:controller:attachdetach-controller                              30h
system:controller:certificate-controller                               30h
system:controller:clusterrole-aggregation-controller                   30h
system:controller:cronjob-controller                                   30h
system:controller:daemon-set-controller                                30h
system:controller:deployment-controller                                30h
system:controller:disruption-controller                                30h
system:controller:endpoint-controller                                  30h
system:controller:expand-controller                                    30h
system:controller:generic-garbage-collector                            30h
system:controller:horizontal-pod-autoscaler                            30h
system:controller:job-controller                                       30h
system:controller:namespace-controller                                 30h
system:controller:node-controller                                      30h
system:controller:persistent-volume-binder                             30h
system:controller:pod-garbage-collector                                30h
system:controller:pv-protection-controller                             30h
system:controller:pvc-protection-controller                            30h
system:controller:replicaset-controller                                30h
system:controller:replication-controller                               30h
system:controller:resourcequota-controller                             30h
system:controller:route-controller                                     30h
system:controller:service-account-controller                           30h
system:controller:service-controller                                   30h
system:controller:statefulset-controller                               30h
system:controller:ttl-controller                                       30h
system:kube-controller-manager                                         30h

以 deployment controller 为例：

xxxxxxxxxx
kubectl describe clusterrole system:controller:deployment-controller
​
Name:         system:controller:deployment-controller
Labels:       kubernetes.io/bootstrapping=rbac-defaults
Annotations:  rbac.authorization.kubernetes.io/autoupdate: true
PolicyRule:
  Resources                          Non-Resource URLs  Resource Names  Verbs
  ---------                          -----------------  --------------  -----
  replicasets.apps                   []                 []              [create delete get list patch update watch]
  replicasets.extensions             []                 []              [create delete get list patch update watch]
  events                             []                 []              [create patch update]
  events.events.k8s.io               []                 []              [create patch update]
  pods                               []                 []              [get list update watch]
  deployments.apps                   []                 []              [get list update watch]
  deployments.extensions             []                 []              [get list update watch]
  deployments.apps/finalizers        []                 []              [update]
  deployments.apps/status            []                 []              [update]
  deployments.extensions/finalizers  []                 []              [update]
  deployments.extensions/status      []                 []              [update]