二进制安装部署k8s

概要

常见的K8S按照部署方式

minikube

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

Kubeadmin

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

二进制安装部署

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

一、环境准备

端口介绍

主机名ip地址所需组件
master0120.0.0.55kube-apiserver、kubu-controller-manager、kube-scheduler、etcd
master0220.0.0.58kube-apiserver、kubu-controller-manager、kube-scheduler
node0120.0.0.56kubelet、kube-proxy、docker、flannel、etcd
node0220.0.0.57kubelet、kube-proxy、docker、flannel、etcd
lb0120.0.0.59nginx+keepalive
lb0220.0.0.60nginx+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地址
etcd0120.0.0.55
etcd0220.0.0.56
etcd0320.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 {acassen@firewall.locfailover@firewall.locsysadmin@firewall.loc}# 邮件发送地址notification_email_from Alexandre.Cassen@firewall.locsmtp_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

 

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/120096.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

ubuntu 22.04 设置 apt 代理 配置 清华源 add-apt-repository 代理

另一种临时代理 export http_proxyhttp://<proxy>:<port> export https_proxyhttp://<proxy>:<port> sudo -E add-apt-repository ppa:linaro-maintainers/toolchainhttps://askubuntu.com/questions/53146/how-do-i-get-add-apt-repository-to-work-…

谷歌云的利润增长才刚刚开始

来源&#xff1a;猛兽财经 作者&#xff1a;猛兽财经 总结&#xff1a; &#xff08;1&#xff09;自从Google Cloud(谷歌云&#xff09;今年开始盈利以来&#xff0c;投资者都在怀疑这种盈利能力能否持续下去。 &#xff08;2&#xff09;虽然微软Azure目前在全球的人工智能竞…

【开源】基于SpringBoot的高校学院网站的设计和实现

目录 一、摘要1.1 项目介绍1.2 项目录屏 二、功能模块2.1 学院院系模块2.2 竞赛报名模块2.3 教育教学模块2.4 招生就业模块2.5 实时信息模块 三、系统设计3.1 用例设计3.2 数据库设计3.2.1 学院院系表3.2.2 竞赛报名表3.2.3 教育教学表3.2.4 招生就业表3.2.5 实时信息表 四、系…

【Linux】进程优先级|进程并发概念|在vim中批量化注释

文章目录 前言tips——如何在vim中批量化注释进程更深度理解一、什么是进程优先级二、 为什么要有优先级三、Linux怎么设置优先级查看进程优先级的命令PRI and NI用top命令更改已存在进程的nice&#xff1a; 如何根据优先级开展调度呢&#xff1f;五、其他概念并发&#xff08;…

【数据结构练习】树和二叉树的选择题精选集锦

前言 编程想要学的好&#xff0c;刷题少不了&#xff0c;我们不仅要多刷题&#xff0c;还要刷好题&#xff01;为此我开启了一个弯道超车必做好题锦集的系列&#xff0c;此为树和二叉树的选择题精选集锦。该系列会不定期更新&#xff0c;敬请期待&#xff01; 1.已知某二叉树的…

排序整理2

一、一些概念 排序方法是“稳定的”&#xff1a;假设两个元素相等&#xff0c;若在排序后的序列中&#xff0c;排序前就在前面的元素仍在前面&#xff0c;则称所用的排序方法是稳定的&#xff1b;反之&#xff0c;若排序后两个相等元素调换相对位置&#xff0c;则称所用的排序…

cola架构:cola源码中访问者模式应用浅析

目录 1.访问者模式简介 2.cola访问者模式应用 2.1 cola被访问者类图 2.2 cola访问者类图 我们知道&#xff0c;如果一个对象结构包含很多类型的对象&#xff0c;希望对这些对象实施一些依赖其具体类型的操作&#xff0c;但又避免让这些操作“污染”这些对象的类&#xff0c…

如何使用爬虫做一个网站

​ 大家如果有兴趣做网站&#xff0c;在买了VPS&#xff0c;部署了wordpress&#xff0c;配置LNMP环境&#xff0c;折腾一番却发现内容提供是一个大问题&#xff0c;往往会在建站的大&#xff08;da&#xff09;道&#xff08;keng&#xff09;上泄气 &#xff0c;别怕&#xf…

java毕业设计基于springboot的民宿预订信息网站

运行环境 开发语言&#xff1a;Java 框架&#xff1a;springboot JDK版本&#xff1a;JDK1.8 服务器&#xff1a;tomcat7 数据库&#xff1a;mysql 数据库工具&#xff1a;Navicat11 开发软件&#xff1a;eclipse/myeclipse/idea Maven包&#xff1a;Maven 项目介绍 民宿短租…

iPhone强制重启教程来了!(已解决)

强制重启是解决苹果手机系统故障问题的首选操作&#xff0c;是通过特殊组合按键来强制关机并重新启动设备的操作。可以用来应对系统崩溃、设备无响应、白苹果、死机、闪退、莫名其妙黑屏等情况。 那么大家知道该如何将iPhone手机强制重启吗&#xff1f;iphone强制重启的方法是…

电脑上怎么录制视频教程带画笔工具?

无论你是创建教程、还是演示文稿&#xff0c;可能都希望使用带有画笔工具的录屏软件来帮助你创建吸引观众注意力的重要内容。幸运的是&#xff0c;有一些很棒的录屏软件可供你选择&#xff0c;本文就为你推荐一款带有画笔工具的最佳录屏软件&#xff0c;继续阅读查看吧&#xf…

日本IT Week秋季展丨美格智能以技术创新共建美好数字生活

10月25日至27日&#xff0c;日本国际IT消费电子展览会&#xff08;Japan IT Week 2023秋季展&#xff09;在日本千叶幕张国际展览中心举行。日本IT周是日本IT市场的标杆&#xff0c;涵盖软件开发、大数据管理、嵌入式系统、数据存储、信息安全、数据中心、云计算、物联网&#…

Wappalyzer——非常好用的前端工具

Edge浏览器https://microsoftedge.microsoft.com/addons/detail/wappalyzer-technology-p/mnbndgmknlpdjdnjfmfcdjoegcckoikn谷歌浏览器https://chrome.google.com/webstore/detail/wappalyzer-technology-pro/gppongmhjkpfnbhagpmjfkannfbllamg火狐浏览器https://addons.mozil…

【Django restframework】django跨域问题,解决PUT/PATCH/DELETE用ajax请求无法提交数据的问题

【Django restframework】django跨域问题&#xff0c;解决PUT/PATCH/DELETE用ajax请求无法提交数据的问题 1 问题描述&#xff1a; 我用restframework(ModelSerializerGenericApiView)开发了一组符合RestFul接口标准的接口&#xff0c;这意味着它将支持客户端发来的GET、POST、…

Redis实现方式开启新篇章,解决分布式环境下的资源竞争问题,提升系统稳定性

前言 分布式锁一般有三种实现方式&#xff1a; 数据库乐观锁&#xff1b;基于Redis的分布式锁&#xff1b;基于ZooKeeper的分布式锁 本篇博客将介绍第二种方式&#xff0c;基于Redis实现分布式锁。 虽然网上已经有各种介绍Redis分布式锁实现的博客&#xff0c;然而他们的实…

飞桨大模型套件:一站式体验,性能极致,生态兼容

在Wave Summit 2023深度学习开发者大会上&#xff0c;来自百度的资深研发工程师贺思俊和王冠中带来的分享主题是&#xff1a;飞桨大模型套件&#xff0c;一站式体验&#xff0c;性能极致&#xff0c;生态兼容。 大语言模型套件PaddleNLP 众所周知PaddleNLP并不是一个全新的模型…

微服务-Ribbon负载均衡

文章目录 负载均衡原理流程原理源码分析负载均衡流程 负载均衡策略饥饿加载总结 负载均衡原理 流程 原理 LoadBalanced 标记RestTemplate发起的http请求要被Ribbon进行拦截和处理 源码分析 ctrlshiftN搜索LoadBalancerInterceptor&#xff0c;进入。发现实现了ClientHttpRequ…

电脑扬声器未插入?4个方法帮你恢复声音!

“太奇怪了吧&#xff0c;我的电脑扬声器一直显示未插入&#xff0c;我使用电脑的时候也是一直都没有声音。这是为什么呢&#xff1f;我应该怎么解决这个问题呀&#xff1f;” 我们使用电脑播放音频或视频时&#xff0c;都需要用到电脑扬声器。如果扬声器无法播放声音&#xff…

导入Embassy库进行爬虫

Embassy是一个基于Lua的轻量级爬虫框架&#xff0c;可以方便地进行网页抓取和数据提取。它提供了简单易用的接口和丰富的功能&#xff0c;可以帮助开发者快速构建爬虫应用。 要使用Embassy进行爬虫&#xff0c;首先需要安装Embassy库。可以通过Lua的包管理工具luarocks来安装E…

LabVIEW应用开发——控件的使用(四)

接上文&#xff0c;这篇介绍时间控件。 LabVIEW应用开发——控件的使用&#xff08;三&#xff09; 1、时间控件Time Stamp control 在日常软件开发场景中&#xff0c;时间也是一种常用的控件&#xff0c;用于表达当前时间的显示、对下设置时间、时间同步等等场景。LabVIEW专门…