Kubernetes部署通用手册 (支持版本1.19,1.18,1.17,1.16)
操做环境
rbac 划分（HA高可用双master部署实例）
本文穿插了ha 高可用部署的实例，当前章节设计的是ha部署双master 部署html
| 内网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只是跨机器宿主机和容器通信使用node
-
docker能够只安装node上，master上能够不安装linux
-
etcd 键值对的数据库，是独立三台机器。不要复用。nginx
-
192.168.0.200是keepalived上的vipgit
自签SSL证书
k8s安装包下载
https://github.com/kubernetesgithub
部署网络说明
Kubernetes 网络架构图
Overlay Network：覆盖网络，在基础网络上叠加的一种虚拟网络技术模式，该网络中的主机经过虚拟链路链接起来。算法
VXLAN：将源数据包封装到UDP中，并使用基础网络的IP/MAC做为外层报文头进行封装，而后在以太网上传输，到达目的地后由隧道端点解封装并将数据发送给目标地址。docker
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/
将启动文件、配置文件拷贝到 节点一、节点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 注意：若是flanneld 没有启动成功，能够经过日志进行判断问题，也能够经过flanneld 命令后面加上etcd的参数进行进行启动，打印最新日志
查看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文件只是证书生成策略配置文件，主要就是设定了证书的有效时间和profile
建立 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 相关参数，参考：
- https://github.com/kubernetes-incubator/apiserver-builder/blob/master/docs/concepts/auth.md
- https://docs.bitnami.com/kubernetes/how-to/configure-autoscaling-custom-metrics/
注意：
-
--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". # 若是没有绑定集群的cluster-admin，本身建立的用户，要本身手动进行集群用户角色的绑定 kubectl get clusterrolebinbig kubectl create clusterrolebinding kubectl create clusterrolebinding cluster-admin-binding \ --clusterrole cluster-admin \ --user user-account [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
相关文章
- 1. Kubernetes部署通用手册 (支持版本1.19,1.18,1.17,1.16)
- 2. kubernetes v1.15.4 部署手册
- 3. 用Helm部署Kubernetes应用，支持多环境部署与版本回滚
- 4. Elasticsearch 5.0.0版本部署手册
- 5. MariaDB通用二进制部署手册
- 6. redis部署手册
- 7. Kubernetes对Docker的版本支持列表
- 8. fis3 部署手册
- 9. Phabricator部署手册
- 10. Rancher+K8S部署手册
- 更多相关文章...
- • Maven 自动化部署 - Maven教程
- • MySQL的版本以及版本号 - MySQL教程
- • 使用阿里云OSS+CDN部署前端页面与加速静态资源
- • Docker容器实战(八) - 漫谈 Kubernetes 的本质
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
欢迎关注本站公众号,获取更多信息
