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

最后编辑于：2019.12.14 19:56:09

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 206,968评论 6赞 482
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 88,601评论 2赞 382
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 153,220评论 0赞 344
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 55,416评论 1赞 279
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 64,425评论 5赞 374
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 49,144评论 1赞 285
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 38,432评论 3赞 401
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 37,088评论 0赞 261
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 43,586评论 1赞 300
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 36,028评论 2赞 325
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,137评论 1赞 334
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,783评论 4赞 324
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,343评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,333评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,559评论 1赞 262
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 45,595评论 2赞 355
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,901评论 2赞 345

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

组件版本和配置策略

组件版本

核心插件：

主要配置策略

1. K8S系统初始化

1.1 系统环境

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

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

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

1.5 所有节点设置时间同步

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

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

1.8 无密码 ssh 登录其它节点

2. 创建CA根证书和密钥

2.1 安装cfssl工具集

2.2 创建根证书CA

2.03 创建配置文件

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

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

2.6 分发证书文件

3. 部署etcd集群

3.1 下载二进制文件

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

3.3 生成证书和私钥

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

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

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

3.7 验证集群

4. 部署kubectl命令行工具

4.1 下载kubectl二进制文件

4.2 创建 admin 证书和私钥

创建证书签名请求

生成证书和私钥

4.3 创建 kubectl 的 kubeconfig 配置文件

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

5. 部署master节点

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

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

5.1 部署高可用组件

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

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

5.1.2 配置和启动 keepalived 服务

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

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

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

5.1.6 查看 haproxy 状态页面

5.2 部署 kube-apiserver 组件

下载二进制文件

5.2.1 创建 kube-apiserver证书和私钥

创建证书签名请求

生成证书和私钥

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

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

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

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

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

5.2.7 检查, 验证集群

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

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

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

创建证书签名请求：

生成证书和私钥

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

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

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

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

6.4 部署高可用 kube-scheduler 集群

6.4.1 创建 kube-scheduler 证书和私钥

创建证书签名请求：

生成证书和私钥

5.4.2 创建 kube-scheduler.kubeconfig 文件

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

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

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

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

推荐阅读更多精彩内容

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