K8s进阶2——二进制搭建K8s高可用集群

已于 2023-05-29 14:07:22 修改
阅读量1.5k 收藏 13
点赞数 1
分类专栏： K8s 文章标签： kubernetes 运维 云原生
于 2023-05-17 22:59:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yi_qingjun/article/details/130720554
版权

文章目录

一、单master资源清单

角色IP配置安装服务操作系统
k8s-master1192.168.130.1452核2G50Gkube-apiserver、kube-controller-manager、kube-scheduler、kubelet、kube-proxy、docker、cri-docker、etcdCentOS 7.5.1804 (mini)
k8s-node1192.168.130.1462核2G50Gkube-apiserver、kube-controller-manager、kube-scheduler、kubelet、kube-proxy、docker、cri-dockerCentOS 7.5.1804 (mini)
k8s-node2192.168.130.1472核2G50Gkubelet、kube-proxy、docker、cri-docker、etcdCentOS 7.5.1804 (mini)
VIP192.168.130.151

二、系统初始化

##关闭防火墙。
systemctl stop firewalld
systemctl disable firewalld

##关闭selinux
sed -i 's/enforcing/disabled/' /etc/selinux/config   ##永久关闭。
setenforce 0    ##临时关闭。

##关闭swap
swapoff -a    ##临时关闭
sed -ri 's/.*swap.*/#&/' /etc/fstab    ##永久关闭

##根据规划设置主机名
hostnamectl set-hostname k8s-master1
hostnamectl set-hostname k8s-node1
hostnamectl set-hostname k8s-node2

##将桥接的IPv4流量传递到iptables的链
cat > /etc/sysctl.d/k8s.conf << EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
sysctl --system     ##重新读取生效

##时间同步
yum install ntpdate -y
ntpdate time.windows.com


##在master节点添加hosts
cat >> /etc/hosts << EOF
192.168.130.145 k8s-master1
192.168.130.146 k8s-node1
192.168.130.147 k8s-node2
EOF

三、部署etcd集群

  • Etcd是一个分布式键值存储系统，集群方式部署可以有效提防单节点故障问题。
  • 这里使用3台组建集群，可容忍1台机器故障，也可以使用5台组建集群，可容忍2台机器故障。
  • 这里是与k8s节点公用机器是为节省资源，资源充足的情况下优先考虑独立于k8s集群之外部署，只要apiserver能连接到就行。
节点名称IP
etcd-1192.168.130.145
etcd-2192.168.130.146
etcd-3192.168.130.147

3.1 生成etcd证书

1.任意节点上下载cfssl证书生成工具，这里放在master节点。

wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64
wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64
wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64
chmod +x cfssl_linux-amd64 cfssljson_linux-amd64 cfssl-certinfo_linux-amd64
mv cfssl_linux-amd64 /usr/local/bin/cfssl
mv cfssljson_linux-amd64 /usr/local/bin/cfssljson
mv cfssl-certinfo_linux-amd64 /usr/bin/cfssl-certinfo

2.自签证书颁发机构（CA）。

##创建工作目录。
mkdir -p ~/TLS/{etcd,k8s}
cd ~/TLS/etcd

##自签CA证书。
cat > ca-config.json << EOF
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "www": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
EOF

cat > ca-csr.json << EOF
{
    "CN": "etcd CA",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing"
        }
    ]
}
EOF

##生成证书，生成ca.pem和ca-key.pem文件。
cfssl gencert -initca ca-csr.json | cfssljson -bare ca -

3.使用自签CA签发Etcd HTTPS客户端证书。

  • 文件里的hosts字段中IP为所有etcd节点的集群内部通信IP，一个都不能少！
  • 为了方便后期扩容可以多写几个预留的IP，我这里多预留了一个192.168.130.148。
##创建证书申请文件。
cat > server-csr.json << EOF
{
    "CN": "etcd",
    "hosts": [
    "192.168.130.145",
    "192.168.130.146",
    "192.168.130.147",
    "192.168.130.148"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "BeiJing",
            "ST": "BeiJing"
        }
    ]
}
EOF

##生成证书，生成server.pem和server-key.pem文件。
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server

3.2 部署流程

部署思路：

  • 可以将etcd-1上生成的所有文件拷贝到etcd-2和etcd-3节点上，可以简化操作。
  • 以下在etcd-1节点上操作。

3.2.1 准备二进制安装文件

wget https://github.com/etcd-io/etcd/releases/download/v3.5.1/etcd-v3.5.1-linux-amd64.tar.gz

3.2.2 创建工作目录

mkdir /opt/etcd/{bin,cfg,ssl} -p
tar zxvf etcd-v3.5.1-linux-amd64.tar.gz
mv etcd-v3.5.1-linux-amd64/{etcd,etcdctl} /opt/etcd/bin/

3.2.3 创建etcd配置文件

参数释义
ETCD_NAME节点名称，集群中唯一
ETCD_DATA_DIR数据目录
ETCD_LISTEN_PEER_URLS集群通信监听地址
ETCD_LISTEN_CLIENT_URLS客户端访问监听地址
ETCD_INITIAL_ADVERTISE_PEERURLS集群通告地址
ETCD_ADVERTISE_CLIENT_URLS客户端通告地址
ETCD_INITIAL_CLUSTER集群节点地址
ETCD_INITIALCLUSTER_TOKEN集群Token
ETCD_INITIALCLUSTER_STATE加入集群的当前状态，new是新集群，existing表示加入已有集群
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://192.168.130.145:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.130.145:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.130.145:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.130.145:2379"
ETCD_INITIAL_CLUSTER="etcd-1=https://192.168.130.145:2380,etcd-2=https://192.168.130.146:2380,etcd-3=https://192.168.130.147:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
EOF

3.2.4 设置成systemd服务

1.设置成系统服务。

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

2.拷贝证书至指定路径，把刚才生成的证书拷贝到配置文件中的路径。

cp ~/TLS/etcd/ca*pem ~/TLS/etcd/server*pem /opt/etcd/ssl/

3.2.5 添加etcd-2和etcd-3节点

1.将上面etcd-1所有生成的文件拷贝到其他两个节点

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

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

2.然后在节点2和节点3分别修改etcd.conf配置文件中的节点名称和当前服务器。
在这里插入图片描述

3.2.6 所有节点启动etcd并设置开机启动

1.依次启动etcd-1、etcd-2、etcd-3节点。

systemctl daemon-reload
systemctl start etcd
systemctl enable etcd

2.查看etcd集群状态，返回状态为True代表搭建无误。

/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.130.145:2379,https://192.168.130.146:2379,https://192.168.130.147:2379" endpoint health --write-out=table

在这里插入图片描述

四、安装容器引擎（docker）

  • 可以二进制安装，也可以yum安装。
  • 以下操作，所有节点执行。

4.1 二进制安装

1.下载安装二进制文件。

wget https://download.docker.com/linux/static/stable/x86_64/docker-19.03.9.tgz

2.解压二进制包。

tar zxvf docker-19.03.9.tgz
mv docker/* /usr/bin

4.2 设置成systemd服务

cat > /usr/lib/systemd/system/docker.service << EOF
[Unit]
Description=Docker Application Container Engine
Documentation=https://docs.docker.com
After=network-online.target firewalld.service
Wants=network-online.target

[Service]
Type=notify
ExecStart=/usr/bin/dockerd
ExecReload=/bin/kill -s HUP $MAINPID
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
TimeoutStartSec=0
Delegate=yes
KillMode=process
Restart=on-failure
StartLimitBurst=3
StartLimitInterval=60s

[Install]
WantedBy=multi-user.target
EOF

4.3 创建配置文件

1.使用阿里云镜像加速器。

mkdir /etc/docker
cat > /etc/docker/daemon.json << EOF
{
  "registry-mirrors": ["https://b9pmyelo.mirror.aliyuncs.com"]
}
EOF

4.4 启动并设置开机启动

systemctl daemon-reload
systemctl start docker
systemctl enable docker

在这里插入图片描述

4.5 安装cri-dockerd

1.下载二进制文件，并解压文件。

https://github.com/Mirantis/cri-dockerd/releases/download/v0.2.5/cri-dockerd-0.2.5.amd64.tgz
tar zxvf cri-dockerd-0.2.5.amd64.tgz
mv cri-dockerd/cri-dockerd /usr/bin/

2.设置成系统服务。

cat >/usr/lib/systemd/system/cri-docker.service << EOF
[Unit]
Description=CRI Interface for Docker Application Container Engine
Documentation=https://docs.mirantis.com
After=network-online.target firewalld.service docker.service
Wants=network-online.target

[Service]
Type=notify
ExecStart=/usr/bin/cri-dockerd --network-plugin=cni --pod-infra-container-image=registry.aliyuncs.com/google_containers/pause:3.7
ExecReload=/bin/kill -s HUP $MAINPID
TimeoutSec=0
RestartSec=2
Restart=always

[Install]
WantedBy=multi-user.target
EOF

3.启动并设置开机自启。

systemctl daemon-reload
systemctl start cri-docker
systemctl enable cri-docker

在这里插入图片描述

五、部署Master节点组件

5.1 生成kube-apiserver证书

1.自签证书颁发机构（CA）。

##该目录前面已生成。
cd ~/TLS/k8s

cat > ca-config.json << EOF
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "kubernetes": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
EOF

cat > ca-csr.json << EOF
{
    "CN": "kubernetes",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing",
            "O": "k8s",
            "OU": "System"
        }
    ]
}
EOF

2.生成证书，会生成ca.pem和ca-key.pem文件。

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

3.使用自签CA签发kube-apiserver HTTPS证书。

  • hosts字段中IP为所有Master/LB/VIP IP，一个都不能少。
  • 为了方便后期扩容可以多写几个预留的IP。
cat > server-csr.json << EOF
{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
      "127.0.0.1",
      "192.168.130.145",
      "192.168.130.146",
      "192.168.130.147",
      "192.168.130.148",
      "192.168.130.151",
      "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

4.生成证书，会生成server.pem和server-key.pem文件。

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

5.2 准备安装文件

1.打开下载地址，下载server和node安装包，注意版本。下载地址
在这里插入图片描述
在这里插入图片描述
2.将下载的server包和node包上传到服务器，解压server安装包，node安装包后面用。

mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs} 
tar zxvf kubernetes-server-linux-amd64.tar.gz
cd kubernetes/server/bin
cp kube-apiserver kube-scheduler kube-controller-manager /opt/kubernetes/bin
cp kubectl /usr/bin/

5.3 部署kube-apiserver

5.3.1 创建配置文件

配置文件参数释义
–logtostderr启用日志
—v日志等级
–log-dir日志目录
–etcd-serversetcd集群地址
–bind-address监听地址
–secure-porthttps安全端口
–advertise-address集群通告地址
–allow-privileged启用授权
–service-cluster-ip-rangeService虚拟IP地址段
–enable-admission-plugins准入控制模块
–authorization-mode认证授权，启用RBAC授权和节点自管理
–enable-bootstrap-token-auth启用TLS bootstrap机制
–token-auth-filebootstrap token文件
–service-node-port-rangeService nodeport类型默认分配端口范围
–kubelet-client-xxxapiserver访问kubelet客户端证书
–tls-xxx-fileapiserver https证书
–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		启动聚合层相关配置
–service-account-issuer服务帐号令牌颁发者的标识符，1.20版本必须加的参数。
–service-account-signing-key-file包含 PEM 编码的 x509 RSA 或 ECDSA 私钥或公钥的文件，用于验证 ServiceAccount 令牌。
1.20版本必须加的参数。

1.创建配置文件，有两个\ \， 第一个是转义符，第二个是换行符，使用转义符是为了使用EOF保留换行符，方便后面运维适配。

cat > /opt/kubernetes/cfg/kube-apiserver.conf << EOF
KUBE_APISERVER_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--etcd-servers=https://192.168.130.145:2379,https://192.168.130.146:2379,https://192.168.130.147:2379 \\
--bind-address=192.168.130.145 \\
--secure-port=6443 \\
--advertise-address=192.168.130.145 \\
--allow-privileged=true \\
--service-cluster-ip-range=10.0.0.0/24 \\
--enable-admission-plugins=NodeRestriction \\
--authorization-mode=RBAC,Node \\
--enable-bootstrap-token-auth=true \\
--token-auth-file=/opt/kubernetes/cfg/token.csv \\
--service-node-port-range=30000-32767 \\
--kubelet-client-certificate=/opt/kubernetes/ssl/server.pem \\
--kubelet-client-key=/opt/kubernetes/ssl/server-key.pem \\
--tls-cert-file=/opt/kubernetes/ssl/server.pem  \\
--tls-private-key-file=/opt/kubernetes/ssl/server-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/ca-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/server.pem \\
--proxy-client-key-file=/opt/kubernetes/ssl/server-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

2.把刚才生成的证书拷贝到配置文件中的路径。

cp ~/TLS/k8s/ca*pem ~/TLS/k8s/server*pem /opt/kubernetes/ssl/

5.3.2 启用 TLS Bootstrapping 机制

前提了解：

  • 当master apiserver启用TLS认证后，Node节点kubelet和kube-proxy要与kube-apiserver进行通信，必须使用CA签发的有效证书才可以，当Node节点很多时，这种客户端证书颁发需要大量工作，人工投入成本大。
  • TLS bootstraping机制可以自动颁发客户端证书，kubelet会以一个低权限用户自动向apiserver申请证书，kubelet的证书由apiserver动态签署。
  • 烈建议在Node上使用这种方式，目前主要用于kubelet，kube-proxy还是由我们统一颁发一个证书。

1.生成一个token。

[root@k8s-master1 bin]# head -c 16 /dev/urandom | od -An -t x | tr -d ' '
c6587b7961975e59da7d44a952c7cce5

2.apiserver配置文件中指定了token文件，这里生成这个token文件。

##格式：token，用户名，UID，用户组
cat > /opt/kubernetes/cfg/token.csv << EOF
c6587b7961975e59da7d44a952c7cce5,kubelet-bootstrap,10001,"system:node-bootstrapper"
EOF

5.3.3 设置成systemd服务

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.conf
ExecStart=/opt/kubernetes/bin/kube-apiserver \$KUBE_APISERVER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

5.3.4 启动并设置开机自启

systemctl daemon-reload
systemctl start kube-apiserver 
systemctl enable kube-apiserver

在这里插入图片描述

5.4 部署kube-controller-manager

5.4.1 创建配置文件

配置文件参数释义
–kubeconfig连接apiserver配置文件
–leader-elect当该组件启动多个时，自动选举（HA）
–cluster-signing-cert-file、–cluster-signing-key-file自动为kubelet颁发证书的CA，与apiserver保持一致
cat > /opt/kubernetes/cfg/kube-controller-manager.conf << 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

5.4.2 生成kubeconfig文件

1.生成kube-controller-manager证书

##切换工作目录。
cd ~/TLS/k8s

##创建证书请求文件。
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

2.生成kubeconfig文件。

##shell命令，直接执行。
KUBE_CONFIG="/opt/kubernetes/cfg/kube-controller-manager.kubeconfig"
KUBE_APISERVER="https://192.168.130.145: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}

5.4.3 设置成systemd服务

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.conf
ExecStart=/opt/kubernetes/bin/kube-controller-manager \$KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

5.4.4 启动并设置开机自启

systemctl daemon-reload
systemctl start kube-controller-manager
systemctl enable kube-controller-manager

在这里插入图片描述

5.5 部署kube-scheduler

5.5.1 创建配置文件

配置文件参数释义
–kubeconfig连接apiserver配置文件
–leader-elect当该组件启动多个时，自动选举（HA）
cat > /opt/kubernetes/cfg/kube-scheduler.conf << EOF
KUBE_SCHEDULER_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--leader-elect \\
--kubeconfig=/opt/kubernetes/cfg/kube-scheduler.kubeconfig \\
--bind-address=127.0.0.1"
EOF

5.5.2 生成kubeconfig文件

1.生成kube-scheduler证书。

##切换工作目录。
cd ~/TLS/k8s

##创建证书请求文件。
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

2.生成kubeconfig文件

KUBE_CONFIG="/opt/kubernetes/cfg/kube-scheduler.kubeconfig"
KUBE_APISERVER="https://192.168.130.145: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}

5.5.3 设置成systemd服务

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.conf
ExecStart=/opt/kubernetes/bin/kube-scheduler \$KUBE_SCHEDULER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

5.5.4 启动并设置开机自启

systemctl daemon-reload
systemctl start kube-scheduler
systemctl enable kube-scheduler

在这里插入图片描述

5.6 kubectl命令和用户授权

1.生成kubectl连接集群的证书。

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

2.生成kubeconfig文件。

mkdir /root/.kube

KUBE_CONFIG="/root/.kube/config"
KUBE_APISERVER="https://192.168.130.145: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 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}

3.查看当前集群组件状态，保证组件运行正常。
在这里插入图片描述

4.授权kubelet-bootstrap用户允许请求证书，也就是上面生成token时指定的那个用户。

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

六、Node节点加入集群

  • 先把master节点加入集群，后面部署了node节点再加入。
  • 以下操作在Master上操作，即同时作为Worker Node。

6.1 创建工作目录并拷贝二进制文件

1.所有worker node创建工作目录，后面部署的node节点也要创建。

mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}

2.将master节点上的kubelet和kube-proxy拷贝到对应目录，现在是在master节点上操作所以是本地拷贝。

cd kubernetes/server/bin
cp kubelet kube-proxy /opt/kubernetes/bin

6.2 部署kubelet

配置文件参数释义
–hostname-override显示名称，集群中唯一
–network-plugin启用CNI
–kubeconfig空路径，会自动生成，后面用于连接apiserver
–bootstrap-kubeconfig首次启动向apiserver申请证书
–config配置参数文件
–cert-dirkubelet证书生成目录
–pod-infra-container-image管理Pod网络容器的镜像

1.创建配置文件。

cat > /opt/kubernetes/cfg/kubelet.conf << EOF
KUBELET_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--hostname-override=k8s-master1 \\
--kubeconfig=/opt/kubernetes/cfg/kubelet.kubeconfig \\
--bootstrap-kubeconfig=/opt/kubernetes/cfg/bootstrap.kubeconfig \\
--config=/opt/kubernetes/cfg/kubelet-config.yml \\
--cert-dir=/opt/kubernetes/ssl \\
--container-runtime-endpoint=unix:///var/run/cri-dockerd.sock"
EOF

2.配置参数文件

cat > /opt/kubernetes/cfg/kubelet-config.yml << EOF
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: 0.0.0.0
port: 10250
readOnlyPort: 10255
cgroupDriver: cgroupfs
clusterDNS:
- 10.0.0.2
clusterDomain: cluster.local 
failSwapOn: false
authentication:
  anonymous:
    enabled: false
  webhook:
    cacheTTL: 2m0s
    enabled: true
  x509:
    clientCAFile: /opt/kubernetes/ssl/ca.pem 
authorization:
  mode: Webhook
  webhook:
    cacheAuthorizedTTL: 5m0s
    cacheUnauthorizedTTL: 30s
evictionHard:
  imagefs.available: 15%
  memory.available: 100Mi
  nodefs.available: 10%
  nodefs.inodesFree: 5%
maxOpenFiles: 1000000
maxPods: 110
EOF

3.生成kubelet初次加入集群引导kubeconfig文件。

KUBE_CONFIG="/opt/kubernetes/cfg/bootstrap.kubeconfig"
KUBE_APISERVER="https://192.168.130.145:6443"    ##修改
TOKEN="c6587b7961975e59da7d44a952c7cce5"       ##修改，与token.csv里保持一致。

# 生成 kubelet bootstrap kubeconfig 配置文件
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 "kubelet-bootstrap" \
  --token=${TOKEN} \
  --kubeconfig=${KUBE_CONFIG}
kubectl config set-context default \
  --cluster=kubernetes \
  --user="kubelet-bootstrap" \
  --kubeconfig=${KUBE_CONFIG}
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}

4.设置成systemd服务。

cat > /usr/lib/systemd/system/kubelet.service << EOF
[Unit]
Description=Kubernetes Kubelet
After=docker.service

[Service]
EnvironmentFile=/opt/kubernetes/cfg/kubelet.conf
ExecStart=/opt/kubernetes/bin/kubelet \$KUBELET_OPTS
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF

5.启动，并设置开机自启。

systemctl daemon-reload
systemctl start kubelet
systemctl enable kubelet

在这里插入图片描述

6.批准kubelet证书申请并加入集群，查看集群节点。

kubectl get csr
kubectl certificate approve 【csr名称】
kubectl  get node

在这里插入图片描述

6.3 部署kube-proxy

1.创建配置文件。

cat > /opt/kubernetes/cfg/kube-proxy.conf << EOF
KUBE_PROXY_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--config=/opt/kubernetes/cfg/kube-proxy-config.yml"
EOF

2.配置参数文件。

cat > /opt/kubernetes/cfg/kube-proxy-config.yml << EOF
kind: KubeProxyConfiguration
apiVersion: kubeproxy.config.k8s.io/v1alpha1
bindAddress: 0.0.0.0
metricsBindAddress: 0.0.0.0:10249
clientConnection:
  kubeconfig: /opt/kubernetes/cfg/kube-proxy.kubeconfig
hostnameOverride: k8s-master1
clusterCIDR: 10.244.0.0/16
EOF

3.生成kube-proxy.kubeconfig文件。

# 切换工作目录
cd ~/TLS/k8s

# 创建证书请求文件
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

4.生成kubeconfig文件。

KUBE_CONFIG="/opt/kubernetes/cfg/kube-proxy.kubeconfig"
KUBE_APISERVER="https://192.168.130.145: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-proxy \
  --client-certificate=./kube-proxy.pem \
  --client-key=./kube-proxy-key.pem \
  --embed-certs=true \
  --kubeconfig=${KUBE_CONFIG}
kubectl config set-context default \
  --cluster=kubernetes \
  --user=kube-proxy \
  --kubeconfig=${KUBE_CONFIG}
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}

5.设置成systemd服务。

cat > /usr/lib/systemd/system/kube-proxy.service << EOF
[Unit]
Description=Kubernetes Proxy
After=network.target

[Service]
EnvironmentFile=/opt/kubernetes/cfg/kube-proxy.conf
ExecStart=/opt/kubernetes/bin/kube-proxy \$KUBE_PROXY_OPTS
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF

6.启动，并设置开机自启。

systemctl daemon-reload
systemctl start kube-proxy
systemctl enable kube-proxy

6.4 部署网络组件

1.官网下载yaml，修改定义Pod网络（CALICO_IPV4POOL_CIDR），与前面kubeadm init的 --pod-network-cidr指定一致。

kubectl apply -f calico.yaml
kubectl get pods -n kube-system

在这里插入图片描述
2.等Calico Pod都Running，节点也会准备就绪。
在这里插入图片描述

6.5 授权apiserver访问kubelet

cat > apiserver-to-kubelet-rbac.yaml << EOF
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  annotations:
    rbac.authorization.kubernetes.io/autoupdate: "true"
  labels:
    kubernetes.io/bootstrapping: rbac-defaults
  name: system:kube-apiserver-to-kubelet
rules:
  - apiGroups:
      - ""
    resources:
      - nodes/proxy
      - nodes/stats
      - nodes/log
      - nodes/spec
      - nodes/metrics
      - pods/log
    verbs:
      - "*"
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: system:kube-apiserver
  namespace: ""
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: system:kube-apiserver-to-kubelet
subjects:
  - apiGroup: rbac.authorization.k8s.io
    kind: User
    name: kubernetes
EOF

kubectl apply -f apiserver-to-kubelet-rbac.yaml

6.6 新增node节点

1.master节点操作，将Worker Node涉及文件拷贝到新节点192.168.130.146。

scp -r /opt/kubernetes root@192.168.130.146:/opt/
scp -r /usr/lib/systemd/system/{kubelet,kube-proxy}.service root@192.168.130.146:/usr/lib/systemd/system

2.node1节点操作，删除kubelet证书和kubeconfig文件。因为这几个文件是证书申请审批后自动生成的，每个Node不同，必须删除

rm -f /opt/kubernetes/cfg/kubelet.kubeconfig 
rm -f /opt/kubernetes/ssl/kubelet*

3.node1节点修改配置文件主机名。

vi /opt/kubernetes/cfg/kubelet.conf
--hostname-override=k8s-node1

vi /opt/kubernetes/cfg/kube-proxy-config.yml
hostnameOverride: k8s-node1

4.node1节点操作，启动并设置开机自启。

systemctl daemon-reload
systemctl start kubelet kube-proxy
systemctl enable kubelet kube-proxy

在这里插入图片描述
5.master节点操作，批准新Node kubelet证书申请。

# 查看证书请求
kubectl get csr

# 授权请求
kubectl certificate approve 【csr名称】

6.将kubelet命令复制到/usr/bin，方便查询。
在这里插入图片描述
7.master1节点上操作，将连接集群命令文件传到其他node节点。

scp /root/.kube/config root@192.168.130.146:/root/.kube/
scp /root/.kube/config root@192.168.130.147:/root/.kube/

8.查看Node状态。
在这里插入图片描述
9.其他node节点加入也是同理。
在这里插入图片描述

七、部署Dashboard和Coredns

7.1 部署Dashboard

1.下载yaml文件。

wget https://raw.githubusercontent.com/kubernetes/dashboard/v2.4.0/aio/deploy/recommended.yaml

2.修改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    ##添加此行。
  selector:
    k8s-app: kubernetes-dashboard
  type: NodePort   ##添加此行。
......

3.导入yaml，查看容器运行状态。

kubectl apply -f recommended.yaml

在这里插入图片描述
4.获取token，准备登录。


[root@k8s-master ~]# kubectl create serviceaccount dashboard-admin -n kubernetes-dashboard

[root@k8s-master ~]# kubectl create clusterrolebinding dashboard-admin --clusterrole=cluster-admin --serviceaccount=kubernetes-dashboard:dashboard-admin

[root@k8s-master ~]# kubectl create token dashboard-admin -n kube-system

5.访问k8s任意节点IP:30001，会发现被拦截了，这是因为chrome认为该网站不安全，不让访问，我们在当前页面随意处输入“thisisunsafe”回车即可解决，相当于了解了风险依然访问，之后就可以访问网页，但那之后再出问题也就没有责任了。
在这里插入图片描述

7.2 部署Coredns

1.下载官网yaml，修改几个配置参数，下载地址。
在这里插入图片描述
2.修改集群名称和clusterip ，这个在安装kubelet组件时在它的参数文件里已经制定了，需要一一对应。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3.修改coredns镜像下载地址和容器资源限制。
在这里插入图片描述
4.导入yaml，查看容器运行状态。
在这里插入图片描述
5.创建测试容器，进入容器测试，测试无误。

kubectl run bs --image=busybox:1.28.4 -- sleep 24h

在这里插入图片描述

八、高可用架构

8.1 多master资源清单

  • 这里就是接着上面的单master集群扩展了一个master节点，并加上nginx+keepalived。
角色IP配置安装服务操作系统
k8s-master1192.168.130.1452核2G50Gkube-apiserver、kube-controller-manager、kube-scheduler、kubelet、kube-proxy、docker、cri-docker、etcd、nginx、keepalivedCentOS 7.5.1804 (mini)
k8s-node1192.168.130.1462核2G50Gkube-apiserver、kube-controller-manager、kube-scheduler、kubelet、kube-proxy、docker、cri-dockerCentOS 7.5.1804 (mini)
k8s-node2192.168.130.1472核2G50Gkubelet、kube-proxy、docker、cri-docker、etcdCentOS 7.5.1804 (mini)
k8s-master2192.168.130.1482核2G50Gkube-apiserver、kube-controller-manager、kube-scheduler、kubelet、kube-proxy、docker、cri-docker、nginx、keepalivedCentOS 7.5.1804 (mini)
VIP192.168.130.151

8.2 安装Docker

1.master1节点上操作，把相关环境文件传到master2节点。

scp /usr/bin/docker* root@192.168.130.148:/usr/bin
scp /usr/bin/runc root@192.168.130.148:/usr/bin
scp /usr/bin/containerd* root@192.168.130.148:/usr/bin
scp /usr/lib/systemd/system/docker.service root@192.168.130.148:/usr/lib/systemd/system
scp -r /etc/docker root@192.168.130.148:/etc

2.master2节点上操作，启动Docker。

systemctl daemon-reload
systemctl start docker
systemctl enable docker

8.2 安装cri-docker

1.下载二进制文件，并解压文件。

https://github.com/Mirantis/cri-dockerd/releases/download/v0.2.5/cri-dockerd-0.2.5.amd64.tgz
tar zxvf cri-dockerd-0.2.5.amd64.tgz
mv cri-dockerd/cri-dockerd /usr/bin/

2.设置成系统服务。

cat >/usr/lib/systemd/system/cri-docker.service << EOF
[Unit]
Description=CRI Interface for Docker Application Container Engine
Documentation=https://docs.mirantis.com
After=network-online.target firewalld.service docker.service
Wants=network-online.target

[Service]
Type=notify
ExecStart=/usr/bin/cri-dockerd --network-plugin=cni --pod-infra-container-image=registry.aliyuncs.com/google_containers/pause:3.7
ExecReload=/bin/kill -s HUP $MAINPID
TimeoutSec=0
RestartSec=2
Restart=always

[Install]
WantedBy=multi-user.target
EOF

3.启动并设置开机自启。

systemctl daemon-reload
systemctl start cri-docker
systemctl enable cri-docker

在这里插入图片描述

8.3 拷贝etcd文件

1.master2节点上操作，创建etcd证书目录。

mkdir -p /opt/etcd/ssl

2.master1节点上操作，将所有K8s文件和etcd证书传到master2节点。

scp -r /opt/kubernetes root@192.168.130.148:/opt
scp -r /opt/etcd/ssl root@192.168.130.148:/opt/etcd
scp /usr/lib/systemd/system/kube* root@192.168.130.148:/usr/lib/systemd/system
scp /usr/bin/kubectl  root@192.168.130.148:/usr/bin
scp -r ~/.kube root@192.168.130.148:~

3.master2节点上操作，删除kubelet证书和kubeconfig文件。

rm -f /opt/kubernetes/cfg/kubelet.kubeconfig 
rm -f /opt/kubernetes/ssl/kubelet*

8.4 修改配置文件IP和主机名

1.master2节点上操作，修改apiserver、kubelet和kube-proxy配置文件为master2节点IP。

vim /opt/kubernetes/cfg/kube-apiserver.conf 
--bind-address=192.168.130.148 \
--advertise-address=192.168.130.148 \

---
vim /opt/kubernetes/cfg/kube-controller-manager.kubeconfig
server: https://192.168.130.148:6443

---
vim /opt/kubernetes/cfg/kube-scheduler.kubeconfig
server: https://192.168.130.148:6443

---
vim /opt/kubernetes/cfg/kubelet.conf
--hostname-override=k8s-master2

---
vim /opt/kubernetes/cfg/kube-proxy-config.yml
hostnameOverride: k8s-master2

---
vim ~/.kube/config
server: https://192.168.130.148:6443

8.5 启动服务设置开机自启

1.master2节点操作。

systemctl daemon-reload
systemctl start kube-apiserver kube-controller-manager kube-scheduler kubelet kube-proxy
systemctl enable kube-apiserver kube-controller-manager kube-scheduler kubelet kube-proxy

2.查看集群组件状态。
在这里插入图片描述

8.6 批准kubelet证书申请

1.master1节点上操作，查看证书请求。

kubectl get csr
kubectl certificate approve 【csr名称】

在这里插入图片描述
2.查看节点状态。
在这里插入图片描述

8.7 部署nginx+keepalived

  • 我这里是把master1做主节点，master2做备节点。

8.7.1 安装服务

  • 主备节点都执行。
 yum install epel-release -y
 yum install nginx keepalived -y
 yum -y install nginx-all-modules.noarch # 依赖模块，不然nginx会启动失败。

8.7.2 配置nginx配置文件

  • 主备节点都执行，配置内容一样。
cat > /etc/nginx/nginx.conf << "EOF"
user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log;
pid /run/nginx.pid;

include /usr/share/nginx/modules/*.conf;

events {
    worker_connections 1024;
}
# 四层负载均衡，为两台Master apiserver组件提供负载均衡。
stream {

    log_format  main  '$remote_addr $upstream_addr - [$time_local] $status $upstream_bytes_sent';

    access_log  /var/log/nginx/k8s-access.log  main;

    upstream k8s-apiserver {
       server 192.168.130.145:6443;   # Master1 APISERVER IP:PORT
       server 192.168.130.148:6443;   # Master2 APISERVER IP:PORT
    }
    
    server {
       listen 16443;  # 由于nginx与master节点复用，这个监听端口不能是6443，否则会冲突
       proxy_pass k8s-apiserver;
    }
}

http {
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile            on;
    tcp_nopush          on;
    tcp_nodelay         on;
    keepalive_timeout   65;
    types_hash_max_size 2048;

    include             /etc/nginx/mime.types;
    default_type        application/octet-stream;
}
EOF

8.7.3 配置keepalived配置文件（主）

1.修改配置文件，添加VIP。

cat > /etc/keepalived/keepalived.conf << EOF
global_defs { 
   notification_email { 
     acassen@firewall.loc 
     failover@firewall.loc 
     sysadmin@firewall.loc 
   } 
   notification_email_from Alexandre.Cassen@firewall.loc  
   smtp_server 127.0.0.1 
   smtp_connect_timeout 30 
   router_id NGINX_MASTER
} 

vrrp_script check_nginx {     #指定检查nginx工作状态脚本（根据nginx状态判断是否故障转移）
    script "/etc/keepalived/check_nginx.sh"
}

vrrp_instance VI_1 { 
    state MASTER 
    interface ens33  # 修改为实际网卡名
    virtual_router_id 51 # VRRP 路由 ID实例，每个实例是唯一的 
    priority 100    # 优先级，备服务器设置 90 
    advert_int 1    # 指定VRRP 心跳包通告间隔时间，默认1秒 
    authentication { 
        auth_type PASS      
        auth_pass 1111 
    }  
    # 虚拟IP
    virtual_ipaddress { 
        192.168.130.151/24
    } 
    track_script {
        check_nginx
    } 
}
EOF

2.准备配置文件中检查nginx运行状态的脚本。

cat > /etc/keepalived/check_nginx.sh  << "EOF"
#!/bin/bash
count=$(ss -antp |grep 16443 |egrep -cv "grep|$$")

if [ "$count" -eq 0 ];then
    exit 1
else
    exit 0
fi
EOF
chmod +x /etc/keepalived/check_nginx.sh

8.7.4 配置keepalived配置文件（备）

1.修改配置文件，添加VIP。

cat > /etc/keepalived/keepalived.conf << EOF
global_defs { 
   notification_email { 
     acassen@firewall.loc 
     failover@firewall.loc 
     sysadmin@firewall.loc 
   } 
   notification_email_from Alexandre.Cassen@firewall.loc  
   smtp_server 127.0.0.1 
   smtp_connect_timeout 30 
   router_id NGINX_BACKUP
} 

vrrp_script check_nginx {
    script "/etc/keepalived/check_nginx.sh"
}

vrrp_instance VI_1 { 
    state BACKUP 
    interface ens33
    virtual_router_id 51 # VRRP 路由 ID实例，每个实例是唯一的 
    priority 90
    advert_int 1
    authentication { 
        auth_type PASS      
        auth_pass 1111 
    }  
    virtual_ipaddress { 
        192.168.130.151/24
    } 
    track_script {
        check_nginx
    } 
}
EOF

2.准备配置文件中检查nginx运行状态的脚本。

cat > /etc/keepalived/check_nginx.sh  << "EOF"
#!/bin/bash
count=$(ss -antp |grep 16443 |egrep -cv "grep|$$")

if [ "$count" -eq 0 ];then
    exit 1
else
    exit 0
fi
EOF
chmod +x /etc/keepalived/check_nginx.sh

8.7.5 启动并设置开机自启

  • 主备节点都执行。

1.启动服务。

systemctl daemon-reload
systemctl start nginx keepalived
systemctl enable nginx keepalived

2.查看VIP。
在这里插入图片描述

8.7.6 测试高可用性和负载均衡

1.杀掉VIP所在节点的nginx服务，查看VIP是否会转移到另外一台机器。若转移成功，则说明已实现高可用。
在这里插入图片描述
2.集群任意节点，使用VIP访问集群，查看是否能返回数据。若能返回信息，则说明负载均衡已实现。
在这里插入图片描述
3.请求数据流程为：curl ——> vip(nginx) ——> apiserver。
在这里插入图片描述

8.7.7 修改所有Node连接VIP

  • 因为我们是从单Master架构扩容的，也就是说目前所有的Worker Node组件连接都还是master1，若不改为连接VIP走负载均衡器，那么master还是单点故障。

1.查看所有节点，所有节点执行替换VIP命令。

sed -i 's#192.168.130.145:6443#192.168.130.151:16443#' /opt/kubernetes/cfg/*

2.重启服务，检查节点状态。

systemctl restart kubelet kube-proxy

在这里插入图片描述

百慕卿君
关注
专栏目录
K8S二进制部署详解，一文教会你部署高可用K8S集群
景天科技苑
02-07 4346
虽然kubeadm方式搭建K8S比较简单，但是对里面的原理都不清楚的话，生产中使用功能可能不便于排查故障。二进制方式部署的k8s集群比较稳定。 二进制方式搭建：在官网下载相关组件的二进制包，如果手动安装，对kubernetes理解也会更全面。 Kubeadm和二进制都适合生产环境，在生产环境运行都很稳定，具体如何选择，可以根据实际项目进行评估。
二进制部署k8s高可用集群（二进制-V1.20）.docx
06-29
说明：二进制部署k8s高可用集群，内容真实有效！
二进制方式搭建k8s集群
weixin_42072280的博客
01-29 7519
使用二进制方式搭建K8S集群 k8s架构 k8s 集群控制节点，对集群进行调度管理，接受集群外用户去集群操作请求 master节点上的主要组件包括： 1、kube-apiserver：集群控制的入口，提供 HTTP REST 服务，同时交给etcd存储，提供认证、授权、访问控制、API注册和发现等机制 2、kube-controller-manager：Kubernetes 集群中所有资源对象的自动化控制中心，理集群中常规后台任务，一个资源对应一个控制器 3、kube-scheduler：负责 Pod 的
二进制方式部署K8s高可用集群
最新发布
qq_63652578的博客
09-08 1741
kube-apiserver.service是kube-apiserver守护进程的systemd服务单元。当你新增或修改了某个单位文件（如.service文件、.socket文件等），需要运行该命令来刷新systemd对该文件的配置。当你新增或修改了某个单位文件（如.service文件、.socket文件等），需要运行该命令来刷新systemd对该文件的配置。当你新增或修改了某个单位文件（如.service文件、.socket文件等），需要运行该命令来刷新systemd对该文件的配置。
二进制方式部署kubernetes集群
YIYIYI
06-18 3730
二进制方式部署kubernetes集群
二进制部署高可用k8s集群
weixin_45112997的博客
05-22 1745
二进制部署高可用k8s集群
一套完整的K8s高可用集群二进制部署（-V1.20）
10-17
Kubernetes 高可用集群二进制部署指南 本文档将指导您部署一套完整的 Kubernetes 高可用集群，我们将从基础知识点开始，介绍 Kubernetes 集群的两种部署方式，然后详细介绍如何准备环境、部署 Etcd 集群、安装 ...
二进制高可用k8s集群一键部署脚本
04-02
"二进制高可用k8s集群一键部署脚本"是为简化k8s集群搭建过程而设计的工具，它基于阿良的二进制部署文档，旨在帮助开发者和学习者快速创建一个稳定的高可用k8s集群。 首先，了解二进制部署意味着不依赖于预打包的...
二进制方式搭建k8s集群所需文件.zip
01-29
二进制方式搭建k8s集群所需文件.zip
离线部署k8s_1.18.3集群(二进制方式).zip
05-06
参考提供的`参考《二进制方式搭建一个完整K8s集群》1.18新版.pdf`文档，可以获取更详细的操作指南和解决常见问题的方法。 在整个部署过程中，对Linux命令行和网络配置的熟悉程度至关重要，同时也需要理解k8s的基本...
二进制部署k8s集群
m0_46079130的博客
03-30 3098
欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示； 增加了 图片
k8s（kubernetes）集群的两种搭建方式（二进制方式）
2301_77673652的博客
02-21 1706
在开始之前,部署Kubernetes集群机器需要满足以下几个条件:(1)一台或多台机器,操作系统Cent0S7.x-86x64(2)硬件配置:2GB或更多RAM,2个CPU或更多CPU,硬盘30GB 或更多或更多(3)集群中所有机器之间网络互通(4)可以访问外网,需要拉取镜像,如果服务器不能上网,需要提前下载镜像并导入节点(5)禁止swap分区。
2 二进制方式搭建K8S集群
Frank的博客
07-27 2174
本文介绍单Master的K8S集群搭建全过程。 1 环境要求、节点规划、配置 1.1 环境要求 操作系统：CentOS7.8_x64 （mini） 系统配置（每台虚拟机）：2G内存、2个CPU、每个CPU上1个核心、20G硬盘 网络要求：每台虚拟机可访问外网，机器之间可相互访问 Docker 版本：19-ce Kubernetes 版本：1.18 1.2 节点规划 由于我只有一台笔记本电脑（WIN10，16G内存），为了在VMWare中少开启几台虚拟机，就把ETCD集群分别放到仅有的3个节点
k8s高可用集群部署(二进制、containerd)
神神秘秘
12-11 1921
同步k8s更新后部署的坑
【K8S 的二进制搭建】
DiKL_Y的博客
08-09 305
k8s的二进制搭建
【云原生】Kubernetes二进制--多节点Master集群高可用
Hard work results, technology is willing to dream
05-11 1226
多节点Master集群高可用
部署k8s集群
qfyangsheng的博客
08-18 789
准备环境 三台机器,所有机器相互做解析 关闭防火墙和selinux [root@k8s-master ~]# vim /etc/hosts 192.168.96.134 k8s-master 192.168.96.135 k8s-node1 192.168.96.136 k8s-node2 部署Etcd集群 使用cfssl来生成自签证书,任何机器都行，证书这块儿知道怎么生成、怎么用即可，暂且不用过多研究（这个证书随便在那台机器生成都可以。哪里用将证书拷贝到哪里就可以了。） 下载cfssl工具：下载
手动部署K8s高可用集群：二进制方法详解
"二进制部署k8s高可用集群的详细步骤及注意事项" 在Kubernetes（K8s）的世界里，构建一个高可用的集群是至关重要的，以确保服务的稳定性和可靠性。本文档主要讲解如何通过二进制方式部署一个基于v1.20版本的K8s高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

百慕卿君

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值