k8s的二进制部署

2023-12-28 11:44:18

k8s的二进制部署：源码包部署

架构：

kubemaster01:192.168.233.91? kube-apiserver? kube-controller kube-scheduler（资源调度器）? ETCD

kubemaster02:192.168.233.92? kube-apiserver? kube-controller kube-schedule

node节点01：192.168.233.93? kubelet? ?kube-proxy? ? etcd

node节点02：192.168.233.94? kubelet? ?kube-proxy? ? etcd

负载均衡：nginx+keepalived：master：192.168.233.95

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?backup：192.168.233.96

etcd：192.168.233.91

? ? ? ? ? 192.168.233.93

? ? ? ? ? 192.168.233.94

操作系统初始化配置

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

iptables -F：清除默认的 iptables 规则链（如 INPUT、FORWARD、OUTPUT）中的所有规则。
iptables -t nat -F：清除 "nat" 表中的所有规则，这通常包含用于网络地址转换（NAT）的规则。
iptables -t mangle -F：清除 "mangle" 表中的所有规则，这通常包含用于修改数据包头部的规则。
iptables -X：删除用户自定义的链。它将删除你可能在 iptables 中创建的任何自定义链。
-----------------------------------------------------------------------------------------

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

#关闭swap

关闭交换分区，提升性能
swap交换分区，如果机器内存不够，就会使用swap交换分区，但是swap交换分区的性能较低，
k8s设计的时候为了提升性能，默认是不允许使用交换分区的。kubeadm初始化的时候会检测swap是否关闭，
如果没关闭就会初始化失败。如果不想关闭交换分区，
安装k8s的时候可以指定-ignore-preflight-errors=Swap来解决。

swapoff -a
sed -ri 's/.*swap.*/#&/' /etc/fstab?

swapoff -a

k8s在设计时，为了提升性能，默认是不使用swap交换分区，kubernetes在初始化，会检查swap是否关闭

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

在master添加hosts
cat >> /etc/hosts << EOF
192.168.233.91 master01
192.168.233.93 node01
192.168.233.94 node02
EOF

开启网桥模式

net.bridge.bridge-nf-call-ip6tables=1

net.bridge.bridge-nf-call-iptables=1

#网桥的流量传给iptables的链，实现地址映射

#关闭ipv6的流量（可选项）

net.ipv6.conf.all.disable_ipv6=1

#根据工作中的实际情况，自定。

net.ipv4.ip_forward=1

#开启网关转发功能

sysctl --system使之生效

时间同步：yum -y install ntpdata

ntpdata ntp.aliyun.com

部署 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?

部署 etcd 集群?

部署第一个组件：

存储k8s的集群信息和用户配置组件? etcd：

etcd的一个高可用---------分布式的键值存储数据库

采用raft算法保证节点信息的一致性。etcd是go语言写的。

etcd的端口：2379：api接口，对外为客户端提供通信

? ? ? ? ? ? ? ? ? ? ?2380：内部服务的通信端口。

etcd一般都是集群部署，etcd也有选举leader的机制，至少要3台，或者奇数台

准备签发证书环境

k8s的内部通信依靠证书认证，密钥认证：证书的签发环境

证书签发：

cfssl：证书签发的命令工具?

cfssl-certinfo：查看证书信息的工具

cfssljson：把证书的格式转换成json格式，变成文件的承载式证书。

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

### 生成Etcd证书 ###

mkdir /opt/k8s
cd /opt/k8s/

#上传 etcd-cert.sh 和 etcd.sh 到 /opt/k8s/ 目录中
chmod +x etcd-cert.sh etcd.sh

etcd配置文件创建:
etcd.sh：
在 /opt/etcd/cfg/etcd 路径下创建了一个配置文件，用于定义 etcd 节点的各种参数，
包括节点名称、数据目录、监听地址等。这个配置文件描述了etcd节点在集群中的角色和通信方式。

etcd服务管理文件创建:
在 /usr/lib/systemd/system/etcd.service 路径下创建了一个 systemd 服务管理文件。
这个文件定义了 etcd 服务的启动方式、环境变量以及其他配置，例如 TLS 证书的路径。

启动etcd服务:
使用 systemd 启动了 etcd 服务。systemd 是 Linux 系统的一个服务管理工具，它能够启动、停止和管理后台服务。

vim 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

#CN：Common Name，浏览器使用该字段验证网站或机构是否合法，一般写的是>域名?
#key：指定了加密算法，一般使用rsa（size：2048）
#C：Country，国家
#ST：State，州，省
#L：Locality，地区,城市
#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": [
? ? "20.0.0.100",
? ? "20.0.0.180",
? ? "20.0.0.181",
? ? "20.0.0.182",
? ? "20.0.0.183"
? ? ],
? ? "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

vim etcd.sh

#!/bin/bash
#example: ./etcd.sh etcd01 192.168.80.10 etcd02=https://192.168.80.11:2380,etcd03=https://192.168.80.12: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
?

chmod 777 etcd-cert.sh? etcd.sh

mkdir /opt/k8s/etcd-cert

mv etcd-cert.sh etcd-cert/

生成配置文件

ca-config.json? 证书颁发机构的配置文件，定义了证书生成的策略，默认的过期时间和模版

ca-csr.json? 签名的请求文件，包括一些组织信息和加密方式

ca.pem? 根证书文件，用于给其他组件签发证书

server.csr? etcd的服务器签发证书的请求文件

server.key.pem? etcd服务器的私钥文件

ca.csr：根证书签发请求文件

ca-key.pem? 根证书的私钥文件

etcd-cert.sh

server-csr.json 用于生成etcd的服务器证书的私钥签名文件。

server.pem? etcd服务器的证书文件，用于加密和认证etcd节点之间的通信。

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

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

cd /opt/k8s/
tar zxvf etcd-v3.4.9-linux-amd64.tar.gz
ls etcd-v3.4.9-linux-amd64
Documentation ?etcd ?etcdctl ?README-etcdctl.md ?README.md ?READMEv2-etcdctl.md

#创建用于存放 etcd 配置文件，命令文件，证书的目录

mkdir -p /opt/etcd/{cfg,bin,ssl}

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

cd /opt/k8s/
./etcd.sh etcd01 192.168.233.91 etcd02=https://192.168.233.93:2380,etcd03=https://192.168.233.94:2380
#进入卡住状态等待其他节点加入，这里需要三台etcd服务同时启动，如果只启动其中一台后，
服务会卡在那里，直到集群中所有etcd节点都已启动，可忽略这个情况

#可另外打开一个窗口查看etcd进程是否正常
ps -ef | grep etcd

#把etcd相关证书文件、命令文件和服务管理文件全部拷贝到另外两个etcd集群节点
scp -r /opt/etcd/ root@192.168.233.93:/opt/
scp -r /opt/etcd/ root@192.168.233.94:/opt/
scp /usr/lib/systemd/system/etcd.service root@192.168.233.93:/usr/lib/systemd/system/
scp /usr/lib/systemd/system/etcd.service root@192.168.233.94:/usr/lib/systemd/system/

//在 node01 节点上操作

vim /opt/etcd/cfg/etcd

#[Member]
ETCD_NAME="etcd02"?? ??? ??? ??? ??? ??? ??? ??? ??? ??? ??? ?#修改
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.233.93:2380"?? ??? ??? ?#修改
ETCD_LISTEN_CLIENT_URLS="https://192.168.233.93:2379"?? ??? ?#修改

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.233.93:2380"?? ??? ?#修改
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.233.93:2379"?? ??? ??? ??? ?#修改
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.233.91:2380,etcd02=https://192.168.233.93:2380,etcd03=https://192.168.233.94:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

#启动etcd服务
systemctl start etcd
systemctl enable etcd
systemctl status etcd

注：要先起master节点，再起node节点

//在 node02 节点上操作

vim /opt/etcd/cfg/etcd

#[Member]
ETCD_NAME="etcd03"?? ??? ??? ??? ??? ??? ??? ??? ??? ??? ??? ?#修改
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.233.94:2380"?? ??? ??? ?#修改
ETCD_LISTEN_CLIENT_URLS="https://192.168.233.94:2379"?? ??? ?#修改

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.233.94:2380"?? ??? ?#修改
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.233.94:2379"?? ??? ??? ??? ?#修改
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.233.91:2380,etcd02=https://192.168.233.93:2380,etcd03=https://192.168.233.94:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

#启动etcd服务
systemctl start etcd
systemctl enable etcd
systemctl status etcd

#检查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.233.91:2379,https://192.168.233.93:2379,https://192.168.233.94:2379" endpoint health --write-out=table

#查看etcd集群成员列表

部署 Master 组件

//在 master01 节点上操作
#上传 master.zip 和 k8s-cert.sh 到 /opt/k8s 目录中，解压 master.zip 压缩包
cd /opt/k8s/
unzip master.zip
chmod +x *.sh

vim apiserver.sh

service-node-port-range=30000-50000：对外暴露端口的范围信息

vim controller-manager

cluster-cidr=10.244.0.0/16 （10:04）声明pod资源的网段地址，flannel网络默认的网段就10.244.0.0/16? ?calico网络插件：192.168.0.0/16

--service-cluster-ip-range=10.0.0.0/24: 指定 Service Cluster IP 地址段。

#生成证书

KUBE_APISERVER="https://20.0.0.181:6443" 指向master的IP地址

vim scheduler.sh

生成kubeconfig文件

KUBE_APISERVER 也必须指向master的地址

vim admin.sh

一样API_SERVER的ip地址要改为本机的ip地址

kubectl config set-cluster kubernetes \
? --certificate-authority=/opt/kubernetes/ssl/ca.pem \
? --embed-certs=true \
? --server=${KUBE_APISERVER} \
? --kubeconfig=${KUBE_CONFIG}
?

context上下文：

定义连接到哪个k8s集群，以及使用哪个用户的身份来进行操作，上下文包含了集群，用户，和可选命名空间的信息。

在k8s的集群环境中进行切换。

#创建kubernetes工作目录

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

#创建用于生成CA证书、相关组件的证书和私钥的目录

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

k8s-cert.sh
这个脚本用于生成 Kubernetes 集群中各个组件所需的证书和私钥。

ls *pem
admin-key.pem ?apiserver-key.pem ?ca-key.pem ?kube-proxy-key.pem ?
admin.pem ? ? ?apiserver.pem ? ? ?ca.pem ? ? ?kube-proxy.pem

admin.csr：Admin 用户证书签发请求文件。

admin.pem：Admin 用户证书文件。

admin-key.pem：Admin 用户证书私钥文件。

ca.csr：CA（Certificate Authority）证书签发请求文件。

ca.pem：CA 证书文件，是根证书。

ca-key.pem：CA 证书私钥文件，是根证书的私钥。

apiserver-key.pem: 包含 Kubernetes API Server 的私钥。

apiserver.pem: 包含 Kubernetes API Server 的证书。

kube-proxy-csr.json：kube-proxy 组件的证书签发请求文件。

kube-proxy-key.pem：kube-proxy 组件的证书私钥文件。

kube-proxy-csr：kube-proxy 组件的证书签发请求文件。

kube-proxy.pem：kube-proxy 组件的证书文件。

ca-config.json：CA 配置文件，用于定义颁发证书的策略和过期时间等参数。

ca-csr.json：CA 证书签发请求文件的配置，定义 CA 证书的各项信息。

ca-key.pem：CA 证书的私钥文件。

#复制CA证书、apiserver相关证书和私钥到 kubernetes工作目录的 ssl 子目录中

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

#上传 kubernetes-server-linux-amd64.tar.gz 到 /opt/k8s/ 目录中，解压 kubernetes 压缩包
#下载地址：https://github.com/kubernetes/kubernetes/blob/release-1.20/CHANGELOG/CHANGELOG-1.20.md
#注：打开链接你会发现里面有很多包，下载一个server包就够了，包含了Master和Worker Node二进制文件。

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

生成一个16进制的密钥对，用于集群授权，节点授权

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

cd /opt/k8s/
./apiserver.sh 192.168.233.91 https://192.168.233.91:2379,https://192.168.233.93:2379,https://192.168.233.94:2379

#检查进程是否启动成功

ps aux | grep kube-apiserver

netstat -natp | grep 6443 ? #安全端口6443用于接收HTTPS请求，用于基于Token文件或客户端证书等认证

#启动 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

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

kubectl get cs
NAME ? ? ? ? ? ? ? ? STATUS ? ?MESSAGE ? ? ? ? ? ? ERROR
controller-manager ? Healthy ? ok ? ? ? ? ? ? ? ? ?
scheduler ? ? ? ? ? ?Healthy ? ok ? ? ? ? ? ? ? ? ?
etcd-2 ? ? ? ? ? ? ? Healthy ? {"health":"true"} ??
etcd-1 ? ? ? ? ? ? ? Healthy ? {"health":"true"} ??
etcd-0 ? ? ? ? ? ? ? Healthy ? {"health":"true"} ?

#查看版本信息

kubectl version

kubectl api-resources

调用接口的api信息

调用命名空间信息等

部署 Worker Node 组件

//在所有 node 节点上操作

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

//在 master01 节点上操作

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

cd /opt/k8s/kubernetes/server/bin
scp kubelet kube-proxy root@192.168.233.93:/opt/kubernetes/bin/
scp kubelet kube-proxy root@192.168.233.94:/opt/kubernetes/bin/

到node节点查看一下

vim kubelet.sh

#--network-plugin=cni：启用CNI

#--bootstrap-kubeconfig：指定连接 apiserver 的 bootstrap.kubeconfig >文件

--bootstrap-kubeconfig=/opt/kubernetes/cfg/bootstrap.kubeconfig \\ master节点申请认证证书的秘钥

vim porxy.sh

#--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模式

集群的秘钥文件

用于集群授权

?传入配置文件当中

RBAC授权，生成和赋权用户kubelet-bootstrap，发起node节点

k8s的网络类型

网络部署

k8s中的通信模式：

1、pod内部之间容器与容器之间的通信。

在同一个pod容器中的容器共享资源和网络，使用同一个网络命名空间。可以之间通信的。

2、同一个node节点之内，不同pod之间的通信

每个pod都有一个全局的真实的ip地址，同一个node之间的不同pod可以直接使用对方pod的ip地址进行通信。

pod1和pod2是通过docker0的网桥来进行通信。

3、不同node节点上的pod之间如何进行通信？

cni的插件：

cni是一个标准接口，用于容器运行时调用网络插件，配置容器网络，负责设置容器的网络命名空间，ip地址，路由等参数。

flannel插件：功能就是让集群之中不同节点的docker容器具有全集群唯一的虚拟ip地址。

overlay网络，在底层物理网络的基础之上，创建一个逻辑的网络层。二层+三层的集合。二层（数据链路层）是物理网络，三层是逻辑上的网络层。

overlay网络也是一种网络虚拟化的技术。

flannel支持的数据转发方式：

1、UDP模式，默认模式，应用转发，配置简单，但是性能最差

2、vxlan，基于内核转发，也是最常用的网络类型（小集群都是用这个）

3、host-gw（性能最好，但是配置麻烦。）

UDP：基于应用转发，由flannel提供路由表（转发），flannel封装数据包，解封装。

node都会有一个flannel的虚拟网卡，负责封装和解封装。（封装，提供路由表）

udp的工作模式图：

vxlan：使用的就是overlay的虚拟隧道通信模式。二层+三层的模式。

udp是基于应用层，用户。

vxlan：flannel提供路由表，内核封装解封装。

flannel1.1接口

vxlan的工作流程图（9:52）

flannel负责识别对应的VNP的ip地址

? ? ? ? 根据vni+ip地址寻址，找到目标地址的网段进行通信。

组件

Calico插件：

flannel：每个发向容器的数据包进行封装，vxlan通过vtep打包数据，由内核封装数据包--->转发到

目标的node节点

到了目标节点，还有一个解封装的过程，再发送目标pod。性能是有一定影响的。

calico：采用直接路由的方式。BGP路由（动态路由）。不需要修改报文，统一直接通过路由表转发，路由表会很复杂，运行维护的要求比较高。

BGP

BGP模式的特点：交换路由信息的外部网关协议，可以连接不同的node节点（自制系统），node节点可能不是一个网段，BGP会自动寻址。BGP会实现可靠的（安全），最佳的（路径最短），而且是动态的路由选择。自动识别相邻的路由设备。

?Calico不使用overlay，也不需要交换，直接通过虚拟路由实现，每一台虚拟路由，都通过BGP转发。转发到另外的组件。

核心组件：

felix：也是运行在主机的一个个pod，一个进程，k8s daemonset的方式部署的pod。

daemon set 会在每个node节点部署相同的pod，后台的运行方式。

负责在宿主机上插入路由规则，维护calico需要的网络设备。网络接口的管理，监听，路由等等。

BGP Client：bird? BGP的客户端，专门负责在集群中分发路由规则的信息。每一个节点都会有一个BGP Client。

BGP协议广播方式通知其他节点的，分发路由的规则。实现网络互通。

etcd：保存路由信息，负责整个网络元数据的一致性。保证网络状态的一致和准确。

calico的工作原理：

路由表来维护每个pod之间的通信。

创建好pod之后，添加一个设备call? veth? pair设备。

虚拟网卡：veth? pair是一对设备，虚拟的以太网设备。

一头连接在容器的网络命名空间? ? ? ? etho

另一头连接宿主机的网络命名空间? ? cali

ip地址分配：veth? pair连接容器的部分给容器分配一个ip地址，这个ip地址是唯一标识，宿主机也会被veth? pair分配一个calico网络的内部ip地址。和其他节点上的容器进行通信。

veth设备，容器发出的ip地址通过veth? pair设备到宿主机，宿主机根据路由规则的下一跳地址，发送到网关（目标宿主机）。

数据包到达目标宿主机，veth? pair设备，目标宿主机也是根据路由规则，下一跳地址，转发到目标容器。

原理图：（calico纯路由转发，通过BGP协议发现对方设备）

在ip in ip模式：会生成一个tunnel。数据包都在tunnel内部打包。封装：宿主机ip? 容器内部的IP地址。

每一个pod生成一个网卡，也自动生成路由条目，删除之后，网卡也会删除

k8s网络类型总结：

常用的网络类型插件：

flannerl和calico：

flannel：配置简单，功能简单，基于overlay叠加网络实现，在物理层的网络再封装一个虚拟的网络

vxlan是虚拟的三层网络。

udp是默认模式

vxlan 用的最多的模式? ? vni + ip进行转发，flannel提供路由表，内核封装和解封装

hodt-gw

由于封装和解封装的过程，对数据传输的性能会有影响。没有网络策略配置的能力。? UDO（协议）

默认网段：10.244.0.0/16

Calico：功能强大，基于路由表进行转发，没有封装和解封装的过程，具备网络策略的配置能力。但是路由表维护起来复杂。

模式：ipip? ? BGP

BGP：通过维护ip路由表的前缀来实现目标主机的可达性。

对比ipip模式，BGP模式没有隧道。BGP模式下，POD的数据包直接通过网卡发送到目的地。

ipip的隧道：隧道进行数据包的封装? ?ipv4 ------ ipv4。

简单的小集群：flannel

扩容，配置网络策略：calico

我用的是flannel 用的是vxlan

BGP 和ipip

集群较大calico

11:53

coredns：

可以为集群当中的service资源创建一个域名和ip进行对应解析的关系。

service是对外提供访问的地址，现在我们加入DNS机制之后，可以直接访问服务名，

kubectl? run -it? rm? dns-test? --image=busybox：1.28.4? ?sh

apiserver

manager

master02没有

Dashboard：

仪表盘，kubenetes的可视化界面。在这个可视化界面上，可以对k8s集群进行管理。

文章来源:https://blog.csdn.net/m0_70766460/article/details/135213115
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！