二进制安装部署k8s

概要

常见的K8S按照部署方式

minikube

• 是一个工具，可以在本地快速运行一个单节点微型K8S，仅用于学习，预习K8S的一些特性使用。

Kubeadmin

• kubeadmin也是一个工具，特工kubeadm init 和kubedm join，用于快速部署k8s。相对简单。

二进制安装部署

• 生产首选，从官方下载发行版的二进制包，手动部署每个组件的和自签TLS证书，组成K8S集群。

一、环境准备

端口介绍

主机名	ip地址	所需组件
master01	20.0.0.55	kube-apiserver、kubu-controller-manager、kube-scheduler、etcd
master02	20.0.0.58	kube-apiserver、kubu-controller-manager、kube-scheduler
node01	20.0.0.56	kubelet、kube-proxy、docker、flannel、etcd
node02	20.0.0.57	kubelet、kube-proxy、docker、flannel、etcd
lb01	20.0.0.59	nginx+keepalive
lb02	20.0.0.60	nginx+keepalive

VIP：20.0.0.100

二、操作系统的初始化

一键部署环境脚本。

#!/bin/bash
# 关闭防火墙
systemctl stop firewalld
systemctl disable firewalld
iptables -F && iptables -t nat -F && iptables -t mangle -F && iptables -X# 关闭selinux
# 永久关闭
sed -i 's/enforcing/disabled/' /etc/selinux/config  
# 临时关闭
setenforce 0  # 关闭swap
# 临时
swapoff -a 
# 永久关闭
sed -ri 's/.*swap.*/#&/' /etc/fstab# 在master添加hosts
cat >> /etc/hosts << EOF
20.0.0.55 master01
20.0.0.56 node01
20.0.0.57 node02
EOF# 将桥接的IPv4流量传递到iptables的链
cat > /etc/sysctl.d/k8s.conf << EOF
#开启网桥模式，可将网桥的流量传递给iptables链
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
#关闭ipv6协议
net.ipv6.conf.all.disable_ipv6=1
net.ipv4.ip_forward=1
EOF# 生效
sysctl --system  # 时间同步
yum install ntpdate -y
ntpdate time.windows.comcrontab -e 
*/10 * * * * /usr/sbin/ntpdate/ntpdate time.windows.com

# 根据规划设置主机名【master01节点上操作】
hostnamectl set-hostname master01

# 根据规划设置主机名【node01节点操作】
hostnamectl set-hostname node01

# 根据规划设置主机名【node02节点操作】
hostnamectl set-hostname node02

 三、部署Etcd集群

etcd是一个分布式键值存储系统，Kubernetes使用Etcd进行数据存储，所以先准备一个Etcd进行数据存储，为了解决Etcd单点故障，应采用集群方式部署。

• 这里使用3台组组件集群，可以容忍一台机器故障，当然也可以使用5台组件集群，可以容忍2台机器故障

节点名称	ip地址
etcd01	20.0.0.55
etcd02	20.0.0.56
etcd03	20.0.0.57

 注：为了节省机器，这里与 K8s 节点机器复用。也可以独立于 k8s 集群之外部署，只要apiserver 能连接到就行。

1、 准备cfssl证书生成工具

cfssl是一个开源的证书管理工具，使用json文件生成证书，相比openssl更方便使用，找任意一台服务器操作。这边使用master01节点。

cd /usr/local/binwget 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 
#获取生成证书的工具
---------------------------------------------------------------
cfssl: 证书签发的工具命令
cfssljson: 将cfssl生成的证书(json格式)变成文件承载式证书
cfssl-certinfo: 验证证书的信息
cfssl-certinfo -cert <证书名称>   #查看证书的信息
---------------------------------------------------------------chmod +x *
#给予执行权限mv cfssl-certinfo_linux-amd64 cfssl
mv cfssljson_linux-amd64 cfssljson
mv cfssl_linux-amd64 cfssl-certinfo
#修改为简单的名称，好识别

2、生成etcd证书

自签证书颁发机构CA

mkdir -p /opt/k8s/etcd-cert
#创建存放etcd证书的目录cd /opt/k8s/etcd-cert
#############自签CA，包含证书的过期时间10年 ###############
cat > ca-config.json << EOF
{"signing": {"default": {"expiry": "87600h"},"profiles": {"www": {"expiry": "87600h","usages": ["signing","key encipherment","server auth","client auth"]}}}
}
EOFcat > ca-csr.json<< EOF 
{"CN": "etcd CA","key": {"algo": "rsa","size": 2048},"names": [{"C": "CN","L": "Beijing","ST": "Beijing"}]
}
EOF#######生成证书########################
cfssl gencert -initca ca-csr.json | cfssljson -bare ca -
##当前目录下会生成 ca.pem和ca-key.pem文件

使用自签CA签发Etcd HTTPS证书 

cat > server-csr.json <<EOF
{"CN": "etcd","hosts": ["20.0.0.55","20.0.0.56","20.0.0.57"],"key": {"algo": "rsa","size": 2048},"names": [{"C": "CN","L": "BeiJing","ST": "BeiJing"}]
}
EOF
//上述文件hosts字段中ip为所有etcd节点的集群内部通信ip，一个都不能少，为了方便后期扩容，可以多些几个预留的IP。##############生成证书####################
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server
#当前目录下会生成server.pem 和 server-key.pem

3、部署Etcd集群

因为咱们证书是在master01节点上操作的证书，先以master为例演示，然后将所有文件拷贝到node01和node02节点上操作。

创建工作目录并下载二进制包

wget https://github.com/etcd-io/etcd/releases/download/v3.4.9/etcd-v3.4.9-linux-amd64.tar.gzmkdir -p /opt/etcd/{bin,cfg,ssl}
#创建etcd集群的工作目录，【bin里面存放的是可执行文件,cfg配置文件,ssl证书】tar -zxvf etcd-v3.4.9-linux-amd64.tar.gz 
#将下载的包解压mv etcd-v3.4.9-linux-amd64/{etcd,etcdctl} /opt/etcd/bin/
#将解压后的文件中，两个执行文件剪切到，前面创建集群目录中的bin目录下

创建etcd配置文件 

cat > /opt/etcd/cfg/etcd.conf << EOF
#[Member]
ETCD_NAME="etcd-1"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://20.0.0.55:2380" 
ETCD_LISTEN_CLIENT_URLS="https://20.0.0.55:2379" 
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://20.0.0.55:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://20.0.0.55:2379"
ETCD_INITIAL_CLUSTER="etcd-1=https://20.0.0.55:2380,etcd-2=https://20.0.0.56:2380,etcd-3=https://20.0.0.57: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表示加入已有集群

systemd管理etcd

 

cat > /usr/lib/systemd/system/etcd.service << EOF
[Unit]
Description=Etcd Server
After=network.target
After=network-online.target
Wants=network-online.target
[Service]
Type=notify
EnvironmentFile=/opt/etcd/cfg/etcd.conf
ExecStart=/opt/etcd/bin/etcd \--cert-file=/opt/etcd/ssl/server.pem \--key-file=/opt/etcd/ssl/server-key.pem \--peer-cert-file=/opt/etcd/ssl/server.pem \--peer-key-file=/opt/etcd/ssl/server-key.pem \--trusted-ca-file=/opt/etcd/ssl/ca.pem \--peer-trusted-ca-file=/opt/etcd/ssl/ca.pem \--logger=zap
Restart=on-failure
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target
EOF

将刚才生成的证书拷贝到配置文件中 

cp /opt/k8s/etcd-cert/ca*pem /opt/k8s/etcd-cert/server*pem /opt/etcd/ssl/
#在存放证书的目录中将需要的证书拷贝到etcd的工作目录中去

 

将上面master01生成所有文件拷贝到node01和node02 

# 拷贝到node01
scp -r /opt/etcd/ root@20.0.0.56:/opt/
scp /usr/lib/systemd/system/etcd.service root@20.0.0.56:/usr/lib/systemd/system/

#拷贝到node02
scp -r /opt/etcd/ root@20.0.0.57:/opt/
scp /usr/lib/systemd/system/etcd.service root@20.0.0.57:/usr/lib/systemd/system/

 

然后修改node01和node02上面etcd.conf配置文件中的节点名称和ip地址

• 下面仅演示模板

vim /opt/etcd/cfg/etcd.conf
#[Member]
ETCD_NAME="etcd-1" # 修改此处，节点 2 改为 etcd-2，节点 3改为 etcd-3
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://20.0.0.56:2380" # 修改此处为当前服务器 IP ETCD_LISTEN_CLIENT_URLS="https://20.0.0.56:2379" # 修改此处为当前服务器 IP
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://20.0.0.56:2380" # 修改此处为当前服务器 IP
ETCD_ADVERTISE_CLIENT_URLS="https://20.0.0.56:2379" # 修改此处为当前服务器IP
ETCD_INITIAL_CLUSTER="etcd-1=https://20.0.0.55:2380,etcd-2=https://20.0.0.56:2380,etcd-3=https://:20.0.0.56::2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

启动并设置开机启动（3个节点都要） 

systemctl daemon-reload 
systemctl start etcd 
systemctl enable etcd

systemctl status etcd

####注意！启动的时候，需要至少启动两个，才会正常完成启动，不然会卡出。

查看集群的状态

ETCDCTL_API=3 /opt/etcd/bin/etcdctl --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --endpoints="https://20.0.0.55:2379,https://20.0.0.56:2379,https://20.0.0.57:2379" endpoint healthETCDCTL_API=3 /opt/etcd/bin/etcdctl --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --endpoints="https://20.0.0.55:2379,https://20.0.0.56:2379,https://20.0.0.57:2379" endpoint status --write-out=table####任意节点都可

 

 

四、安装docker(所有node节点)

//所有 node 节点部署docker引擎
yum install -y yum-utils device-mapper-persistent-data lvm2 yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo yum clean all && yum makecacheyum install -y docker-ce docker-ce-cli containerd.iosystemctl start docker.service
systemctl enable docker.service 

五、部署master组件

1、 准备证书

mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}
#创建k8s的工作目录

mkdir /opt/k8s/k8s-cert
#创建k8s证书、脚本存储的目录

cd /opt/k8s/k8s-cert

生成CA证书、相关组件的证书和私钥的脚本

vim /opt/k8s/k8s-cert/k8s-cert.sh#!/bin/bash
#配置证书生成策略，让 CA 软件知道颁发有什么功能的证书，生成用来签发其他组件证书的根证书
cat > ca-config.json <<EOF
{"signing": {"default": {"expiry": "87600h"},"profiles": {"kubernetes": {"expiry": "87600h","usages": ["signing","key encipherment","server auth","client auth"]}}}
}
EOF#生成CA证书和私钥（根证书和私钥）
cat > ca-csr.json <<EOF
{"CN": "kubernetes","key": {"algo": "rsa","size": 2048},"names": [{"C": "CN","L": "Beijing","ST": "Beijing","O": "k8s","OU": "System"}]
}
EOFcfssl gencert -initca ca-csr.json | cfssljson -bare ca -#-----------------------
#生成 apiserver 的证书和私钥（apiserver和其它k8s组件通信使用）
#hosts中将所有可能作为 apiserver 的 ip 添加进去，后面 keepalived 使用的 VIP 也要加入
cat > apiserver-csr.json <<EOF
{"CN": "kubernetes","hosts": ["10.0.0.1","127.0.0.1","20.0.0.55",		"20.0.0.58",		"20.0.0.100",		"20.0.0.56",		"20.0.0.57",		"kubernetes","kubernetes.default","kubernetes.default.svc","kubernetes.default.svc.cluster","kubernetes.default.svc.cluster.local"],"key": {"algo": "rsa","size": 2048},"names": [{"C": "CN","L": "BeiJing","ST": "BeiJing","O": "k8s","OU": "System"}]
}
EOF
//cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes apiserver-csr.json | cfssljson -bare apiserver#-----------------------
#生成 kubectl 连接集群的证书和私钥，具有admin权限
cat > admin-csr.json <<EOF
{"CN": "admin","hosts": [],"key": {"algo": "rsa","size": 2048},"names": [{"C": "CN","L": "BeiJing","ST": "BeiJing","O": "system:masters","OU": "System"}]
}
EOFcfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes admin-csr.json | cfssljson -bare admin#-----------------------
#生成 kube-proxy 的证书和私钥
cat > kube-proxy-csr.json <<EOF
{"CN": "system:kube-proxy","hosts": [],"key": {"algo": "rsa","size": 2048},"names": [{"C": "CN","L": "BeiJing","ST": "BeiJing","O": "k8s","OU": "System"}]
}
EOFcfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy

此处一定要检查生成的证书配置文件是否到位 

2、 准备二进制文件、token

准备二进制文件

cd /opt/k8s/k8s-certcp ca*pem apiserver*pem /opt/kubernetes/ssl/
##复制CA证书、apiserver相关证书和私钥到 kubernetes工作目录的 ssl 子目录中#然后再上传kubernetes-server-linux-amd64.tar.gz压缩包tar zxvf kubernetes-server-linux-amd64.tar.gz
#将上传的压缩包解压cd  kubernetes/server/bin
#进入到压缩后的目录中cp kube-apiserver kubectl kube-controller-manager kube-scheduler /opt/kubernetes/bin/
#将三个master的组件和一个kubectl命令拷贝到k8s的工作目录中的bin目录下ln -s /opt/kubernetes/bin/* /usr/local/bin/
#创建master组件的关键命令文件到 kubernetes工作目录的 bin 子目录中(此处需要使用绝对路径创建软连接，不然软连接找不到源文件)

准备token令牌 

#创建 bootstrap token 认证文件，apiserver 启动时会调用，然后就相当于在集群内创建了一个这个用户，接下来就可以用 RBAC 给他授权cd /opt/k8s/vim token.sh
#!/bin/bash
#获取随机数前16个字节内容，以十六进制格式输出，并删除其中空格
BOOTSTRAP_TOKEN=$(head -c 16 /dev/urandom | od -An -t x | tr -d ' ')
#生成 token.csv 文件，按照 Token序列号,用户名,UID,用户组 的格式生成
cat > /opt/kubernetes/cfg/token.csv <<EOF
${BOOTSTRAP_TOKEN},kubelet-bootstrap,10001,"system:kubelet-bootstrap"
EOFchmod +x token.sh
./token.sh

3、 启动kube-apiserver服务

准备启动脚本

vim /opt/k8s/k8s-cert/apiserver.sh#!/bin/bash
#例子: apiserver.sh 20.0.0.55 https://20.0.0.55:2379,https://20.0.0.56:2379,https://20.0.0.57:2379
#创建 kube-apiserver 启动参数配置文件
MASTER_ADDRESS=$1
ETCD_SERVERS=$2cat >/opt/kubernetes/cfg/kube-apiserver <<EOF
KUBE_APISERVER_OPTS="--logtostderr=false  \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--etcd-servers=${ETCD_SERVERS} \\
--bind-address=${MASTER_ADDRESS} \\
--secure-port=6443 \\
--advertise-address=${MASTER_ADDRESS} \\
--allow-privileged=true \\
--service-cluster-ip-range=10.0.0.0/24 \\
--enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,ResourceQuota,NodeRestriction \\
--authorization-mode=RBAC,Node \\
--enable-bootstrap-token-auth=true \\
--token-auth-file=/opt/kubernetes/cfg/token.csv \\
--service-node-port-range=30000-50000 \\
--kubelet-client-certificate=/opt/kubernetes/ssl/apiserver.pem \\
--kubelet-client-key=/opt/kubernetes/ssl/apiserver-key.pem \\
--tls-cert-file=/opt/kubernetes/ssl/apiserver.pem  \\
--tls-private-key-file=/opt/kubernetes/ssl/apiserver-key.pem \\
--client-ca-file=/opt/kubernetes/ssl/ca.pem \\
--service-account-key-file=/opt/kubernetes/ssl/ca-key.pem \\
--service-account-issuer=api \\
--service-account-signing-key-file=/opt/kubernetes/ssl/apiserver-key.pem \\
--etcd-cafile=/opt/etcd/ssl/ca.pem \\
--etcd-certfile=/opt/etcd/ssl/server.pem \\
--etcd-keyfile=/opt/etcd/ssl/server-key.pem \\
--requestheader-client-ca-file=/opt/kubernetes/ssl/ca.pem \\
--proxy-client-cert-file=/opt/kubernetes/ssl/apiserver.pem \\
--proxy-client-key-file=/opt/kubernetes/ssl/apiserver-key.pem \\
--requestheader-allowed-names=kubernetes \\
--requestheader-extra-headers-prefix=X-Remote-Extra- \\
--requestheader-group-headers=X-Remote-Group \\
--requestheader-username-headers=X-Remote-User \\
--enable-aggregator-routing=true \\
--audit-log-maxage=30 \\
--audit-log-maxbackup=3 \\
--audit-log-maxsize=100 \\
--audit-log-path=/opt/kubernetes/logs/k8s-audit.log"
EOF#--logtostderr=true：启用日志。输出日志到标准错误控制台，不输出到文件
#--v=4：日志等级。指定输出日志的级别，v=4为调试级别详细输出
#--etcd-servers：etcd集群地址。指定etcd服务器列表（格式：//ip:port），逗号分隔
#--bind-address：监听地址。指定 HTTPS 安全接口的监听地址，默认值0.0.0.0
#--secure-port：https安全端口。指定 HTTPS 安全接口的监听端口，默认值6443
#--advertise-address：集群通告地址。通过该 ip 地址向集群其他节点公布 api server 的信息，必须能够被其他节点访问
#--allow-privileged=true：启用授权。允许拥有系统特权的容器运行，默认值false
#--service-cluster-ip-range：Service虚拟IP地址段。指定 Service Cluster IP 地址段
#--enable-admission-plugins：准入控制模块。kuberneres集群的准入控制机制，各控制模块以插件的形式依次生效，集群时必须包含ServiceAccount，运行在认证（Authentication）、授权（Authorization）之后，Admission Control是权限认证链上的最后一环， 对请求API资源对象进行修改和校验
#--authorization-mode：认证授权，启用RBAC授权和节点自管理。在安全端口使用RBAC,Node授权模式，未通过授权的请求拒绝，默认值AlwaysAllow。RBAC是用户通过角色与权限进行关联的模式；Node模式（节点授权）是一种特殊用途的授权模式，专门授权由kubelet发出的API请求，在进行认证时，先通过用户名、用户分组验证是否是集群中的Node节点，只有是Node节点的请求才能使用Node模式授权
#--enable-bootstrap-token-auth：启用TLS bootstrap机制。在apiserver上启用Bootstrap Token 认证
#--token-auth-file=/opt/kubernetes/cfg/token.csv：指定bootstrap token认证文件路径
#--service-node-port-range：指定 Service  NodePort 的端口范围，默认值30000-32767
#–-kubelet-client-xxx：apiserver访问kubelet客户端证书
#--tls-xxx-file：apiserver https证书
#1.20版本必须加的参数：–-service-account-issuer，–-service-account-signing-key-file
#--etcd-xxxfile：连接Etcd集群证书
#–-audit-log-xxx：审计日志
#启动聚合层相关配置：–requestheader-client-ca-file，–proxy-client-cert-file，–proxy-client-key-file，–requestheader-allowed-names，–requestheader-extra-headers-prefix，–requestheader-group-headers，–requestheader-username-headers，–enable-aggregator-routing#创建 kube-apiserver.service 服务管理文件
cat >/usr/lib/systemd/system/kube-apiserver.service <<EOF
[Unit]
Description=Kubernetes API Server
Documentation=https://github.com/kubernetes/kubernetes[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-apiserver
ExecStart=/opt/kubernetes/bin/kube-apiserver \$KUBE_APISERVER_OPTS
Restart=on-failure[Install]
WantedBy=multi-user.target
EOFsystemctl daemon-reload
systemctl enable kube-apiserver
systemctl restart kube-apiserver

执行脚本、验证是否启动成功

cd /opt/k8s/k8s-cert
./apiserver.sh 20.0.0.55 https://20.0.0.55:2379,https://20.0.0.56:2379,https://20.0.0.57:2379
#执行创建的脚本，注意有两个位置变量，一个是确定本机的IP地址，一个是etcd集群的IP和端口ps aux | grep kube-apiserver
#检查进程是否启动成功netstat -natp | grep 6443   
#安全端口6443用于接收HTTPS请求，用于基于Token文件或客户端证书等认证

4、启动scheduler服务

准备启动脚本，脚本放在 /opt/k8s 中

vim /opt/k8s/k8s-cert/scheduler.sh#!/bin/bash
##创建 kube-scheduler 启动参数配置文件
MASTER_ADDRESS=$1cat >/opt/kubernetes/cfg/kube-scheduler <<EOF
KUBE_SCHEDULER_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--leader-elect=true \\
--kubeconfig=/opt/kubernetes/cfg/kube-scheduler.kubeconfig \\
--bind-address=127.0.0.1"
EOF#-–kubeconfig：连接 apiserver 用的配置文件，用于识别 k8s 集群
#--leader-elect=true：当该组件启动多个时，自动启动 leader 选举
#k8s中Controller-Manager和Scheduler的选主逻辑：k8s中的etcd是整个集群所有状态信息的存储，涉及数据的读写和多个etcd之间数据的同步，对数据的一致性要求严格，所以使用较复杂的 raft 算法来选择用于提交数据的主节点。而 apiserver 作为集群入口，本身是无状态的web服务器，多个 apiserver 服务之间直接负载请求并不需要做选主。Controller-Manager 和 Scheduler 作为任务类型的组件，比如 controller-manager 内置的 k8s 各种资源对象的控制器实时的 watch apiserver 获取对象最新的变化事件做期望状态和实际状态调整，调度器watch未绑定节点的pod做节点选择，显然多个这些任务同时工作是完全没有必要的，所以 controller-manager 和 scheduler 也是需要选主的，但是选主逻辑和 etcd 不一样的，这里只需要保证从多个 controller-manager 和 scheduler 之间选出一个 leader 进入工作状态即可，而无需考虑它们之间的数据一致和同步。##生成kube-scheduler证书
cd /opt/k8s/k8s-cert/
#创建证书请求文件
cat > kube-scheduler-csr.json << EOF
{"CN": "system:kube-scheduler","hosts": [],"key": {"algo": "rsa","size": 2048},"names": [{"C": "CN","L": "BeiJing","ST": "BeiJing","O": "system:masters","OU": "System"}]
}
EOF#生成证书
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-scheduler-csr.json | cfssljson -bare kube-scheduler#生成kubeconfig文件
KUBE_CONFIG="/opt/kubernetes/cfg/kube-scheduler.kubeconfig"
KUBE_APISERVER="https://$MASTER_ADDRESS:6443"kubectl config set-cluster kubernetes \--certificate-authority=/opt/kubernetes/ssl/ca.pem \--embed-certs=true \--server=${KUBE_APISERVER} \--kubeconfig=${KUBE_CONFIG}
kubectl config set-credentials kube-scheduler \--client-certificate=./kube-scheduler.pem \--client-key=./kube-scheduler-key.pem \--embed-certs=true \--kubeconfig=${KUBE_CONFIG}
kubectl config set-context default \--cluster=kubernetes \--user=kube-scheduler \--kubeconfig=${KUBE_CONFIG}
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}##创建 kube-scheduler.service 服务管理文件
cat >/usr/lib/systemd/system/kube-scheduler.service <<EOF
[Unit]
Description=Kubernetes Scheduler
Documentation=https://github.com/kubernetes/kubernetes[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-scheduler
ExecStart=/opt/kubernetes/bin/kube-scheduler \$KUBE_SCHEDULER_OPTS
Restart=on-failure[Install]
WantedBy=multi-user.target
EOFsystemctl daemon-reload
systemctl enable kube-scheduler
systemctl restart kube-scheduler

执行脚本、验证是否启动成功

cd /opt/k8s/k8s-cert

./scheduler.sh 20.0.0.55
#执行脚本,主要位置变量，需要写入本机的IP地址

ps aux | grep kube-scheduler

5、启动controller-manager 服务

准备启动脚本

vim /opt/k8s/k8s-cert/controller-manager.sh#!/bin/bash
##创建 kube-controller-manager 启动参数配置文件
MASTER_ADDRESS=$1cat >/opt/kubernetes/cfg/kube-controller-manager <<EOF
KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--leader-elect=true \\
--kubeconfig=/opt/kubernetes/cfg/kube-controller-manager.kubeconfig \\
--bind-address=127.0.0.1 \\
--allocate-node-cidrs=true \\
--cluster-cidr=10.244.0.0/16 \\
--service-cluster-ip-range=10.0.0.0/24 \\
--cluster-signing-cert-file=/opt/kubernetes/ssl/ca.pem \\
--cluster-signing-key-file=/opt/kubernetes/ssl/ca-key.pem  \\
--root-ca-file=/opt/kubernetes/ssl/ca.pem \\
--service-account-private-key-file=/opt/kubernetes/ssl/ca-key.pem \\
--cluster-signing-duration=87600h0m0s"
EOF#––leader-elect：当该组件启动多个时，自动选举（HA）
#-–kubeconfig：连接 apiserver 用的配置文件，用于识别 k8s 集群
#--cluster-cidr=10.244.0.0/16：pod资源的网段，需与pod网络插件的值设置一致。通常，Flannel网络插件的默认为10.244.0.0/16，Calico插件的默认值为192.168.0.0/16
#--cluster-signing-cert-file/–-cluster-signing-key-file：自动为kubelet颁发证书的CA，与apiserver保持一致。指定签名的CA机构根证书，用来签名为 TLS BootStrapping 创建的证书和私钥
#--root-ca-file：指定根CA证书文件路径，用来对 kube-apiserver 证书进行校验，指定该参数后，才会在 Pod 容器的 ServiceAccount 中放置该 CA 证书文件
#--experimental-cluster-signing-duration：设置为 TLS BootStrapping 签署的证书有效时间为10年，默认为1年##生成kube-controller-manager证书
cd /opt/k8s/k8s-cert/
#创建证书请求文件
cat > kube-controller-manager-csr.json << EOF
{"CN": "system:kube-controller-manager","hosts": [],"key": {"algo": "rsa","size": 2048},"names": [{"C": "CN","L": "BeiJing", "ST": "BeiJing","O": "system:masters","OU": "System"}]
}
EOF#生成证书
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-controller-manager-csr.json | cfssljson -bare kube-controller-manager#生成kubeconfig文件
KUBE_CONFIG="/opt/kubernetes/cfg/kube-controller-manager.kubeconfig"
KUBE_APISERVER="https://$1:6443"kubectl config set-cluster kubernetes \--certificate-authority=/opt/kubernetes/ssl/ca.pem \--embed-certs=true \--server=${KUBE_APISERVER} \--kubeconfig=${KUBE_CONFIG}
kubectl config set-credentials kube-controller-manager \--client-certificate=./kube-controller-manager.pem \--client-key=./kube-controller-manager-key.pem \--embed-certs=true \--kubeconfig=${KUBE_CONFIG}
kubectl config set-context default \--cluster=kubernetes \--user=kube-controller-manager \--kubeconfig=${KUBE_CONFIG}
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}##创建 kube-controller-manager.service 服务管理文件
cat >/usr/lib/systemd/system/kube-controller-manager.service <<EOF
[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/kubernetes/kubernetes[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-controller-manager
ExecStart=/opt/kubernetes/bin/kube-controller-manager \$KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure[Install]
WantedBy=multi-user.target
EOFsystemctl daemon-reload
systemctl enable kube-controller-manager
systemctl restart kube-controller-manager

 执行脚本、验证是否启动成功

cd /opt/k8s/k8s-cert

./controller-manager.sh 20.0.0.55
#启动脚本，并带上位置变量,位置变量为本机IP

ps aux | grep kube-controller-manager

 

 

6、生成kubectl连接集群的kubeconfig文件

准备执行脚本

vim /opt/k8s/k8s-cert/admin.sh#!/bin/bash
mkdir /root/.kube
KUBE_CONFIG="/root/.kube/config"
KUBE_APISERVER="https://20.0.0.55:6443"cd /opt/k8s/k8s-cert/kubectl config set-cluster kubernetes \--certificate-authority=/opt/kubernetes/ssl/ca.pem \--embed-certs=true \--server=${KUBE_APISERVER} \--kubeconfig=${KUBE_CONFIG}
kubectl config set-credentials cluster-admin \--client-certificate=./admin.pem \--client-key=./admin-key.pem \--embed-certs=true \--kubeconfig=${KUBE_CONFIG}
kubectl config set-context default \--cluster=kubernetes \--user=cluster-admin \--kubeconfig=${KUBE_CONFIG}
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}

执行脚本 

 7、通过kubectl工具查看当前集群组件状态

kubectl get cs
#查看当前集群组件状态(都为健康状态即可，如果不健康，需要排错)

kubectl version
#查看版本信息(显示客户端和服务端的版本信息)

 

六、部署worker node组件 

理论部分描述

kubelet 采用TLS Bootstapping 机制，自动完成到kube-apiserver的注册，在node节点量较大或后期自动扩容时非常有用。

master apiserver 启用TLS认证后，node节点kubelet组件想要加入集群，必须使用CA签发的有效证书才能于apiserver通信，当node节点很多时，**签署证书是一件很繁琐的事情，因此kubernetes引入了 TLS bootstraping 机制来自动颁发客户端证书，**kubelet会以一个低权限的用户自动向api server申请证书，kuubelet的证书由apiserver动态签署。
kuubelet首次启动通过加载bootstrap.kubeconfig 中的用户 Token 和 apiserver CA 证书发起首次CSR 请求， 这个Token被预先内置在apiserver节点的token.csv中，其身份为 kubelet-bootstrap 用户和system:kubelet-bootstrap 用户组，想要首次CSR请求成功（就是不会被apiserver 401拒绝），则需要先创建一个 ClusterRoleBinding，将kubelet-bootstrap用户和system:node-bootstrapper内置 ClusterRole绑定（通过kubelet get clustterroles 可查询），使其能够发起CSR认证请求。
TLS bootstrapping 时的证书实际是由 kube-controller-manager 组件来签署的，也就是说证书有效期是 kube-controller-manager 组件控制的； kube-controller-manager 组件提供了一个 --experimental-cluster-signing-duration 参数来设置签署的证书有效时间；默认为 8760h0m0s，将其改为 87600h0m0s，即 10 年后再进行 TLS bootstrapping 签署证书即可。
也就是说 kubelet 首次访问 API Server 时，是使用 token 做认证，通过后，Controller Manager 会为 kubelet 生成一个证书，以后的访问都是用证书做认证了。
 

1、在所有 node 节点上操作

mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}
#创建kubernetes的工作目录(提前创建号两个node的k8s的工作目录)

2、在master01上生成文件scp到node01

 cd /opt/k8s/k8s-cert/kubernetes/server/bin
#在master01中进入到前面解压的用压缩文件，里面有node节点需要用到的两个组件，一个kubelet、一个lube-proxy组件
scp kubelet kube-proxy root@20.0.0.56:/opt/kubernetes/bin/
scp kubelet kube-proxy root@20.0.0.57:/opt/kubernetes/bin/
#把kubelet、kube-proxy 拷贝到 node 节点的工作目录中(因为是执行文件所以拷贝到bin目录下)

 准备kubeconfig脚本文件

vim /opt/k8s/k8s-cert/kubeconfig.sh#!/bin/bash
#example: kubeconfig 20.0.0.55 /opt/k8s/k8s-cert/
#创建bootstrap.kubeconfig文件
#该文件中内置了 token.csv 中用户的 Token，以及 apiserver CA 证书；kubelet 首次启动会加载此文件，使用 apiserver CA 证书建立与 apiserver 的 TLS 通讯，使用其中的用户 Token 作为身份标识向 apiserver 发起 CSR 请求BOOTSTRAP_TOKEN=$(awk -F ',' '{print $1}' /opt/kubernetes/cfg/token.csv)
#获取token令牌APISERVER=$1   #位置变量，获取本机ip
SSL_DIR=$2     #获取存放路径。export KUBE_APISERVER="https://$APISERVER:6443"# 设置集群参数
kubectl config set-cluster kubernetes \--certificate-authority=$SSL_DIR/ca.pem \--embed-certs=true \--server=${KUBE_APISERVER} \--kubeconfig=bootstrap.kubeconfig
#--embed-certs=true：表示将ca.pem证书写入到生成的bootstrap.kubeconfig文件中# 设置客户端认证参数，kubelet 使用 bootstrap token 认证
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# 使用上下文参数生成 bootstrap.kubeconfig 文件
kubectl config use-context default --kubeconfig=bootstrap.kubeconfig#----------------------#创建kube-proxy.kubeconfig文件
# 设置集群参数
kubectl config set-cluster kubernetes \--certificate-authority=$SSL_DIR/ca.pem \--embed-certs=true \--server=${KUBE_APISERVER} \--kubeconfig=kube-proxy.kubeconfig# 设置客户端认证参数，kube-proxy 使用 TLS 证书认证
kubectl config set-credentials kube-proxy \--client-certificate=$SSL_DIR/kube-proxy.pem \--client-key=$SSL_DIR/kube-proxy-key.pem \--embed-certs=true \--kubeconfig=kube-proxy.kubeconfig# 设置上下文参数
kubectl config set-context default \--cluster=kubernetes \--user=kube-proxy \--kubeconfig=kube-proxy.kubeconfig# 使用上下文参数生成 kube-proxy.kubeconfig 文件
kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig

执行脚本文件

cd /opt/k8s/k8s-cert/chmod +x kubeconfig.sh./kubeconfig.sh 20.0.0.55 /opt/k8s/k8s-cert/
#执行脚本，需要添加两个位置变量，一个本机IP，一个生成的文件所在的目录

cd /opt/k8s/k8s-cert/scp bootstrap.kubeconfig kube-proxy.kubeconfig root@20.0.0.56:/opt/kubernetes/cfg/scp bootstrap.kubeconfig kube-proxy.kubeconfig root@20.0.0.57:/opt/kubernetes/cfg/
#把配置文件 bootstrap.kubeconfig、kube-proxy.kubeconfig 拷贝到 node 节点kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap
#RBAC授权，使用户 kubelet-bootstrap 能够有权限发起 CSR 请求证书kubectl create clusterrolebinding cluster-system-anonymous --clusterrole=cluster-admin --user=system:anonymous
#给kubectl绑定默认cluster-admin管理员集群角色，授权集群操作权限

3、node01安装kubelet服务

准备kubelet服务的执行脚本文件

mkdir /opt/k8s-cert/
#创建一个目录用来存储脚本文件vim /opt/k8s-cert/kubelet.sh#!/bin/bash
#例子:./kubelet.sh 20.0.0.56
NODE_ADDRESS=$1
DNS_SERVER_IP=${2:-"10.0.0.2"}#创建 kubelet 启动参数配置文件
cat >/opt/kubernetes/cfg/kubelet <<EOF
KUBELET_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--hostname-override=${NODE_ADDRESS} \\
--network-plugin=cni \\
--kubeconfig=/opt/kubernetes/cfg/kubelet.kubeconfig \\
--bootstrap-kubeconfig=/opt/kubernetes/cfg/bootstrap.kubeconfig \\
--config=/opt/kubernetes/cfg/kubelet.config \\
--cert-dir=/opt/kubernetes/ssl \\
--pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google-containers/pause-amd64:3.0"
EOF#--hostname-override：指定kubelet节点在集群中显示的主机名或IP地址，默认使用主机hostname；kube-proxy和kubelet的此项参数设置必须完全一致
#--network-plugin：启用CNI
#--kubeconfig：指定kubelet.kubeconfig文件位置，当前为空路径，会自动生成，用于如何连接到apiserver，里面含有kubelet证书，master授权完成后会在node节点上生成 kubelet.kubeconfig 文件
#--bootstrap-kubeconfig：指定连接 apiserver 的 bootstrap.kubeconfig 文件
#--config：指定kubelet配置文件的路径，启动kubelet时将从此文件加载其配置
#--cert-dir：指定master颁发的kubelet证书生成目录
#--pod-infra-container-image：指定Pod基础容器（Pause容器）的镜像。Pod启动的时候都会启动一个这样的容器，每个pod之间相互通信需要Pause的支持，启动Pause需要Pause基础镜像#----------------------
#创建kubelet配置文件（该文件实际上就是一个yml文件，语法非常严格，不能出现tab键，冒号后面必须要有空格，每行结尾也不能有空格）
cat >/opt/kubernetes/cfg/kubelet.config <<EOF
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: ${NODE_ADDRESS}
port: 10250
readOnlyPort: 10255
cgroupDriver: cgroupfs
clusterDNS:
- ${DNS_SERVER_IP} 
clusterDomain: cluster.local
failSwapOn: false
authentication:anonymous:enabled: true
EOF#PS：当命令行参数与此配置文件（kubelet.config）有相同的值时，就会覆盖配置文件中的该值。#----------------------
#创建 kubelet.service 服务管理文件
cat >/usr/lib/systemd/system/kubelet.service <<EOF
[Unit]
Description=Kubernetes Kubelet
After=docker.service
Requires=docker.service[Service]
EnvironmentFile=/opt/kubernetes/cfg/kubelet
ExecStart=/opt/kubernetes/bin/kubelet \$KUBELET_OPTS
Restart=on-failure
KillMode=process[Install]
WantedBy=multi-user.target
EOFsystemctl daemon-reload
systemctl enable kubelet
systemctl restart kubelet

执行脚本

cd /opt
chmod +x kubelet.sh
./kubelet.sh 20.0.0.56
#执行脚本，需要带上本机node节点的IP，此脚本，主要时出啊关键kubelet的配置文件，启动kubelet的时候，也相当于给master01发送了CSR认证请求。ps aux|grep kubelet
#查看是否启动

4、master01验证CSR请求 

kubectl get csr
#检查到 node01 节点的 kubelet 发起的 CSR 请求，Pending 表示等待集群给该节点签发证书kubectl certificate approve 【node-csr-duiobEzQ0R93HsULoS9NT9JaQylMmid_nBF3Ei3NtFE(这里面的根据实际的来)】
#通过CSR请求kubectl get csr
#Approved,Issued 表示已授权 CSR 请求并签发证书kubectl get node
#查看节点，由于网络插件还没有部署，节点会没有准备就绪，就会显示NotReady

 

5、node01安装proxy服务

准备执行脚本

for i in $(ls /usr/lib/modules/$(uname -r)/kernel/net/netfilter/ipvs|grep -o "^[^.]*");do echo $i; /sbin/modinfo -F filename $i >/dev/null 2>&1 && /sbin/modprobe $i;done
#使用一个for循环，加载ip_vs模块
-------------------------------------------------------------------------------
vim /opt/k8s-cert/proxy.sh #!/bin/bash
#例子: ./proxy.sh 20.0.0.56
NODE_ADDRESS=$1#创建 kube-proxy 启动参数配置文件
cat >/opt/kubernetes/cfg/kube-proxy <<EOF
KUBE_PROXY_OPTS="--logtostderr=true \\
--v=4 \\
--hostname-override=${NODE_ADDRESS} \\
--cluster-cidr=172.17.0.0/16 \\
--proxy-mode=ipvs \\
--kubeconfig=/opt/kubernetes/cfg/kube-proxy.kubeconfig"
EOF#--hostnameOverride: 参数值必须与 kubelet 的值一致，否则 kube-proxy 启动后会找不到该 Node，从而不会创建任何 ipvs 规则
#--cluster-cidr：指定 Pod 网络使用的聚合网段，Pod 使用的网段和 apiserver 中指定的 service 的 cluster ip 网段不是同一个网段。 kube-proxy 根据 --cluster-cidr 判断集群内部和外部流量，指定 --cluster-cidr 选项后 kube-proxy 才会对访问 Service IP 的请求做 SNAT，即来自非 Pod 网络的流量被当成外部流量，访问 Service 时需要做 SNAT。
#--proxy-mode：指定流量调度模式为ipvs模式，可添加--ipvs-scheduler选项指定ipvs调度算法（rr|wrr|lc|wlc|lblc|lblcr|dh|sh|sed|nq）
#--kubeconfig: 指定连接 apiserver 的 kubeconfig 文件	#----------------------
#创建 kube-proxy.service 服务管理文件
cat >/usr/lib/systemd/system/kube-proxy.service <<EOF
[Unit]
Description=Kubernetes Proxy
After=network.target[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-proxy
ExecStart=/opt/kubernetes/bin/kube-proxy \$KUBE_PROXY_OPTS
Restart=on-failure[Install]
WantedBy=multi-user.target
EOFsystemctl daemon-reload
systemctl enable kube-proxy
systemctl restart kube-proxy

执行脚本

cd /opt
chmod +x proxy.sh
./proxy.sh 20.0.0.56
#指向脚本，注意需要带入位置参数，为本机的IP地址，此脚本主要时配置proxy的配置文件，并启动它ps aux |grep kube-proxy

 

七、部署CNI网络组建

1、部署flannel

在node01节点上操作

cd /opt/k8s-cert
#上传 cni-plugins-linux-amd64-v0.8.6.tgz 和 flannel.tar 到 /opt 目录中
//一个为cni的各种执行文件，一个为docker镜像docker load -i flannel.tar
#将镜像上传到容器本地中mkdir  -p /opt/cni/bin
#创建一个存放cni插件的执行工作目录tar zxvf cni-plugins-linux-amd64-v0.8.6.tgz -C /opt/cni/bin
#将有压缩包解压到cni的工作目录

 

在master01节点上操作 

cd /opt/k8s/k8s-cert
#上传 kube-flannel.yml 文件到 /opt/k8s 目录中，部署 CNI 网络kubectl apply -f kube-flannel.yml 
#基于yml文件创建pod。kubectl get pods -n kube-system
#查看此pod是否正常运行(runing即可)kubectl get nodes
#再次查看node节点的状态是否为就绪状态(ready即可)
------------------------------------------------------------
此步骤如果pod一直无法变成runing状态
可以使用 kubectl delete -f kube-flannel.yml  #删除然后重新创建，大部分原因是镜像问题，需要重新下

 

2、部署calico

在master01节点上操作

cd /opt/k8s/k8s-cert/
#上传 calico.yaml 文件到 /opt/k8s 目录中，部署 CNI 网络vim calico.yaml
//修改里面定义 Pod 的网络（CALICO_IPV4POOL_CIDR），需与前面 kube-controller-manager 配置文件指定的 cluster-cidr 网段一样- name: CALICO_IPV4POOL_CIDRvalue: "10.244.0.0/16"      #(3878行)Calico 默认使用的网段为 192.168.0.0/16kubectl apply -f calico.yaml
#基于calico.yml文件创建podkubectl get pods -n kube-system
#查看状态kubectl get nodes
##等 Calico Pod 都 Running，节点也会准备就绪--------------------------------------------------------------
此步骤如果pod一直无法变成runing状态
可以使用 kubectl delete -f calico.yml  #删除然后重新创建，大部分原因是镜像问题，需要重新下

 

3、node02节点部署

• 在 node01 节点上操作

cd /opt/k8s-cert/
scp kubelet.sh proxy.sh root@20.0.0.57:/opt/
#将node01上面的两个组件的安装脚本拷贝到node02上面进行安装组件scp -r /opt/cni root@20.0.0.57:/opt/
#将node01的cni里面的插件拷贝到node02上面

• 在 node02节点上操作

cd /opt/chmod +x kubelet.sh
./kubelet.sh 20.0.0.57
#执行kubelet.sh脚本，带入本机的IP地址，进行安装kubelet组件，这里也是相当于申请了CSR认证，需要在master01上进行认证。systemctl status  kubelet
#查看kube组件是否启动

• 在master01节点上操作

kubectl get csrkubectl certificate approve 【node-csr-BbqEh6LvhD4R6YdDUeEPthkb6T_CJDcpVsmdvnh81y0】
#通过请求(两台都要通过，前面node01的已经通过)kubectl get csr

• 在node02 节点操作

for i in $(ls /usr/lib/modules/$(uname -r)/kernel/net/netfilter/ipvs|grep -o "^[^.]*");do echo $i; /sbin/modinfo -F filename $i >/dev/null 2>&1 && /sbin/modprobe $i;done
#使用for循环，加载 ipvs 模块cd /opt
chmod +x proxy.sh./proxy.sh 20.0.0.57
##使用proxy.sh脚本启动proxy服务，位置变量为本机IP地址。systemctl status kube-proxy
#查看kube-proxy组件服务是否启动

• 在master节点操作

kubectl get nodes
#查看群集中的节点状态kubectl get pods -n kube-system
#需要等里面的几个pod都启动起来，变成running(显示init可以稍微等下，或者PodInitializing，如果显示pullimage失败，可以安装上述办法重新创建)

 

八、部署core DNS

• 在所有node节点上操作

cd /opt/
#上传coredns.tar 到/opt目录上docker load -i coredns.tar
#上传到docker中

• 在master01 节点上操作

cd /opt/k8s
#上传 coredns.yaml 文件到 /opt/k8s 目录中，部署 CoreDNSkubectl apply -f coredns.yaml
#根据coredns.yml文件创建podkubectl get pods -n kube-system 
#再次查看创建的dns的pod是否运行成功kubectl run -it --rm dns-test --image=busybox:1.28.4 sh
#运行一个容器，镜像为busybos：1.28.4，并且直接运行(网不好就多等会)，然后解析kubernetes成功即可

 

九、master02 节点部署

需要安装步骤一的系统初始化脚本，并且更名为master02

• 在master01上操作

scp -r /opt/etcd/ root@20.0.0.58:/opt/
#拷贝matser01上面的etcd证书到master02上面scp -r /opt/kubernetes/ root@20.0.0.58:/opt
#拷贝master01上的整个kubernetes工作目录scp -r /root/.kube root@20.0.0.58:/root
#拷贝运行master01上面的.kube运行文件kubect命令文件到master02上面scp /usr/lib/systemd/system/{kube-apiserver,kube-controller-manager,kube-scheduler}.service root@20.0.0.58:/usr/lib/systemd/system/
#从 master01 节点上拷贝三大组件到master02上面

master02节点查看 

master02节点修改 

vim /opt/kubernetes/cfg/kube-apiserverKUBE_APISERVER_OPTS="--logtostderr=true \
--v=4 \
--etcd-servers=https://20.0.0.55:2379,https://20.0.0.56:2379,https://20.0.0.57:2379 \
--bind-address=20.0.0.58 \				#修改
--secure-port=6443 \
--advertise-address=20.0.0.58 \			#修改
......###修改apiserver组件指向的IP地址，修改监听地址为本即IP地址

systemctl start kube-apiserver.service
systemctl enable kube-apiserver.service
systemctl start kube-controller-manager.service
systemctl enable kube-controller-manager.service
systemctl start kube-scheduler.service
systemctl enable kube-scheduler.service
#在 master02 节点上启动各服务并设置开机自启ln -s /opt/kubernetes/bin/* /usr/local/bin/kubectl get nodes
kubectl get nodes -o wide			#-o=wide：输出额外信息；对于Pod，将输出Pod所在的Node名##此时在master02节点查到的node节点状态仅是从etcd查询到的信息，而此时node节点实际上并未与master02节点建立通信连接，因此需要使用一个VIP把node节点与master节点都关联起来

 至此，以上的两主两从，已安装完成，下面将配置负载均衡，通过nginx将负载均衡到两台master主机上。

十、负载均衡部署（lb01、lb02）

1、部署nginx服务、配置四层负载均衡

systemctl stop firewalld
systemctl disable firewalld
setenforce 0
#关闭防火墙cat > /etc/yum.repos.d/nginx.repo << 'EOF'
[nginx]
name=nginx repo
baseurl=http://nginx.org/packages/centos/7/$basearch/
gpgcheck=0
EOF
#配置nginx的官方在线源，配置本地nginx的yum源yum -y install nginx
#下载nginx-----#修改nginx配置文件，配置四层反向代理负载均衡，指定k8s群集2台master的节点ip和6443端口-----
vim /etc/nginx/nginx.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 20.0.0.55:6443;server 20.0.0.58:6443;}server {listen 6443;proxy_pass k8s-apiserver;}
}http {
......
---------------------------------------------------------------------
nginx -t
#检查语法systemctl start nginx.service 
systemctl enable nginx.service
netstat -natp |grep nginx
#启动nginx服务，查看自己的监听6443端口

2、部署keepalived服务 

yum install keepalived -y
#下载keepalived服务#修改配置文件
vim /etc/keepalived/keepalived.conf
! Configuration File for keepalivedglobal_defs {# 接收邮件地址notification_email {[e-mail]@[e-mail]}# 邮件发送地址notification_email_from [e-mail]_server 127.0.0.1smtp_connect_timeout 30router_id NGINX_MASTER	#lb01节点的为 NGINX_MASTER，lb02节点的为 NGINX_BACKUP
}#添加一个周期性执行的脚本
vrrp_script check_nginx {script "/etc/nginx/check_nginx.sh"	#指定检查nginx存活的脚本路径
}vrrp_instance VI_1 {state MASTER			#lb01节点的为 MASTER，lb02节点的为 BACKUPinterface ens33			#指定网卡名称 ens33virtual_router_id 51	#指定vrid，两个节点要一致priority 100			#lb01节点的为 100，lb02节点的为 90advert_int 1authentication {auth_type PASSauth_pass 1111}virtual_ipaddress {20.0.0.100/24	#指定 VIP}track_script {check_nginx			#指定vrrp_script配置的脚本}
}

配置lb01的配置文件

配置lb02 的 keepailved文件

启动keepalived服务 

#创建nginx状态检查脚本
vim /etc/nginx/check_nginx.sh
#!/bin/bash
#egrep -cv "grep|$$" 用于过滤掉包含grep 或者 $$ 表示的当前Shell进程ID，即脚本运行的当前进程ID号
count=$(ps -ef | grep nginx | egrep -cv "grep|$$")if [ "$count" -eq 0 ];thensystemctl stop keepalived
fichmod +x /etc/nginx/check_nginx.shsystemctl start keepalived
systemctl enable keepalived
#启动keepalived服务（一定要先启动了nginx服务，再启动keepalived服务）
//这里使用ip a 查看VIP是否已生成

lb01的启动

lb02的keepalived服务启动 

修改node节点上的bootstrap.kubeconfig,kubelet.kubeconfig配置文件为VIP 

cd /opt/kubernetes/cfg/
vim bootstrap.kubeconfig 
server: https://20.0.0.100：6443vim kubelet.kubeconfig
server: https://20.0.0.100:6443vim kube-proxy.kubeconfig
server: https://20.0.0.100:6443systemctl restart kubelet.service 
systemctl restart kube-proxy.service
#重启kubelet和kube-proxy服务

 

在 lb01 上查看 nginx 和 node 、 master 节点的连接状态

netstat -natp |grep nginx

 

在master01节点操作

kubectl run nginx --image=nginx
#测试创建podkubectl get pods
#查看pod的状态信息
--------------------------------------
kubectl get pods
NAME                    READY   STATUS              RESTARTS   AGE
nginx-dbddb74b8-nf9sk   0/1     ContainerCreating   0          33s   #正在创建中kubectl get pods
NAME                    READY   STATUS    RESTARTS   AGE
nginx-dbddb74b8-nf9sk   1/1     Running   0          80s  			#创建完成，运行中
---------------------------------kubectl get pods -o wide
#READY为1/1，表示这个Pod中有1个容器,-o wide 表示查看详细信息，主要是可以查看到IP地址
#显示的IP地址，就是为pod 的IP地址

在任意node节点上执行验证操作

curl 10.244.33.197

#在对应网段的node节点上操作，可以直接使用浏览器或者curl命令访问

 

在master01节点上查看nginx日志 

十一、部署Dashboard(master01) 

Dashboard 介绍
仪表板是基于Web的Kubernetes用户界面。您可以使用仪表板将容器化应用程序部署到Kubernetes集群，对容器化应用程序进行故障排除，并管理集群本身及其伴随资源。您可以使用仪表板来概述群集上运行的应用程序，以及创建或修改单个Kubernetes资源（例如deployment，job，daemonset等）。例如，您可以使用部署向导扩展部署，启动滚动更新，重新启动Pod或部署新应用程序。仪表板还提供有关群集中Kubernetes资源状态以及可能发生的任何错误的信息。
 

上传文件并进行暴露端口

cd /opt/k8s/k8s-cert/
#上传 recommended.yaml 文件到 /opt/k8s 目录中------------------------------------------------------------
vim recommended.yaml
#默认Dashboard只能集群内部访问，修改Service为NodePort类型，暴露到外部：
kind: Service
apiVersion: v1
metadata:labels:k8s-app: kubernetes-dashboardname: kubernetes-dashboardnamespace: kubernetes-dashboard
spec:ports:- port: 443targetPort: 8443nodePort: 30001     #添加type: NodePort          #添加selector:k8s-app: kubernetes-dashboard
------------------------------------------------------------------kubectl apply -f recommended.yaml
#基于yml文件创建podkubectl get pods -n kubernetes-dashboard
#查看是否创建成功

 

创建service account并绑定默认cluster-admin管理员集群角色 

kubectl create serviceaccount dashboard-admin -n kube-system
#创建资源，并指定账号kubectl create clusterrolebinding dashboard-admin --clusterrole=cluster-admin --serviceaccount=kube-system:dashboard-admin
#kubectl describe secrets -n kube-system $(kubectl -n kube-system get secret | awk '/dashboard-admin/{print $1}')
#查看信息
eyJhbGciOiJSUzI1NiIsImtpZCI6ImRyOUpLNnZNaUxfbHAySGpiV0xKdHlZaTJGU192V3VUX2RieXdqT1RRb2MifQ.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJrdWJlLXN5c3RlbSIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VjcmV0Lm5hbWUiOiJkYXNoYm9hcmQtYWRtaW4tdG9rZW4tOWNodjciLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlcnZpY2UtYWNjb3VudC5uYW1lIjoiZGFzaGJvYXJkLWFkbWluIiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZXJ2aWNlLWFjY291bnQudWlkIjoiZTE2ZWIwYzUtMDg2NC00MGIyLTg4MzAtZjAyODYxOTQxMTFiIiwic3ViIjoic3lzdGVtOnNlcnZpY2VhY2NvdW50Omt1YmUtc3lzdGVtOmRhc2hib2FyZC1hZG1pbiJ9.HV7CM-5NFqzz99250Pou_qXrpDdzNbA7kUmYnl3gdcXHSLeUpAQXbrEH_JEkS5LTwp62Q_QCZlrYkO_wKXIzUpQI9_3Th3zZUec76SWlIVXf6rqEh2VZj45jdYXVqpZzwhI-FJ6NQ5H5sIxOQlyP1wKqwtb8XNB6Oj2uQsWEHuJFnKfm7wzF5n8-4WKQ0RVHWPcrCkScgY_POYv1utK55kVgrPk2dFH97eUDOuOv7ZaqiYJqupOluRpoVAqeks0z0i4BZNoZL_nxvuRlN-KBvuTkeWrr5Fb3WyI-BUZNurYFuIDhM6vNjSHuDyTQL2LQbkK2DRPepBFbniZWjMiu-w

 

最后网页进行登录 

https://NodeIP:30001

例子：https://20.0.0.56:30001