k8s的二进制部署

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集群进行管理。