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

开启网桥模式

k8s的二进制部署_第1张图片

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使之生效

k8s的二进制部署_第2张图片

k8s的二进制部署_第3张图片

时间同步: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*

k8s的二进制部署_第4张图片

### 生成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 系统的一个服务管理工具,它能够启动、停止和管理后台服务。

k8s的二进制部署_第5张图片

vim etcd-cert.sh

#!/bin/bash
#配置证书生成策略,让 CA 软件知道颁发有什么功能的证书,生成用来签发其
他组件证书的根证书
cat > ca-config.json < {
  "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 < {
    "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 文件用的是相对路径,所以 cfssl 的时候需要 csr 文件的路
径下执行,也可以指定为绝对路径。
#cfssljson 将 cfssl 生成的证书(json格式)变为文件承载式证书,-bare >用于命名生成的证书文件。


#生成 etcd 服务器证书和私钥
cat > server-csr.json < {
    "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  < #[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 < [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
 

k8s的二进制部署_第6张图片

chmod 777 etcd-cert.sh  etcd.sh

mkdir /opt/k8s/etcd-cert

mv etcd-cert.sh etcd-cert/

生成配置文件

k8s的二进制部署_第7张图片

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

k8s的二进制部署_第8张图片

#创建用于存放 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/

k8s的二进制部署_第9张图片

k8s的二进制部署_第10张图片

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/ [email protected]:/opt/
scp -r /opt/etcd/ [email protected]:/opt/
scp /usr/lib/systemd/system/etcd.service [email protected]:/usr/lib/systemd/system/
scp /usr/lib/systemd/system/etcd.service [email protected]:/usr/lib/systemd/system/
k8s的二进制部署_第11张图片

k8s的二进制部署_第12张图片

k8s的二进制部署_第13张图片

k8s的二进制部署_第14张图片

//在 node01 节点上操作

vim /opt/etcd/cfg/etcd

k8s的二进制部署_第15张图片

#[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

k8s的二进制部署_第16张图片

注:要先起master节点,再起node节点

k8s的二进制部署_第17张图片

k8s的二进制部署_第18张图片

//在 node02 节点上操作

vim /opt/etcd/cfg/etcd

k8s的二进制部署_第19张图片

#[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

k8s的二进制部署_第20张图片

k8s的二进制部署_第21张图片

#检查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
k8s的二进制部署_第22张图片

#查看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" --write-out=table member list
k8s的二进制部署_第23张图片

部署 Master 组件

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

k8s的二进制部署_第24张图片

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 地址段。

k8s的二进制部署_第25张图片

#生成证书

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

k8s的二进制部署_第26张图片

vim scheduler.sh

生成kubeconfig文件

KUBE_APISERVER 也必须指向master的地址

k8s的二进制部署_第27张图片

vim admin.sh

k8s的二进制部署_第28张图片

一样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 集群中各个组件所需的证书和私钥。

k8s的二进制部署_第29张图片

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

k8s的二进制部署_第30张图片

#复制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/

k8s的二进制部署_第31张图片

#创建 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 < ${BOOTSTRAP_TOKEN},kubelet-bootstrap,10001,"system:kubelet-bootstrap"
EOF

chmod +x token.sh
./token.sh

cat /opt/kubernetes/cfg/token.csv

k8s的二进制部署_第32张图片

k8s的二进制部署_第33张图片

生成一个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

k8s的二进制部署_第34张图片

#检查进程是否启动成功

ps aux | grep kube-apiserver

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


#启动 scheduler 服务

cd /opt/k8s/
./scheduler.sh
ps aux | grep kube-scheduler

k8s的二进制部署_第35张图片

#启动 controller-manager 服务

./controller-manager.sh
ps aux | grep kube-controller-manager

k8s的二进制部署_第36张图片

#生成kubectl连接集群的kubeconfig文件

./admin.sh

k8s的二进制部署_第37张图片

#通过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"}  

k8s的二进制部署_第38张图片

#查看版本信息

kubectl version

k8s的二进制部署_第39张图片

kubectl api-resources

调用接口的api信息

调用命名空间信息等

k8s的二进制部署_第40张图片

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

k8s的二进制部署_第41张图片

k8s的二进制部署_第42张图片

//在 master01 节点上操作

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

cd /opt/k8s/kubernetes/server/bin
scp kubelet kube-proxy [email protected]:/opt/kubernetes/bin/
scp kubelet kube-proxy [email protected]:/opt/kubernetes/bin/

k8s的二进制部署_第43张图片

到node节点查看一下

vim kubelet.sh

k8s的二进制部署_第44张图片

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

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

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

vim porxy.sh

k8s的二进制部署_第45张图片

k8s的二进制部署_第46张图片

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

集群的秘钥文件

用于集群授权

k8s的二进制部署_第47张图片

 传入配置文件当中

k8s的二进制部署_第48张图片

k8s的二进制部署_第49张图片

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

k8s的二进制部署_第50张图片

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)

k8s的二进制部署_第51张图片

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

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

k8s的二进制部署_第52张图片

组件

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协议发现对方设备)

k8s的二进制部署_第53张图片

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

你可能感兴趣的:(kubernetes,linux,容器)