K8S入门系列之集群二进制部署--> master篇(一)

组件版本和配置策略

组件版本

• Kubernetes 1.17 https://github.com/kubernetes/kubernetes/releases
• Etcd 3.3.18 https://github.com/etcd-io/etcd/releases/
• Docker 19.03-ce

核心插件：

• CNI : 二选一
  flannel --> yaml文件部署 https://github.com/coreos/flannel/releases/
  calico --> yaml文件部署
• coredns --> yaml文件部署

主要配置策略

• kube-apiserver：
  使用 keepalived 和 haproxy 实现 3 节点高可用；
  在安全端口 6443 接收 https 请求；
  严格的认证和授权策略 (x509、token、RBAC)；
  开启 bootstrap token 认证，支持 kubelet TLS bootstrapping；
  手动生成token.csv
  使用 https 访问 kubelet、etcd，加密通信；

• kube-controller-manager：
  3 节点高可用；主备备
  使用 kubeconfig 访问 apiserver 的安全端口；
  自动 approve kubelet 证书签名请求 (CSR)，证书过期后自动轮转；
  各 controller 使用自己的 ServiceAccount 访问 apiserver；

• kube-scheduler：
  3 节点高可用；主备备
  使用 kubeconfig 访问 apiserver 的安全端口；

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

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

1. K8S系统初始化

1.1 系统环境

[root@localhost ~]# cat /etc/redhat-release 
CentOS Linux release 8.0.1905 (Core) 

1.2 修改各个节点的对应hostname, 并分别写入/etc/hosts

# 对应主机修改
hostnamectl set-hostname k8s-master01

# 写入hosts--> 注意是 >> 表示不改变原有内容追加!
cat>> /etc/hosts <<EOF
192.168.2.201 k8s-master01
192.168.2.202 k8s-master02
192.168.2.203 k8s-master03
192.168.2.11 k8s-node01
192.168.2.12 k8s-node02
EOF

1.3 所有节点安装常用工具和依赖包

yum install wget yum-utils net-tools tar curl jq ipvsadm ipset conntrack iptables sysstat libseccomp -y

1.4 所有节点关闭 firewalld, selinux 以及 swap

# 关闭防火墙并清空防火墙规则
systemctl disable firewalld && systemctl stop firewalld && systemctl status firewalld
iptables -F && iptables -X && iptables -F -t nat && iptables -X -t nat
iptables -P FORWARD ACCEP

# 关闭selinux  --->selinux=disabled 需重启生效!
setenforce 0 && sed -i 's/^SELINUX=.*/SELINUX=disabled/' /etc/selinux/config

# 关闭swap --->注释掉swap那一行, 需重启生效!
swapoff -a && sed -i '/ swap / s/^\(.*\)$/# \1/g' /etc/fstab

1.5 所有节点设置时间同步

timedatectl set-timezone Asia/Shanghai
timedatectl set-local-rtc 0

yum install chrony -y
systemctl enable chronyd && systemctl start chronyd && systemctl status chronyd

1.6 所有节点调整内核参数, k8s必备参数!

# 先加载模块
modprobe br_netfilter

# 直接写入对应位置
cat> /etc/sysctl.d/kubernetes.conf <<EOF
net.bridge.bridge-nf-call-iptables=1
net.bridge.bridge-nf-call-ip6tables=1
net.ipv6.conf.all.disable_ipv6=1
net.netfilter.nf_conntrack_max = 6553500
net.nf_conntrack_max = 6553500
net.ipv4.tcp_max_tw_buckets = 4096
EOF

# 生效配置
sysctl -p /etc/sysctl.d/kubernetes.conf

• net.bridge.bridge-nf-call-iptables=1 二层的网桥在转发包时也会被iptables的FORWARD规则所过滤
• net.ipv6.conf.all.disable_ipv6=1 禁用整个系统所有的ipv6接口, 预防触发docker的bug
• net.netfilter.nf_conntrack_max 这个默认值是65535，当服务器上的连接超过这个数的时候，系统会将数据包丢掉，直到小于这个值或达到过期时间net.netfilter.nf_conntrack_tcp_timeout_established，默认值432000，5天。期间的数据包都会丢掉。
• net.ipv4.tcp_max_tw_buckets 这个默认值18000，服务器TIME-WAIT状态套接字的数量限制，如果超过这个数量， 新来的TIME-WAIT套接字会直接释放。过多的TIME-WAIT影响服务器性能，根据服务自行设置.

1.7 所有节点创建k8s工作目录并设置环境变量!

# 在每台机器上创建目录：
mkdir -p /opt/k8s/{bin,cert,script}
mkdir -p /opt/etcd/{bin,cert}
mkdir -p /opt/lib/etcd
mkdir -p /root/.kube
mkdir -p /opt/log/kubernetes

# 在每台机器上添加环境变量：
sh -c "echo 'PATH=/opt/k8s/bin:/opt/etcd/bin:/opt/flanneld/bin:$PATH:$HOME/bin:$JAVA_HOME/bin' >> /etc/profile.d/k8s.sh"
# 生效配置
source /etc/profile.d/k8s.sh

1.8 无密码 ssh 登录其它节点

# 生成秘钥对 ( 在操作节点上生成)
ssh-keygen

# 将自己的公钥发给其他服务器
ssh-copy-id root@k8s-master01
ssh-copy-id root@k8s-master02
ssh-copy-id root@k8s-master03

# 重启机器, 最好做一下! 并验证检查各项初始化设置
reboot

2. 创建CA根证书和密钥

• kubernetes 系统各组件需要使用 x509 证书对通信进行加密和认证。
• 使用证书的组件如下：
  etcd：使用 ca.pem、etcd.pem、etcd-key.pem(etcd对外提供服务、节点间通信（etcd peer）用同一套证书)
  kubectl：使用 ca.pem、admin.pem、admin-key.pem
  kube-apiserver：使用 ca.pem、ca-key.pem、kube-apiserver-key.pem、kube-apiserver.pem
  kube-controller-manager：使用 ca.pem、ca-key.pem、kube-controller-manager.pem、kube-controller-manager-key.pem
  kube-scheduler：使用ca.pem、ca-key.pem、kube-scheduler-key.pem、kube-scheduler.pem
  kubelet：使用 ca.pem 、ca-key.pem
  kube-proxy：使用 ca.pem、kube-proxy-key.pem、kube-proxy.pem

2.1 安装cfssl工具集

[root@k8s-master01 ~]# wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64
[root@k8s-master01 ~]# mv cfssl_linux-amd64 /opt/k8s/bin/cfssl

[root@k8s-master01 ~]# wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64
[root@k8s-master01 ~]# mv cfssljson_linux-amd64 /opt/k8s/bin/cfssljson

[root@k8s-master01 ~]# wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64
[root@k8s-master01 ~]# mv cfssl-certinfo_linux-amd64 /opt/k8s/bin/cfssl-certinfo

[root@k8s-master01 ~]# chmod +x /opt/k8s/bin/*

2.2 创建根证书CA

• CA 证书是集群所有节点共享的，只需要创建一个CA证书，后续创建的所有证书都由它签名。
• CA (Certificate Authority) 是自签名的根证书，用来签名后续创建的其它证书。

2.03 创建配置文件

• 这个文件中包含后面签署其它证书用到的配置

[root@k8s-master01 ~]# cat> /opt/k8s/cert/ca-config.json <<EOF
{
    "signing": {
        "default": {
            "expiry": "876000h"
        },
        "profiles": {
            "kubernetes": {
                "usages": [
                    "signing",
                    "key encipherment",
                    "server auth",
                    "client auth"
                ],
                "expiry": "876000h"
            }
        }
    }
}
EOF

• ca-config.json：可以定义多个 profiles，分别指定不同的过期时间、使用场景等参数；后续在签名证书时使用某个 profile;
• signing：表示该证书可用于签名其它证书；生成的 ca.pem 证书中 CA=TRUE;
• server auth：表示client可以用该 CA 对server提供的证书进行验证;
• client auth：表示server可以用该CA对client提供的证书进行验证;
• expiry: 表示证书过期时间，我们设置10年，当然你如果比较在意安全性，可以适当减少

2.4 创建 CA 证书签名请求模板

[root@k8s-master01 ~]# cat > /opt/k8s/cert/ca-csr.json <<EOF
{
    "CN": "kubernetes",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "BeiJing",
            "L": "BeiJing",
            "O": "k8s",
            "OU": "steams"
        }
    ]
}
EOF

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

2.5 生成CA证书、私钥和csr证书签名请求

[root@k8s-master01 ~]## cfssl gencert -initca /opt/k8s/cert/ca-csr.json | cfssljson -bare /opt/k8s/cert/ca

# 查看是否生成!
[root@k8s-master01 ~]# ls /opt/k8s/cert/
ca-config.json  ca.csr  ca-csr.json  ca-key.pem  ca.pem

2.6 分发证书文件

• 简单脚本, 注意传参! 后期想写整合脚本的话可以拿来参考!
• 将生成的 CA 证书、秘钥文件、配置文件拷贝到所有节点的/opt/k8s/cert 目录下：

# 创建分发脚本
[root@k8s-master01 cert]# vi /opt/k8s/script/scp_k8s_cacert.sh 
MASTER_IPS=("$1" "$2" "$3")
for master_ip in ${MASTER_IPS[@]};do
    echo ">>> ${master_ip}"
    scp /opt/k8s/cert/ca*.pem /opt/k8s/cert/ca-config.json root@${master_ip}:/opt/k8s/cert
done

# 执行脚本, 注意传参!
[root@k8s-master01 cert]# bash /opt/k8s/script/scp_k8s_cacert.sh 192.168.2.201 192.168.2.202 192.168.2.203

3. 部署etcd集群

• etcd 是基于Raft的分布式key-value存储系统，常用于服务发现、共享配置以及并发控制(如leader选举、分布式锁等)
• kubernetes 使用 etcd 存储所有运行数据。这里把etcd部署在master三台节点上做高可用，etcd集群采用raft算法选举Leader， 由于Raft算法在做决策时需要多数节点的投票，所以etcd一般部署集群推荐奇数个节点，推荐的数量为3、5或者7个节点构成一个集群。

3.1 下载二进制文件

[root@k8s-master01 ~]# wget https://github.com/etcd-io/etcd/releases/download/v3.3.18/etcd-v3.3.18-linux-amd64.tar.gz
[root@k8s-master01 ~]# tar -xvf etcd-v3.3.18-linux-amd64.tar.gz 

3.2 创建etcd证书请求模板文件

• etcd集群要与k8s-->apiserver通信, 所以需要用证书签名验证!
• hosts 字段指定授权使用该证书的 etcd 节点 IP 或域名列表，这里将 etcd 集群的三个节点 IP 都列在其中

[root@k8s-master01 cert]# cat > /opt/etcd/cert/etcd-csr.json <<EOF
{
    "CN": "etcd",
    "hosts": [
        "127.0.0.1",
        "192.168.2.201",
        "192.168.2.202",
        "192.168.2.203"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "BeiJing",
            "L": "BeiJing",
            "O": "k8s",
            "OU": "steams"
        }
    ]
}
EOF

3.3 生成证书和私钥

[root@k8s-master01 ~]# cfssl gencert \
-ca=/opt/k8s/cert/ca.pem \
-ca-key=/opt/k8s/cert/ca-key.pem \
-config=/opt/k8s/cert/ca-config.json \
-profile=kubernetes /opt/etcd/cert/etcd-csr.json | cfssljson -bare /opt/etcd/cert/etcd

# 查看是否生成!
[root@k8s-master01 ~]# ls /opt/etcd/cert/*
etcd.csr       etcd-csr.json  etcd-key.pem   etcd.pem  

3.4 分发生成的证书, 私钥和etcd安装文件到各etcd节点

# 创建分发 etcd 以及证书私钥
[root@k8s-master01 ~]# vi /opt/k8s/script/scp_etcd.sh
MASTER_IPS=("$1" "$2" "$3")
for master_ip in ${MASTER_IPS[@]};do
        echo ">>> ${master_ip}"
        scp /root/etcd-v3.3.18-linux-amd64/etcd* root@${master_ip}:/opt/etcd/bin
        ssh root@${master_ip} "chmod +x /opt/etcd/bin/*"
        scp /opt/etcd/cert/etcd*.pem root@${master_ip}:/opt/etcd/cert/
done

# 执行脚本, 注意传参!
[root@k8s-master01 ~]# bash /opt/k8s/script/scp_etcd.sh 192.168.2.201 192.168.2.202 192.168.2.203

3.5 为所有 etcd 节点(共用master节点)创建 etcd 的 systemd unit 文件

[root@k8s-master01 ~]# vi /etc/systemd/system/etcd.service
[Unit]
Description=Etcd Server
Documentation=https://github.com/coreos
After=network.target
After=network-online.target
Wants=network-online.target

[Service]
User=root
Type=notify
WorkingDirectory=/opt/lib/etcd/
ExecStart=/opt/etcd/bin/etcd \
--client-cert-auth=true \
--trusted-ca-file=/opt/k8s/cert/ca.pem \
--cert-file=/opt/etcd/cert/etcd.pem \
--key-file=/opt/etcd/cert/etcd-key.pem \
--peer-client-cert-auth=true \
--peer-trusted-ca-file=/opt/k8s/cert/ca.pem \
--peer-cert-file=/opt/etcd/cert/etcd.pem \
--peer-key-file=/opt/etcd/cert/etcd-key.pem \
--name=##ETCD_NAME## \
--data-dir=/opt/lib/etcd \
--listen-client-urls=https://##MASTER_IP##:2379 \
--listen-peer-urls=https://##MASTER_IP##:2380 \
--initial-cluster-state=new \
--initial-cluster-token=k8s-etcd-cluster  \
--advertise-client-urls=https://##MASTER_IP##:2379 \
--initial-advertise-peer-urls=https://##MASTER_IP##:2380 \
--initial-cluster=etcd0=https://192.168.2.201:2380,etcd1=https://192.168.2.202:2380,etcd2=https://192.168.2.203:2380 
Restart=on-failure
RestartSec=5
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target

• 修改 ##ETCD_NAME## 为当前etcd节点的名称!
• 修改 ##MASTER_IP## 为当前etcd节点对应的IP!
• WorkingDirectory 、 --data-dir：指定工作目录和数据目录为/opt/lib/etcd ，需在启动服务前创建这个目录；
• --name ：指定各个节点名称，当 --initial-cluster-state 值为new时， --name的参数值必须位于--initial-cluster 列表中；
• --trusted-ca-file：签名 client 证书的 CA 证书，用于验证 client 证书；
• --cert-file 、 --key-file：etcd server 与 client 通信时使用的证书和私钥；
• --peer-trusted-ca-file：签名 peer 证书的 CA 证书，用于验证 peer 证书；
• --peer-cert-file 、 --peer-key-file：etcd 与 peer 通信使用的证书和私钥；

3.6 在所有节点为 etcd 服务设置开机启动, 并启动检查服务

• etcd集群需要三台etcd服务同时启动，启动一台后，服务暂停等待，直到集群中所有etcd节点都已启动。

systemctl daemon-reload && systemctl enable etcd && systemctl restart etcd && systemctl status etcd

3.7 验证集群

• etcd3版本，默认API=v3, 如需使用v2版本命令在命令前加环境变量! ETCDCTL_API=2

# 查看集群健康状态
etcdctl --endpoints=https://192.168.2.201:2379,https://192.168.2.202:2379,https://192.168.2.203:2379 \
--cert-file=/opt/etcd/cert/etcd.pem \
--ca-file=/opt/k8s/cert/ca.pem \
--key-file=/opt/etcd/cert/etcd-key.pem \
cluster-health

# 查看集群成员列表
etcdctl --endpoints=https://192.168.2.201:2379,https://192.168.2.202:2379,https://192.168.2.203:2379 \
--cert-file=/opt/etcd/cert/etcd.pem \
--ca-file=/opt/k8s/cert/ca.pem \
--key-file=/opt/etcd/cert/etcd-key.pem \
member list

4. 部署kubectl命令行工具

• kubectl 是 kubernetes 集群的命令行管理工具
• kubectl 默认从 ~/.kube/config 文件读取 kube-apiserver 地址、证书、用户名等信息，如果没有配置，执行 kubectl 命令时可能会出错：
• 本文档只需要部署一次，生成的 kubeconfig 文件与机器无关。

4.1 下载kubectl二进制文件

• kubernetes-server-linux-amd64.tar.gz包含所有组件!

# 下载二进制文件(直连无法下载!)
[root@k8s-master01 ~]# wget https://dl.k8s.io/v1.17/kubernetes-server-linux-amd64.tar.gz
# 解压, 复制到相应目录以及增加执行权限
[root@k8s-master01 ~]# tar -zxvf kubernetes-server-linux-amd64.tar.gz
[root@k8s-master01 ~]# cp ./kubernetes/server/bin/kubectl /opt/k8s/bin/ && chmod +x /opt/k8s/bin/*

4.2 创建 admin 证书和私钥

• kubectl用于日常直接管理K8S集群，kubectl要进行管理k8s，就需要和k8s的组件进行通信
• kubectl 作为集群的管理工具，需要被授予最高权限。这里创建具有最高权限的admin 证书

创建证书签名请求

[root@k8s-master01 ~]# cat > /opt/k8s/cert/admin-csr.json <<EOF
{
    "CN": "admin",
    "hosts": [],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "BeiJing",
            "L": "BeiJing",
            "O": "system:masters",
            "OU": "steams"
        }
    ]
}
EOF

• O 为 system:masters ，kube-apiserver 收到该证书后将请求的 Group 设置为system:masters；
• 该证书只会被 kubectl 当做 client 证书使用，所以 hosts 字段为空；

生成证书和私钥

[root@k8s-master01 ~]# cfssl gencert \
-ca=/opt/k8s/cert/ca.pem \
-ca-key=/opt/k8s/cert/ca-key.pem \
-config=/opt/k8s/cert/ca-config.json \
-profile=kubernetes /opt/k8s/cert/admin-csr.json | cfssljson -bare /opt/k8s/cert/admin

# 查看生成的证书和私钥
[root@k8s-master01 ~]# ls /opt/k8s/cert/admin*
admin.csr       admin-csr.json  admin-key.pem   admin.pem  

4.3 创建 kubectl 的 kubeconfig 配置文件

• 下面几个步骤会在家目录下的.kube生成config文件，之后kubectl和api通信就需要用到该文件，也就是说如果在其他节点上操作集群需要用到这个kubectl，就需要将该配置文件拷贝到其他节点。
• 未指定情况下默认文件名和位置: ~/.kube/config

# step.1 设置集群参数
# --server=${KUBE_APISERVER}, 指定IP和端口; 本文使用的是haproxy的VIP和端口；
[root@k8s-master01 ~]# kubectl config set-cluster kubernetes \
--certificate-authority=/opt/k8s/cert/ca.pem \
--embed-certs=true \
--server=https://192.168.2.210:8443 

# step.2 设置客户端认证参数
[root@k8s-master01 ~]# kubectl config set-credentials kube-admin \
--client-certificate=/opt/k8s/cert/admin.pem \
--client-key=/opt/k8s/cert/admin-key.pem \
--embed-certs=true 

# step.3 设置上下文参数
[root@k8s-master01 ~]#  kubectl config set-context kube-admin@kubernetes \
--cluster=kubernetes \
--user=kube-admin 

# step.4设置默认上下文
[root@k8s-master01 ~]# kubectl config use-context kube-admin@kubernetes

--certificate-authority ：验证 kube-apiserver 证书的根证书；
--client-certificate 、 --client-key ：刚生成的 admin 证书和私钥，连接 kube-apiserver 时使用；
--embed-certs=true ：将 ca.pem 和 admin.pem 证书内容嵌入到生成的kubectl.kubeconfig 文件中(不加时，写入的是证书文件路径)；

4.4 分发 kubeclt , 证书私钥和kubeconfig 文件

# 编写分发脚本
[root@k8s-master01 ~]# vi /opt/k8s/script/scp_kubectl_config.sh
MASTER_IPS=("$1" "$2" "$3")
for master_ip in ${MASTER_IPS[@]};do
    echo ">>> ${master_ip}"
    scp /root/kubernetes/server/bin/kubectl root@${master_ip}:/opt/k8s/bin/
    ssh root@${master_ip} "chmod +x /opt/k8s/bin/*"
    scp /opt/k8s/cert/admin*.pem root@${master_ip}:/opt/k8s/cert/
    scp /root/.kube/config root@${master_ip}:/root/.kube/config
done

# 执行脚本, 注意传参!
[root@k8s-master01 ~]# bash /opt/k8s/script/scp_kubectl_config.sh 192.168.2.201 192.168.2.202 192.168.2.203

5. 部署master节点

• kubernetes master 节点运行如下K8S组件：
  kube-apiserver
  kube-scheduler
  kube-controller-manager

• kube-scheduler 和 kube-controller-manager 可以以集群模式运行，通过 leader 选举产生一个工作进程，其它进程处于阻塞模式。

• 对于 kube-apiserver，可以运行多个实例, 但对其它组件需要提供统一的访问地址，该地址需要高可用。本文档使用 keepalived 和 haproxy 实现 kube-apiserver VIP 高可用和负载均衡。

• 因为对master做了keepalived高可用，所以3台服务器都有可能会升成master服务器（主master宕机，会有从升级为主）；因此所有的master操作，在3个服务器上都要进行。

下载二进制文件, 想办法!!!

# 下载二进制文件
[root@k8s-master01 ~]# wget https://dl.k8s.io/v1.17/kubernetes-server-linux-amd64.tar.gz
# 解压
[root@k8s-master01 ~]# tar -xvf kubernetes-server-linux-amd64.tar.gz

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

# 编写脚本
[root@k8s-master01 ~]# vi /opt/k8s/script/scp_master.sh
MASTER_IPS=("$1" "$2" "$3")
for master_ip in ${MASTER_IPS[@]};do
    echo ">>> ${master_ip}"
    scp /root/kubernetes/server/bin/{kube-apiserver,kube-controller-manager,kube-scheduler} root@${master_ip}:/opt/k8s/bin/
    ssh root@${master_ip} "chmod +x /opt/k8s/bin/*"
done

# 执行, 注意传参!
[root@k8s-master01 ~]# bash /opt/k8s/script/scp_master.sh 192.168.2.201 192.168.2.202 192.168.2.203

5.1 部署高可用组件

• 本文档讲解使用 keepalived 和 haproxy 实现 kube-apiserver 高可用的步骤：
  keepalived 提供 kube-apiserver 对外服务的 VIP；
  haproxy 监听 VIP，后端连接所有 kube-apiserver 实例，提供健康检查和负载均衡功能；
• 运行 keepalived 和 haproxy 的节点称为 LB 节点。由于 keepalived 是一主多备运行模式，故至少两个 LB 节点。
• 本文档复用 master 节点的三台机器，haproxy 监听的端口(8443) 需要与 kube-apiserver的端口 6443 不同，避免冲突。
• keepalived 在运行过程中周期检查本机的 haproxy 进程状态，如果检测到 haproxy 进程异常，则触发重新选主的过程，VIP 将飘移到新选出来的主节点，从而实现 VIP 的高可用。
• 所有组件（如 kubeclt、apiserver、controller-manager、scheduler 等）都通过 VIP 和haproxy 监听的 8443 端口访问 kube-apiserver 服务。

5.1.1 在 master 节点分别安装haproxy, keepalived，并配置haproxy 配置文件

• haproxy 配置文件相同可以复用, 以下步骤在各个 master 节点分别执行一次!

# 安装haproxy, keepalived
[root@k8s-master01 ~]# yum install keepalived haproxy -y

# 配置haproxy 配置文件
[root@k8s-master01 ~]# vi /etc/haproxy/haproxy.cfg 
global
    log /dev/log local0
    log /dev/log local1 notice
    chroot /var/lib/haproxy
    stats socket /var/run/haproxy-admin.sock mode 660 level admin
    stats timeout 30s
    user haproxy
    group haproxy
    daemon
    nbproc 1
defaults
    log global
    timeout connect 5000
    timeout client 10m
    timeout server 10m
listen admin_stats
    bind 0.0.0.0:10080
    mode http
    log 127.0.0.1 local0 err
    stats refresh 30s
    stats uri /status
    stats realm welcome login\ Haproxy
    stats auth haproxy:123456
    stats hide-version
    stats admin if TRUE
listen k8s-master
    bind 0.0.0.0:8443
    mode tcp
    option tcplog
    balance source
    server 192.168.2.201 192.168.2.201:6443 check inter 2000 fall 2 rise 2 weight 1
    server 192.168.2.202 192.168.2.202:6443 check inter 2000 fall 2 rise 2 weight 1
    server 192.168.2.203 192.168.2.203:6443 check inter 2000 fall 2 rise 2 weight 1

• haproxy 在 10080 端口输出 status 信息；
• haproxy 监听所有接口的 8443 端口，该端口与环境变量 ${KUBE_APISERVER} 指定的端口必须一致；
• server 字段列出所有kube-apiserver监听的 IP 和端口；

设置开机启动服务, 并开启三个 master 节点的 haproxy 服务

systemctl enable haproxy && systemctl restart haproxy && systemctl status haproxy

# 检查运行是否正常, 任意master节点执行!
[root@k8s-master01 ~]# netstat -lnpt | grep haproxy
# 输出类似:
Active: active (running) since Tue 2019-11-12 01:54:41 CST; 543ms ago
tcp        0      0 0.0.0.0:8443            0.0.0.0:*               LISTEN      4995/haproxy        
tcp        0      0 0.0.0.0:10080           0.0.0.0:*               LISTEN      4995/haproxy   

5.1.2 配置和启动 keepalived 服务

• keepalived 是一主（master）多备（backup）运行模式，故有两种类型的配置文件。
• master 配置文件只有一份，backup 配置文件视节点数目而定，对于本文档而言，规划如下：
  master: 192.168.2.201
  backup：192.168.2.202、192.168.2.203

在192.168.2.201 master主服务的配置文件：

[root@k8s-master01 ~]# vi /etc/keepalived/keepalived.conf
global_defs {
    router_id keepalived_201  # ......
}
vrrp_script check-haproxy {
    script "killall -0 haproxy"
    interval 5
    weight -30
}
vrrp_instance VI-k8s-master {
    state MASTER
    priority 120    # 第一台从数值 -10, 以此类推!
    dont_track_primary
    interface eth0
    virtual_router_id 201  # ......
    advert_int 3
    track_script {
        check-haproxy
    }
    virtual_ipaddress {
        192.168.2.210
    }
}

• 我的VIP 所在的接口nterface 为 eth0；根据自己的情况改变
• 使用 killall -0 haproxy 命令检查所在节点的 haproxy 进程是否正常。如果异常则将权重减少（-30）,从而触发重新选主过程；
• router_id、virtual_router_id 用于标识属于该 HA 的 keepalived 实例，如果有多套keepalived HA，则必须各不相同；

在192.168.2.202, 192.168.2.203两台backup 服务的配置文件：

[root@k8s-master02 ~]# vi /etc/keepalived/keepalived.conf

global_defs {
        router_id keepalived_202    # 对应设置
}
vrrp_script check-haproxy {
        script "killall -0 haproxy"
        interval 5
        weight -30
}
vrrp_instance VI-k8s-master {
        state BACKUP
        priority 110   # 第2台从数值 -10
        dont_track_primary
        interface eth0
        virtual_router_id 202  # 对应设置
        advert_int 3
        track_script {
        check-haproxy
        }
        virtual_ipaddress {
            192.168.2.210
        }
}

• priority 的值必须小于 master 的值；两个从的值也需要不一样；

设置开机启动服务, 并开启三个 master 节点的 keepalived 服务

systemctl enable keepalived && systemctl restart keepalived && systemctl status keepalived

• 在各个 master 节点上检查 eth0 网卡是否有VIP的IP地址存在

[root@k8s-master01 ~]# ip addr
...
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
    link/ether 00:15:5d:00:68:05 brd ff:ff:ff:ff:ff:ff
    inet 192.168.2.201/24 brd 192.168.2.255 scope global noprefixroute eth0
       valid_lft forever preferred_lft forever
    inet 192.168.2.210/32 scope global eth0
       valid_lft forever preferred_lft forever
    inet6 fe80::f726:9d22:2b89:694c/64 scope link noprefixroute 
       valid_lft forever preferred_lft forever
...

5.1.6 查看 haproxy 状态页面

• 浏览器访问 192.168.2.210:10080/status 地址

5.2 部署 kube-apiserver 组件

• kube-apiserver 是整个k8s集群中的数据总线和数据中心，提供增删改查及watch等HTTP Rest接口
• kube-apiserver 是无状态的, 客户端如kubelet可通过启动参数"--api-servers"指定多个api-server，但只有第一个生效

下载二进制文件

• kubernetes_server 包里有, 已经解压并分发到/opt/k8s/bin下

5.2.1 创建 kube-apiserver证书和私钥

创建证书签名请求

• host地址可以多预留几个备用!

[root@k8s-master01 ~]# cat > /opt/k8s/cert/kube-apiserver-csr.json <<EOF
{
    "CN": "kubernetes",
    "hosts": [
        "127.0.0.1",
        "10.96.0.1",
        "192.168.2.210",
        "192.168.2.201",
        "192.168.2.202",
        "192.168.2.203",
        "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": "steams"
        }
    ]
}
EOF

• hosts 字段指定授权使用该证书的 IP 或域名列表，这里列出了service IP , VIP , apiserver节点 IP和域名；
• 域名最后字符不能是 . (如不能为kubernetes.default.svc.cluster.local. )，否则解析时失败，提示： x509:cannot parse dnsName "kubernetes.default.svc.cluster.local." ；
• 如果使用非 cluster.local 域名，如 opsnull.com ，则需要修改域名列表中的最后两个域名为： kubernetes.default.svc.opsnull 、 kubernetes.default.svc.opsnull.com
• service IP 是 apiserver 自动创建的，一般是 --service-cluster-ip-range 参数指定的网段的第一个IP，后续可以通过如下命令获取：kubectl get svc kubernetes

生成证书和私钥

[root@k8s-master01 ~]# cfssl gencert \
-ca=/opt/k8s/cert/ca.pem \
-ca-key=/opt/k8s/cert/ca-key.pem \
-config=/opt/k8s/cert/ca-config.json \
-profile=kubernetes /opt/k8s/cert/kube-apiserver-csr.json | cfssljson -bare /opt/k8s/cert/kube-apiserver

[root@k8s-master01 ~]# ls /opt/k8s/cert/kube-apiserver*
kube-apiserver.csr      kube-apiserver-csr.json  kube-apiserver-key.pem  kube-apiserver.pem 

5.2.2 手动生成 token 并保存在 /opt/k8s/bootstrap-token.csv 里

• kubelet 启动时向 kube-apiserver发送注册信息，在双向的TLS加密通信环境中需要认证，采用TLS Bootstrapping 机制，可使大量的node节点自动完成向kube-apiserver的注册请求。
  原理：kubelet 首次启动时向 kube-apiserver 发送 TLS Bootstrapping 请求，kube-apiserver 验证 kubelet 请求中的 token 是否与它配置的 token.csv 一致，如果一致则自动为 kubelet生成证书和秘钥。

# 生成 token
[root@k8s-master01 ~]# head -c 16 /dev/urandom | od -An -t x | tr -d ' '
fb8f04963e38858eab0867e8d2296d6b

# 保存
[root@k8s-master01 ~]# vi /opt/k8s/bootstrap-token.csv
fb8f04963e38858eab0867e8d2296d6b,kubelet-bootstrap,10001,"system:kubelet-bootstrap"

或者:

# 生成, 并写入文件
[root@k8s-master01 ~]# echo "`head -c 16 /dev/urandom | od -An -t x | tr -d ' '`,kubelet-bootstrap,10001,\"system:kubelet-bootstrap\"" > /opt/k8s/bootstrap-token.csv

# 查看
[root@k8s-master01 ~]# cat /opt/k8s/bootstrap-token.csv

5.2.3 将生成的证书和私钥、加密配置文件和 bootstrap-token.csv 传送到 所有 master 节点的 /opt/k8s 目录下

# 编写传送脚本
[root@k8s-master01 ~]# vi /opt/k8s/script/scp_apiserver.sh
MASTER_IPS=("$1" "$2" "$3")
for master_ip in ${MASTER_IPS[@]};do
    echo  ">>> ${master_ip}"
    scp /opt/k8s/cert/kube-apiserver*.pem root@${master_ip}:/opt/k8s/cert/
    scp /opt/k8s/bootstrap-token.csv root@${master_ip}:/opt/k8s/
done 

# 执行脚本, 注意传参!
[root@k8s-master01 ~]# bash /opt/k8s/script/scp_apiserver.sh 192.168.2.201 192.168.2.202 192.168.2.203

5.2.4 为所有 master 节点分别创建 kube-apiserver 的 systemd unit 文件

• 注意变量 ##MASTER_IP## 的修改!

[root@k8s-master01 ~]# vi /etc/systemd/system/kube-apiserver.service
[Unit]
Description=Kubernetes API Server
Documentation=https://github.com/GoogleCloudPlatform/kubernetes
After=network.target
After=etcd.service

[Service]
ExecStart=/opt/k8s/bin/kube-apiserver \
--admission-control=NamespaceLifecycle,LimitRanger,ServiceAccount,PersistentVolumeLabel,DefaultStorageClass,ResourceQuota,DefaultTolerationSeconds  \
--allow-privileged=true \
--anonymous-auth=false \
--authorization-mode=Node,RBAC \
--advertise-address=##MASTER_IP## \
--bind-address=##MASTER_IP## \
--secure-port=6443 \
--service-cluster-ip-range=10.96.0.0/16 \
--service-node-port-range=30000-50000 \
--enable-bootstrap-token-auth=true \
--token-auth-file=/opt/k8s/bootstrap-token.csv \
--client-ca-file=/opt/k8s/cert/ca.pem \
--runtime-config=api/all=true \
--service-account-key-file=/opt/k8s/cert/ca-key.pem \
--tls-cert-file=/opt/k8s/cert/kube-apiserver.pem \
--tls-private-key-file=/opt/k8s/cert/kube-apiserver-key.pem \
--kubelet-https=true \
--kubelet-certificate-authority=/opt/k8s/cert/ca.pem \
--kubelet-client-certificate=/opt/k8s/cert/kube-apiserver.pem \
--kubelet-client-key=/opt/k8s/cert/kube-apiserver-key.pem \
--etcd-cafile=/opt/k8s/cert/ca.pem \
--etcd-certfile=/opt/k8s/cert/kube-apiserver.pem \
--etcd-keyfile=/opt/k8s/cert/kube-apiserver-key.pem \
--etcd-servers=https://192.168.2.201:2379,https://192.168.2.202:2379,https://192.168.2.203:2379 \
--apiserver-count=3 \
--audit-log-maxage=30 \
--audit-log-maxbackup=3 \
--audit-log-maxsize=100 \
--audit-log-path=/opt/log/kube-apiserver-audit.log \
--alsologtostderr=true \
--logtostderr=false \
--log-dir=/opt/log/kubernetes \
--v=2
Restart=on-failure
RestartSec=5
Type=notify
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target

• --authorization-mode=Node,RBAC ： 开启 Node 和 RBAC 授权模式，拒绝未授权的请求；
• --enable-admission-plugins ：启用 ServiceAccount 和NodeRestriction ；
• --service-account-key-file ：签名 ServiceAccount Token 的公钥文件，kube-controller-manager 的 --service-account-private-key-file 指定私钥文件，两者配对使用；
• --tls-*-file ：指定 apiserver 使用的证书、私钥和 CA 文件。 --client-ca-file 用于验证 client (kue-controller-manager、kube-scheduler、kubelet、kube-proxy 等)请求所带的证书；
• --kubelet-client-certificate 、 --kubelet-client-key ：如果指定，则使用 https 访问 kubelet APIs；需要为证书对应的用户定义 RBAC 规则，否则访问 kubelet API 时提示未授权；
• --bind-address ： 不能为 127.0.0.1 ，否则外界不能访问它的安全端口6443；
• --service-cluster-ip-range ： 指定 Service Cluster IP 地址段；
• --service-node-port-range ： 指定 NodePort 的端口范围；
• --runtime-config=api/all=true ： 启用所有版本的 APIs，如autoscaling/v2alpha1；
• --enable-bootstrap-token-auth ：启用 kubelet bootstrap 的 token 认证；
• --apiserver-count=3 ：指定集群有三个节点

5.2.5 各个 master 节点启动并检查 kube-apiserver 服务

# 启动
systemctl daemon-reload && systemctl enable kube-apiserver && systemctl restart kube-apiserver && systemctl status kube-apiserver

5.2.6 授予 kubernetes 证书访问 kubelet API 的权限 (待定!!!)

[root@k8s-master01 ~]# kubectl create clusterrolebinding kube-apiserver:kubelet-apis \
--clusterrole=system:kubelet-api-admin \
--user=kubernetes

• 后面部署好集群，在执行 kubectl exec、run、logs 等命令时，apiserver 会转发到 kubelet。这里定义RBAC 规则，授权 apiserver 调用 kubelet API，否则会报类似以下错误：
  Error from server (Forbidden): Forbidden (user=kubernetes, verb=get, resource=nodes, subresource=proxy) ( pods/log nginx-8477bdff5d-2lf7k)

5.2.7 检查, 验证集群

[root@k8s-master01 ~]# kubectl cluster-info
Kubernetes master is running at https://192.168.2.210:8443

[root@k8s-master01 ~]# kubectl get all --all-namespaces
NAMESPACE   NAME                 TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
default     service/kubernetes   ClusterIP   10.96.0.1    <none>        443/TCP   49m

# 6443: 接收 https 请求的安全端口，对所有请求做认证和授权；
[root@k8s-master01 ~]# ss -nutlp | grep apiserver
tcp    LISTEN   0        128         192.168.2.201:6443           0.0.0.0:*      users:(("kube-apiserver",pid=3342,fd=8))                                       
tcp    LISTEN   0        128             127.0.0.1:8080           0.0.0.0:*      users:(("kube-apiserver",pid=3342,fd=7))  

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

• 该集群包含 3 个节点，kube-controller-manager是有状态的服务，会修改集群的状态信息。如果多个master节点上的相关服务同时生效，则会有同步与一致性问题，所以多master节点中的kube-controller-manager服务只能是主备的关系
• 为保证通信安全，使用 x509 证书和私钥，kube-controller-manager 在如下两种情况下使用该证书：
  与 kube-apiserver 的安全端口通信时;
  在安全端口(https，10252) 输出 prometheus 格式的 metrics；

准备工作：下载kube-controller-manager二进制文件(包含在kubernetes-server包里, 已解压发送)

5.3.1 创建 kube-controller-manager 的证书和私钥

创建证书签名请求：

[root@k8s-master01 ~]# cat > /opt/k8s/cert/kube-controller-manager-csr.json <<EOF
{
    "CN": "system:kube-controller-manager",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "hosts": [
        "127.0.0.1",
        "192.168.2.201",
        "192.168.2.202",
        "192.168.2.203",
        "localhost"
    ],
    "names": [
        {
            "C": "CN",
            "ST": "BeiJing",
            "L": "BeiJing",
            "O": "system:kube-controller-manager",
            "OU": "steams"
        }
    ]
}
EOF

• hosts 列表包含所有 kube-controller-manager 节点 IP；
• CN 为 system:kube-controller-manager;
  O 为 system:kube-controller-manager;
  kube-apiserver预定义的 RBAC使用的ClusterRoleBindings system:kube-controller-manager将用户system:kube-controller-manager与ClusterRole system:kube-controller-manager绑定。

生成证书和私钥

[root@k8s-master01 ~]# cfssl gencert \
-ca=/opt/k8s/cert/ca.pem \
-ca-key=/opt/k8s/cert/ca-key.pem \
-config=/opt/k8s/cert/ca-config.json \
-profile=kubernetes /opt/k8s/cert/kube-controller-manager-csr.json | cfssljson -bare /opt/k8s/cert/kube-controller-manager

# 查看证书
[root@k8s-master01 ~]# ls /opt/k8s/cert/kube-controller-manager*
kube-controller-manager.csr       kube-controller-manager-csr.json  kube-controller-manager-key.pem   kube-controller-manager.pem  

5.3.2 创建 kube-controller-manager.kubeconfig 文件

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

### --kubeconfig：指定kubeconfig文件路径与文件名；如果不设置，默认生成在~/.kube/config文件。
### 后面需要用到此文件，所以我们把配置信息单独指向到指定文件中
# step.1 设置集群参数:
[root@k8s-master01 ~]# kubectl config set-cluster kubernetes \
--certificate-authority=/opt/k8s/cert/ca.pem \
--embed-certs=true \
--server=https://192.168.2.210:8443 \
--kubeconfig=/opt/k8s/kube-controller-manager.kubeconfig

# step.2 设置客户端认证参数
[root@k8s-master01 ~]# kubectl config set-credentials system:kube-controller-manager \
--client-certificate=/opt/k8s/cert/kube-controller-manager.pem \
--client-key=/opt/k8s/cert/kube-controller-manager-key.pem \
--embed-certs=true \
--kubeconfig=/opt/k8s/kube-controller-manager.kubeconfig

# step.3 设置上下文参数
[root@k8s-master01 ~]# kubectl config set-context system:kube-controller-manager@kubernetes \
--cluster=kubernetes \
--user=system:kube-controller-manager \
--kubeconfig=/opt/k8s/kube-controller-manager.kubeconfig

# tep.4 设置默认上下文
[root@k8s-master01 ~]# kubectl config use-context system:kube-controller-manager@kubernetes \
--kubeconfig=/opt/k8s/kube-controller-manager.kubeconfig

5.3.3 分发生成的证书和私钥、kubeconfig 到所有 master 节点

# 编写分发脚本
[root@k8s-master01 ~]# vi /opt/k8s/script/scp_controller-manager.sh
MASTER_IPS=("$1" "$2" "$3")
for master_ip in ${MASTER_IPS[@]};do
    echo ">>> ${master_ip}"
    scp /opt/k8s/cert/kube-controller-manager*.pem root@${master_ip}:/opt/k8s/cert/
    scp /opt/k8s/kube-controller-manager.kubeconfig root@${master_ip}:/opt/k8s/
done

# 执行, 注意传参!
[root@k8s-master01 ~]# bash /opt/k8s/script/scp_controller-manager.sh 192.168.2.201 192.168.2.202 192.168.2.203

5.3.4 为所有 master 节点分别创建 kube-controller-manager 的 systemd unit 文件

• 一样的配置, 可复用!
• --bind-address=0.0.0.0 目前这样设置!

[root@k8s-master01 ~]# vi /etc/systemd/system/kube-controller-manager.service
[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/GoogleCloudPlatform/kubernetes
After=kube-apiserver.service

[Service]
ExecStart=/opt/k8s/bin/kube-controller-manager \
--address=127.0.0.1 \
--port=10252 \
--bind-address=0.0.0.0 \
--secure-port=10257 \
--cluster-name=kubernetes \
--allocate-node-cidrs=true \
--service-cluster-ip-range=10.96.0.0/16 \
--authentication-kubeconfig=/opt/k8s/kube-controller-manager.kubeconfig \
--authorization-kubeconfig=/opt/k8s/kube-controller-manager.kubeconfig \
--kubeconfig=/opt/k8s/kube-controller-manager.kubeconfig \
--root-ca-file=/opt/k8s/cert/ca.pem \
--use-service-account-credentials=true \
--service-account-private-key-file=/opt/k8s/cert/ca-key.pem \
--cluster-signing-cert-file=/opt/k8s/cert/ca.pem \
--cluster-signing-key-file=/opt/k8s/cert/ca-key.pem \
--experimental-cluster-signing-duration=876000h \
--client-ca-file=/opt/k8s/cert/ca.pem \
--requestheader-client-ca-file=/opt/k8s/cert/ca.pem \
--leader-elect=true \
--feature-gates=RotateKubeletServerCertificate=true \
--controllers=*,bootstrapsigner,tokencleaner \
--horizontal-pod-autoscaler-use-rest-clients=true \
--horizontal-pod-autoscaler-sync-period=10s \
--tls-cert-file=/opt/k8s/cert/kube-controller-manager.pem \
--tls-private-key-file=/opt/k8s/cert/kube-controller-manager-key.pem \
--alsologtostderr=true \
--logtostderr=false \
--log-dir=/opt/log/kubernetes \
--v=2
Restart=on-failure
RestartSec=5
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target

• --port=10252, --address=127.0.0.1:将不安全端口 10252 绑定到 127.0.0.1 确保 kuebctl get cs 有正确返回
• --secure-port=10257、--bind-address=0.0.0.0: 在所有网络接口监听 10257 端口的 https /metrics 请求；
• --kubeconfig：指定 kubeconfig 文件路径，kube-controller-manager 使用它连接和验证 kube-apiserver；
• --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 的节点负责处理工作，其它节点为阻塞状态；
• --feature-gates=RotateKubeletServerCertificate=true：开启 kublet server 证书的自动更新特性；
• --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:
• --authentication-kubeconfig:
• --authorization-kubeconfig:

5.3.5 为各 master 节点设置开机启动, 并检查启动 kube-controller-manager

systemctl daemon-reload && systemctl enable kube-controller-manager && systemctl start kube-controller-manager && systemctl status kube-controller-manager

# 查看输出的 metric
[root@k8s-master03 ~]# ss -nutlp |grep kube-controll
tcp    LISTEN   0        128             127.0.0.1:10252          0.0.0.0:*      users:(("kube-controller",pid=3951,fd=6))                                      
tcp    LISTEN   0        128                     *:10257                *:*      users:(("kube-controller",pid=3951,fd=7)) 

# 停掉一个或两个节点的 kube-controller-manager 服务，观察其它节点的日志，看是否获取了 leader 权限。
# 查看当前的 leader 
[root@k8s-master02 ~]# kubectl get endpoints kube-controller-manager --namespace=kube-system -o yaml

6.4 部署高可用 kube-scheduler 集群

• 该集群包含 3 个节点，启动后将通过竞争选举机制产生一个 leader 节点，其它节点为阻塞状态。当 leader 节点不可用后，剩余节点将再次进行选举产生新的 leader 节点，从而保证服务的可用性。
• 为保证通信安全，生成 x509 证书和私钥，kube-scheduler 在如下两种情况下使用该证书：
  与 kube-apiserver 的安全端口通信;
  在安全端口(https，10251) 输出 prometheus 格式的 metrics；

准备工作：下载kube-scheduler 的二进制文件---^^^

6.4.1 创建 kube-scheduler 证书和私钥

创建证书签名请求：

[root@k8s-master01 ~]# cat > /opt/k8s/cert/kube-scheduler-csr.json <<EOF
{
    "CN": "system:kube-scheduler",
    "hosts": [
      "127.0.0.1",
      "192.168.2.201",
      "192.168.2.202",
      "192.168.2.203",
      "localhost"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
      {
        "C": "CN",
        "ST": "BeiJing",
        "L": "BeiJing",
        "O": "system:kube-scheduler",
        "OU": "steams"
      }
    ]
}
EOF

• hosts 列表包含所有 kube-scheduler 节点 IP；
• CN 为 system:kube-scheduler、O 为 system:kube-scheduler (kubernetes 内置的 ClusterRoleBindings system:kube-scheduler 将赋予 kube-scheduler 工作所需的权限.)

生成证书和私钥

[root@k8s-master01 ~]# cfssl gencert \
-ca=/opt/k8s/cert/ca.pem \
-ca-key=/opt/k8s/cert/ca-key.pem \
-config=/opt/k8s/cert/ca-config.json \
-profile=kubernetes /opt/k8s/cert/kube-scheduler-csr.json | cfssljson -bare /opt/k8s/cert/kube-scheduler

# 查看证书
[root@k8s-master01 ~]# ls /opt/k8s/cert/kube-scheduler*
kube-scheduler.csr       kube-scheduler-csr.json  kube-scheduler-key.pem   kube-scheduler.pem  

5.4.2 创建 kube-scheduler.kubeconfig 文件

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

# step.1 设置集群参数
[root@k8s-master01 ~]# kubectl config set-cluster kubernetes \
--certificate-authority=/opt/k8s/cert/ca.pem \
--embed-certs=true \
--server=https://192.168.2.210:8443 \
--kubeconfig=/opt/k8s/kube-scheduler.kubeconfig

# step.2 设置客户端认证参数
[root@k8s-master01 ~]# kubectl config set-credentials system:kube-scheduler \
--client-certificate=/opt/k8s/cert/kube-scheduler.pem \
--client-key=/opt/k8s/cert/kube-scheduler-key.pem \
--embed-certs=true  \
--kubeconfig=/opt/k8s/kube-scheduler.kubeconfig

# step.3 设置上下文参数
[root@k8s-master01 ~]# kubectl config set-context system:kube-scheduler@kubernetes \
--cluster=kubernetes \
--user=system:kube-scheduler \
--kubeconfig=/opt/k8s/kube-scheduler.kubeconfig

# step.4设置默认上下文
[root@k8s-master01 ~]# kubectl config use-context system:kube-scheduler@kubernetes \
--kubeconfig=/opt/k8s/kube-scheduler.kubeconfig

5.4.3 分发生成的证书和私钥、kubeconfig 到所有 master 节点

# 编写分发脚本
[root@k8s-master01 ~]# vi /opt/k8s/script/scp_scheduler.sh
MASTER_IPS=("$1" "$2" "$3")
for master_ip in ${MASTER_IPS[@]};do
        echo ">>> ${master_ip}"
        scp /opt/k8s/cert/kube-scheduler*.pem root@${master_ip}:/opt/k8s/cert/
        scp /opt/k8s/kube-scheduler.kubeconfig root@${master_ip}:/opt/k8s/
done

# 执行脚本, 注意传参!
[root@k8s-master01 ~]# bash /opt/k8s/script/scp_scheduler.sh 192.168.2.201 192.168.2.202 192.168.2.203

5.4.4 为各个 master 节点分别创建kube-scheduler 的 systemd unit 文件

[root@k8s-master01 ~]# vi /etc/systemd/system/kube-scheduler.service
[Unit]
Description=Kubernetes Scheduler
Documentation=https://github.com/GoogleCloudPlatform/kubernetes
After=kube-apiserver.service

[Service]
ExecStart=/opt/k8s/bin/kube-scheduler \
--address=127.0.0.1 \
--port=10251 \
--bind-address=0.0.0.0 \
--secure-port=10259 \
--kubeconfig=/opt/k8s/kube-scheduler.kubeconfig \
--client-ca-file=/opt/k8s/cert/ca.pem \
--requestheader-client-ca-file=/opt/k8s/cert/ca.pem \
--tls-cert-file=/opt/k8s/cert/kube-scheduler.pem \
--tls-private-key-file=/opt/k8s/cert/kube-scheduler-key.pem \
--leader-elect=true \
--alsologtostderr=true \
--logtostderr=false \
--log-dir=/opt/log/kubernetes \
--v=2
Restart=on-failure
RestartSec=5
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target

• --address：在 127.0.0.1:10251 端口接收 http /metrics 请求；10259 接收 https 请求!
• --kubeconfig：指定 kubeconfig 文件路径，kube-scheduler 使用它连接和验证 kube-apiserver；
• --leader-elect=true：集群运行模式，启用选举功能；被选为 leader 的节点负责处理工作，其它节点为阻塞状态；

5.4.5 为所有 master 节点设置开机启动, 并启动检查 kube-scheduler 服务

systemctl daemon-reload && systemctl enable kube-scheduler && systemctl start kube-scheduler && systemctl status kube-scheduler

# 查看输出的 metric
[root@k8s-master01 ~]# ss -nutlp |grep kube-scheduler
tcp    LISTEN   0        128             127.0.0.1:10251          0.0.0.0:*      users:(("kube-scheduler",pid=8584,fd=6))                                       
tcp    LISTEN   0        128                     *:10259                *:*      users:(("kube-scheduler",pid=8584,fd=7))   
                                    
[root@k8s-master01 ~]# curl -s http://127.0.0.1:10251/metrics |head
# HELP apiserver_audit_event_total [ALPHA] Counter of audit events generated and sent to the audit backend.
# TYPE apiserver_audit_event_total counter
apiserver_audit_event_total 0
# HELP apiserver_audit_requests_rejected_total [ALPHA] Counter of apiserver requests rejected due to an error in audit logging backend.
# TYPE apiserver_audit_requests_rejected_total counter
apiserver_audit_requests_rejected_total 0
# HELP apiserver_client_certificate_expiration_seconds [ALPHA] Distribution of the remaining lifetime on the certificate used to authenticate a request.
# TYPE apiserver_client_certificate_expiration_seconds histogram
apiserver_client_certificate_expiration_seconds_bucket{le="0"} 0
apiserver_client_certificate_expiration_seconds_bucket{le="1800"} 0

# 停掉一个或两个节点的 kube-scheduler 服务，观察其它节点的日志，看是否获取了 leader 权限。
# 查看当前的 leader 
[root@k8s-master02 ~]# kubectl get endpoints kube-scheduler --namespace=kube-system -o yaml

master 节点基本组件已部署完毕!

# 集群健康检查
kubectl get cs

: