美叶设计网站,dw做了网站还可以做淘宝详情吗,图库素材网站,虚拟网站源码概要
常见的K8S按照部署方式
minikube
是一个工具#xff0c;可以在本地快速运行一个单节点微型K8S#xff0c;仅用于学习#xff0c;预习K8S的一些特性使用。
Kubeadmin
kubeadmin也是一个工具#xff0c;特工kubeadm init 和kubedm join#xff0c;用于快速部署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、etcdmaster0220.0.0.58kube-apiserver、kubu-controller-manager、kube-schedulernode0120.0.0.56kubelet、kube-proxy、docker、flannel、etcdnode0220.0.0.57kubelet、kube-proxy、docker、flannel、etcdlb0120.0.0.59nginxkeepalivelb0220.0.0.60nginxkeepalive
VIP20.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_ipv61
net.ipv4.ip_forward1
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.55etcd0220.0.0.56etcd0320.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 -caca.pem -ca-keyca-key.pem -configca-config.json -profilewww server-csr.json | cfssljson -bare server
#当前目录下会生成server.pem 和 server-key.pem3、部署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_NAMEetcd-1
ETCD_DATA_DIR/var/lib/etcd/default.etcd
ETCD_LISTEN_PEER_URLShttps://20.0.0.55:2380
ETCD_LISTEN_CLIENT_URLShttps://20.0.0.55:2379
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLShttps://20.0.0.55:2380
ETCD_ADVERTISE_CLIENT_URLShttps://20.0.0.55:2379
ETCD_INITIAL_CLUSTERetcd-1https://20.0.0.55:2380,etcd-2https://20.0.0.56:2380,etcd-3https://20.0.0.57:2380
ETCD_INITIAL_CLUSTER_TOKENetcd-cluster
ETCD_INITIAL_CLUSTER_STATEnew
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]
DescriptionEtcd Server
Afternetwork.target
Afternetwork-online.target
Wantsnetwork-online.target
[Service]
Typenotify
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 \--loggerzap
Restarton-failure
LimitNOFILE65536
[Install]
WantedBymulti-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/ root20.0.0.56:/opt/ scp /usr/lib/systemd/system/etcd.service root20.0.0.56:/usr/lib/systemd/system/ #拷贝到node02 scp -r /opt/etcd/ root20.0.0.57:/opt/ scp /usr/lib/systemd/system/etcd.service root20.0.0.57:/usr/lib/systemd/system/ 然后修改node01和node02上面etcd.conf配置文件中的节点名称和ip地址
下面仅演示模板
vim /opt/etcd/cfg/etcd.conf
#[Member]
ETCD_NAMEetcd-1 # 修改此处节点 2 改为 etcd-2节点 3改为 etcd-3
ETCD_DATA_DIR/var/lib/etcd/default.etcd
ETCD_LISTEN_PEER_URLShttps://20.0.0.56:2380 # 修改此处为当前服务器 IP ETCD_LISTEN_CLIENT_URLShttps://20.0.0.56:2379 # 修改此处为当前服务器 IP
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLShttps://20.0.0.56:2380 # 修改此处为当前服务器 IP
ETCD_ADVERTISE_CLIENT_URLShttps://20.0.0.56:2379 # 修改此处为当前服务器IP
ETCD_INITIAL_CLUSTERetcd-1https://20.0.0.55:2380,etcd-2https://20.0.0.56:2380,etcd-3https://:20.0.0.56::2380
ETCD_INITIAL_CLUSTER_TOKENetcd-cluster
ETCD_INITIAL_CLUSTER_STATEnew 启动并设置开机启动3个节点都要 systemctl daemon-reload systemctl start etcd systemctl enable etcd systemctl status etcd ####注意启动的时候需要至少启动两个才会正常完成启动不然会卡出。 查看集群的状态
ETCDCTL_API3 /opt/etcd/bin/etcdctl --cacert/opt/etcd/ssl/ca.pem --cert/opt/etcd/ssl/server.pem --key/opt/etcd/ssl/server-key.pem --endpointshttps://20.0.0.55:2379,https://20.0.0.56:2379,https://20.0.0.57:2379 endpoint healthETCDCTL_API3 /opt/etcd/bin/etcdctl --cacert/opt/etcd/ssl/ca.pem --cert/opt/etcd/ssl/server.pem --key/opt/etcd/ssl/server-key.pem --endpointshttps://20.0.0.55:2379,https://20.0.0.56:2379,https://20.0.0.57:2379 endpoint status --write-outtable####任意节点都可四、安装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 -caca.pem -ca-keyca-key.pem -configca-config.json -profilekubernetes 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 -caca.pem -ca-keyca-key.pem -configca-config.json -profilekubernetes 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 -caca.pem -ca-keyca-key.pem -configca-config.json -profilekubernetes 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.sh3、 启动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--logtostderrfalse \\
--v2 \\
--log-dir/opt/kubernetes/logs \\
--etcd-servers${ETCD_SERVERS} \\
--bind-address${MASTER_ADDRESS} \\
--secure-port6443 \\
--advertise-address${MASTER_ADDRESS} \\
--allow-privilegedtrue \\
--service-cluster-ip-range10.0.0.0/24 \\
--enable-admission-pluginsNamespaceLifecycle,LimitRanger,ServiceAccount,ResourceQuota,NodeRestriction \\
--authorization-modeRBAC,Node \\
--enable-bootstrap-token-authtrue \\
--token-auth-file/opt/kubernetes/cfg/token.csv \\
--service-node-port-range30000-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-issuerapi \\
--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-nameskubernetes \\
--requestheader-extra-headers-prefixX-Remote-Extra- \\
--requestheader-group-headersX-Remote-Group \\
--requestheader-username-headersX-Remote-User \\
--enable-aggregator-routingtrue \\
--audit-log-maxage30 \\
--audit-log-maxbackup3 \\
--audit-log-maxsize100 \\
--audit-log-path/opt/kubernetes/logs/k8s-audit.log
EOF#--logtostderrtrue启用日志。输出日志到标准错误控制台不输出到文件
#--v4日志等级。指定输出日志的级别v4为调试级别详细输出
#--etcd-serversetcd集群地址。指定etcd服务器列表格式//ip:port逗号分隔
#--bind-address监听地址。指定 HTTPS 安全接口的监听地址默认值0.0.0.0
#--secure-porthttps安全端口。指定 HTTPS 安全接口的监听端口默认值6443
#--advertise-address集群通告地址。通过该 ip 地址向集群其他节点公布 api server 的信息必须能够被其他节点访问
#--allow-privilegedtrue启用授权。允许拥有系统特权的容器运行默认值false
#--service-cluster-ip-rangeService虚拟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-xxxapiserver访问kubelet客户端证书
#--tls-xxx-fileapiserver 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]
DescriptionKubernetes API Server
Documentationhttps://github.com/kubernetes/kubernetes[Service]
EnvironmentFile-/opt/kubernetes/cfg/kube-apiserver
ExecStart/opt/kubernetes/bin/kube-apiserver \$KUBE_APISERVER_OPTS
Restarton-failure[Install]
WantedBymulti-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--logtostderrfalse \\
--v2 \\
--log-dir/opt/kubernetes/logs \\
--leader-electtrue \\
--kubeconfig/opt/kubernetes/cfg/kube-scheduler.kubeconfig \\
--bind-address127.0.0.1
EOF#-–kubeconfig连接 apiserver 用的配置文件用于识别 k8s 集群
#--leader-electtrue当该组件启动多个时自动启动 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 -caca.pem -ca-keyca-key.pem -configca-config.json -profilekubernetes kube-scheduler-csr.json | cfssljson -bare kube-scheduler#生成kubeconfig文件
KUBE_CONFIG/opt/kubernetes/cfg/kube-scheduler.kubeconfig
KUBE_APISERVERhttps://$MASTER_ADDRESS:6443kubectl config set-cluster kubernetes \--certificate-authority/opt/kubernetes/ssl/ca.pem \--embed-certstrue \--server${KUBE_APISERVER} \--kubeconfig${KUBE_CONFIG}
kubectl config set-credentials kube-scheduler \--client-certificate./kube-scheduler.pem \--client-key./kube-scheduler-key.pem \--embed-certstrue \--kubeconfig${KUBE_CONFIG}
kubectl config set-context default \--clusterkubernetes \--userkube-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]
DescriptionKubernetes Scheduler
Documentationhttps://github.com/kubernetes/kubernetes[Service]
EnvironmentFile-/opt/kubernetes/cfg/kube-scheduler
ExecStart/opt/kubernetes/bin/kube-scheduler \$KUBE_SCHEDULER_OPTS
Restarton-failure[Install]
WantedBymulti-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--logtostderrfalse \\
--v2 \\
--log-dir/opt/kubernetes/logs \\
--leader-electtrue \\
--kubeconfig/opt/kubernetes/cfg/kube-controller-manager.kubeconfig \\
--bind-address127.0.0.1 \\
--allocate-node-cidrstrue \\
--cluster-cidr10.244.0.0/16 \\
--service-cluster-ip-range10.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-duration87600h0m0s
EOF#––leader-elect当该组件启动多个时自动选举HA
#-–kubeconfig连接 apiserver 用的配置文件用于识别 k8s 集群
#--cluster-cidr10.244.0.0/16pod资源的网段需与pod网络插件的值设置一致。通常Flannel网络插件的默认为10.244.0.0/16Calico插件的默认值为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 -caca.pem -ca-keyca-key.pem -configca-config.json -profilekubernetes kube-controller-manager-csr.json | cfssljson -bare kube-controller-manager#生成kubeconfig文件
KUBE_CONFIG/opt/kubernetes/cfg/kube-controller-manager.kubeconfig
KUBE_APISERVERhttps://$1:6443kubectl config set-cluster kubernetes \--certificate-authority/opt/kubernetes/ssl/ca.pem \--embed-certstrue \--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-certstrue \--kubeconfig${KUBE_CONFIG}
kubectl config set-context default \--clusterkubernetes \--userkube-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]
DescriptionKubernetes Controller Manager
Documentationhttps://github.com/kubernetes/kubernetes[Service]
EnvironmentFile-/opt/kubernetes/cfg/kube-controller-manager
ExecStart/opt/kubernetes/bin/kube-controller-manager \$KUBE_CONTROLLER_MANAGER_OPTS
Restarton-failure[Install]
WantedBymulti-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_APISERVERhttps://20.0.0.55:6443cd /opt/k8s/k8s-cert/kubectl config set-cluster kubernetes \--certificate-authority/opt/kubernetes/ssl/ca.pem \--embed-certstrue \--server${KUBE_APISERVER} \--kubeconfig${KUBE_CONFIG}
kubectl config set-credentials cluster-admin \--client-certificate./admin.pem \--client-key./admin-key.pem \--embed-certstrue \--kubeconfig${KUBE_CONFIG}
kubectl config set-context default \--clusterkubernetes \--usercluster-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 root20.0.0.56:/opt/kubernetes/bin/
scp kubelet kube-proxy root20.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_APISERVERhttps://$APISERVER:6443# 设置集群参数
kubectl config set-cluster kubernetes \--certificate-authority$SSL_DIR/ca.pem \--embed-certstrue \--server${KUBE_APISERVER} \--kubeconfigbootstrap.kubeconfig
#--embed-certstrue表示将ca.pem证书写入到生成的bootstrap.kubeconfig文件中# 设置客户端认证参数kubelet 使用 bootstrap token 认证
kubectl config set-credentials kubelet-bootstrap \--token${BOOTSTRAP_TOKEN} \--kubeconfigbootstrap.kubeconfig# 设置上下文参数
kubectl config set-context default \--clusterkubernetes \--userkubelet-bootstrap \--kubeconfigbootstrap.kubeconfig# 使用上下文参数生成 bootstrap.kubeconfig 文件
kubectl config use-context default --kubeconfigbootstrap.kubeconfig#----------------------#创建kube-proxy.kubeconfig文件
# 设置集群参数
kubectl config set-cluster kubernetes \--certificate-authority$SSL_DIR/ca.pem \--embed-certstrue \--server${KUBE_APISERVER} \--kubeconfigkube-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-certstrue \--kubeconfigkube-proxy.kubeconfig# 设置上下文参数
kubectl config set-context default \--clusterkubernetes \--userkube-proxy \--kubeconfigkube-proxy.kubeconfig# 使用上下文参数生成 kube-proxy.kubeconfig 文件
kubectl config use-context default --kubeconfigkube-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 root20.0.0.56:/opt/kubernetes/cfg/scp bootstrap.kubeconfig kube-proxy.kubeconfig root20.0.0.57:/opt/kubernetes/cfg/
#把配置文件 bootstrap.kubeconfig、kube-proxy.kubeconfig 拷贝到 node 节点kubectl create clusterrolebinding kubelet-bootstrap --clusterrolesystem:node-bootstrapper --userkubelet-bootstrap
#RBAC授权使用户 kubelet-bootstrap 能够有权限发起 CSR 请求证书kubectl create clusterrolebinding cluster-system-anonymous --clusterrolecluster-admin --usersystem: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--logtostderrfalse \\
--v2 \\
--log-dir/opt/kubernetes/logs \\
--hostname-override${NODE_ADDRESS} \\
--network-plugincni \\
--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-imageregistry.cn-hangzhou.aliyuncs.com/google-containers/pause-amd64:3.0
EOF#--hostname-override指定kubelet节点在集群中显示的主机名或IP地址默认使用主机hostnamekube-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]
DescriptionKubernetes Kubelet
Afterdocker.service
Requiresdocker.service[Service]
EnvironmentFile/opt/kubernetes/cfg/kubelet
ExecStart/opt/kubernetes/bin/kubelet \$KUBELET_OPTS
Restarton-failure
KillModeprocess[Install]
WantedBymulti-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
#查看节点由于网络插件还没有部署节点会没有准备就绪就会显示NotReady5、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 21 /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--logtostderrtrue \\
--v4 \\
--hostname-override${NODE_ADDRESS} \\
--cluster-cidr172.17.0.0/16 \\
--proxy-modeipvs \\
--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]
DescriptionKubernetes Proxy
Afternetwork.target[Service]
EnvironmentFile-/opt/kubernetes/cfg/kube-proxy
ExecStart/opt/kubernetes/bin/kube-proxy \$KUBE_PROXY_OPTS
Restarton-failure[Install]
WantedBymulti-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 root20.0.0.57:/opt/
#将node01上面的两个组件的安装脚本拷贝到node02上面进行安装组件scp -r /opt/cni root20.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 21 /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 --imagebusybox:1.28.4 sh
#运行一个容器镜像为busybos1.28.4并且直接运行(网不好就多等会)然后解析kubernetes成功即可九、master02 节点部署
需要安装步骤一的系统初始化脚本并且更名为master02
在master01上操作
scp -r /opt/etcd/ root20.0.0.58:/opt/
#拷贝matser01上面的etcd证书到master02上面scp -r /opt/kubernetes/ root20.0.0.58:/opt
#拷贝master01上的整个kubernetes工作目录scp -r /root/.kube root20.0.0.58:/root
#拷贝运行master01上面的.kube运行文件kubect命令文件到master02上面scp /usr/lib/systemd/system/{kube-apiserver,kube-controller-manager,kube-scheduler}.service root20.0.0.58:/usr/lib/systemd/system/
#从 master01 节点上拷贝三大组件到master02上面master02节点查看 master02节点修改
vim /opt/kubernetes/cfg/kube-apiserverKUBE_APISERVER_OPTS--logtostderrtrue \
--v4 \
--etcd-servershttps://20.0.0.55:2379,https://20.0.0.56:2379,https://20.0.0.57:2379 \
--bind-address20.0.0.58 \ #修改
--secure-port6443 \
--advertise-address20.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 #-owide输出额外信息对于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]
namenginx repo
baseurlhttp://nginx.org/packages/centos/7/$basearch/
gpgcheck0
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 {acassenfirewall.locfailoverfirewall.locsysadminfirewall.loc}# 邮件发送地址notification_email_from Alexandre.Cassenfirewall.locsmtp_server 127.0.0.1smtp_connect_timeout 30router_id NGINX_MASTER #lb01节点的为 NGINX_MASTERlb02节点的为 NGINX_BACKUP
}#添加一个周期性执行的脚本
vrrp_script check_nginx {script /etc/nginx/check_nginx.sh #指定检查nginx存活的脚本路径
}vrrp_instance VI_1 {state MASTER #lb01节点的为 MASTERlb02节点的为 BACKUPinterface ens33 #指定网卡名称 ens33virtual_router_id 51 #指定vrid两个节点要一致priority 100 #lb01节点的为 100lb02节点的为 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.1006443vim 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 --imagenginx
#测试创建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资源例如deploymentjobdaemonset等。例如您可以使用部署向导扩展部署启动滚动更新重新启动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 --clusterrolecluster-admin --serviceaccountkube-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
