K8s部署-CSDN博客

阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6

目录

k8s部署方式

1、Minikube

2、二进制安装部署

1操作系统初始化配置

2部署 etcd 集群

3生成Etcd证书

4在node节点部署 docker引擎

5部署 Master 组件

6部署 Worker Node 组件

7部署 CNI 网络组件

8部署keepalived+nginx实现负载均衡和高可用

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

10重启kubelet和kube-proxy服务

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

12部署 Dashboard

k8s部署方式

1、Minikube

Minikube是一个工具可以在本地快速运行一个单节点微型K8S仅用于学习、预览K8S的一些特性使用。
部署地址https://kubernetes.io/docs/setup/minikube

2、二进制安装部署

生产首选从官方下载发行版的二进制包手动部署每个组件和自签TLS证书组成K8S集群新手推荐。
https://github.com/kubernetes/kubernetes/releases

二进制安装部署及高可用部署步骤

二进制高可用安装部署环境
集群名IP部署的应用
master01192.168.3.100

kube-apiserver

kube-controller-manager

kube-scheduler etcd

master02192.168.3.101

kube-apiserver

kube-controller-manager

kube-scheduler etcd

master03192.168.3.102

kube-apiserver

kube-controller-manager

kube-scheduler etcd

node01192.168.3.103

kubelet

kube-proxy

docker

node02192.168.3.104

kubelet

kube-proxy

docker

keepalived01192.168.3.105nginx或haproxy+keepalived
keepalived02192.168.3.106nginx或haproxy+keepalived

1操作系统初始化配置

#关闭防火墙
systemctl stop firewalld
systemctl disable firewalld
iptables -F && iptables -t nat -F && iptables -t mangle -F && iptables -X

#关闭selinux
setenforce 0
sed -i 's/enforcing/disabled/' /etc/selinux/config


#根据规划设置主机名
hostnamectl set-hostname master01
hostnamectl set-hostname master02
hostnamectl set-hostname master03
hostnamectl set-hostname node01
hostnamectl set-hostname node02
hostnamectl set-hostname keepalived01
hostnamectl set-hostname keepalived02

#在所有主机上添加hosts
cat >> /etc/hosts << EOF
192.168.3.100 master01
192.168.3.101 master02
192.168.3.102 master03
192.168.3.103 node01
192.168.3.104 node02
192.168.3.105 keepalived01
192.168.3.106 keepalived02
EOF

#master和node节点调整内核参数
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.com

2部署 etcd 集群

在 master01 节点上操作

mkdir  /opt/k8s
cd  /opt/k8s/

//上传cfssl证书生成工具或者去下载
wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -O /usr/local/bin/cfssl
wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 -O /usr/local/bin/cfssljson
wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 -O /usr/local/bin/cfssl-certinfo

chmod +x /usr/local/bin/cfssl*

cfssl证书签发的工具命令
cfssljson将 cfssl 生成的证书json格式变为文件承载式证书
cfssl-certinfo验证证书的信息

3生成Etcd证书

上传 etcd-cert.sh 和 etcd.sh 到 /opt/k8s/ 目录中并赋予执行权限

chmod +x etcd-cert.sh etcd.sh

 etcd-cert.sh脚本内容

#!/bin/bash
#配置证书生成策略让 CA 软件知道颁发有什么功能的证书生成用来签发其他组件证书的根证书
cat > ca-config.json <<EOF
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "www": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
EOF

#ca-config.json可以定义多个 profiles分别指定不同的过期时间、使用场景等参数
#后续在签名证书时会使用某个 profile此实例只有一个 www 模板。
#expiry指定了证书的有效期87600h 为10年如果用默认值一年的话证书到期后集群会立即宕掉
#signing表示该证书可用于签名其它证书生成的 ca.pem 证书中 CA=TRUE
#key encipherment表示使用非对称密钥加密如 RSA 加密
#server auth表示client可以用该 CA 对 server 提供的证书进行验证
#client auth表示server可以用该 CA 对 client 提供的证书进行验证
#注意标点符号最后一个字段一般是没有逗号的。


#-----------------------
#生成CA证书和私钥根证书和私钥
#特别说明 cfssl和openssl有一些区别openssl需要先生成私钥然后用私钥生成请求文件最后生成签名的证书和私钥等但是cfssl可以直接得到请求文件。
cat > ca-csr.json <<EOF
{
    "CN": "etcd",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing"
        }
    ]
}
EOF

#CNCommon Name浏览器使用该字段验证网站或机构是否合法一般写的是域名 
#key指定了加密算法一般使用rsasize2048
#CCountry国家
#STState州省
#LLocality地区,城市
#O: Organization Name组织名称公司名称
#OU: Organization Unit Name组织单位名称公司部门

cfssl gencert -initca ca-csr.json | cfssljson -bare ca

#生成的文件
#ca-key.pem根证书私钥
#ca.pem根证书
#ca.csr根证书签发请求文件

#cfssl gencert -initca <CSRJSON>使用 CSRJSON 文件生成新的证书和私钥。如果不添加管道符号会直接把所有证书内容输出到屏幕。
#注意CSRJSON 文件用的是相对路径所以 cfssl 的时候需要 csr 文件的路径下执行也可以指定为绝对路径。
#cfssljson 将 cfssl 生成的证书json格式变为文件承载式证书-bare 用于命名生成的证书文件。


#-----------------------
#生成 etcd 服务器证书和私钥
cat > server-csr.json <<EOF
{
    "CN": "etcd",
    "hosts": [
    "192.168.3.100",
    "192.168.3.101",
    "192.168.3.102"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "BeiJing",
            "ST": "BeiJing"
        }
    ]
}
EOF

#hosts将所有 etcd 集群节点添加到 host 列表需要指定所有 etcd 集群的节点 ip 或主机名不能使用网段新增 etcd 服务器需要重新签发证书。

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server

#生成的文件
#server.csr服务器的证书请求文件
#server-key.pem服务器的私钥
#server.pem服务器的数字签名证书

#-config引用证书生成策略文件 ca-config.json
#-profile指定证书生成策略文件中的的使用场景比如 ca-config.json 中的 www

 etcd.sh脚本的内容

#!/bin/bash
#example: ./etcd.sh etcd01 192.168.3.100 etcd02=https://192.168.3.101:2380,etcd03=https://192.168.3.102:2380

#创建etcd配置文件/opt/etcd/cfg/etcd
ETCD_NAME=$1
ETCD_IP=$2
ETCD_CLUSTER=$3

WORK_DIR=/opt/etcd

cat > $WORK_DIR/cfg/etcd  <<EOF
#[Member]
ETCD_NAME="${ETCD_NAME}"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://${ETCD_IP}:2380"
ETCD_LISTEN_CLIENT_URLS="https://${ETCD_IP}:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://${ETCD_IP}:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://${ETCD_IP}:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://${ETCD_IP}:2380,${ETCD_CLUSTER}"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
EOF

#Member:成员配置
#ETCD_NAME节点名称集群中唯一。成员名字集群中必须具备唯一性如etcd01
#ETCD_DATA_DIR数据目录。指定节点的数据存储目录这些数据包括节点ID集群ID集群初始化配置Snapshot文件若未指定-wal-dir还会存储WAL文件如果不指定会用缺省目录
#ETCD_LISTEN_PEER_URLS集群通信监听地址。用于监听其他member发送信息的地址。ip为全0代表监听本机所有接口
#ETCD_LISTEN_CLIENT_URLS客户端访问监听地址。用于监听etcd客户发送信息的地址。ip为全0代表监听本机所有接口

#Clustering集群配置
#ETCD_INITIAL_ADVERTISE_PEER_URLS集群通告地址。其他member使用其他member通过该地址与本member交互信息。一定要保证从其他member能可访问该地址。静态配置方式下该参数的value一定要同时在--initial-cluster参数中存在
#ETCD_ADVERTISE_CLIENT_URLS客户端通告地址。etcd客户端使用客户端通过该地址与本member交互信息。一定要保证从客户侧能可访问该地址
#ETCD_INITIAL_CLUSTER集群节点地址。本member使用。描述集群中所有节点的信息本member根据此信息去联系其他member
#ETCD_INITIAL_CLUSTER_TOKEN集群Token。用于区分不同集群。本地如有多个集群要设为不同
#ETCD_INITIAL_CLUSTER_STATE加入集群的当前状态new是新集群existing表示加入已有集群。


#创建etcd.service服务管理文件
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=${WORK_DIR}/cfg/etcd
ExecStart=${WORK_DIR}/bin/etcd \
--cert-file=${WORK_DIR}/ssl/server.pem \
--key-file=${WORK_DIR}/ssl/server-key.pem \
--trusted-ca-file=${WORK_DIR}/ssl/ca.pem \
--peer-cert-file=${WORK_DIR}/ssl/server.pem \
--peer-key-file=${WORK_DIR}/ssl/server-key.pem \
--peer-trusted-ca-file=${WORK_DIR}/ssl/ca.pem \
--logger=zap \
--enable-v2
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF

#--enable-v2开启 etcd v2 API 接口。当前 flannel 版本不支持 etcd v3 通信
#--logger=zap使用 zap 日志框架。zap.Logger 是go语言中相对日志库中性能最高的
#--peer开头的配置项用于指定集群内部TLS相关证书peer 证书这里全部都使用同一套证书认证
#不带--peer开头的的参数是指定 etcd 服务器TLS相关证书server 证书这里全部都使用同一套证书认证


systemctl daemon-reload
systemctl enable etcd
systemctl restart etcd

创建用于生成CA证书、etcd 服务器证书以及私钥的目录然后生成CA证书

mkdir /opt/k8s/etcd-cert
mv etcd-cert.sh etcd-cert/
cd /opt/k8s/etcd-cert/
./etcd-cert.sh            #生成CA证书、etcd 服务器证书以及私钥

上传 etcd-v3.4.9-linux-amd64.tar.gz 到 /opt/k8s 目录中启动etcd服务

cd /opt/k8s/
tar zxvf etcd-v3.4.26-linux-amd64.tar.gz
ls etcd-v3.4.26-linux-amd64

#创建用于存放 etcd 配置文件命令文件证书的目录
mkdir -p /opt/etcd/{cfg,bin,ssl}

cd /opt/k8s/etcd-v3.4.26-linux-amd64/
mv etcd etcdctl /opt/etcd/bin/
cp /opt/k8s/etcd-cert/*.pem /opt/etcd/ssl/

cd /opt/k8s/
#启动etcd
./etcd.sh etcd01 192.168.3.100     etcd02=https://192.168.3.101:2380,etcd03=https://192.168.3.102:2380

把etcd相关证书文件、命令文件和服务管理文件全部拷贝到另外两个etcd集群节点

scp -r /opt/etcd/ root@192.168.3.101:/opt/
scp -r /opt/etcd/ root@192.168.3.102:/opt/
scp /usr/lib/systemd/system/etcd.service root@192.168.3.101:/usr/lib/systemd/system/
scp /usr/lib/systemd/system/etcd.service root@192.168.3.102:/usr/lib/systemd/system/

在master02和master03上操作修改配置文件

vim /opt/etcd/cfg/etcd
#[Member]
ETCD_NAME="etcd02"			#master02上修改为etcd02master03上修改成etcd03
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.3.101:2380"			#修改成本地的IP
ETCD_LISTEN_CLIENT_URLS="https://192.168.3.101:2379"		#修改成本地的IP

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.3.101:2380"		#修改成本地的IP
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.3.101:2379"				#修改成本地的IP
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.3.100:2380,etcd02=https://192.168.3.101:2380,etcd03=https://192.168.3.102:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

启动etcd服务

systemctl start etcd
systemctl enable etcd
systemctl status etcd

然后再任意一台master上检查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://192.168.3.100:2379,https://192.168.3.101:2379,https://192.168.3.102:2379" endpoint health --write-out=table

查看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://192.168.3.100:2379,https://192.168.3.101:2379,https://192.168.3.102:2379" --write-out=table member list

4在node节点部署 docker引擎

所有 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 install -y docker-ce docker-ce-cli containerd.io

systemctl start docker.service
systemctl enable docker.service

编写加速镜像配置文件

加速镜像链接自己去阿里云申请

vim /etc/docker/daemon.json
{
  "registry-mirrors": ["https://6na95ym4.mirror.aliyuncs.com"],
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "500m", "max-file": "3"
  }
}

然后重启docker 

systemctl  restart docker.service

5部署 Master 组件

在 master01 节点上操作

上传 master.zip 和 k8s-cert.sh 到 /opt/k8s 目录中解压 master.zip 压缩包并创建kubernetes工作目录

cd /opt/k8s/
unzip master.zip
chmod +x *.sh
mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}

解压 master.zip 压缩包后出现几个脚本几个脚本的内容如下

admin.sh脚本

#!/bin/bash
mkdir /root/.kube
KUBE_CONFIG="/root/.kube/config"
KUBE_APISERVER="https://192.168.3.100:6443"

#切换到k8s证书目录操作
cd /opt/k8s/k8s-cert/

#配置kubernetes集群参数
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 admin \
  --client-certificate=./admin.pem \
  --client-key=./admin-key.pem \
  --embed-certs=true \
  --kubeconfig=${KUBE_CONFIG}
#设置设置一个环境项配置上下文参数
kubectl config set-context default \
  --cluster=kubernetes \
  --user=admin \
  --kubeconfig=${KUBE_CONFIG}
#设置默认环境上下文
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}
#生成的 kubeconfig 被保存到 /root/.kube/config 文件

#########################################################
#集群参数
#本段设置了所需要访问的集群的信息。使用set-cluster设置了需要访问的集群如上为kubernetes这只是个名称实际为--server指向
的apiserver--certificate-authority设置了该集群的公钥--embed-certs为true表示将--certificate-authority证书写入到kubeconfig中--server则表示该集群的kube-apiserver地址

#用户参数
#本段主要设置用户的相关信息主要是用户证书。如上的用户名为admin证书为/opt/kubernetes/ssl/admin.pem私钥为/opt/kubernetes/ssl/admin-key.pem。注意客户端的证书首先要经过集群CA的签署否则不会被集群认可。此处使用的是ca认证方式也可以使用token认证如kubelet的 TLS Boostrap 机制下的 bootstrapping 使用的就是token认证方式。上述kubectl使用的是ca认证不需要token字
段

#上下文参数
#集群参数和用户参数可以同时设置多对在上下文参数中将集群参数和用户参数关联起来。上面的上下文名称为default集群为kubenetes用户为admin表示使用admin的用户凭证来访问kubenetes集群的default命名空间也可以增加--namspace来指定访问的命名空间。

#最后使用 kubectl config use-context default 来使用名为 default 的环境项来作为配置。 如果配置了多个环境项可以通过切换不>同的环境项名字来访问到不同的集群环境。                                                                                                                      
apiserver.sh脚本

#!/bin/bash
#example: apiserver.sh 192.168.3.100 https://192.168.3.100:2379,https://192.168.3.101:2379,https://192.168.3.102:2379
#创建 kube-apiserver 启动参数配置文件
MASTER_ADDRESS=$1
ETCD_SERVERS=$2

cat >/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-serversetcd集群地址。指定etcd服务器列表格式//ip:port逗号分隔
#--bind-address监听地址。指定 HTTPS 安全接口的监听地址默认值0.0.0.0
#--secure-porthttps安全端口。指定 HTTPS 安全接口的监听端口默认值6443
#--advertise-address集群通告地址。通过该 ip 地址向集群其他节点公布 api server 的信息必须能够被其他节点访问
#--allow-privileged=true启用授权。允许拥有系统特权的容器运行默认值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]
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
EOF

systemctl daemon-reload
systemctl enable kube-apiserver
systemctl restart kube-apiserver
controller-manager.sh脚本

#!/bin/bash
##创建 kube-controller-manager 启动参数配置文件
MASTER_ADDRESS=$1

cat >/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/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证书
#切换到k8s证书目录操作
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://192.168.3.100:6443"

#配置kubernetes集群参数
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
EOF

systemctl daemon-reload
systemctl enable kube-controller-manager
systemctl restart kube-controller-manager
scheduler.sh脚本

#!/bin/bash
##创建 kube-scheduler 启动参数配置文件
MASTER_ADDRESS=$1

cat >/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 获取对象最新的变化事件做期望状态和实
际状态调整scheduler watch 未绑定节点的 pod 做节点选择 显然多个这些任务同时工作是完全没有必要的所以 controller-manager 和 scheduler 也是需要选主的但是选主逻辑和 etcd 不一样的这里只需要保证从多个 controller-manager 和 scheduler 之间选出
一个 leader 进入工作状态即可而无需考虑它们之间的数据一致和同步。


##生成kube-scheduler证书
#切换到k8s证书目录操作
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://192.168.3.100:6443"

#配置kubernetes集群参数
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
EOF

systemctl daemon-reload
systemctl enable kube-scheduler
systemctl restart kube-scheduler

创建用于生成CA证书、相关组件的证书和私钥的目录并复制CA证书、apiserver相关证书和私钥到 kubernetes工作目录的 ssl 子目录中

mkdir /opt/k8s/k8s-cert
mv /opt/k8s/k8s-cert.sh /opt/k8s/k8s-cert
cd /opt/k8s/k8s-cert/
./k8s-cert.sh				#生成CA证书、相关组件的证书和私钥

cp ca*pem apiserver*pem /opt/kubernetes/ssl/

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"
        }
    ]
}
EOF

cfssl 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",
      "192.168.3.100",
      "192.168.3.101",
      "192.168.3.102",
      "192.168.3.254",
      "192.168.3.105",
      "192.168.3.106",
      "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 连接集群的证书和私钥kubectl 和 apiserver 通信使用
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"
    }
  ]
}
EOF

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes admin-csr.json | cfssljson -bare admin


#-----------------------
#生成 kube-proxy 的证书和私钥kube-proxy 和 apiserver 通信使用
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"
    }
  ]
}
EOF

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy

上传 kubernetes-server-linux-amd64.tar.gz 到 /opt/k8s/ 目录中解压 kubernetes 压缩包

cd /opt/k8s/
tar zxvf kubernetes-server-linux-amd64.tar.gz

复制master组件的关键命令文件到 kubernetes工作目录的 bin 子目录中

cd /opt/k8s/kubernetes/server/bin
cp kube-apiserver kubectl kube-controller-manager kube-scheduler /opt/kubernetes/bin/
ln -s /opt/kubernetes/bin/* /usr/local/bin/

创建 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"
EOF

chmod +x token.sh
./token.sh
cat /opt/kubernetes/cfg/token.csv

二进制文件、token、证书都准备好后开启 apiserver 服务

cd /opt/k8s/
./apiserver.sh 192.168.3.100 https://192.168.3.100:2379,https://192.168.3.101:2379,https://192.168.3.102:2379

然后分别启动scheduler 服务和controller-manager 服务以及生成kubectl连接集群的kubeconfig文并绑定默认cluster-admin管理员集群角色授权kubectl访问集群

#启动 scheduler 服务
cd /opt/k8s/
./scheduler.sh
ps aux | grep kube-scheduler

#启动 controller-manager 服务
./controller-manager.sh
ps aux | grep kube-controller-manager

#生成kubectl连接集群的kubeconfig文件
./admin.sh

#绑定默认cluster-admin管理员集群角色授权kubectl访问集群
kubectl create clusterrolebinding cluster-system-anonymous --clusterrole=cluster-admin --user=system:anonymous

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

kubectl get cs

从 master01 节点上拷贝证书文件、各master组件的配置文件和服务管理文件到 master02 和master03节点上

scp -r /opt/etcd/ root@192.168.3.101:/opt/
scp -r /opt/kubernetes/ root@192.168.3.101:/opt
scp /usr/lib/systemd/system/{kube-apiserver,kube-controller-manager,kube-scheduler}.service root@192.168.3.101:/usr/lib/systemd/system/
scp -r /root/.kube 192.168.3.101:`pwd`

scp -r /opt/etcd/ root@192.168.3.102:/opt/
scp -r /opt/kubernetes/ root@192.168.3.102:/opt
scp /usr/lib/systemd/system/{kube-apiserver,kube-controller-manager,kube-scheduler}.service root@192.168.3.102:/usr/lib/systemd/system/
scp -r /root/.kube 192.168.3.102:`pwd`

在master02和master03上修改配置文件kube-apiserver中的IP

vim /opt/kubernetes/cfg/kube-apiserver
KUBE_APISERVER_OPTS="--logtostderr=true \
--v=4 \
--etcd-servers=https://192.168.3.100:2379,https://192.168.3.101:2379,https://192.168.3.102:2379 \
--bind-address=192.168.3.103 \				#分别修改为master02和master03的本地IP
--secure-port=6443 \
--advertise-address=192.168.3.103 \			#分别修改为master02和master03的本地IP
......

最后开启服务并查看node节点状态

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

ln -s /opt/kubernetes/bin/* /usr/local/bin/

6部署 Worker Node 组件

在所有 node 节点上操作

创建kubernetes工作目录并上传 node.zip 到 /opt 目录中解压 node.zip 压缩包获得kubelet.sh、proxy.sh

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

#上传 node.zip 到 /opt 目录中解压 node.zip 压缩包获得kubelet.sh、proxy.sh
cd /opt/
unzip node.zip
chmod +x kubelet.sh proxy.sh

kubelet.sh、proxy.sh的内容

kubelet.sh

#!/bin/bash

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.2"
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: systemd
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
EOF

systemctl daemon-reload
systemctl enable kubelet
systemctl restart kubelet

proxy.sh内容

#!/bin/bash

NODE_ADDRESS=$1

#创建 kube-proxy 启动参数配置文件
cat >/opt/kubernetes/cfg/kube-proxy <<EOF
KUBE_PROXY_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--hostname-override=${NODE_ADDRESS} \\
--cluster-cidr=10.244.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。
#--kubeconfig: 指定连接 apiserver 的 kubeconfig 文件
#--proxy-mode指定流量调度模式为ipvs模式可添加--ipvs-scheduler选项指定ipvs调度算法rr|lc|dh|sh|sed|nq
#rr: round-robin轮询。
#lc: least connection最小连接数。
#dh: destination hashing目的地址哈希。
#sh: source hashing ,原地址哈希。
#sed: shortest expected delay最短期望延时。
#nq: never queue 永不排队。

#----------------------
#创建 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
EOF

systemctl daemon-reload
systemctl enable kube-proxy
systemctl restart kube-proxy

在 master01 节点上操作

把 kubelet、kube-proxy 拷贝到 node 节点

cd /opt/k8s/kubernetes/server/bin
scp kubelet kube-proxy root@192.168.3.103:/opt/kubernetes/bin/
scp kubelet kube-proxy root@192.168.3.104:/opt/kubernetes/bin/

上传kubeconfig.sh文件到/opt/k8s/kubeconfig目录中生成kubelet初次加入集群引导kubeconfig文件和kube-proxy.kubeconfig文件

mkdir /opt/k8s/kubeconfig

cd /opt/k8s/kubeconfig
chmod +x kubeconfig.sh
./kubeconfig.sh 192.168.3.100 /opt/k8s/k8s-cert/

kubeconfig.sh脚本内容 

kubeconfig.sh脚本内容 

#!/bin/bash
#example: kubeconfig 192.168.3.100 /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)
APISERVER=$1
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

把配置文件 bootstrap.kubeconfig、kube-proxy.kubeconfig 拷贝到 node 节点

scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.3.103:/opt/kubernetes/cfg/
scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.3.104:/opt/kubernetes/cfg/

RBAC授权使用户 kubelet-bootstrap 能够有权限发起 CSR 请求证书

kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap

在 node 节点上操作

#启动 kubelet 服务
cd /opt/
./kubelet.sh 192.168.3.103
ps aux | grep kubelet

#启动 kubelet 服务
cd /opt/
./kubelet.sh 192.168.3.104
ps aux | grep kubelet

在node节点重启kubelet服务

systemctl restart kubelet.service
systemctl status kubelet.service

在 master01 节点上操作通过 CSR 请求

检查到 node01 节点的 kubelet 发起的 CSR 请求Pending 表示等待集群给该节点签发证书

kubectl get csr

kubectl certificate approve  node-csr-0tis6PhXIq2xv90DxbYLOQtespexe864jKfD67NGGIg

kubectl certificate approve  node-csr-xSWZhyg5fBY_bAyFzlbFv8ygeUBcDUUAejh5VHQYTmI

查看节点由于网络插件还没有部署节点会没有准备就绪 NotReady

kubectl get node

7部署 CNI 网络组件

CNI网络组件有多种如flannel、calico以及cilium等

下面部署flannel网络组件为例

在 node 节点上操作

上传 flannel-v0.21.5.zip 到 /opt 目录中

cd /opt/
unzip flannel-v0.21.5.zip
docker load -i flannel.tar
mkdir  -p /opt/cni/bin
tar zxvf cni-plugins-linux-amd64-v1.3.0.tgz -C /opt/cni/bin/

在 master01 节点上操作

从node节点将 kube-flannel.yml 文件传到master01的 /opt/k8s 目录中部署 CNI 网络

scp kube-flannel.yml 192.168.3.100:/opt/k8s

#在master01上部署CNI网络
cd /opt/k8s
kubectl apply -f kube-flannel.yml

然后查看节点状态

kubectl get pods -A
或
kubectl get nodes

8部署keepalived+nginx实现负载均衡和高可用

在haproxy节点主机上下载nginx和haproxy服务

yum install -y keepalived.x86_64 nginx.x86_64

配置nginx四层反向负载均衡

……
stream {
    upstream k8s_apiserver {
       server 192.168.3.100:6443;
       server 192.168.3.101:6443;
       server 192.168.3.102:6443;
    }
    server {
      listen 6443;
      proxy_pass k8s_apiserver;
    }
}
http{……}

检查nginx配置文件没错的话直接启动nginx有错排错

编写nginx健康检查脚本

在/etc/keepalived/目录下编写

cd /etc/keepalived/
vim chk_nginx.sh
#!/bin/bash
if ! killall -0 nginx
then
systemctl stop keepalived
fi

chmod +x chk_nginx.sh

修改keepalived的配置文件

启动keepalived服务

systemctl start keepalived
systemctl enable keepalived
ip a				#查看VIP是否生成

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

cd /opt/kubernetes/cfg/
vim bootstrap.kubeconfig 
server: https://192.168.3.254:6443
                      
vim kubelet.kubeconfig
server: https://192.168.3.254:6443
                        
vim kube-proxy.kubeconfig
server: https://192.168.3.254:6443

10重启kubelet和kube-proxy服务

systemctl restart kubelet.service 
systemctl restart kube-proxy.service

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

 netstat -napt | grep nginx

12部署 Dashboard

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

在 master01 节点上操作

上传 recommended.yaml 文件到 /opt/k8s 目录中

cd /opt/k8s
vim recommended.yaml
#默认Dashboard只能集群内部访问修改Service为NodePort类型暴露到外部
kind: Service
apiVersion: v1
metadata:
  labels:
    k8s-app: kubernetes-dashboard
  name: kubernetes-dashboard
  namespace: kubernetes-dashboard
spec:
  ports:
    - port: 443
      targetPort: 8443
      nodePort: 30001     #添加
  type: NodePort          #添加
  selector:
    k8s-app: kubernetes-dashboard

kubectl apply -f recommended.yaml

创建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}')

在虚拟机的浏览器中使用输出的token登录Dashboard

https://任意一个node节点的IP:30001

阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6
标签: k8s
返回列表

上一篇：VMware Tanzu 和 Spring 更新-CSDN博客

下一篇：C++二分算法：水位上升的泳池中游泳-CSDN博客

“K8s部署-CSDN博客” 的相关文章

云原生 | Kubernetes - kube-scheduler1年前 (2023-02-02)
Kubernetes 基本概念1年前 (2023-02-02)
【Kubernetes 企业项目实战】04、基于 K8s 构建 EFK+logstash+kafka 日志平台（上）1年前 (2023-02-02)
k8s之挂载NFS到POD中1年前 (2023-02-02)
kubetpl - kubernetes 模板管理工具1年前 (2023-02-02)
kubernetes资源对象应用类（二）1年前 (2023-02-02)
k8s之部署有状态应用1年前 (2023-02-02)
Kubernetes集群部署与实践1年前 (2023-02-02)
19 | Rancher 使用介绍（管理 K8s 平台）1年前 (2023-02-03)
在GCP的Kubernetes上安装dapr1年前 (2023-02-04)

阿里云国际版