前言

一：单master节点用二进制部署K8S集群

1.1：拓扑图与主机分配

主机名	IP地址	资源分配	所需部署组件
master	20.0.0.32	1G+2CPU	kube-apiserver、kube-controller-manager、kube-scheduler、etcd
node01	20.0.0.33	2G+4CPU	kubelet、kube-proxy、docker、flannel、etcd
node02	20.0.0.34	2G+4CPU	kubelet、kube-proxy、docker、flannel、etcd

1.1.1：拓扑图介绍

-master组件介绍：

kube-apiserver：是集群的统一入口，各个组件的协调者，所有对象资源的增删改查和监听操作都交给APIserver处理，再提交给etcd存储。
kube-controller-manager：处理群集中常规的后台任务，一个资源对应一个控制器，而controller-manager就是负责管理这些控制器。
kube-scheduler：根据调度算法为新创建的pod选择一个node节点，可以任意部署，可以部署同一个节点上，也可以部署在不同节点上

• node组件介绍：

kubelet：kube是master在node节点上的Agent，管理本机运行容器的生命周期，比如创建容器、Pod挂载数据卷、下载secret、获取容器和节点状态等工作。kubelet将每个pod转换成一组容器
kube-proxy：在node节点上实现pod网络代理，维护网络规划和四层负载均衡的工作
docker：Docker引擎
flannel：flannel网络

• etcd集群介绍：etcd集群在这里分布的部署到了三个节点上

etcd是CoreOS团队于2013年6月发起的开源项目，基于go语言开发，目标是构建一个高可用的分布式键值（key-value）数据库。etcd内部采用raft协议作为一致性算法。
etcd集群数据无中心化集群，有如下特点：
1、简单：安装配置简单，而且提供了HTTP进行交互，使用也很简单
2、安全：支持SSL证书验证
3、快速：根据官方提供的benchmark数据，单实例支持每秒2k+读操作
4、可靠：采用raft算法，实现分布式数据的可用性和一致性

• 部署K8S集群中会用到的自签SSL证书
  |组件 | 使用的证书 |
  |–|--|
  | etcd | ca.pem，server.pem，server-key.pem |
  | flannel | ca.pem，server.pem，server-key.pem|
  | kube-apiserver | ca.pem，server.pem，server-key.pem |
  | kubelet | ca.pem，ca-key.pem |
  | kube-proxy | ca.pem，kube-proxy.pem，kube-proxy-key.pem |
  | kubectl | ca.pem，admin-pem，admin-key.pem |

1.2：开局优化

• 1、修改主机名

[root@localhost ~]# hostnamectl set-hostname master	'//相同方法修改另外两台主机'
[root@localhost ~]# su
[root@master ~]# 

• 2、关闭防火墙与核心防护，三个节点都做，此处仅展示master 的操作

[root@node02 ~]# systemctl stop firewalld && systemctl disable firewalld
Removed symlink /etc/systemd/system/multi-user.target.wants/firewalld.service.
Removed symlink /etc/systemd/system/dbus-org.fedoraproject.FirewallD1.service.
[root@node02 ~]# setenforce 0 && sed -i "s/SELINUX=enforcing/SELNIUX=disabled/g" /etc/selinux/config

1.3：ETCD集群部署

• 1、master主机创建k8s文件夹并上传etcd脚本，下载cffssl官方证书生成工具

[root@master ~]# mkdir -p k8s/etcd-cert
[root@master ~]# cd k8s/
[root@master k8s]# rz -E	'//上传etcd脚本'
rz waiting to receive.
[root@master k8s]# ls
etcd-cert  etcd-cert.sh  etcd.sh
注释：etcd-cert.sh：生成一些etcd证书的素材脚本；etcd.sh：服务脚本，这个服务脚本包含了你的配置文件和启动脚本

[root@master k8s]# mv etcd-cert.sh etcd-cert	'//移动到相应目录'

[root@master k8s]# vim cfssl.sh   //下载证书制作工具
curl -L https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -o /usr/local/bin/cfssl
curl -L https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 -o /usr/local/bin/cfssljson
curl -L https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 -o /usr/local/bin/cfssl-certinfo
chmod +x /usr/local/bin/cfssl /usr/local/bin/cfssljson /usr/local/bin/cfssl-certinfo
[root@master k8s]# bash cfssl.sh	'//运行下载工具的脚本'

注释：1.//cfssl生成证书工具；2.cfssljson：这个工具能够识别当中的格式类型，就是因为cfssljson这个工具包，也就是说证书配置的格式是以json的格式来的，通过传入json文件生成证书；
3.cfssl-certinfo查看证书信息，该工具自带了证书的一些源信息和属性信息

• 2、创建证书

//定义ca证书       给服务端生成证书使用的
cat > ca-config.json <<EOF
{
"signing" : {
"default": {
"expiry" : "87600h"
},
"profiles":  {
"www" : {
"expiry" : "87600h",
"usages" :  [
"signing",
"key encipherment",
"server auth",
"client auth"
]
}
}
}
}
EOF

注意：EOF的后面一定不能有空格，否则系统会让你一直输入
注释："signing"签名的意思；"key encipherment",加密密钥，然后客户端和服务端都可以拿着这钥匙去验证



//实现证书签名
cat > ca-csr.json <<EOF 
{   
    "CN": "etcd CA",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing"
        }
    ]
}
EOF

//生产证书，生成ca-key.pem  ca.pem
cfssl gencert -initca ca-csr.json | cfssljson -bare ca 
-
2020/01/13 16:32:56 [INFO] generating a new CA key and certificate from CSR
2020/01/13 16:32:56 [INFO] generate received request
2020/01/13 16:32:56 [INFO] received CSR
2020/01/13 16:32:56 [INFO] generating key: rsa-2048
2020/01/13 16:32:56 [INFO] encoded CSR
2020/01/13 16:32:56 [INFO] signed certificate with serial number 595395605361409801445623232629543954602649157326


注释：gencert 创建里面的证书
-initca初始化里面的ca，用到的是里面的签名证书ca-csr.json
cfssljson 之前下载的工具，能够识别json的格式
-bare：基本信息的读取

• 3.指定etcd三个节点之间的通信验证（定义server的签名配置文件，它是构建三个集群通信所用）

cat > server-csr.json <<EOF
{
    "CN": "etcd",
    "hosts": [
    "20.0.0.32",       指定各个节点包括master
    "20.0.0.33",
    "20.0.0.34"
    ],
    "key": {
        "algo": "rsa",        这边一定要写跟ca证书一样的密钥类型和大小
        "size": 2048
    },
    "names": [             
        {
            "C": "CN",             并且也要跟ca证书写的地点名称也是要一样
            "L": "BeiJing",
            "ST": "BeiJing"
        }
    ]
}
EOF


注释：假如你的node节点要变更，那么你就要重新生成你server的证书（就是下面操作生成的俩个server证书，上面那个是证书签名），否则你就加入不了这个etcd的集群中，你不需要重新生成ca证书，因为ca证书并没有标明节点信息的地址

//生成ETCD证书 server-key.pem   server.pem
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server

注释：-profile指明你的开头是以www；cfssljson -bare server：生成什么端的证书（服务端）

• 4、下载并解压ETCD二进制包，下载地址：https://github.com/etcd-io/etcd/releases

[root@localhost k8s]# ls
cfssl.sh   etcd.sh                          flannel-v0.10.0-linux-amd64.tar.gz 使不同裸金属上的docker能够互相通信
etcd-cert  etcd-v3.3.10-linux-amd64.tar.gz  二进制包
kubernetes-server-linux-amd64.tar.gz 获得构建集群所需的工具etcd 和 etcdctl

[root@localhost k8s]# tar zxvf etcd-v3.3.10-linux-amd64.tar.gz

5、创建命令，配置文件和证书的文件夹，并移动相应文件到相应目录

[root@master k8s]# mkdir -p /opt/etcd/{cfg,bin,ssl}
[root@master k8s]# ls /opt/etcd/
bin  cfg  ssl
[root@master k8s]# ls etcd-v3.3.10-linux-amd64
Documentation  etcd  etcdctl  README-etcdctl.md  README.md  READMEv2-etcdctl.md
[root@master k8s]# mv etcd-v3.3.10-linux-amd64/etcd* /opt/etcd/bin	'//移动命令到刚刚创建的 bin目录'
[root@master k8s]# ls /opt/etcd/bin/
etcd  etcdctl
[root@master k8s]# cp etcd-cert/*.pem /opt/etcd/ssl	'//将证书文件复制到刚刚创建的ssl目录'
[root@master k8s]# ls /opt/etcd/ssl
ca-key.pem  ca.pem  server-key.pem  server.pem

 ...省略内容
[root@localhost k8s]#vi etcd.sh       下面就用之前宿主机拉取过来的脚本文件中就已经定义了之后生产配置文件的位置

能看出这边系统定义把etcd交给了systemd管理，之后再传输的试试也把该etcd服务文件传给了node端，可以往下看

• 6、主节点执行脚本并声明本地节点名称和地址，此时会进入监控状态，等待其他节点加入，等待时间2分钟

[root@master k8s]# ls /opt/etcd/cfg/	'//此时查看这个目录是没有文件的'
[root@localhost k8s]# bash etcd.sh etcd01 20.0.0.32 etcd02=https://20.0.0.33:2380,etcd03=https://20.0.0.34:2380

[root@master k8s]# ls /opt/etcd/cfg/	'//此时重新打开终端，发现已经生成了文件'
etcd


//进入卡住状态等待其他节点加入,因为目前node节点还没有配置，所以构建不了集群会超时推出，超时退出

当构建集群的时候可以在打开一个终端，看一下进程有没有起来

[root@localhost ~]# ps -ef | grep etcd

• 7、拷贝证书和启动脚本到两个工作节点

//拷贝证书去其他节点  -r表示递归，如果拷贝目录就用这个，还有一点需要注意上传到对方的目录一定是要/opt目录下，因为server的配置文件已经指了，如果你传到其他路径，那么还需要修改配置文件

[root@localhost k8s]# scp -r /opt/etcd/ root@20.0.0.33:/opt/
[root@localhost k8s]# scp -r /opt/etcd/ root@20.0.0.34:/opt

//启动脚本拷贝其他节点交给system管理
[root@localhost k8s]# scp /usr/lib/systemd/system/etcd.service root@20.0.0.33:/usr/lib/systemd/system/
[root@localhost k8s]# scp /usr/lib/systemd/system/etcd.service root@20.0.0.34:/usr/lib/systemd/system/

• node01和node02两个工作节点修改修改etcd配置文件，修改相应的名称和IP地址

[root@node01 ~]# vim /opt/etcd/cfg/etcd	'//两个节点相同方法修改，此处指展示node01的修改'

• 先开启主节点的集群脚本，然后两个节点启动etcd

[root@master k8s]# bash etcd.sh etcd01 20.0.0.32 etcd02=https://20.0.0.33:2380,etcd03=https://20.0.0.34:2380	'//master节点开启集群脚本'
[root@node01 ~]# systemctl start etcd	'//然后两个节点启动etcd'
[root@node01 ~]# systemctl status etcd
[root@node02 ~]# systemctl starts etcd
[root@node02 ~]# systemctl status etcd

• 检查集群状态：注意相对路径

注意因为需要使用到证书，但是证书写的路径是相对路径，因为现在证书已经全部挪到
/opt/etcd/ssl目录下，所有要切到该目录下在执行该文件
（还有一个etcd的工具猜想可能是安装etcd用的）
root@node1 ssl]# /opt/etcd/bin/etcdctl --ca-file=ca.pem --cert-file=server.pem --key-file=server-key.pem --endpoints="https://20.0.0.32:2379,https://20.0.0.33:2379,https://20.0.0.34:2379" cluster-health

member 3eae9a550e2e3ec is healthy: got healthy result from https://192.168.195.151:2379
member 26cd4dcf17bc5cbd is healthy: got healthy result from https://192.168.195.150:2379
member 2fcd2df8a9411750 is healthy: got healthy result from https://192.168.195.149:2379
cluster is healthy

但是我之前在检测集群状态的时候，是有一个报错的，显示20.0.0.34不可达。后开查看了一下自己的防火墙发现是开着的，把其关闭就好了

• 到此，ETCD集群已经搭建成功

1.4：部署Docker

• 两个node节点部署Docker，这边就不要操作了，如果还有不懂的可以看我前面的博客

1.5：flannel容器集群网络部署

1.5.1：flannel网络理论介绍

• Overlay Network：覆盖网络，在基础网络上叠加的一种虚拟化网络技术模式，该网络中的主机通过虚拟链路连接起来
• VXLAN：将源数据包封装到UDP中，并使用基础网络的IP/MAC作为外层报文头进行封装，然后在以太网上进行传输，到达目的地后由隧道端点解封装并将数据发送给目标地址
• Flannel：是Overlay网络的一种，也是将源数据包封装在另一种网络包里面进行路由转发和通信，目前已经支持UDP、VXLAN、AWS VPC和GCE路由等数据转发方式

• Flannel是CoreOS团队针对 Kubernetes设计的一个网络规划服务，简单来说，它的功能是让集群中的不同节点主机创建的 Docker容器都具有全集群唯一的虚拟IP地址。而且它还能在这些IP地址之间建立一个覆盖网络（overlay Network），通过这个覆盖网络，将数据包原封不动地传递到目标容器内

• ETCD在这里的作用：为Flannel提供说明
  - 存储管理 Flannel可分配的IP地址段资源
  - 监控ETCD中每个Pod的实际地址，并在内存中建立维护Pod节点路由表

1.5.2：部署

• 1、master节点写入分配的子网段到ETCD中，供flannel使用

[root@localhost ssl]# /opt/etcd/bin/etcdctl --ca-file=ca.pem --cert-file=server.pem --key-file=server-key.pem --endpoints="https://20.0.0.32:2379,https://20.0.0.33:2379,https://20.0.0.34:2379" set /coreos.com/network/config '{ "Network": "172.17.0.0/16", "Backend": {"Type": "vxlan"}}'

注释：
set /coreos.com/network/config '{ "Network": "172.17.0.0/16", "Backend": {"Type": "vxlan"}}'
这句话就是设置了一个键值对，/coreos.com/network/config 网络的地址，"Network": "172.17.0.0/16", "Backend": {"Type": "vxlan"}}' 设置了一个网段，类型是vxlan




//查看写入的信息
[root@master ss]# /opt/etcd/bin/etcdctl --ca-file=ca.pem --cert-file=server.pem --key-file=server-key.pem --endpoints="https://20.0.0.32:2379,https://20.0.0.33:2379,https://20.0.0.34:2379" get /coreos.com/network/config
{ "Network": "172.17.0.0/16", "Backend": {"Type": "vxlan"}}

2、在两个node节点部署flannel

• 1、master节点写入分配的子网段到ETCD中，供flannel使用

[root@localhost ssl]# /opt/etcd/bin/etcdctl --ca-file=ca.pem --cert-file=server.pem --key-file=server-key.pem --endpoints="https://20.0.0.32:2379,https://20.0.0.33:2379,https://20.0.0.34:2379" set /coreos.com/network/config '{ "Network": "172.17.0.0/16", "Backend": {"Type": "vxlan"}}'

注释：
set /coreos.com/network/config '{ "Network": "172.17.0.0/16", "Backend": {"Type": "vxlan"}}'
这句话就是设置了一个键值对，/coreos.com/network/config 网络的地址，"Network": "172.17.0.0/16", "Backend": {"Type": "vxlan"}}' 设置了一个网段，类型是vxlan


flanneld              //启动文件
mk-docker-opts.sh    //脚本
README.md            //说明书

• 2、在两个node节点部署flannel

[root@master ssl]# cd /root/k8s/
[root@master k8s]# scp flannel-v0.10.0-linux-amd64.tar.gz root@20.0.0.33:/opt
[root@master k8s]# scp flannel-v0.10.0-linux-amd64.tar.gz root@20.0.0.34:/opt
[root@node01 ~]# cd /opt
[root@node01 opt]# ls
containerd  etcd  flannel-v0.10.0-linux-amd64.tar.gz
[root@node01 opt]# tar zxvf flannel-v0.10.0-linux-amd64.tar.gz 	'//node02也要解压，不在赘述'
flanneld
mk-docker-opts.sh
README.md
'//谁需要跑pod，谁就需要安装flannel网络'

• 3、node节点创建k8s工作目录，将两个脚本移动到对应工作目录

[root@node01 opt]# mkdir -p /opt/k8s/{cfg,bin,ssl}	'//创建对应配置文件，命令和证书目录'
[root@node01 opt]# mv mk-docker-opts.sh flanneld ./k8s/bin/	'//移动flannel脚本命令到相应目录'
[root@node01 opt]# ls k8s/bin/
mk-docker-opts.sh

• 4、两个node节点都编辑flannel.sh脚本：创建配置文件与启动脚本，定义的端口是2379，节点对外提供的端口

[root@localhost ~]# vim flannel.sh
#!/bin/bash

ETCD_ENDPOINTS=${1:-"http://127.0.0.1:2379"}

cat <<EOF >/opt/kubernetes/cfg/flanneld

FLANNEL_OPTIONS="--etcd-endpoints=${ETCD_ENDPOINTS} \
-etcd-cafile=/opt/etcd/ssl/ca.pem \
-etcd-certfile=/opt/etcd/ssl/server.pem \
-etcd-keyfile=/opt/etcd/ssl/server-key.pem"

EOF

cat <<EOF >/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=/opt/kubernetes/cfg/flanneld
ExecStart=/opt/kubernetes/bin/flanneld --ip-masq \$FLANNEL_OPTIONS
ExecStartPost=/opt/kubernetes/bin/mk-docker-opts.sh -k DOCKER_NETWORK_OPTIONS -d /run/flannel/subnet.env
Restart=on-failure

[Install]
WantedBy=multi-user.target

EOF

systemctl daemon-reload
systemctl enable flanneld
systemctl restart flanneld 

上面三句话也是脚本里面的

• 5、执行脚本，开启flannel网络功能

[root@node01 opt]# bash flannel.sh https://192.168.233.131:2379,https://192.168.233.132：2379,https://192.168.233.133:2379	'//两个node节点都开启'
Created symlink from /etc/systemd/system/multi-user.target.wants/flanneld.service to /usr/lib/systemd/system/flanneld.service.
[root@node02 opt]# systemctl status flanneld	'//查看flanneld服务是否正常开启'

• 6、配置docker连接flannel网络

• 7、查看flannel分配给docker的IP地址

[root@node01 opt]# cat /run/flannel/subnet.env	'//node01节点分配的地址'
DOCKER_OPT_BIP="--bip=172.17.26.1/24"
DOCKER_OPT_IPMASQ="--ip-masq=false"
DOCKER_OPT_MTU="--mtu=1450"
DOCKER_NETWORK_OPTIONS=" --bip=172.17.26.1/24 --ip-masq=false --mtu=1450"	'//bip指定启动时的子网'
[root@node02 opt]# cat /run/flannel/subnet.env	'//node02节点分配的地址'
DOCKER_OPT_BIP="--bip=172.17.4.1/24"
DOCKER_OPT_IPMASQ="--ip-masq=false"
DOCKER_OPT_MTU="--mtu=1450"
DOCKER_NETWORK_OPTIONS=" --bip=172.17.4.1/24 --ip-masq=false --mtu=1450"

注释：
$DOCKER_NETWORK_OPTIONS 这是docker网桥生效

• 8、重启Docker服务，再次查看flannel网络是否有变化

[root@node02 opt]# systemctl daemon-reload
[root@node02 opt]# systemctl restart docker
[root@node02 opt]# ifconfig	'//两个节点应该能查看到各自对应的flannel网络的网段'

• 9、创建容器测试两个node节点是否可以互联互通

[root@node01 opt]# docker run -it centos:7 /bin/bash	'//两个节点都创建并运行容器'
[root@8ffe415fb35e /]# yum -y install net-tools	'//两个容器中都安装网络工具'
[root@8ffe415fb35e /]# ifconfig

eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1450
        inet 172.17.26.2  netmask 255.255.255.0  broadcast 172.17.26.255
...省略内容	'//经过查看，node01节点容器的IP地址是172.17.26.2，node02节点容器的IP地址是172.17.4.2 '
[root@8ffe415fb35e /]# ping 172.17.4.2 	'//node01节点的容器ping node02节点的容器成功'
PING 172.17.4.2 (172.17.4.2) 56(84) bytes of data.
64 bytes from 172.17.4.2: icmp_seq=1 ttl=62 time=0.477 ms
64 bytes from 172.17.4.2: icmp_seq=2 ttl=62 time=0.697 ms
64 bytes from 172.17.4.2: icmp_seq=3 ttl=62 time=0.705 ms
^C
--- 172.17.4.2 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2002ms
rtt min/avg/max/mdev = 0.477/0.626/0.705/0.107 ms
[root@e8e969f37720 /]# ping 172.17.26.2	'//node02 ping node01容器'
PING 172.17.26.2 (172.17.26.2) 56(84) bytes of data.
64 bytes from 172.17.26.2: icmp_seq=1 ttl=62 time=0.813 ms
64 bytes from 172.17.26.2: icmp_seq=2 ttl=62 time=1.02 ms
64 bytes from 172.17.26.2: icmp_seq=3 ttl=62 time=0.513 ms
^C
--- 172.17.26.2 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2003ms
rtt min/avg/max/mdev = 0.513/0.785/1.029/0.211 ms
'//证明flannel网络部署成功'

1.6：部署master组件

• 下图是node节点的kubectl启动的流程图，根据此流程图，我们需要在master节点将kubelet-bootstrap用户绑定到集群，然后部署一些证书认证使node节点能够被master节点检测到并且成功连接。

• 1、master节点操作，api-server生成证书

//在master上操作，api-server生成证书
[root@localhost k8s]# unzip master.zip

[root@localhost k8s]# mkdir /opt/kubernetes/{cfg,bin,ssl} -p

在操作配置之前一定要先创建证书，不然别人没有办法找你验证，也没有办法加入到你的集群

[root@localhost k8s]# mkdir k8s-cert  创建一个证书目录
[root@node1 k8s]# mkdir k8s-cert

[root@localhost k8s]# cd k8s-cert/  
[root@localhost k8s-cert]# ls  有脚本，或者复制下面大大的长段
k8s-cert.sh

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

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

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

#-----------------------

cat > server-csr.json <<EOF
{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
      "127.0.0.1",
      "20.0.0.32",  //master1
      "20.0.0.35",  //master2
      "20.0.0.100",  //vip
      "20.0.0.37",  //lb （master）负载均衡 nginx
      "20.0.0.38",  //lb （backup）
      "kubernetes",
      "kubernetes.default",
      "kubernetes.default.svc",
      "kubernetes.default.svc.cluster",
      "kubernetes.default.svc.cluster.local"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "BeiJing",
            "ST": "BeiJing",
            "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

#-----------------------

cat > admin-csr.json <<EOF     这是管理员的角色证书
{
  "CN": "admin",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing",
      "O": "system:masters",
      "OU": "System"
    }
  ]
}
EOF

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

#-----------------------

cat > kube-proxy-csr.json <<EOF      node节点中需要用的代理证书
{
  "CN": "system:kube-proxy",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing",
      "O": "k8s",
      "OU": "System"
    }
  ]
}
EOF

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

• 2、生成证书

[root@master k8s-cert]# bash k8s-cert.sh 	'//生成证书'
[root@master k8s-cert]# ls
admin.csr       admin.pem       ca-csr.json  k8s-cert.sh          kube-proxy-key.pem  server-csr.json
admin-csr.json  ca-config.json  ca-key.pem   kube-proxy.csr       kube-proxy.pem      server-key.pem
admin-key.pem   ca.csr          ca.pem       kube-proxy-csr.json  server.csr          server.pem
[root@master k8s-cert]# ls *.pem
admin-key.pem  ca-key.pem  kube-proxy-key.pem  server-key.pem
admin.pem      ca.pem      kube-proxy.pem      server.pem
[root@master k8s-cert]# cp ca*.pem server*.pem /opt/kubernets/ssl/	'//复制证书到工作目录'
[root@master k8s-cert]# ls /opt/kubernets/ssl/
ca-key.pem  ca.pem  server-key.pem  server.pem

• 3、解压k8s服务器端压缩包

[root@master k8s-cert]# cd ..
[root@master k8s]# ls
cfssl.sh   etcd-v3.3.10-linux-amd64            k8s-cert
etcd-cert  etcd-v3.3.10-linux-amd64.tar.gz     kubernetes-server-linux-amd64.tar.gz
etcd.sh    flannel-v0.10.0-linux-amd64.tar.gz  master.zip

[root@master k8s]# tar zxvf kubernetes-server-linux-amd64.tar.gz 

• 4、复制服务器端关键命令到k8s工作目录中

[root@master k8s]# cd kubernetes/server/bin/
[root@master bin]# cp kube-controller-manager kube-scheduler kubectl kube-apiserver /opt/kubernets/bin/
[root@master bin]# ls /opt/kubernetes/bin/
kube-apiserver  kube-controller-manager  kubectl  kube-scheduler

等会我们要用我们的master去管理k8s集群的时候就要用到kubectl这条指令文件，那我们要把这个命令让系统所能识别，有俩种方法：
第一种建立软链接，第二种方法环境变量

• 5、编辑令牌并绑定角色kubelet-bootstrap

[root@master bin]# cd /root/k8s/
[root@master k8s]# head -c 16 /dev/urandom | od -An -t x | tr -d ''	'//随机生成序列号'
 7ea8f86b 157225fd 4b927376 5e88a3ca
[root@master k8s]# vim /opt/kubernets/cfg/token.csv
7ea8f86b157225fd4b9273765e88a3ca,kubelet-bootstrap,10001,"system:kubelet-bootstrap"
'//序列号，用户名，id，角色，这个用户是master用来管理node节点的'

• 6、开启apiserver，将数据存放在etcd集群中并检查kube状态

[root@master kubernetes]# bash apiserver.sh 20.0.0.32 https://20.0.0.32:2379,https://20.0.0.33:2379,https://20.0.0.34:2379
[root@master kubernetes]# ls /opt/kubernetes/cfg/
kube-apiserver  token.csv
[root@master kubernetes]# netstat -ntap |grep kube
[root@master kubernetes]# ps aux |grep kube

[root@master kubernetes]# vim /opt/kubernetes/cfg/kube-apiserver 进去看看内容

api server的端口是6443\ ‘//其实就是6443，https协议通信端口’

[root@master kubernetes]# netstat -ntap |grep 6443
tcp 0 0 20.0.0.32:6443 0.0.0.0:* LISTEN 12636/kube-apiserve
tcp 0 0 20.0.0.32:40686 192.168.233.131:6443 ESTABLISHED 12636/kube-apiserve
tcp 0 0 20.0.0.32:6443 192.168.233.131:40686 ESTABLISHED 12636/kube-apiserve

[root@localhost k8s]# netstat -ntap | grep 8080
tcp 0 0 127.0.0.1:8080 0.0.0.0:* LISTEN 46459/kube-apiserve

- //查看配置文件
[root@localhost k8s]# cat /opt/kubernetes/cfg/kube-apiserver 

- 7、启动scheduler服务

```c
[root@master kubernetes]# ./scheduler.sh 127.0.0.1
Created symlink from /etc/systemd/system/multi-user.target.wants/kube-scheduler.service to /usr/lib/systemd/system/kube-scheduler.service.
[root@master kubernetes]# systemctl status kube-scheduler

注释：在这边kube-apiserve用到了俩个协议，一个是http还有一个是https，http用到的端口是8080，https用到的端口是6443，也就是你可以通过http或者https去访问api server

• 8、启动scheduler服务
  vim scheduler 进入脚本看一下
  
  还有一点需要主机scheduler去跟api server沟通的时候需要用到的是8080端口

[root@localhost k8s]# ./scheduler.sh 127.0.0.1  开启
这边为什么要写127.0.0.1，目前是在mster节点，master上有三个主键，有一个apiserver，下面部署一个scheduler，scheduler调度完成之后，会联系本地的apiserver，告诉apiserver我准备在那个节点穿件资源了，请你apiserver去调度资源，apiserver数据资源记录在etcd当中。etcd也是apiserver去找etcd，所以scheduler只要单独跟apiserver通讯就可以了，那么找本地端的apiserver就可以了，也不需要找对端的apiserver
下面是提示信息：
Created symlink from /etc/systemd/system/multi-user.target.wants/kube-scheduler.service to /usr/lib/systemd/system/kube-scheduler.service.
[root@localhost k8s]# ps aux | grep kusystemctl status kube-apiserver
[root@node1 k8s]# systemctl status kube-scheduler.service

• 9.启动controller-manager
  [root@localhost k8s]# chmod +x controller-manager.sh 给controller-manager.sh一个执行权限
  vim controller-manager.sh 看一下配置文件
  

[root@localhost k8s]# ./controller-manager.sh 127.0.0.1
Created symlink from /etc/systemd/system/multi-user.target.wants/kube-controller-manager.service to /usr/lib/systemd/system/kube-controller-manager.service.
//查看master 节点状态
[root@localhost k8s]# /opt/kubernetes/bin/kubectl get cs   通过该指令检查master的状态
NAME                 STATUS    MESSAGE             ERROR
scheduler            Healthy   ok                  
controller-manager   Healthy   ok                  
etcd-2               Healthy   {"health":"true"}   
etcd-1               Healthy   {"health":"true"}   
etcd-0               Healthy   {"health":"true"}   

[root@node1 k8s]# ln -s /opt/kubernetes/bin/* /usr/local/bin/
建立一个软连接，这时候就可以tob补全了

1.7：node01节点部署

• 1、master节点上将kubectl和kube-proxy拷贝到node节点

[root@master kubernetes]# cd /root/k8s/kubernetes/server/bin/
[root@master bin]# ls
apiextensions-apiserver              kube-apiserver.docker_tag           kube-proxy
cloud-controller-manager             kube-apiserver.tar                  kube-proxy.docker_tag
cloud-controller-manager.docker_tag  kube-controller-manager             kube-proxy.tar
cloud-controller-manager.tar         kube-controller-manager.docker_tag  kube-scheduler
hyperkube                            kube-controller-manager.tar         kube-scheduler.docker_tag
kubeadm                              kubectl                             kube-scheduler.tar
kube-apiserver                       kubelet  

在master上操作把 kubelet、kube-proxy拷贝到node节点上去
[root@master bin]# scp kubelet kube-proxy root@20.0.0.33:/opt/kubernetes/bin/
[root@master bin]# scp kubelet kube-proxy root@20.0.0.34:/opt/kubernetes/bin/
- 2、node节点解压node.zip

```c
[root@node01 ~]# rz -E
rz waiting to receive.
[root@node01 ~]# ls
anaconda-ks.cfg  flannel-v0.10.0-linux-amd64.tar.gz  node.zip
[root@node01 ~]# unzip node.zip
[root@node01 ~]# ls
anaconda-ks.cfg  flannel-v0.10.0-linux-amd64.tar.gz  node.zip   公共  视频  文档  音乐
flannel.sh       initial-setup-ks.cfg 

• 3、master节点创建kubeconfig目录

[root@master bin]# cd /root/k8s/
[root@master k8s]# mkdir kubeconfig
[root@master k8s]# cd kubeconfig/

/拷贝kubeconfig.sh文件进行重命名

进入配合文件修改看下
[root@master kubeconfig]# vim kubeconfig

上面很多行都删了
##############################

APISERVER=$1
SSL_DIR=$2

# 创建kubelet bootstrapping kubeconfig 
export KUBE_APISERVER="https://$APISERVER:6443"  k8s中的apiserver用的是https协议，端口是6443

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

# 设置客户端认证参数
kubectl config set-credentials kubelet-bootstrap \
  --token=7ea8f86b157225fd4b9273765e88a3ca \	'//此token后面要写自己之前随机生成的数字
  前/opt/kubernetes/cfg/token.csv 文件中使用的的'
  
  --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=$SSL_DIR/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=kube-proxy.kubeconfig

kubectl config set-credentials kube-proxy \
  --client-certificate=$SSL_DIR/kube-proxy.pem \
  --client-key=$SSL_DIR/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
[root@master kubeconfig]# export PATH=$PATH://opt/kubernetes/bin	'//设置环境变量（可以写入到/etc/prlfile中）'

[root@node1 kubeconfig]# cat /opt/kubernetes/cfg/token.csv
02ed671c78cb103cc208c49d7c11c4db 把这数字替换进去

[root@localhost kubeconfig]# mv kubeconfig.sh kubeconfig 改名（kubeconfig定义了环境和参数，之后找master进行证书申请的时候要用到它）

• 4、在master上拷贝配置文件到node节点

[root@localhost kubeconfig]# scp bootstrap.kubeconfig kube-proxy.kubeconfig root@20.0.0.33:/opt/kubernetes/cfg/
[root@localhost kubeconfig]# scp bootstrap.kubeconfig kube-proxy.kubeconfig root@20.0.0.34:/opt/kubernetes/cfg/

• 5、在master上创建bootstrap角色并赋予权限用于连接apiserver请求签名

[root@master kubeconfig]# kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap
下面是生成的文件
clusterrolebinding.rbac.authorization.k8s.io/kubelet-bootstrap created
--clusterrole=system:node-bootstrapper 绑定的角色
--user=kubelet-bootstrap 用户名的全名称
kubelet-bootstrap 用户名
clusterrolebinding三个单词组成（群集、角色、绑定）

• 6、node01节点操作生成kubelet kubelet.config配置文件

[root@node01 ~]# vim kubelet.sh 	
'//将/opt/kubernetes路径都修改为/opt/k8s'
[root@node01 ~]# bash kubelet.sh 20.0.0.33
Created symlink from /etc/systemd/system/multi-user.target.wants/kubelet.service to /usr/lib/systemd/system/kubelet.service.


//检查kubelet服务启动
[root@localhost ~]# ps aux | grep kube
[root@node01 ~]# ls /opt/k8s/cfg/

bootstrap.kubeconfig  flanneld  kubelet  kubelet.config  kube-proxy.kubeconfig
[root@node01 ~]# systemctl status kubelet

• 7、master上检查到node01节点的请求，查看证书状态

[root@master kubeconfig]# kubectl get csr
NAME                                                   AGE   REQUESTOR           CONDITION
node-csr-xmi9gQiUIFuyZ9KAIKFIyf4JiQOuPN1tACjVzu_SH6s   71s   kubelet-bootstrap   Pending
'//pending：等待集群给该节点办法证书'

• 8.在master上操作颁发证书，再次查看证书状态

[root@localhost kubeconfig]# kubectl certificate approve node-csr-UutCKVazkKdupCRV0WTGk-4fBILJAI3NcJcF_AhBMT4 （这个是上面查询node节点的申请记录，颁发的时候要用到这个）
certificatesigningrequest.certificates.k8s.io/node-csr-NOI-9vufTLIqJgMWq4fHPNPHKbjCXlDGHptj7FqTa8A approved
//master继续查看证书状态
[root@localhost kubeconfig]# kubectl get csr
NAME                                                   AGE     REQUESTOR           CONDITION
node-csr-NOI-9vufTLIqJgMWq4fHPNPHKbjCXlDGHptj7FqTa8A   8m56s   kubelet-bootstrap   Approved,Issued（已经被允许加入群集）

9.在master查看群集节点，成功加入node01节点

[root@localhost kubeconfig]# kubectl get node
NAME              STATUS   ROLES    AGE    VERSION
20.0.0.33   Ready    <none>   118s   v1.12.3

//在node01节点操作，启动proxy服务
[root@localhost ~]# bash proxy.sh 20.0.0.33
Created symlink from /etc/systemd/system/multi-user.target.wants/kube-proxy.service to /usr/lib/systemd/system/kube-proxy.service.

[root@localhost ~]# systemctl status kube-proxy.service 
● kube-proxy.service - Kubernetes Proxy
   Loaded: loaded (/usr/lib/systemd/system/kube-proxy.service; enabled; vendor preset: disabled)
   Active: active (running) since 日 2020-02-02 00:47:29 CST; 11s ago
 Main PID: 108006 (kube-proxy)
   Memory: 7.5M
   CGroup: /system.slice/kube-proxy.service
           ‣ 108006 /opt/kubernetes/bin/kube-proxy --logtostderr=true --v=4 --hostname-override=1...

node02节点部署

• 在node01节点操作把现成的/opt/kubernetes目录复制到其他节点进行修改即可

[root@localhost ~]# scp -r /opt/kubernetes/ root@20.0.0.34:/opt/

因为节点二的操作与节点一一样，所有把 /opt/kubernetes整个目录都拷贝到节点二上，但是有点需要主机节点一的证书，是节点一找master去申请的，所以节点二用不了，需要删除证书，然后节点二去找master去申请

• 把kubelet，kube-proxy的service文件拷贝到node2中

[root@localhost ~]# scp /usr/lib/systemd/system/{kubelet,kube-proxy}.service root@20.0.0.34:/usr/lib/systemd/system/

• 首先删除复制过来的证书，等会node02会自行申请证书

[root@localhost ~]# cd /opt/kubernetes/ssl/
[root@localhost ssl]# rm -rf *
//修改配置文件kubelet  kubelet.config kube-proxy（三个配置文件）

把 kubelet文件中的地址更改成自己节点的地址

[root@localhost ssl]# cd ../cfg/
[root@localhost cfg]# vim kubelet

KUBELET_OPTS="--logtostderr=true \
--v=4 \
--hostname-override=20.0.0.34 \
--kubeconfig=/opt/kubernetes/cfg/kubelet.kubeconfig \
--bootstrap-kubeconfig=/opt/kubernetes/cfg/bootstrap.kubeconfig \
--config=/opt/kubernetes/cfg/kubelet.config \
liyuncs.com/google-containers/pause-amd64:3.0"

• 把 kubelet.config的文件中的地址改成自己节点的ip

[root@localhost cfg]# vim kubelet.config 
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: 20.0.0.34
port: 10250
readOnlyPort: 10255
cgroupDriver: cgroupfs
clusterDNS:
- 10.0.0.2
clusterDomain: cluster.local.
failSwapOn: false
authentication:
  anonymous:
    enabled: true

• 把kube-proxy地址改成自己节点的ip

[root@localhost cfg]# vim kube-proxy
KUBE_PROXY_OPTS="--logtostderr=true \
--v=4 \
--hostname-override=20.0.0.34 \
--cluster-cidr=10.0.0.0/24 \
--proxy-mode=ipvs \
--kubeconfig=/opt/kubernetes/cfg/kube-proxy.kubeconfig"

启动服务

[root@localhost cfg]# systemctl start kubelet.service 
[root@localhost cfg]# systemctl enable kubelet.service 


[root@localhost cfg]# systemctl start kube-proxy.service 
[root@localhost cfg]# systemctl enable kube-proxy.service 

• 在master上操作查看请求

[root@localhost k8s]# kubectl get csr  //master上检查到node01节点的请求，查看证书状态
NAME                                                   AGE   REQUESTOR           CONDITION
node-csr-OaH9HpIKh6AKlfdjEKm4C6aJ0UT_1YxNaa70yEAxnsU   15s   kubelet-bootstrap   Pending

• 在master上授权许可加入群集

[root@localhost k8s]# kubectl certificate approve node-csr-OaH9HpIKh6AKlfdjEKm4C6aJ0UT_1YxNaa70yEAxnsU

certificatesigningrequest.certificates.k8s.io/node-csr-OaH9HpIKh6AKlfdjEKm4C6aJ0UT_1YxNaa70yEAxnsU approved
//查看群集中的节点

• 在master上 查看群集中的节点

[root@localhost k8s]# kubectl get nodes
NAME              STATUS   ROLES    AGE   VERSION
20.0.0.33   Ready    <none>   21h   v1.12.3
20.0.0.34   Ready    <none>   37s   v1.12.3