Kubernetes部署通用手册 (支持版本1.19,1.18,1.17,1.16)

2020 年 7 月 12 日
筆記
Kubernetes

操作环境

rbac 划分（HA高可用双master部署实例）

本文穿插了ha 高可用部署的实例，当前章节设计的是ha部署双master 部署

内网ip	角色	安装软件
192.168.0.10	master01	etcd,kube-apiserver,kube-controller-manager,kube-scheduler
192.168.0.12	master02	etcd,kube-apiserver,kube-controller-manager,kube-scheduler
192.168.0.7	node01	docker,kubelet,kube-proxy,flannel
192.168.0.8	node02	docker,kubelet,kube-proxy,flannel
192.168.0.4	slb master	etcd，nginx
192.168.0.9
192.168.0.200	keepalived上的VIP

注意

flannel可以只安装node上，flannel只是跨机器宿主机和容器通讯使用
docker可以只安装node上，master上可以不安装
etcd 键值对的数据库，是独立三台机器。不要复用。
192.168.0.200是keepalived上的vip

自签SSL证书

k8s安装包下载

//github.com/kubernetes

部署网络说明

Kubernetes 网络架构图

Overlay Network：覆盖网络，在基础网络上叠加的一种虚拟网络技术模式，该网络中的主机通过虚拟链路连接起来。

VXLAN：将源数据包封装到UDP中，并使用基础网络的IP/MAC作为外层报文头进行封装，然后在以太网上传输，到达目的地后由隧道端点解封装并将数据发送给目标地址。

Flannel：是Overlay网络的一种，也是将源数据包封装在另一种网络包里面进行路由转发和通信，目前已经支持UDP、VXLAN、AWS VPC和GCE路由等数据转发方式。

Flannel网络架构图

数据从源容器中发出后，经由所在主机的docker0虚拟网卡转发到flannel0虚拟网卡，这是个P2P的虚拟网卡，flanneld服务监听在网卡的另外一端。
Flannel通过Etcd服务维护了一张节点间的路由表，在稍后的配置部分我们会介绍其中的内容。
源主机的flanneld服务将原本的数据内容UDP封装后根据自己的路由表投递给目的节点的flanneld服务，数据到达以后被解包，然后直接进入目的节点的flannel0虚拟网卡，
然后被转发到目的主机的docker0虚拟网卡，最后就像本机容器通信一下的有docker0路由到达目标容器。

Kubernetes基本工作流程

客户端创建pod 流程：

首先管理员创建 Pod 的请求默认是通过kubectl 客户端管理命令 api server 组件进行交互的，默认会将请求发送给 API Server 集群统一入口。
API Server 会根据请求的类型选择用何种 REST API 对请求作出处理（比如：创建 Pod 时 Storage 类型是 Pods 时，其对应的就是 REST Storage API）。
REST Storage API 会对请求作相应的处理并将处理的结果存入高可用键值存储系统 Etcd 中。
同时Scheduler会检测到etcd集群的变化，Scheduler 会根据ETCD集群中运行 Pod情况及 Node 信息进行判断，将需要创建的 Pod 分发到可用的 Node 节点上。然后根据一组相关规则将pod分配到可以运行它们的节点上，并更新etcd数据库，记录pod分配情况。
Node节点上Kubelet监控etcd数据库变化，管理创建pod，kubelet在Node节点上面开始创建新的pod，就会进行docker组件的启动，docker组件会启动对应的容器（pod），会在该节点上运行这个新pod。
kube-proxy运行在集群各个节点主机上，管理网络通信，如服务发现、负载均衡。例如当有数据发送到主机时，将其路由到正确的pod或容器。对于从主机上发出的数据，它可以基于请求地址发现远程服务器，并将数据正确路由，在某些情况下会使用轮训调度算法(Round-robin)将请求发送到集群中的多个实例。

集群功能各模块功能描述：

Master节点：

Master节点上面主要由四个模块组成，APIServer，schedule,controller-manager,etcd.

APIServer: APIServer负责对外提供RESTful的kubernetes API的服务，它是系统管理指令的统一接口，任何对资源的增删该查都要交给APIServer处理后再交给etcd，如图，kubectl(kubernetes提供的客户端工具，该工具内部是对kubernetes API的调用）是直接和APIServer交互的。
schedule: schedule负责调度Pod到合适的Node上，如果把scheduler看成一个黑匣子，那么它的输入是pod和由多个Node组成的列表，输出是Pod和一个Node的绑定。 kubernetes目前提供了调度算法，同样也保留了接口。用户根据自己的需求定义自己的调度算法。
controller manager: 如果APIServer做的是前台的工作的话，那么controller manager就是负责后台的。每一个资源都对应一个控制器。而controller manager就是负责管理这些控制器的，比如我们通过APIServer创建了一个Pod，当这个Pod创建成功后，APIServer的任务就算完成了。
etcd：etcd是一个高可用的键值存储系统，kubernetes使用它来存储各个资源的状态，从而实现了Restful的API。

Node节点：

每个Node节点主要由三个模板组成：kublet, kube-proxy,Docker

kube-proxy: 该模块实现了kubernetes中的服务发现和反向代理功能。kube-proxy支持TCP和UDP连接转发，默认基Round Robin算法将客户端流量转发到与service对应的一组后端pod。服务发现方面，kube-proxy使用etcd的watch机制监控集群中service和endpoint对象数据的动态变化，并且维护一个service到endpoint的映射关系，从而保证了后端pod的IP变化不会对访问者造成影响，另外，kube-proxy还支持session affinity。
kublet：kublet是Master在每个Node节点上面的agent，是Node节点上面最重要的模块，它负责维护和管理该Node上的所有容器，但是如果容器不是通过kubernetes创建的，它并不会管理。本质上，它负责使Pod的运行状态与期望的状态一致。
Docker:进行容器生成、配置和使用，作为pod节点的重要支撑。

Kubernetes单节点安装及配置

前面划分的ha 高可用双master部署 K8S ，先以单master实例进行演示，后续增加master，但是不冲突，后续增加LB 节点、和master高可用既可以。

ip	操作系统	角色	安装软件
192.168.0.10	centos7.6_x64	master01	docker，etcd
192.168.0.7	centos7.6_x64	node01	docker
192.168.0.8	centos7.6_x64	node02	docker

本教程以安装Centos7 mini版本为系统镜像安装

初始化环境

设置关闭防火墙及SELINUX

systemctl stop firewalld && systemctl disable firewalld
setenforce 0
yum install yum-utils -y 
vi /etc/selinux/config
SELINUX=disabled

关闭Swap

swapoff -a && sysctl -w vm.swappiness=0
vi /etc/fstab
UUID=7bff6243-324c-4587-b550-55dc34018ebf swap                    swap    defaults        0 0

设置Docker所需参数（未做）

cat << EOF | tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1                                                                 
net.ipv4.ip_forward = 1
EOF

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

在node节点上安装 Docker

1. 安装好docker
yum-config-manager --add-repo //mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
yum list docker-ce --showduplicates | soft -r
yum install docker-ce -y
systemctl start docker && systemctl enable docker

2. 配置docker加速器
curl -sSL //get.daocloud.io/daotools/set_mirror.sh | sh -s //f1361db2.m.daocloud.io && systemctl restart docker

创建安装目录

mkdir /data/soft/etcd/{bin,cfg,ssl} -p
mkdir /data/soft/kubernetes/{bin,cfg,ssl} -p

安装及配置CFSSL

使用cfssl来生成自签证书，先下载cfssl工具：
wget //pkg.cfssl.org/R1.2/cfssl_linux-amd64
wget //pkg.cfssl.org/R1.2/cfssljson_linux-amd64
wget //pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64

chmod +x cfssl_linux-amd64 cfssljson_linux-amd64 cfssl-certinfo_linux-amd64
mv cfssl_linux-amd64 /usr/local/bin/cfssl
mv cfssljson_linux-amd64 /usr/local/bin/cfssljson
mv cfssl-certinfo_linux-amd64 /usr/bin/cfssl-certinfo

部署ETCD

创建etcd集群认证证书

创建 ETCD 证书

创建以下三个文件：

首先创建一个etcd-cert证书存储目录目录，命令如下

mkdir  /data/www/etcd-cert 
cd 	   /data/www/etcd-cert

创建 ETCD 证书生成策略配置文件

cat << EOF | tee etcd-ca-config.json
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "www": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
EOF

# 参数详解
ca-config.json：可以定义多个 profiles，分别指定不同的过期时间、使用场景等参数；后续在签名证书时使用某个 profile；
signing：	   表示该证书可用于签名其它证书；生成的 ca.pem 证书中 CA=TRUE；
server auth：   表示client可以用该 CA 对server提供的证书进行验证；
client auth：   表示server可以用该CA对client提供的证书进行验证；

创建 ETCD CA 证书签名请求

cat << EOF | tee etcd-ca-csr.json
{
    "CN": "etcd CA",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Shenzhen",
            "ST": "Shenzhen"
        }
    ]
}
EOF

参数详解：
CN：Common Name，kube-apiserver 从证书中提取该字段作为请求的用户名 (User Name)；浏览器使用该字段验证网站是否合法；

names中的字段：
C : country，国家
ST: state，州或省份
L：location，城市
O：organization，组织，kube-apiserver 从证书中提取该字段作为请求用户所属的组 (Group)
OU：organization unit,组织单位

创建 ETCD SERVER 证书签名请求

cat << EOF | tee etcd-server-csr.json
{
    "CN": "etcd",
    "hosts": [
    "192.168.0.10",
    "192.168.0.12",
    "192.168.0.4"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Shenzhen",
            "ST": "Shenzhen"
        }
    ]
}
EOF


hosts：指定授权使用该证书的 etcd 节点 IP 列表，需要将 etcd 集群所有节点 IP 都列在其中；

生成 ETCD CA 证书和私钥

cfssl gencert -initca etcd-ca-csr.json | cfssljson -bare etcd-ca 
cfssl gencert -ca=etcd-ca.pem -ca-key=etcd-ca-key.pem -config=etcd-ca-config.json -profile=www etcd-server-csr.json | cfssljson -bare etcd-server 

# cfssl参数详解
gencert: 生成新的key(密钥)和签名证书
	-initca：初始化一个新ca
	-ca：指明ca的证书
	-ca-key：指明ca的私钥文件
	-config：指明请求证书的json文件
	-profile：与-config中的profile对应，是指根据config中的profile段来生成证书的相关信息

查看cert(证书信息):
cfssl certinfo -cert ca.pem

查看CSR(证书签名请求)信息：
cfssl certinfo -csr ca.csr

# cfssljson
	-bare 来自CFSSL的返回值，使用cert，csr和key字段拆分成JSON格式以生成文件。

ssh-key认证

# ssh-keygen
Generating **public**/**private** rsa key pair.
Enter file **in** which to save the **key** (/root/.ssh/id_rsa): 
Created directory '/root/.ssh'.
Enter **passphrase** (empty **for** no passphrase): 
Enter same passphrase again: 
Your identification has been saved **in** /root/.ssh/id_rsa.
Your **public** key has been saved **in** /root/.ssh/id_rsa.pub.
The key fingerprint **is**:
SHA256:FQjjiRDp8IKGT+UDM+GbQLBzF3DqDJ+pKnMIcHGyO/o root@qas-k8s-master01
The key's randomart image **is**:
+---[RSA 2048]----+
|o.==o o. ..      |
|ooB+o+ o.  .     |
|B++@o o   .      |
|=X**o    .       |
|o=O. .  S        |
|..+              |
|oo .             |
|* .              |
|o+E              |
+----[SHA256]-----+

# ssh-copy-id 192.168.0.10**
# ssh-copy-id 192.168.0.12**
# ssh-copy-id 192.168.0.4**
# ssh-copy-id 192.168.0.7**
# ssh-copy-id 192.168.0.8**
# ssh-copy-id 192.168.0.9**

**master主节点要和node节点做免密，方便拷贝文件**

解压etcd安装文件

以下部署步骤在规划的三个etcd节点操作一样，唯一不同的是etcd配置文件中的服务器IP要写当前的服务器：

tar -xvf etcd-v3.3.10-linux-amd64.tar.gz
cd etcd-v3.3.10-linux-amd64/
\cp etcd etcdctl /data/soft/etcd/bin/


cat << EOF | tee /data/soft/etcd/cfg/etcd
#[Member]
ETCD_NAME="etcd01"
ETCD_DATA_DIR="/data/www/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="//192.168.0.10:2380"
ETCD_LISTEN_CLIENT_URLS="//192.168.0.10:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="//192.168.0.10:2380"
ETCD_ADVERTISE_CLIENT_URLS="//192.168.0.10:2379"
ETCD_INITIAL_CLUSTER="etcd01=//192.168.0.10:2380,etcd02=//192.168.0.12:2380,etcd03=//192.168.0.4:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
EOF

配置文件详解：

ETCD_NAME 节点名称
ETCD_DATA_DIR 数据目录
ETCD_LISTEN_PEER_URLS 集群通信监听地址
ETCD_LISTEN_CLIENT_URLS 客户端访问监听地址
ETCD_INITIAL_ADVERTISE_PEER_URLS 集群通告地址
ETCD_ADVERTISE_CLIENT_URLS 客户端通告地址
ETCD_INITIAL_CLUSTER 集群节点地址
ETCD_INITIAL_CLUSTER_TOKEN 集群Token
ETCD_INITIAL_CLUSTER_STATE 加入集群的当前状态，new是新集群，existing表示加入已有集群

创建 etcd的 etcd.service文件

vim /usr/lib/systemd/system/etcd.service
[Unit]
Description=Etcd Server
After=network.target
After=network-online.target
Wants=network-online.target

[Service]
User=www
Group=www
Type=notify
EnvironmentFile=/data/soft/etcd/cfg/etcd
ExecStart=/data/soft/etcd/bin/etcd \
--name=${ETCD_NAME} \
--data-dir=${ETCD_DATA_DIR} \
--listen-peer-urls=${ETCD_LISTEN_PEER_URLS} \
--listen-client-urls=${ETCD_LISTEN_CLIENT_URLS},//127.0.0.1:2379 \
--advertise-client-urls=${ETCD_ADVERTISE_CLIENT_URLS} \
--initial-advertise-peer-urls=${ETCD_INITIAL_ADVERTISE_PEER_URLS} \
--initial-cluster=${ETCD_INITIAL_CLUSTER} \
--initial-cluster-token=${ETCD_INITIAL_CLUSTER_TOKEN} \
--initial-cluster-state=new \
--cert-file=/data/soft/etcd/ssl/etcd-server.pem \
--key-file=/data/soft/etcd/ssl/etcd-server-key.pem \
--peer-cert-file=/data/soft/etcd/ssl/etcd-server.pem \
--peer-key-file=/data/soft/etcd/ssl/etcd-server-key.pem \
--trusted-ca-file=/data/soft/etcd/ssl/etcd-ca.pem \
--peer-trusted-ca-file=/data/soft/etcd/ssl/etcd-ca.pem
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target


# 参数详解：

WorkingDirectory、--data-dir：指定工作目录和数据目录为 ${ETCD_DATA_DIR}，需在启动服务前创建这个目录；
--wal-dir：指定 wal 目录，为了提高性能，一般使用 SSD 或者和 --data-dir 不同的磁盘；
--name：指定节点名称，当 --initial-cluster-state 值为 new 时，--name 的参数值必须位于 --initial-cluster 列表中；
--cert-file、--key-file：etcd server 与 client 通信时使用的证书和私钥；
--peer-cert-file、--peer-key-file：etcd 与 peer 通信使用的证书和私钥；
--trusted-ca-file：签名 client 证书的 CA 证书，用于验证 client 证书；
--peer-trusted-ca-file：签名 peer 证书的 CA 证书，用于验证 peer 证书；

拷贝证书文件

把刚才生成的证书拷贝到配置文件中的位置：

另外两台etcd集群也要创建目录
mkdir /data/soft/etcd/{bin,cfg,ssl} -p
mkdir /data/soft/kubernetes/{bin,cfg,ssl} -p

cd /data/www/etcd-cert
cp etcd-ca.pem etcd-server.pem etcd-server-key.pem /data/soft/etcd/ssl/
scp -P 12525 etcd-ca.pem etcd-server.pem  etcd-server-key.pem [email protected]:/data/soft/etcd/ssl/
scp -P 12525 etcd-ca.pem etcd-server.pem  etcd-server-key.pem [email protected]:/data/soft/etcd/ssl/

将启动文件、配置文件拷贝到节点1、节点2

cd /data/soft/ 

scp -P 12525 -r etcd [email protected]:/data/soft
scp -P 12525 -r etcd [email protected]:/data/soft

scp -P 12525 -r /usr/lib/systemd/system/etcd.service  [email protected]:/usr/lib/systemd/system/etcd.service
scp -P 12525 -r /usr/lib/systemd/system/etcd.service  [email protected]:/usr/lib/systemd/system/etcd.service

192.168.0.12 node01配置文件修改

cat << EOF | tee /data/soft/etcd/cfg/etcd 
#[Member]
ETCD_NAME="etcd02"
ETCD_DATA_DIR="/data/www/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="//192.168.0.12:2380"
ETCD_LISTEN_CLIENT_URLS="//192.168.0.12:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="//192.168.0.12:2380"
ETCD_ADVERTISE_CLIENT_URLS="//192.168.0.12:2379"
ETCD_INITIAL_CLUSTER="etcd01=//192.168.0.10:2380,etcd02=//192.168.0.12:2380,etcd03=//192.168.0.4:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
EOF

192.168.0.4 node02配置文件修改

cat << EOF | tee /data/soft/etcd/cfg/etcd
#[Member]
ETCD_NAME="etcd03"
ETCD_DATA_DIR="/data/www/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="//192.168.0.4:2380"
ETCD_LISTEN_CLIENT_URLS="//192.168.0.4:2379"
 

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="//192.168.0.4:2380"
ETCD_ADVERTISE_CLIENT_URLS="//192.168.0.4:2379"
ETCD_INITIAL_CLUSTER="etcd01=//192.168.0.10:2380,etcd02=//192.168.0.12:2380,etcd03=//192.168.0.4:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
EOF

启动ETCD服务

systemctl daemon-reload
systemctl enable etcd
systemctl restart etcd

#etcd 进程首次启动时会等待其它节点的 etcd 加入集群，命令 systemctl start etcd 会卡住一段时间，为正常现象；

验证ETCD集群是否正常运行

/data/soft/etcd/bin/etcdctl \
--ca-file=/data/soft/etcd/ssl/ca.pem \
--cert-file=/data/soft/etcd/ssl/server.pem \
--key-file=/data/soft/etcd/ssl/server-key.pem \
--endpoints="//192.168.0.10:2379,\
//192.168.0.12:2379,\
//192.168.0.4:2379" cluster-health
member b8fffb7f5b2f26e is healthy: got healthy result from //192.168.0.12:2379
member 5ac283d796e472ba is healthy: got healthy result from //192.168.0.4:2379
member a569e0ee3b34eefa is healthy: got healthy result from //192.168.0.10:2379
cluster is healthy


注意：
启动ETCD集群同时最少启动二个节点，启动一个节点集群是无法正常启动的；

常见etcd配置问题

etcd启动不起来

错误1：因为etcd之间https通讯是基于证书的。我证书中的IP地址有错误。

etcd启动后不加入集群

错误2：现象: Apr 18 10:34:45 k8s-master01 etcd: request cluster ID mismatch (got cf138cda9790f1d0 want 8732ef518b18f052)

解决方法：
此时etcd节点都已经启动，但是无法连接，发现有request cluster ID mismatch报错。找到etcd数据存储目录
[www@k8s-master01 ssl]# grep -i ETCD_DATA_DIR /data/soft/etcd/cfg/etcd 
ETCD_DATA_DIR="/data/www/etcd/default.etcd"
删除各节点/data/www/etcd/default.etcd，重启etcd即可解决。
由于删除的是数据存储目录，不是新建etcd集群，或者有重要数据的不可直接删除。
可以通过 journalctl -xefu etcd来详细排查问题。

etcd排查思路

排查思路，如下：
1. iptables防火墙、Selinux问题。
2. 时间是否同步。
3. 二进制文件是否存在
4. 检查日志journalctl -xefu 或者是查询/var/log/message 或者 日志目录
4. 配置文件没修改完或者多个空格？
5. 目录是否存在
6. 证书是否存在,且是否正确[初始化的时候需要指定三台etcd机器，我就搞错了，第一次错误，证书问题搞了好久]

新机器加入etc集群
//github.com/k8sp/sextant/issues/333

部署Flannel网络

Kubernetes网络模型设计基本要求

一个Pod一个IP
每个Pod独立IP，Pod内所有容器共享网络（同一个IP）
所有容器都可以与所有其他容器通信
所有节点都可以与所有容器通信

网络模型实现

flannel
calico
weaveworks
ovs
contiv
romana
cilium

前两个比较用的多。flannel小规模[百台以下]，calcio基于BGP[路由表]适合大规模。但是维护成本高[上百台以上]。当前我们配置是flannel网络。

ip	操作系统	角色	安装软件
192.168.0.10	centos7.6_x64	master1	docker，etcd
192.168.0.7	centos7.6_x64	node1	docker
192.168.0.8	centos7.6_x64	node2	docker

flannel 只需要部署在node节点上，master不用部署

以下部署步骤在规划的每个node节点都操作。

安装好docker

yum install -y yum-utils device-mapper-persistent-data lvm2 && yum-config-manager --add-repo //download.docker.com/linux/centos/docker-ce.repo && yum list docker-ce --showduplicates | soft -r &&  yum install docker-ce -y && systemctl start docker && systemctl enable docker

配置docker加速器

cat > /etc/docker/daemon.json<<EOF
{
"registry-mirrors":["//registry.docker-cn.com"]
}
EOF

service docker restart

部署Flannel 网络

向 master写入集群 Pod 网段信息(etcd主节点上操作)

cd /data/soft/etcd/ssl/
/data/soft/etcd/bin/etcdctl \
--ca-file=etd-ca.pem --cert-file=etd-server.pem \
--key-file=etd-server-key.pem \
--endpoints="//192.168.0.10:2379,//192.168.0.12:2379,//192.168.0.4:2379" \
set /coreos.com/network/config  '{ "Network": "172.18.0.0/16", "Backend": {"Type": "vxlan"}}'


返回写入结果：
{ "Network": "172.18.0.0/16", "Backend": {"Type": "vxlan"}}

注意：

Falnnel要用etcd存储自身一个子网信息，所以要保证能成功连接Etcd，写入预定义子网段：
flanneld 当前版本 (v0.10.0) 不支持 etcd v3，故使用 etcd v2 API 写入配置 key 和网段数据；
写入的 Pod 网段 ${CLUSTER_CIDR} 必须是 /16 段地址，必须与 kube-controller-manager 的 –cluster-cidr 参数值一致；

解压安装

tar -xvf flannel-v0.11.0-linux-amd64.tar.gz
mv flanneld mk-docker-opts.sh /data/soft/kubernetes/bin/

配置Flannel

cat << EOF | tee /data/soft/kubernetes/cfg/flanneld
FLANNEL_OPTIONS="--etcd-endpoints=//192.168.0.10:2379,//192.168.0.12:2379,//192.168.0.4:2379 -etcd-cafile=/data/soft/etcd/ssl/etcd-ca.pem -etcd-certfile=/data/soft/etcd/ssl/etcd-server.pem -etcd-keyfile=/data/soft/etcd/ssl/etcd-server-key.pem"
EOF

注意：
这里是定义一个FLANNEL_OPTIONS的变量：指定etcd的位置和连接etcd集群的证书，好让flannel网络读取etcd

创建 flanneld 的 flanneld.service 文件，配置所有node节点

vim /usr/lib/systemd/system/flanneld.service
[Unit]
Description=Flanneld overlay address etcd agent
After=network-online.target network.target
Before=docker.service
 

[Service]
Type=notify
EnvironmentFile=/data/soft/kubernetes/cfg/flanneld
ExecStart=/data/soft/kubernetes/bin/flanneld --ip-masq $FLANNEL_OPTIONS
ExecStartPost=/data/soft/kubernetes/bin/mk-docker-opts.sh -k DOCKER_NETWORK_OPTIONS -d /run/flannel/subnet.env
Restart=on-failure

[Install]
WantedBy=multi-user.target

注意：

mk-docker-opts.sh 脚本将分配给 flanneld 的 Pod 子网网段信息写入 /run/flannel/docker 文件，后续 docker 启动时使用这个文件中的环境变量配置 docker0 网桥；
flanneld 使用系统缺省路由所在的接口与其它节点通信，对于有多个网络接口（如内网和公网）的节点，可以用 -iface 参数指定通信接口，如上面的 eth0 接口;
flanneld 运行时需要 root 权限；

配置Docker启动指定子网段，所有node节点

vim /usr/lib/systemd/system/docker.service 
[Unit]
Description=Docker Application Container Engine
Documentation=//docs.docker.com
After=network-online.target firewalld.service
Wants=network-online.target

[Service]
Type=notify
EnvironmentFile=/run/flannel/subnet.env
ExecStart=/usr/bin/dockerd $DOCKER_NETWORK_OPTIONS
ExecReload=/bin/kill -s HUP $MAINPID
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
TimeoutStartSec=0
Delegate=yes
KillMode=process
Restart=on-failure
StartLimitBurst=3
StartLimitInterval=60s

[Install]
WantedBy=multi-user.target

将flanneld systemd unit 文件到所有节点

cd /data/soft/
scp -P 12525 -r kubernetes [email protected]:/data/soft/
scp -P 12525 -r kubernetes [email protected]:/data/soft/
scp -P 12525 /data/soft/kubernetes/cfg/flanneld [email protected]:/data/soft/kubernetes/cfg/flanneld
scp -P 12525 /data/soft/kubernetes/cfg/flanneld [email protected]:/data/soft/kubernetes/cfg/flanneld
scp /usr/lib/systemd/system/docker.service  192.168.0.7:/usr/lib/systemd/system/docker.service 
scp /usr/lib/systemd/system/docker.service  192.168.0.8:/usr/lib/systemd/system/docker.service
scp /usr/lib/systemd/system/flanneld.service  192.168.0.7:/usr/lib/systemd/system/flanneld.service 
scp /usr/lib/systemd/system/flanneld.service  192.168.0.8:/usr/lib/systemd/system/flanneld.service

Node节点启动服务

systemctl daemon-reload
systemctl start flanneld
systemctl enable flanneld
systemctl restart docker

查看flannel网络是否生效

node1 回显：
---
ip add
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
    link/ether 00:16:3e:00:e9:96 brd ff:ff:ff:ff:ff:ff
    inet 192.168.0.7/24 brd 192.168.0.255 scope global dynamic eth0
       valid_lft 290352654sec preferred_lft 290352654sec
3: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default 
    link/ether 02:42:9d:2d:f5:46 brd ff:ff:ff:ff:ff:ff
    inet 172.18.39.1/24 brd 172.18.39.255 scope global docker0
       valid_lft forever preferred_lft forever
4: flannel.1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1450 qdisc noqueue state UNKNOWN group default 
    link/ether 0e:4e:b2:09:66:59 brd ff:ff:ff:ff:ff:ff
    inet 172.18.39.0/32 scope global flannel.1
       valid_lft forever preferred_lft forever




node2 回显：
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
    link/ether 00:16:3e:00:1a:5b brd ff:ff:ff:ff:ff:ff
    inet 192.168.0.8/24 brd 192.168.0.255 scope global dynamic eth0
       valid_lft 290352443sec preferred_lft 290352443sec
3: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default 
    link/ether 02:42:0c:6d:3f:30 brd ff:ff:ff:ff:ff:ff
    inet 172.18.98.1/24 brd 172.18.98.255 scope global docker0
       valid_lft forever preferred_lft forever
4: flannel.1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1450 qdisc noqueue state UNKNOWN group default 
    link/ether 86:2f:59:3b:1f:88 brd ff:ff:ff:ff:ff:ff
    inet 172.18.98.0/32 scope global flannel.1
       valid_lft forever preferred_lft forever

确保docker0与flannel.1在同一网段。测试不同节点互通，在当前节点访问另一个Node节点docker0 IP。

# ping 172.17.58.1
PING 172.17.58.1 (172.17.58.1) 56(84) bytes of data.
64 bytes from 172.17.58.1: icmp_seq=1 ttl=64 time=0.263 ms
64 bytes from 172.17.58.1: icmp_seq=2 ttl=64 time=0.204 ms

可以使用创建一个容器的方法，分别在node节点上面创建一个容器测试容器是否通信正常，命令如下

docker run -it busybox sh，双方节点各开启容器进行互ping 测试

并保证互ping 全网通信

如果能通说明Flannel部署成功。如果不通检查下日志：journalctl -u flannel，检查node节点是否开启端口转发。

部署 master 节点

kubernetes master 节点运行如下组件：

kube-apiserver
kube-scheduler
kube-controller-manager

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

创建 Kubernetes Apiserver CA 证书

首先创建一个api-cert证书存储目录目录，(当前实战是把api-server所需证书和kube-proxy所需证书和kuber-controller-manager都存储在api-cert目录中)，kube-controller-manager和kube-scheduler当前使用的是apiserver生成的证书，也可以单独生成。

命令如下：

mkdir  /data/www/api-cert 
cd     /data/www/api-cert

创建 Kubernetes apiserver 证书生成策略配置文件

cat << EOF | tee api-ca-config.json
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "kubernetes": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
EOF

# 参数详解
ca-config.json：可以定义多个 profiles，分别指定不同的过期时间、使用场景等参数；后续在签名证书时使用某个 profile；
signing：	   表示该证书可用于签名其它证书；生成的 ca.pem 证书中 CA=TRUE；
server auth：   表示client可以用该 CA 对server提供的证书进行验证；
client auth：   表示server可以用该CA对client提供的证书进行验证；

# 上面生成的这个ca config文件只是

创建 Kubernetes Apiserver CA 证书签名请求

cat << EOF | tee api-ca-csr.json
{
    "CN": "kubernetes",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Shenzhen",
            "ST": "Shenzhen",
            "O": "k8s",
            "OU": "System"
        }
    ]
}
EOF

参数详解：
CN：Common Name，kube-apiserver 从证书中提取该字段作为请求的用户名 (User Name)；浏览器使用该字段验证网站是否合法；

names中的字段：
C : country，国家
ST: state，州或省份
L：location，城市
O：organization，组织，kube-apiserver 从证书中提取该字段作为请求用户所属的组 (Group)
OU：organization unit,组织单位

cfssl gencert -initca api-ca-csr.json | cfssljson -bare api-ca

生成Kubernetes Apiserver 证书配置文件

cat << EOF | tee api-server-csr.json
{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
      "127.0.0.1",
      "192.168.0.10",
      "192.168.0.12",
      "192.168.0.7",
      "192.168.0.8",
      "192.168.0.4",
      "192.168.0.9",
      "192.168.0.200",
      "kubernetes",
      "kubernetes.default",
      "kubernetes.default.svc",
      "kubernetes.default.svc.cluster",
      "kubernetes.default.svc.cluster.local"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Shenzhen",
            "ST": "Shenzhen",
            "O": "k8s",
            "OU": "System"
        }
    ]
}
EOF

参数详解：
CN：Common Name，kube-apiserver 从证书中提取该字段作为请求的用户名 (User Name)；浏览器使用该字段验证网站是否合法；

names中的字段：
C : country，国家
ST: state，州或省份
L：location，城市
O：organization，组织，kube-apiserver 从证书中提取该字段作为请求用户所属的组 (Group)
OU：organization unit,组织单位

cfssl gencert -ca=api-ca.pem -ca-key=api-ca-key.pem -config=api-ca-config.json -profile=kubernetes api-server-csr.json | cfssljson -bare api-server

# cfssl参数详解
gencert: 生成新的key(密钥)和签名证书
	-initca：初始化一个新ca
	-ca：指明ca的证书
	-ca-key：指明ca的私钥文件
	-config：指明请求证书的json文件
	-profile：与-config中的profile对应，是指根据config中的profile段来生成证书的相关信息

查看cert(证书信息):
cfssl certinfo -cert ca.pem

查看CSR(证书签名请求)信息：
cfssl certinfo -csr ca.csr

# cfssljson
	-bare 来自CFSSL的返回值，使用cert，csr和key字段拆分成JSON格式以生成文件。

创建 Kubernetes Proxy 证书

cat << EOF | tee kube-proxy-csr.json
{
  "CN": "system:kube-proxy",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "Shenzhen",
      "ST": "Shenzhen",
      "O": "k8s",
      "OU": "System"
    }
  ]
}
EOF

cfssl gencert -ca=api-ca.pem -ca-key=api-ca-key.pem -config=api-ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy

# 这个地方利用apiserver 的 ca证书机构颁发kube-proxy的证书请求，生成kube-proxy-key.pem和kube-proxy.pem文件给kube-proxy组件使用，因为kube-proxy 要连接apiserver进行kubernetes网络设置

# cfssl参数详解
gencert: 生成新的key(密钥)和签名证书
	-initca：初始化一个新ca
	-ca：指明ca的证书
	-ca-key：指明ca的私钥文件
	-config：指明请求证书的json文件
	-profile：与-config中的profile对应，是指根据config中的profile段来生成证书的相关信息

查看cert(证书信息):
cfssl certinfo -cert ca.pem

查看CSR(证书签名请求)信息：
cfssl certinfo -csr ca.csr

# cfssljson
	-bare 来自CFSSL的返回值，使用cert，csr和key字段拆分成JSON格式以生成文件。

最终生成以下证书文件：

ls -l /data/www/api-cert/*pem

-rw------- 1 www www 1675 Apr 19 21:34 /data/www/api-cert/api-ca-key.pem
-rw-rw-r-- 1 www www 1363 Apr 19 21:34 /data/www/api-cert/api-ca.pem
-rw------- 1 www www 1679 Apr 19 21:36 /data/www/api-cert/kube-proxy-key.pem
-rw-rw-r-- 1 www www 1407 Apr 19 21:36 /data/www/api-cert/kube-proxy.pem
-rw------- 1 www www 1679 Apr 19 21:35 /data/www/api-cert/api-server-key.pem
-rw-rw-r-- 1 www www 1667 Apr 19 21:35 /data/www/api-cert/api-server.pem

将二进制文件解压拷贝到master 节点

tar -xvf kubernetes-server-linux-amd64.tar.gz 
cd kubernetes/server/bin/
cp kube-scheduler kube-apiserver kube-controller-manager kubectl /data/soft/kubernetes/bin/

拷贝认证

cp /data/www/api-cert/*pem   /data/soft/kubernetes/ssl/

部署 kube-apiserver 组件

创建 TLS Bootstrapping Token

# 生成随机字符串
# head -c 16 /dev/urandom | od -An -t x | tr -d ' '
2366a641f656a0a025abb4aabda4511b

vim /data/soft/kubernetes/cfg/token.csv
2366a641f656a0a025abb4aabda4511b,kubelet-bootstrap,10001,"system:kubelet-bootstrap"


# token.csv是kubelet加入集群时候颁发证书使用
第一列：随机字符串，自己可生成
第二列：用户名
第三列：UID
第四列：用户组

创建apiserver配置文件

vim /data/soft/kubernetes/cfg/kube-apiserver 
KUBE_APISERVER_OPTS="--logtostderr=true \
--v=4 \
--etcd-servers=//192.168.0.10:2379,//192.168.0.12:2379,//192.168.0.4:2379 \
--bind-address=192.168.0.10 \
--secure-port=6443 \
--advertise-address=192.168.0.10 \
--allow-privileged=true \
--service-cluster-ip-range=10.0.0.0/24 \
--enable-admission-plugins=NamespaceLifecycle,LimitRanger,SecurityContextDeny,ServiceAccount,ResourceQuota,NodeRestriction \
--authorization-mode=RBAC,Node \
--enable-bootstrap-token-auth \
--token-auth-file=/data/soft/kubernetes/cfg/token.csv \
--service-node-port-range=30000-50000 \
--tls-cert-file=/data/soft/kubernetes/ssl/api-server.pem  \
--tls-private-key-file=/data/soft/kubernetes/ssl/api-server-key.pem \
--client-ca-file=/data/soft/kubernetes/ssl/api-ca.pem \
--service-account-key-file=/data/soft/kubernetes/ssl/api-ca-key.pem \
--etcd-cafile=/data/soft/etcd/ssl/etcd-ca.pem \
--etcd-certfile=/data/soft/etcd/ssl/etcd-server.pem \
--etcd-keyfile=/data/soft/etcd/ssl/etcd-server-key.pem"

配置好前面生成的etcd证书，确保能连接etcd，apiserver要随时去向etcd存取集群数据。

参数说明( 号代表通配符说明参数相同的有多个)：*

--advertise-address：apiserver 对外通告的 IP（kubernetes 服务后端节点 IP）；
--default-*-toleration-seconds：设置节点异常相关的阈值；
--max-*-requests-inflight：请求相关的最大阈值；
--etcd-*：访问 etcd 的证书和 etcd 服务器地址；
--bind-address： https 监听的 IP，不能为 127.0.0.1，否则外界不能访问它的安全端口 6443；
--secret-port：https 监听端口；
--insecure-port=0：关闭监听 http 非安全端口(8080)；
--tls-*-file：指定 apiserver 使用的证书、私钥和 CA 文件；
--audit-*：配置审计策略和审计日志文件相关的参数；
--client-ca-file：验证 client (kue-controller-manager、kube-scheduler、kubelet、kube-proxy 等)请求所带的证书；
--enable-bootstrap-token-auth：启用 kubelet bootstrap 的 token 认证；
--requestheader-*：kube-apiserver 的 aggregator layer 相关的配置参数，proxy-client & HPA 需要使用；
--requestheader-client-ca-file：用于签名 --proxy-client-cert-file 和 --proxy-client-key-file 指定的证书；在启用了 metric aggregator 时使用；
--requestheader-allowed-names：不能为空，值为逗号分割的 --proxy-client-cert-file 证书的 CN 名称，这里设置为 “aggregator”；
--service-account-key-file：签名 ServiceAccount Token 的公钥文件，kube-controller-manager 的 --service-account-private-key-file 指定私钥文件，两者配对使用；
--runtime-config=api/all=true：启用所有版本的 APIs，如 autoscaling/v2alpha1；
--authorization-mode=Node,RBAC、--anonymous-auth=false：开启 Node 和 RBAC 授权模式，拒绝未授权的请求；
--enable-admission-plugins：启用一些默认关闭的 plugins；
--allow-privileged：运行执行 privileged 权限的容器；
--apiserver-count=3：指定 apiserver 实例的数量；
--event-ttl：指定 events 的保存时间；
--kubelet-*：如果指定，则使用 https 访问 kubelet APIs；需要为证书对应的用户(上面 kubernetes*.pem 证书的用户为 kubernetes) 用户定义 RBAC 规则，否则访问 kubelet API 时提示未授权；
--proxy-client-*：apiserver 访问 metrics-server 使用的证书；
--service-cluster-ip-range：指定 Service Cluster IP 地址段；
--service-node-port-range：指定 NodePort 的端口范围；

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

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

注意：

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

创建 kube-apiserver 的kube-apiserver.service文件

vim /usr/lib/systemd/system/kube-apiserver.service 
[Unit]
Description=Kubernetes API Server
Documentation=//github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=/data/soft/kubernetes/cfg/kube-apiserver
ExecStart=/data/soft/kubernetes/bin/kube-apiserver $KUBE_APISERVER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target

启动服务

systemctl daemon-reload
systemctl enable kube-apiserver
systemctl restart kube-apiserver

查看apiserver是否运行

ps -ef |grep kube-apiserver

root      76300      1 45 08:57 ?        00:00:14 /data/soft/kubernetes/bin/kube-apiserver --logtostderr=true --v=4 --etcd-servers=//192.168.0.10:2379,//192.168.0.12:2379,//192.168.0.4:2379 --bind-address=192.168.0.10 --secure-port=6443 --advertise-address=172.16.9.51 --allow-privileged=true --service-cluster-ip-range=10.0.0.0/24 --enable-admission-plugins=NamespaceLifecycle,LimitRanger,SecurityContextDeny,ServiceAccount,ResourceQuota,NodeRestriction --authorization-mode=RBAC,Node --enable-bootstrap-token-auth --token-auth-file=/data/soft/kubernetes/cfg/token.csv --service-node-port-range=30000-50000 --tls-cert-file=/data/soft/kubernetes/ssl/api-server.pem --tls-private-key-file=/data/soft/kubernetes/ssl/api-server-key.pem --client-ca-file=/data/soft/kubernetes/ssl/api-ca.pem --service-account-key-file=/data/soft/kubernetes/ssl/api-ca-key.pem --etcd-cafile=/data/soft/etcd/ssl/etcd-ca.pem --etcd-certfile=/data/soft/etcd/ssl/etcd-server.pem --etcd-keyfile=/data/soft/etcd/ssl/etcd-server-key.pem

root      76357   4370  0 08:58 pts/1    00:00:00 grep --color=auto kube-apiserver

部署kube-scheduler

创建kube-scheduler配置文件

vim  /data/soft/kubernetes/cfg/kube-scheduler 
KUBE_SCHEDULER_OPTS="--logtostderr=true --v=4 --master=127.0.0.1:8080 --leader-elect=true"

参数说明：

--address：在 127.0.0.1:10251 端口接收 http /metrics 请求；kube-scheduler 目前还不支持接收 https 请求；
--master 连接本地apiserver
--kubeconfig：指定 kubeconfig 文件路径，kube-scheduler 使用它连接和验证 kube-apiserver；
--leader-elect=true：集群运行模式，启用选举功能；被选为 leader 的节点负责处理工作，其它节点为阻塞状态；当该组件启动多个时，自动选举（HA）

创建kube-scheduler的kube-scheduler.service 文件

vim /usr/lib/systemd/system/kube-scheduler.service 
[Unit]
Description=Kubernetes Scheduler
Documentation=//github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=-/data/soft/kubernetes/cfg/kube-scheduler
ExecStart=/data/soft/kubernetes/bin/kube-scheduler $KUBE_SCHEDULER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target

启动服务

systemctl daemon-reload
systemctl enable kube-scheduler.service 
systemctl restart kube-scheduler.service

查看kube-scheduler是否运行

# ps -ef |grep kube-scheduler 
root      77854      1  8 09:17 ?        00:00:02 /data/soft/kubernetes/bin/kube-scheduler --logtostderr=true --v=4 --master=127.0.0.1:8080 --leader-elect
root      77901   1305  0 09:18 pts/0    00:00:00 grep --color=auto kube-scheduler

# systemctl status kube-scheduler.service 
● kube-scheduler.service - Kubernetes Scheduler
   Loaded: loaded (/usr/lib/systemd/system/kube-scheduler.service; disabled; vendor preset: disabled)
   Active: active (running) since 三 2018-12-05 09:17:43 CST; 29s ago
     Docs: https:*//github.com/kubernetes/kubernetes*
 Main PID: 77854 (kube-scheduler)
    Tasks: 13
   Memory: 10.9M
   CGroup: /system.slice/kube-scheduler.service
           └─77854 /data/soft/kubernetes/bin/kube-scheduler --logtostderr=true --v=4 --master=127.0.0.1:8080 --leader-elect

12月 05 09:17:45 qas-k8s-master01 kube-scheduler[77854]: I1205 09:17:45.642632   77854 shared_informer.go:123] caches populated
12月 05 09:17:45 qas-k8s-master01 kube-scheduler[77854]: I1205 09:17:45.743297   77854 shared_informer.go:123] caches populated
12月 05 09:17:45 qas-k8s-master01 kube-scheduler[77854]: I1205 09:17:45.844554   77854 shared_informer.go:123] caches populated
12月 05 09:17:45 qas-k8s-master01 kube-scheduler[77854]: I1205 09:17:45.945332   77854 shared_informer.go:123] caches populated
12月 05 09:17:45 qas-k8s-master01 kube-scheduler[77854]: I1205 09:17:45.945434   77854 controller_utils.go:1027] Waiting **for** caches to sync **for** scheduler controller
12月 05 09:17:46 qas-k8s-master01 kube-scheduler[77854]: I1205 09:17:46.046385   77854 shared_informer.go:123] caches populated
12月 05 09:17:46 qas-k8s-master01 kube-scheduler[77854]: I1205 09:17:46.046427   77854 controller_utils.go:1034] Caches are synced **for** scheduler controller
12月 05 09:17:46 qas-k8s-master01 kube-scheduler[77854]: I1205 09:17:46.046574   77854 leaderelection.go:205] attempting to acquire leader lease  kube-system/kube-scheduler...
12月 05 09:17:46 qas-k8s-master01 kube-scheduler[77854]: I1205 09:17:46.063185   77854 leaderelection.go:214] successfully acquired lease kube-system/kube-scheduler
12月 05 09:17:46 qas-k8s-master01 kube-scheduler[77854]: I1205 09:17:46.164498   77854 shared_informer.go:123] caches populated

部署kube-controller-manager

创建kube-controller-manager配置文件

vim /data/soft/kubernetes/cfg/kube-controller-manager
KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=true \
--v=4 \
--master=127.0.0.1:8080 \
--leader-elect=true \
--address=127.0.0.1 \
--service-cluster-ip-range=10.0.0.0/24 \
--cluster-name=kubernetes \
--cluster-signing-cert-file=/data/soft/kubernetes/ssl/api-ca.pem \
--cluster-signing-key-file=/data/soft/kubernetes/ssl/api-ca-key.pem  \
--root-ca-file=/data/soft/kubernetes/ssl/api-ca.pem \
--service-account-private-key-file=/data/soft/kubernetes/ssl/api-ca-key.pem"

# 证书配置这块使用的是apiserver的证书进行连接集群

配置参数详解：

--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 文件

vim /usr/lib/systemd/system/kube-controller-manager.service 
[Unit]
Description=Kubernetes Controller Manager
Documentation=//github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=-/data/soft/kubernetes/cfg/kube-controller-manager
ExecStart=/data/soft/kubernetes/bin/kube-controller-manager $KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target

启动服务

systemctl daemon-reload
systemctl enable kube-controller-manager
systemctl restart kube-controller-manager

查看kube-controller-manager是否运行

systemctl status kube-controller-manager
● kube-controller-manager.service - Kubernetes Controller Manager
   Loaded: loaded (/usr/lib/systemd/system/kube-controller-manager.service; enabled; vendor preset: disabled)
   Active: active (running) since 三 2018-12-05 09:35:00 CST; 3s ago
     Docs: https:*//github.com/kubernetes/kubernetes*
 Main PID: 79191 (kube-controller)
    Tasks: 8
   Memory: 15.2M
   CGroup: /system.slice/kube-controller-manager.service
           └─79191 /data/soft/kubernetes/bin/kube-controller-manager --logtostderr=true --v=4 --master=127.0.0.1:8080 --leader-elect=true --address=127.0.0.1 --service-cluster-ip-range=10.0.0....

查看进程文件

# ps -ef |grep kube-controller-manager
root      79191      1 10 09:35 ?        00:00:01 /data/soft/kubernetes/bin/kube-controller-manager --logtostderr=true --v=4 --master=127.0.0.1:8080 --leader-elect=true --address=127.0.0.1 --service-cluster-ip-range=10.0.0.0/24 --cluster-name=kubernetes --cluster-signing-cert-file=/data/soft/kubernetes/ssl/ca.pem --cluster-signing-key-file=/data/soft/kubernetes/ssl/ca-key.pem --root-ca-file=/data/soft/kubernetes/ssl/ca.pem --service-account-**private**-key-file=/data/soft/kubernetes/ssl/ca-key.pem
root      79220   1305  0 09:35 pts/0    00:00:00 grep --color=**auto** kube-controller-manager

将可执行文件路/data/soft/kubernetes/ 添加到 PATH 变量中

vim /etc/profile
PATH=/data/soft/kubernetes/bin:$PATH:$HOME/bin
source /etc/profile

查看master集群状态

所有组件都已经启动成功，通过kubectl工具查看当前集群组件状态：

# kubectl get cs,nodes
NAME                                 STATUS    MESSAGE             ERROR
componentstatus/scheduler            Healthy   ok                  
componentstatus/etcd-2               Healthy   {"health":"true"}   
componentstatus/etcd-1               Healthy   {"health":"true"}   
componentstatus/etcd-0               Healthy   {"health":"true"}   
componentstatus/controller-manager   Healthy   ok

部署node 节点

kubernetes work 节点运行如下组件：

docker 前面已经部署
kubelet
kube-proxy

部署 kubelet 组件

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

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

为确保安全，本文档只开启接收 https 请求的安全端口，对请求进行认证和授权，拒绝未授权的访问(如apiserver、heapster)。

Master apiserver启用TLS认证后，Node节点kubelet组件想要加入集群，必须使用CA签发的有效证书才能与apiserver通信，当Node节点很多时，签署证书是一件很繁琐的事情，因此有了TLS Bootstrapping机制，kubelet会以一个低权限用户自动向apiserver申请证书，kubelet的证书由apiserver动态签署。

认证大致工作流程如图所示：

ip	操作系统	角色	安装软件
192.168.0.10	centos7.6_x64	master1	docker，etcd
192.168.0.7	centos7.6_x64	node1	docker
192.168.0.8	centos7.6_x64	node2	docker

node节点安装好docker

yum-config-manager --add-repo //mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
yum list docker-ce --showduplicates | soft -r
yum install docker-ce -y
systemctl start docker && systemctl enable docker

配置docker加速器

curl -sSL //get.daocloud.io/daotools/set_mirror.sh | sh -s //f1361db2.m.daocloud.io \
&& systemctl restart docker

将kubelet 二进制文件拷贝node节点

cd /data/upload/kubernetes/server/bin
[root@localhost bin]# pwd 
/data/upload/kubernetes/server/bin
\cp kubelet kube-proxy /data/soft/kubernetes/bin/

scp -P 12525 -r kubelet kube-proxy [email protected]:/data/soft/kubernetes/bin/
scp -P 12525 -r kubelet kube-proxy [email protected]:/data/soft/kubernetes/bin/

创建 kubelet bootstrap kubeconfig 文件

在生成kubernetes证书的目录下执行以下命令生成kubeconfig文件：

创建脚本快速执行文件时，需要进入/data/soft/kubernetes/ssl/目录中去执行

cd /data/soft/kubernetes/ssl/

vim  environment.sh
# 创建 kubelet bootstrapping kubeconfig
BOOTSTRAP_TOKEN=2366a641f656a0a025abb4aabda4511b

KUBE_APISERVER="//192.168.0.10:6443"
# kuber-apiserver启动参数中的token.csv和kubelet启动参数中指定的bootstrap文件bootstrap.kubeconfig中的token值是否一致，此外该token必须为实际数值，不能使用变量代替

# 设置集群参数
kubectl config set-cluster kubernetes \
  --certificate-authority=./ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=bootstrap.kubeconfig

# 设置客户端认证参数

kubectl config set-credentials kubelet-bootstrap \
  --token=${BOOTSTRAP_TOKEN} \
  --kubeconfig=bootstrap.kubeconfig

# 设置上下文参数

kubectl config set-context default \
  --cluster=kubernetes \
  --user=kubelet-bootstrap \
  --kubeconfig=bootstrap.kubeconfig

# 设置默认上下文

kubectl config use-context default --kubeconfig=bootstrap.kubeconfig

#----------------------
# 创建kube-proxy kubeconfig文件
kubectl config set-cluster kubernetes \
  --certificate-authority=./ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=kube-proxy.kubeconfig

kubectl config set-credentials kube-proxy \
  --client-certificate=./kube-proxy.pem \
  --client-key=./kube-proxy-key.pem \
  --embed-certs=true \
  --kubeconfig=kube-proxy.kubeconfig

kubectl config set-context default \
  --cluster=kubernetes \
  --user=kube-proxy \
  --kubeconfig=kube-proxy.kubeconfig

kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig

执行该脚本

bash  environment.sh

将bootstrap.kubeconfig kube-proxy.kubeconfig 文件拷贝到所有 nodes节点

cp bootstrap.kubeconfig kube-proxy.kubeconfig /data/soft/kubernetes/cfg/
scp -P 12525 -r bootstrap.kubeconfig kube-proxy.kubeconfig [email protected]:/data/soft/kubernetes/cfg/
scp -P 12525 -r bootstrap.kubeconfig kube-proxy.kubeconfig [email protected]:/data/soft/kubernetes/cfg/

node节点配置kubelet

注意：创建kubelet 参数配置文件拷贝到所有nodes节点，这里只列举了其中一个node 的配置，其他的node配置可以参考这个配置，修改下本机ip地址既可

创建 kubelet 参数配置模板文件：

vim /data/soft/kubernetes/cfg/kubelet.config
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: 192.168.0.7
port: 10250
readOnlyPort: 10255
cgroupDriver: cgroupfs
clusterDNS: ["10.0.0.2"]
clusterDomain: cluster.local.
failSwapOn: false
authentication:
  anonymous:
enabled: true

参数说明：

address: 授权绑定的ip地址（node本地ip）

创建kubelet配置文件

vim /data/soft/kubernetes/cfg/kubelet
KUBELET_OPTS="--logtostderr=true \
--v=4 \
--hostname-override=192.168.0.7 \
--kubeconfig=/data/soft/kubernetes/cfg/kubelet.kubeconfig \
--bootstrap-kubeconfig=/data/soft/kubernetes/cfg/bootstrap.kubeconfig \
--config=/data/soft/kubernetes/cfg/kubelet.config \
--cert-dir=/data/soft/kubernetes/ssl \
--pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google-containers/pause-amd64:3.0"

参数说明：

--hostname-override 在集群中显示的主机名（node本机ip）
--kubeconfig 指定kubeconfig文件位置，会自动生成
--bootstrap-kubeconfig 指定刚才生成的bootstrap.kubeconfig文件
--cert-dir 颁发证书存放位置
--pod-infra-container-image 管理Pod网络的镜像

创建kubelet的kubelet.service 文件

vim /usr/lib/systemd/system/kubelet.service 
[Unit]
Description=Kubernetes Kubelet
After=docker.service
Requires=docker.service

[Service]
EnvironmentFile=/data/soft/kubernetes/cfg/kubelet
ExecStart=/data/soft/kubernetes/bin/kubelet $KUBELET_OPTS
Restart=on-failure
KillMode=process

[Install]
WantedBy=multi-user.target

将kubelet.config kubelet 文件拷贝到所有 nodes节点

cd /data/soft/kubernetes/cfg/
\cp kubelet.config   kubelet /data/soft/kubernetes/cfg/
scp -P 12525 -r kubelet.config   kubelet [email protected]:/data/soft/kubernetes/cfg/
scp -P 12525 -r kubelet.config   kubelet [email protected]:/data/soft/kubernetes/cfg/
scp -P 12525 -r /usr/lib/systemd/system/kubelet.service [email protected]:/usr/lib/systemd/system/kubelet.service
scp -P 12525 -r /usr/lib/systemd/system/kubelet.service [email protected]:/usr/lib/systemd/system/kubelet.service

将kubelet-bootstrap用户绑定到系统集群角色,master 执行

/data/soft/kubernetes/bin/kubectl create clusterrolebinding kubelet-bootstrap \
--clusterrole=system:node-bootstrapper \
--user=kubelet-bootstrap

node启动服务kubelet

systemctl daemon-reload
systemctl enable kubelet
systemctl restart kubelet

master节点approve kubelet CSR 请求处理

可以手动或自动 approve CSR 请求。推荐使用自动的方式，因为从 v1.8 版本开始，可以自动轮转approve csr 后生成的证书。

这里采用手动 approve CSR 请求，在Master节点查看请求签名的Node：

查看 CSR 列表：

# kubectl get csr
NAME                                                   AGE    REQUESTOR           CONDITION
node-csr-An1VRgJ7FEMMF_uyy6iPjyF5ahuLx6tJMbk2SMthwLs   39m    kubelet-bootstrap   Pending
node-csr-dWPIyP_vD1w5gBS4iTZ6V5SJwbrdMx05YyybmbW3U5s   5m5s   kubelet-bootstrap   Pending

# kubectl certificate approve node-csr-An1VRgJ7FEMMF_uyy6iPjyF5ahuLx6tJMbk2SMthwLs

certificatesigningrequest.certificates.k8s.io/node-csr-An1VRgJ7FEMMF_uyy6iPjyF5ahuLx6tJMbk2SMthwLs

# kubectl certificate approve node-csr-dWPIyP_vD1w5gBS4iTZ6V5SJwbrdMx05YyybmbW3U5s  
certificatesigningrequest.certificates.k8s.io/node-csr-dWPIyP_vD1w5gBS4iTZ6V5SJwbrdMx05YyybmbW3U5s approved

# kubectl get csr
NAME                                                   AGE     REQUESTOR           CONDITION
node-csr-An1VRgJ7FEMMF_uyy6iPjyF5ahuLx6tJMbk2SMthwLs   41m     kubelet-bootstrap   Approved,Issued
node-csr-dWPIyP_vD1w5gBS4iTZ6V5SJwbrdMx05YyybmbW3U5s   7m32s   kubelet-bootstrap   Approved,Issued


Requesting User：请求 CSR 的用户，kube-apiserver 会对它进行认证和授权；
Subject：请求签名的证书信息；
证书的 CN 是 system:node:kube-node2， Organization 是 system:nodes，kube-apiserver 的 Node 授权模式会授予该证书的相关权限；

查看集群状态

# kubectl get nodes
NAME           STATUS   ROLES    AGE   VERSION
192.168.0.7   Ready    <none>   25s   v1.16.0
192.168.0.8   Ready    <none>   13s   v1.16.0

Node上部署 kube-proxy 组件

kube-proxy 运行在所有 node节点上，它监听 apiserver 中 service 和 Endpoint 的变化情况，创建路由规则来进行服务负载均衡，这里只列举了其中一个node 的配置，其他的node配置可以参考这个配置，修改下本机ip地址既可。

创建 kube-proxy 配置文件

vim /data/soft/kubernetes/cfg/kube-proxy
KUBE_PROXY_OPTS="--logtostderr=true \
--v=4 \
--hostname-override=192.168.0.7 \
--cluster-cidr=10.0.0.0/24 \
--proxy-mode=ipvs \
--masquerade-all=true \
--kubeconfig=/data/soft/kubernetes/cfg/kube-proxy.kubeconfig"

参数详解：

bindAddress: 监听地址（node本机ip）；
clientConnection.kubeconfig: 连接 apiserver 的 kubeconfig 文件；
clusterCIDR: kube-proxy 根据 --cluster-cidr 判断集群内部和外部流量，指定 --cluster-cidr 或 --masquerade-all 选项后 kube-proxy 才会对访问 Service IP 的请求做 SNAT；
hostnameOverride: 参数值必须与 kubelet 的值一致，否则 kube-proxy 启动后会找不到该 Node，从而不会创建任何 ipvs 规则；
mode: 使用 ipvs 模式；

创建kube-proxy systemd unit 文件

vim /usr/lib/systemd/system/kube-proxy.service 
[Unit]
Description=Kubernetes Proxy
After=network.tarsget

[Service]
EnvironmentFile=/data/soft/kubernetes/cfg/kube-proxy
ExecStart=/data/soft/kubernetes/bin/kube-proxy $KUBE_PROXY_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target

将kubelet.config kubelet 文件拷贝到所有 nodes节点

cd /data/soft/kubernetes/cfg/
\cp kube-proxy /data/soft/kubernetes/cfg/
scp -P 12525 -r kube-proxy [email protected]:/data/soft/kubernetes/cfg/
scp -P 12525 -r kube-proxy [email protected]:/data/soft/kubernetes/cfg/
scp -P 12525 -r /usr/lib/systemd/system/kube-proxy.service [email protected]:/usr/lib/systemd/system/kube-proxy.service
scp -P 12525 -r /usr/lib/systemd/system/kube-proxy.service [email protected]:/usr/lib/systemd/system/kube-proxy.service

启动服务

systemctl daemon-reload
systemctl enable kube-proxy
systemctl restart kube-proxy

ps -ef|grep kube-proxy
root      8719     1  1 12:39 ?        00:00:00 /data/soft/kubernetes/bin/kube-proxy --logtostderr=true --v=4 --hostname-override=192.168.0.8 --cluster-cidr=10.0.0.0/24 --proxy-mode=ipvs --masquerade-all=true --kubeconfig=/data/soft/kubernetes/cfg/kube-prox.kubeconfig

其他node节点配置一样，可以使用scp 拷贝过去然后部署。

查看集群状态(master)

打node 或者master 节点的标签

kubectl label node 192.168.0.7  node-role.kubernetes.io/node='node'
kubectl label node 192.168.0.8  node-role.kubernetes.io/node='node'

# kubectl get node,cs
NAME               STATUS   ROLES    AGE    VERSION
node/192.168.0.7   Ready    node     114m   v1.13.0
node/192.168.0.8   Ready    node     93m    v1.13.0

 

NAME                                 STATUS    MESSAGE             ERROR

componentstatus/controller-manager   Healthy   ok                  

componentstatus/scheduler            Healthy   ok                  

componentstatus/etcd-0               Healthy   {"health":"true"}   

componentstatus/etcd-1               Healthy   {"health":"true"}   

componentstatus/etcd-2               Healthy   {"health":"true"}

运行一个Nginx 测试示例

创建一个Nginx Web，测试集群是否正常工作：

# kubectl run nginx --image=nginx --replicas=3
# kubectl expose deployment nginx --port=80 --target-port=80 --type=NodePort

查看Pod，Service：

# kubectl get pods
NAME                     READY     STATUS    RESTARTS   AGE
nginx-64f497f8fd-fjgt2   1/1       Running   3          1d
nginx-64f497f8fd-gmstq   1/1       Running   3          1d
nginx-64f497f8fd-q6wk9   1/1       Running   3          1d

# kubectl get svc
NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)                        AGE
kubernetes   ClusterIP   10.0.0.1     <none>        443/TCP                        28d
nginx        NodePort    10.0.0.175   <none>        88:38696/TCP                   28d

访问集群中部署的Nginx，打开浏览器输入：//192.168.0.7:38696

Kubernets Apiserver HA SLB

准备环境

内网ip	角色	安装软件
192.168.0.10	master01	etcd,kube-apiserver,kube-controller-manager,kube-scheduler
192.168.0.12	master02	etcd,kube-apiserver,kube-controller-manager,kube-scheduler
192.168.0.7	node01	docker,kubelet,kube-proxy,flannel
192.168.0.8	node02	docker,kubelet,kube-proxy,flannel
192.168.0.4	slb master	etcd,keeaplived，nginx
192.168.0.9	slb backup	keeaplived，nginx
192.168.0.200	keepalived上的VIP

我们使用两台机器，当前是使用nginx+keepalived软件进行apiserver 6443接口的负载均衡，实现apiserver高可用。

部署nginx和keepalived

这里我们采用Nginx作为负载均衡软件，现在流量大的apiserver 也可以采用haproxy 作为负载均衡软件，也可以使用。

nginx 配置

yum install -y nginx
k8s-lb01，k8s-lb02都要安装
centos7要是没有nginx源，添加nginx的源

cat > /etc/yum.repos.d/nginx.repo << EOF
[nginx]
name=nginx repo
baseurl=//nginx.org/packages/centos/7/\$basearch/
gpgcheck=0
EOF

nginx 主配置文件

[root@k8s-lb02 nginx]# egrep -v '#|^$' /etc/nginx/nginx.conf
user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log;
pid /run/nginx.pid;
include /usr/share/nginx/modules/*.conf;
events {
    worker_connections 1024;
}
stream {
    log_format main '$remote_addr $upstream_addr - [$time_local] $status $upstream_bytes_sent';
    access_log /var/log/nginx/k8s-access.log main; 
    upstream k8s-apiserver {
        server 192.168.0.10:6443;
        server 192.168.0.12:6443;
    }
    server {
        listen 6443;
        proxy_pass k8s-apiserver;
    }

}
http {
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
    access_log  /var/log/nginx/access.log  main;
    sendfile            on;
    tcp_nopush          on;
    tcp_nodelay         on;
    keepalive_timeout   65;
    types_hash_max_size 2048;
    include             /etc/nginx/mime.types;
    default_type        application/octet-stream;
    include /etc/nginx/conf.d/*.conf;
    server {
        listen       80 default_server;
        listen       [::]:80 default_server;
        server_name  _;
        root         /usr/share/nginx/html;
        include /etc/nginx/default.d/*.conf;
        location / {
        }
        error_page 404 /404.html;
            location = /40x.html {
        }
        error_page 500 502 503 504 /50x.html;
            location = /50x.html {
        }
    }
}

# 两台nginx的配置文件一样

[root@k8s-lb01 nginx]# nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
[root@k8s-lb01 nginx]# systemctl start nginx

Keepalived配置

安装keepalived

yum install -y keepalived

主keepalived.conf

[root@k8s-lb01 ~]# cat /etc/keepalived/keepalived.conf 
! Configuration File for keepalived 
global_defs { 
   notification_email { 
     [email protected] 
     [email protected] 
     [email protected] 
   } 
   notification_email_from [email protected]  
   smtp_server 127.0.0.1 
   smtp_connect_timeout 30 
   router_id NGINX_MASTER 
} 

vrrp_script check_nginx {
    script "/etc/nginx/check_nginx.sh"
}

vrrp_instance VI_1 { 
    state MASTER 
    interface eth0       # 网卡名
    virtual_router_id 51  # VRRP 路由 ID实例，每个实例是唯一的 
    priority 100          # 优先级，备服务器设置 90 
    advert_int 1          # 指定VRRP 心跳包通告间隔时间，默认1秒 
    authentication { 
        auth_type PASS      
        auth_pass 1111 
    }  
    virtual_ipaddress { 
        192.168.0.200/24 # vip地址
    } 
    track_script {
        check_nginx        # 监控脚本
    } 
}

从keepalived.conf

[root@k8s-lb02 nginx]# cat /etc/keepalived/keepalived.conf 
! Configuration File for keepalived 
global_defs { 
   notification_email { 
     [email protected] 
     [email protected] 
     [email protected] 
   } 
   notification_email_from [email protected]  
   smtp_server 127.0.0.1 
   smtp_connect_timeout 30 
   router_id NGINX_MASTER 
} 
 
vrrp_script check_nginx {
    script "/etc/nginx/check_nginx.sh"
}

vrrp_instance VI_1 { 
    state BACKUP 
    interface eth0       # 网卡名
    virtual_router_id 51  # VRRP 路由 ID实例，每个实例是唯一的 
    priority 90           # 优先级，备服务器设置 90 
    advert_int 1          # 指定VRRP 心跳包通告间隔时间，默认1秒 
    authentication { 
        auth_type PASS      
        auth_pass 1111 
    }  
    virtual_ipaddress { 
        192.168.0.200/24 # vip地址
    } 
    track_script {
        check_nginx        # 监控脚本
    } 
}

编写check_nginx.sh

#!/bin/bash
count=$(ps -ef |grep nginx |egrep -cv "grep|$$")
if [ "$count" -eq 0 ];then
    systemctl stop keepalived
fi

keepalived 主备就优先和state 不一样，主备的check_nginx.sh内容一样。

[root@k8s-lb01 ~]# cat /etc/nginx/check_nginx.sh 
#!/bin/bash
count=$(ps -ef |grep nginx |egrep -cv "grep|$$")
if [ "$count" -eq 0 ];then
    systemctl stop keepalived
fi
[root@k8s-lb01 ~]# systemctl start keepalived

# 查看vip

[root@k8s-lb01 ~]# ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
2: ens33: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 00:0c:29:c6:79:90 brd ff:ff:ff:ff:ff:ff
    inet 192.168.0.4/24 brd 192.168.186.255 scope global noprefixroute ens33
       valid_lft forever preferred_lft forever
    inet 192.168.0.200/24 scope global secondary ens33
       valid_lft forever preferred_lft forever
    inet6 fe80::9d58:5651:daa8:880a/64 scope link noprefixroute 
       valid_lft forever preferred_lft forever

到目前为止 k8s的前端HA和SLB做准备已经实现，下面开始部署另一个k8s-master，部署完在测试。

如果想配置 master 机器高可用，其实配置的就是apiserver 应用的高可用，但是需要配置好高可用ip地址之后，再去配置master02。

Kubernets Master02 部署

准备环境

接下来准备安装另一个Kubernets master(192.168.0.12)。我们要安装两个master前端做slb。其实就是新增一个master节点，无非就是把证书，启动文件，拷过去，然后修改对应参数即可。

拷贝master01 配置文件

scp -P 12525 -r /data/soft/kubernetes [email protected]:/data/soft/

scp -P 12525 -r /usr/lib/systemd/system/{kube-apiserver,kube-controller-manager,kube-scheduler}.service [email protected]:/usr/lib/systemd/system/

scp -P 12525 -r /usr/bin/kubectl [email protected]:/usr/bin/

scp -P 12525 -r /data/soft/etcd/ssl/ [email protected]:/data/soft/etcd/

注意修改配置文件，把kube-apiserver中的bind-address和dvertise-address ip地址修改为为本地ip地址

启动apiserver,scheduler,controller-manager组件

systemctl start kube-apiserver.service 
systemctl start kube-scheduler.service 
systemctl start kube-controller-manager.service

检查 master02 对应的进程

[root@k8s-master02 cfg]# ps axf|grep scheduler
  8644 pts/1    S+     0:00          \_ grep --color=auto scheduler
  8576 ?        Ssl    0:01 /data/soft/kubernetes/bin/kube-scheduler --logtostderr=true --v=4 --master=127.0.0.1:8080 --leader-elect

 
[root@k8s-master02 cfg]# ps axf|grep controller-manager
  8646 pts/1    S+     0:00          \_ grep --color=auto controller-manager
  8628 ?        Ssl    0:00 /data/soft/kubernetes/bin/kube-controller-manager --logtostderr=true --v=4 --master=127.0.0.1:8080 --leader-elect=true --address=127.0.0.1 --service-cluster-ip-range=10.0.0.0/24 --cluster-name=kubernetes --cluster-signing-cert-file=/data/soft/kubernetes/ssl/ca.pem --cluster-signing-key-file=/data/soft/kubernetes/ssl/ca-key.pem --root-ca-file=/data/soft/kubernetes/ssl/ca.pem --service-account-private-key-file=/data/soft/kubernetes/ssl/ca-key.pem --experimental-cluster-signing-duration=87600h0m0s

[root@k8s-master02 etcd]# ps axf|grep apiserver
  9528 pts/1    S+     0:00          \_ grep --color=auto apiserver
  9479 ?        Ssl    0:28 /data/soft/kubernetes/bin/kube-apiserver --logtostderr=true --v=4 --etcd-servers=//192.168.0.10:2379,//192.168.0.12:2379,//192.168.0.4:2379 --bind-address=192.168.0.12 --secure-port=6443 --advertise-address=192.168.0.12 --allow-privileged=true --service-cluster-ip-range=10.0.0.0/24 --enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,ResourceQuota,NodeRestriction --authorization-mode=RBAC,Node --kubelet-https=true --enable-bootstrap-token-auth --token-auth-file=/data/soft/kubernetes/cfg/token.csv --service-node-port-range=30000-50000 --tls-cert-file=/data/soft/kubernetes/ssl/server.pem --tls-private-key-file=/data/soft/kubernetes/ssl/server-key.pem --client-ca-file=/data/soft/kubernetes/ssl/ca.pem --service-account-key-file=/data/soft/kubernetes/ssl/ca-key.pem --etcd-cafile=/data/soft/etcd/ssl/ca.pem --etcd-certfile=/data/soft/etcd/ssl/server.pem --etcd-keyfile=/data/soft/etcd/ssl/server-key.pem[root@k8s-master02 etcd]# ps axf|grep scheduler
  9530 pts/1    S+     0:00          \_ grep --color=auto scheduler
  8576 ?        Ssl    0:21 /data/soft/kubernetes/bin/kube-scheduler --logtostderr=true --v=4 --master=127.0.0.1:8080 --leader-elect
[root@k8s-master02 etcd]# ps axf|grep controller-manager
  9532 pts/1    S+     0:00          \_ grep --color=auto controller-manager
  8628 ?        Ssl    0:01 /data/soft/kubernetes/bin/kube-controller-manager --logtostderr=true --v=4 --master=127.0.0.1:8080 --leader-elect=true --address=127.0.0.1 --service-cluster-ip-range=10.0.0.0/24 --cluster-name=kubernetes --cluster-signing-cert-file=/data/soft/kubernetes/ssl/ca.pem --cluster-signing-key-file=/data/soft/kubernetes/ssl/ca-key.pem --root-ca-file=/data/soft/kubernetes/ssl/ca.pem --service-account-private-key-file=/data/soft/kubernetes/ssl/ca-key.pem --experimental-cluster-signing-duration=87600h0m0s

**master02的所有配置文件如下: **

[root@k8s-master02 kubernetes]# tree .
.
├── bin
│   ├── kube-apiserver
│   ├── kube-controller-manager
│   └── kube-scheduler
├── cfg
│   ├── kube-apiserver
│   ├── kube-controller-manager
│   ├── kube-scheduler
│   └── token.csv
├── logs
└── ssl
    ├── ca-key.pem
    ├── ca.pem
    ├── server-key.pem
    └── server.pem
 
4 directories, 11 files

查看master02 上kube-apiserver配置文件

[root@k8s-master02 cfg]# cat kube-apiserver
KUBE_APISERVER_OPTS="--logtostderr=true \
--v=4 \
--etcd-servers=//192.168.0.10:2379,//192.168.0.12:2379,//192.168.0.4:2379 \
--bind-address=192.168.0.12 \
--secure-port=6443 \
--advertise-address=192.168.0.12 \
--allow-privileged=true \
--service-cluster-ip-range=10.0.0.0/24 \
--enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,ResourceQuota,NodeRestriction \
--authorization-mode=RBAC,Node \
--kubelet-https=true \
--enable-bootstrap-token-auth \
--token-auth-file=/data/soft/kubernetes/cfg/token.csv \
--service-node-port-range=30000-50000 \
--tls-cert-file=/data/soft/kubernetes/ssl/server.pem  \
--tls-private-key-file=/data/soft/kubernetes/ssl/server-key.pem \
--client-ca-file=/data/soft/kubernetes/ssl/ca.pem \
--service-account-key-file=/data/soft/kubernetes/ssl/ca-key.pem \
--etcd-cafile=/data/soft/etcd/ssl/ca.pem \
--etcd-certfile=/data/soft/etcd/ssl/server.pem \
--etcd-keyfile=/data/soft/etcd/ssl/server-key.pem"

查看master02 上 kube-controller-manager 配置文件

[root@k8s-master02 cfg]# cat kube-controller-manager
KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=true \
--v=4 \
--master=127.0.0.1:8080 \
--leader-elect=true \
--address=127.0.0.1 \
--service-cluster-ip-range=10.0.0.0/24 \
--cluster-name=kubernetes \
--cluster-signing-cert-file=/data/soft/kubernetes/ssl/ca.pem \
--cluster-signing-key-file=/data/soft/kubernetes/ssl/ca-key.pem  \
--root-ca-file=/data/soft/kubernetes/ssl/ca.pem \
--service-account-private-key-file=/data/soft/kubernetes/ssl/ca-key.pem \
--experimental-cluster-signing-duration=87600h0m0s"

查看master02 上kube-scheduler 配置文件

[root@k8s-master02 cfg]# cat kube-scheduler
KUBE_SCHEDULER_OPTS="--logtostderr=true \
--v=4 \
--master=127.0.0.1:8080 \
--leader-elect"

token.csv 配置文件

[root@k8s-master02 cfg]# cat token.csv
2366a641f656a0a025abb4aabda4511b,kubelet-bootstrap,10001,"system:kubelet-bootstrap"

测试Master02配置

[root@k8s-master02 ~]# kubectl get pods
NAME                   READY   STATUS    RESTARTS   AGE
nginx-5c7588df-c58ql   1/1     Running   0          3d15h
nginx-5c7588df-gh6l9   1/1     Running   0          3d15h
nginx-5c7588df-nlj5l   1/1     Running   0          3d15h
nginx-5c7588df-p8ls9   1/1     Running   0          2d17h
nginx-5c7588df-sv64n   1/1     Running   0          2d17h

[root@k8s-master02 ~]# kubectl get nodes -o wide
NAME              STATUS   ROLES    AGE     VERSION   INTERNAL-IP       EXTERNAL-IP   OS-IMAGE                KERNEL-VERSION               CONTAINER-RUNTIME
192.168.0.7   Ready    <none>   3d16h   v1.13.4   192.168.0.7   <none>        CentOS Linux 7 (Core)   3.10.0-957.el7.x86_64        docker://18.9.5
192.168.0.8   Ready    <none>   3d15h   v1.13.4   192.168.0.8   <none>        CentOS Linux 7 (Core)   3.10.0-957.10.1.el7.x86_64   docker://18.9.5

[root@k8s-master02 kubernetes]# kubectl get cs
NAME                 STATUS    MESSAGE             ERROR
scheduler            Healthy   ok                  
controller-manager   Healthy   ok                  
etcd-0               Healthy   {"health":"true"}   
etcd-1               Healthy   {"health":"true"}   
etcd-2               Healthy   {"health":"true"}

到目前为相当完全复制master[除了修改配置文件]过来，启动一个新的master。以后不管新增几台master都是这样操作。
注意：

服务器时间
证书
配置文件
启动命令

Node节点配置Apiserver负载地址

配置node节点

我们此时将node节点指向到slb上，不在是指向master上了。此时就是将node节点的指向ip由原来的指向master ip改为slb的vip即可。

node1修改配置

[root@k8s-node01 ~]# cd /data/soft/kubernetes/cfg/
[root@k8s-node01 cfg]# ls
bootstrap.kubeconfig  flanneld  kubelet  kubelet.config  kubelet.kubeconfig  kube-proxy  kube-proxy.kubeconfig
[root@k8s-node01 cfg]# grep -irn 0.10 *
bootstrap.kubeconfig:5:    server: //192.168.0.10:6443
flanneld:2:FLANNEL_OPTIONS="--etcd-endpoints=//192.168.0.10:2379,//192.168.0.12:2379,//192.168.0.4:2379 -etcd-cafile=/data/soft/etcd/ssl/ca.pem -etcd-certfile=/data/soft/etcd/ssl/server.pem -etcd-keyfile=/data/soft/etcd/ssl/server-key.pem"kubelet.kubeconfig:5:    server: //192.168.0.10:6443
kube-proxy.kubeconfig:5:    server: //192.168.0.10:6443

其中要修改的 bootstrap.kubeconfig 第五行，kubelet.kubeconfig第五行，kube-proxy.kubeconfig第五行。修改后如下：
[root@k8s-node01 cfg]# grep -irn 200 *
bootstrap.kubeconfig:5:    server: //192.168.0.200:6443
kubelet.kubeconfig:5:    server: //192.168.0.200:6443
kube-proxy.kubeconfig:5:    server: //192.168.0.200:6443

# 重启服务

[root@k8s-node01 cfg]# systemctl restart kubelet
[root@k8s-node01 cfg]# systemctl restart kube-proxy

node2修改配置

[root@k8s-node02 ~]# cd /data/soft/kubernetes/cfg/
[root@k8s-node02 cfg]# ll
total 32
-rw------- 1 root root 2169 Apr 18 17:49 bootstrap.kubeconfig
-rw-r--r-- 1 root root  241 Apr 18 17:49 flanneld
-rw-r--r-- 1 root root  413 Apr 18 17:55 kubelet
-rw-r--r-- 1 root root  269 Apr 18 17:56 kubelet.config
-rw------- 1 root root 2298 Apr 18 18:07 kubelet.kubeconfig
-rw-r--r-- 1 root root  191 Apr 18 18:01 kube-proxy
-rw------- 1 root root 6271 Apr 18 17:49 kube-proxy.kubeconfig

[root@k8s-node02 cfg]# grep -irn 223 *
bootstrap.kubeconfig:5:    server: //192.168.0.10:6443
flanneld:2:FLANNEL_OPTIONS="--etcd-endpoints=//192.168.0.10:2379,//192.168.0.12:2379,//192.168.0.12:2379 -etcd-cafile=/data/soft/etcd/ssl/ca.pem -etcd-certfile=/data/soft/etcd/ssl/server.pem -etcd-keyfile=/data/soft/etcd/ssl/server-key.pem"kubelet.kubeconfig:5:    server: //192.168.0.10:6443
kube-proxy.kubeconfig:5:    server: //192.168.0.10:6443
[root@k8s-node02 cfg]# vim bootstrap.kubeconfig +5
[root@k8s-node02 cfg]# vim kubelet.kubeconfig +5
[root@k8s-node02 cfg]# vim kube-proxy.kubeconfig +5

[root@k8s-node02 cfg]# grep -irn 200 *
bootstrap.kubeconfig:5:    server: //192.168.0.200:6443
kubelet.kubeconfig:5:    server: //192.168.0.200:6443
kube-proxy.kubeconfig:5:    server: //192.168.0.200:6443

重启node2节点服务

[root@k8s-node02 cfg]# systemctl restart kubelet
[root@k8s-node02 cfg]# systemctl restart kube-proxy

到此kubernetes 基础架构配置完成————————-

扩展配置

NODE节点执行kubectl命令

这一章节操作是为了生产kubeconfig文件，此文件主要用于在node节点上面执行kubectl 命令，同时也可以生成此文件给开发或者其他普通用户执行kubectl命令。具体步骤如下：

# 在master01上操作

cd k8s-cert

vim kubectl.sh 
kubectl config set-cluster kubernetes \
--server=//192.168.0.200:6443 \
--embed-certs=true \
--certificate-authority=ca.pem \
--kubeconfig=config

kubectl config set-credentials cluster-admin \
--certificate-authority=ca.pem \
--embed-certs=true \
--client-key=admin-key.pem \
--client-certificate=admin.pem \
--kubeconfig=config

kubectl config set-context default --cluster=kubernetes --user=cluster-admin --kubeconfig=config
kubectl config use-context default --kubeconfig=config

[root@k8s-master01 k8s-cert]# pwd
/data/www/k8s-cert
[root@k8s-master01 k8s-cert]# bash kubectl.sh 
Cluster "kubernetes" set.
User "cluster-admin" set.
Context "default" created.
Switched to context "default".

[root@k8s-master01 k8s-cert]# ls config 
config

[root@k8s-master01 k8s-cert]# ls
admin.csr       bootstrap.kubeconfig  ca-key.pem   kubeconfig.sh        kube-proxy-key.pem     server-csr.json
admin-csr.json  ca-config.json        ca.pem       kubectl.sh           kube-proxy.kubeconfig  server-key.pem
admin-key.pem   ca.csr                config       kube-proxy.csr       kube-proxy.pem         server.pem
admin.pem       ca-csr.json           k8s-cert.sh  kube-proxy-csr.json  server.csr

分发新生成的证书到node节点

192.168.0.7[root@k8s-master01 k8s-cert]# scp  /usr/bin/kubectl [email protected]:/usr/bin/
[email protected]'s password: 
kubectl                                                                                         100%   37MB  68.2MB/s   00:00    
[root@k8s-master01 k8s-cert]# scp  config [email protected]:/root
[email protected]'s password: 
config                                                                                          100% 6273     3.7MB/s   00:00

在node1上操作

[root@k8s-node01 ~]# pwd
/root
[root@k8s-node01 ~]# ls
anaconda-ks.cfg  config  flannel.sh  flannel-v0.10.0-linux-amd64.tar.gz  kubelet.sh  node.zip  proxy.sh  README.md
[root@k8s-node01 ~]# kubectl --kubeconfig=./config  get nodes
NAME              STATUS   ROLES    AGE     VERSION
192.168.0.7   Ready    <none>   3d18h   v1.16.4
192.168.0.8   Ready    <none>   3d17h   v1.16.4

[root@k8s-node01 ~]# kubectl --kubeconfig=./config  get nodes -o wide
NAME              STATUS   ROLES    AGE     VERSION   INTERNAL-IP       EXTERNAL-IP   OS-IMAGE                KERNEL-VERSION               CONTAINER-RUNTIME
192.168.0.7   Ready    <none>   3d18h   v1.16.4   192.168.0.7   <none>        CentOS Linux 7 (Core)   3.10.0-957.el7.x86_64        docker://18.9.5
192.168.0.8   Ready    <none>   3d17h   v1.16.4   192.168.0.8   <none>        CentOS Linux 7 (Core)   3.10.0-957.10.1.el7.x86_64   docker://18.9.5

常见问题

api启动不了报错（配置文件错误）

#发现api-server没启动排错

[root@k8s-master02 cfg]# source /data/soft/kubernetes/cfg/kube-apiserver
[root@k8s-master02 cfg]# /data/soft/kubernetes/bin/kube-apiserver $KUBE_APISERVER_OPTS
error: failed to create listener: failed to listen on 192.168.0.10:6443: listen tcp 192.168.0.10:6443: bind: cannot assign requested address

[root@k8s-master02 cfg]# grep 10 *
kube-apiserver:--etcd-servers=//192.168.0.10:2379,//192.168.0.12:2379,//192.168.0.4:2379 \
kube-apiserver:--bind-address=192.168.0.10 \

**--bind-address=192.168.0.12 要修改成本机的。我模拟了该错误，怎么排查**

[root@k8s-master02 cfg]# systemctl start kube-apiserver.service

链接api-server报错（证书问题）

这个时候如果出现连接api-server 报错时，多数情况是因为api-server 证书连接没有被允许。
可以看出，我们从其他非master的机器通过证书和命令链接到机器中[其实就是通过加载证书，链接apiserver，我没有其他闲置机器。我使用了node1节点，你找其他机器都可以，但是保证你的apiserver的证书中允许该ip]

如果需要再后面配置多个地址链接apiserver，需要提前在k8s-cert.sh中指定了api server允许链接的ip，就是下面这个配置中

cat > api-server-csr.json <<EOF
{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
      "127.0.0.1",
      "192.168.0.10",
      "192.168.0.12",
      "192.168.0.7",
      "192.168.0.8",
      "192.168.0.4",
      "192.168.0.9",
      "192.168.0.200",
      "kubernetes",
      "kubernetes.default",
      "kubernetes.default.svc",
      "kubernetes.default.svc.cluster",
      "kubernetes.default.svc.cluster.local"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Shenzhen",
            "ST": "Shenzhen",
            "O": "k8s",
            "OU": "System"
        }
    ]
}
EOF

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes server-csr.json | cfssljson -bare server

# 具体参考安装master时候，给apiserver 制作的证书

我在做master+nginx slb的时候把证书和启动文件拷贝到node1上 启动的时候加载了证书，显示显示如下: 
[root@k8s-node01 ~]# kubectl --kubeconfig=./config get node   # 其实就是去链接apiserver[apiserver中ip限制].
Unable to connect to the server: x509: certificate is valid for 10.0.0.1, 127.0.0.1, 192.168.0.10, 192.168.0.12, 192.168.0.7,192.168.0.8,192.168.0.4, 192.168.0.9, 192.168.0.200, not 192.168.186.100

后面发现我的vip 192.168.0.200不在apiserver 信任里面。解决办法:

1. 修改我制作apiserver的时候预留的ip
2. 重新制作spiserver证书，分发到其他机器上。

我们选择了第一种

普通用户操作systemd服务启动和重启

普通用户操作systemd服务
解决方案：
根据上面提示得知权限由polkit进行管理，对应的是org.freedesktop.systemd1.policy这个配置文件下的manae-units动作

进入/usr/share/polkit-1/actions/org.freedesktop.systemd1.policy，
配置如下：
				<action id="org.freedesktop.systemd1.manage-units">
				省略...
                        <defaults>
                        <allow_any>yes</allow_any>
                        <allow_inactive>yes</allow_inactive>
                        <allow_active>yes</allow_active>
                </defaults>
        </action>
end---

将对应manae-units的defaults中的授权全部改为yes，然后执行systemctl restart polkit重启polkit

查看pod日志报错

kubectl logs nginx-6db489d4b7-2xnhg
error: You must be logged in to the server (the server has asked for the client to provide credentials ( pods/log nginx-6db489d4b7-2xnhg))

查看日志出现这个错误，需要先授权。

[root@k8s-master01 bin]# kubectl create clusterrolebinding cluster-system-anonymous --clusterrole=cluster-admin --user=system:anonymous
clusterrolebinding.rbac.authorization.k8s.io/cluster-system-anonymous created
[root@k8s-master01 bin]# kubectl logs nginx-5c7588df-c58ql
172.17.66.0 - - [18/Apr/2019:10:17:42 +0000] "GET / HTTP/1.1" 200 612 "-" "curl/7.29.0" "-"
172.17.66.0 - - [18/Apr/2019:10:18:50 +0000] "GET / HTTP/1.1" 200 612 "-" "curl/7.2

Tags: Kubernetes