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

操作环境

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安装包下载

https://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 http://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 https://get.daocloud.io/daotools/set_mirror.sh | sh -s http://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 https://pkg.cfssl.org/R1.2/cfssl_linux-amd64
wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64
wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64

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="https://192.168.0.10:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.0.10:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.0.10:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.0.10:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.0.10:2380,etcd02=https://192.168.0.12:2380,etcd03=https://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},http://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 www@192.168.0.12:/data/soft/etcd/ssl/
scp -P 12525 etcd-ca.pem etcd-server.pem  etcd-server-key.pem www@192.168.0.4:/data/soft/etcd/ssl/

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

cd /data/soft/ 

scp -P 12525 -r etcd www@192.168.0.12:/data/soft
scp -P 12525 -r etcd www@192.168.0.4:/data/soft

scp -P 12525 -r /usr/lib/systemd/system/etcd.service  www@192.168.0.12:/usr/lib/systemd/system/etcd.service
scp -P 12525 -r /usr/lib/systemd/system/etcd.service  www@192.168.0.4:/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="https://192.168.0.12:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.0.12:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.0.12:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.0.12:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.0.10:2380,etcd02=https://192.168.0.12:2380,etcd03=https://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="https://192.168.0.4:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.0.4:2379"
 

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.0.4:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.0.4:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.0.10:2380,etcd02=https://192.168.0.12:2380,etcd03=https://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="https://192.168.0.10:2379,\
https://192.168.0.12:2379,\
https://192.168.0.4:2379" cluster-health
member b8fffb7f5b2f26e is healthy: got healthy result from https://192.168.0.12:2379
member 5ac283d796e472ba is healthy: got healthy result from https://192.168.0.4:2379
member a569e0ee3b34eefa is healthy: got healthy result from https://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集群
https://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 https://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":["https://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="https://192.168.0.10:2379,https://192.168.0.12:2379,https://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=https://192.168.0.10:2379,https://192.168.0.12:2379,https://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=https://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 www@192.168.0.7:/data/soft/
scp -P 12525 -r kubernetes www@192.168.0.8:/data/soft/
scp -P 12525 /data/soft/kubernetes/cfg/flanneld www@192.168.0.7:/data/soft/kubernetes/cfg/flanneld
scp -P 12525 /data/soft/kubernetes/cfg/flanneld www@192.168.0.8:/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=https://192.168.0.10:2379,https://192.168.0.12:2379,https://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=https://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=https://192.168.0.10:2379,https://192.168.0.12:2379,https://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=https://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=https://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 http://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 https://get.daocloud.io/daotools/set_mirror.sh | sh -s http://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 www@192.168.0.7:/data/soft/kubernetes/bin/
scp -P 12525 -r kubelet kube-proxy www@192.168.0.8:/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="https://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 www@192.168.0.7:/data/soft/kubernetes/cfg/
scp -P 12525 -r bootstrap.kubeconfig kube-proxy.kubeconfig www@192.168.0.8:/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 www@192.168.0.7:/data/soft/kubernetes/cfg/
scp -P 12525 -r kubelet.config   kubelet www@192.168.0.8:/data/soft/kubernetes/cfg/
scp -P 12525 -r /usr/lib/systemd/system/kubelet.service www@192.168.0.7:/usr/lib/systemd/system/kubelet.service
scp -P 12525 -r /usr/lib/systemd/system/kubelet.service www@192.168.0.8:/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 www@192.168.0.7:/data/soft/kubernetes/cfg/
scp -P 12525 -r kube-proxy www@192.168.0.8:/data/soft/kubernetes/cfg/
scp -P 12525 -r /usr/lib/systemd/system/kube-proxy.service www@192.168.0.7:/usr/lib/systemd/system/kube-proxy.service
scp -P 12525 -r /usr/lib/systemd/system/kube-proxy.service www@192.168.0.8:/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，打开浏览器输入：http://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=http://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 { 
     acassen@firewall.loc 
     failover@firewall.loc 
     sysadmin@firewall.loc 
   } 
   notification_email_from Alexandre.Cassen@firewall.loc  
   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 { 
     acassen@firewall.loc 
     failover@firewall.loc 
     sysadmin@firewall.loc 
   } 
   notification_email_from Alexandre.Cassen@firewall.loc  
   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 www@192.168.0.12:/data/soft/

scp -P 12525 -r /usr/lib/systemd/system/{kube-apiserver,kube-controller-manager,kube-scheduler}.service www@192.168.0.12:/usr/lib/systemd/system/

scp -P 12525 -r /usr/bin/kubectl root@192.168.0.12:/usr/bin/

scp -P 12525 -r /data/soft/etcd/ssl/ www@192.168.0.12:/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=https://192.168.0.10:2379,https://192.168.0.12:2379,https://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=https://192.168.0.10:2379,https://192.168.0.12:2379,https://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: https://192.168.0.10:6443
flanneld:2:FLANNEL_OPTIONS="--etcd-endpoints=https://192.168.0.10:2379,https://192.168.0.12:2379,https://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: https://192.168.0.10:6443
kube-proxy.kubeconfig:5:    server: https://192.168.0.10:6443

其中要修改的 bootstrap.kubeconfig 第五行，kubelet.kubeconfig第五行，kube-proxy.kubeconfig第五行。修改后如下：
[root@k8s-node01 cfg]# grep -irn 200 *
bootstrap.kubeconfig:5:    server: https://192.168.0.200:6443
kubelet.kubeconfig:5:    server: https://192.168.0.200:6443
kube-proxy.kubeconfig:5:    server: https://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: https://192.168.0.10:6443
flanneld:2:FLANNEL_OPTIONS="--etcd-endpoints=https://192.168.0.10:2379,https://192.168.0.12:2379,https://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: https://192.168.0.10:6443
kube-proxy.kubeconfig:5:    server: https://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: https://192.168.0.200:6443
kubelet.kubeconfig:5:    server: https://192.168.0.200:6443
kube-proxy.kubeconfig:5:    server: https://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=https://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 root@192.168.0.7:/usr/bin/
root@192.168.0.7's password: 
kubectl                                                                                         100%   37MB  68.2MB/s   00:00    
[root@k8s-master01 k8s-cert]# scp  config root@192.168.0.7:/root
root@192.168.0.7'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=https://192.168.0.10:2379,https://192.168.0.12:2379,https://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

来源：oschina

链接：https://my.oschina.net/u/4364212/blog/4359594

标签

Kube

etcd

Docker

flannel

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

操作环境

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

自签SSL证书

k8s安装包下载

部署网络说明

Kubernetes 网络架构图

Flannel网络架构图

Kubernetes基本工作流程

Kubernetes单节点安装及配置

初始化环境

设置关闭防火墙及SELINUX

关闭Swap

设置Docker所需参数（未做）

在node节点上安装 Docker

创建安装目录

安装及配置CFSSL

部署ETCD

创建etcd集群认证证书

ssh-key认证

解压etcd安装文件

创建 etcd的 etcd.service文件

拷贝证书文件

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

192.168.0.12 node01配置文件修改

192.168.0.4 node02配置文件修改

启动ETCD服务

验证ETCD集群是否正常运行

常见etcd配置问题

部署Flannel网络

网络模型实现

部署Flannel 网络

解压安装

配置Flannel

查看flannel网络是否生效

部署 master 节点

创建 Kubernetes Apiserver CA 证书

创建 Kubernetes Proxy 证书

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

部署 kube-apiserver 组件

部署kube-scheduler

部署kube-controller-manager

查看master集群状态

部署node 节点

部署 kubelet 组件

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

node节点配置kubelet

master节点approve kubelet CSR 请求处理

Node上部署 kube-proxy 组件

查看集群状态(master)

运行一个Nginx 测试示例

Kubernets Apiserver HA SLB

准备环境

部署nginx和keepalived

nginx 配置

Keepalived配置

Kubernets Master02 部署

准备环境

拷贝master01 配置文件

启动apiserver,scheduler,controller-manager组件

测试Master02配置

Node节点配置Apiserver负载地址

配置node节点

node1修改配置

node2修改配置

扩展配置

NODE节点执行kubectl命令

常见问题

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

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

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

查看pod日志报错

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