前言
二进制部署 Kubernetes(K8s)集群相对于其他部署方式(如基于发行版的包管理器、容器化部署工具等)具有一些优势,主要包括:
- 灵活性:二进制部署方式更加灵活,您可以根据自己的需求和偏好选择特定版本的Kubernetes组件,并对组件进行个性化配置和定制。
- 精简性:二进制部署只包含Kubernetes组件的原始二进制文件和配置文件,不会包含其他系统组件或依赖,使得部署更加精简和高效。
- 可控性:通过二进制部署,您可以直接控制Kubernetes组件的版本和配置,可以更灵活地进行升级、回滚和调试。
- 定制化:您可以根据自己的需求定制Kubernetes集群的部署方式和配置,以满足特定的业务场景和需求。
- 学习机会:通过二进制部署Kubernetes您可以更深入地了解Kubernetes的内部原理和工作机制,对集群的运行原理和调优策略有更深入的理解。
基础环境配置
请参考:https://blog.csdn.net/qq42004/article/details/136643557?spm=1001.2014.3001.5502
- 下载安装Containerd文件
Github地址:https://github.com/containerd/containerd/releases/tag/v1.7.15
解压文件:mkdir /usr/local/containerd && tar zxf containerd-1.7.15-linux-amd64.tar.gz -C /usr/local/containerd
-
声明环境变量
export CONTAINERD_PATH=/usr/local/containerd
export PATH= C O N T A I N E R D P A T H / b i n : CONTAINERD_PATH/bin: CONTAINERDPATH/bin:PATH环境变量生效source /etc/profile
-
创建配置文件目录生产配置文件:
mdkir /etc/containerd && containerd config > /etc/containerd/config.toml
1)注释掉下面文件(追踪数据收集不需要)
[plugins."io.containerd.tracing.processor.v1.otlp"]
endpoint = ""
insecure = false
protocol = ""
2)修改registry.k8s.io/pause:3.8为registry.cn-hangzhou.aliyuncs.com/google_containers/pause:3.8
3)配置containerd数据存储路径
[plugins."io.containerd.internal.v1.opt"]
path = "/var/lib/containerd"
4)修改containerd驱动
SystemdCgroup = true
- 启动Containerd
yum安装的containerd有service的配置文件,修改启动命令ExecStart=/usr/local/containerd/bin/containerd
,拷贝至/usr/lib/systemd/system。
systemctl daemon-reload
systemctl enable containerd.service
systemctl start containerd.service
- 安装容器进行时
GitHub地址:https://github.com/opencontainers/runc/tags
mkdir /usr/local/runc && chmod 755 runc.amd64 && cp ./runc.amd64 /usr/local/runc/
ln -s /usr/local/runc/runc.amd64 /usr/local/bin/runc
测试:runc -v
[root@master mnt]# runc -v
runc version 1.1.12
commit: v1.1.12-0-g51d5e946
spec: 1.0.2-dev
go: go1.20.13
libseccomp: 2.5.4
- 安装网络接口cni
GitHub地址:https://github.com/containernetworking/plugins/tree/v1.4.1
mkdir -p /opt/cni/bin && tar zxf cni-plugins-linux-amd64-v1.4.1.tgz -C /opt/cni/bin
cni插件须在/opt/cni/bin下
重启containerd
- 安装crictl工具
Github地址:https://github.com/kubernetes-sigs/cri-tools/blob/master/docs/crictl.md
mkdir /usr/local/crictl && tar zxf crictl-v1.28.0-linux-amd64.tar.gz -C /usr/local/crictl
ln -s /usr/local/crictl/* /usr/local/bin
- 配置crictl
1)生成配置文件crictl config --set debug=false
2)修改文件参数/etc/crictl.yaml
[root@master crictl]# cat /etc/crictl.yaml
runtime-endpoint: "unix:///run/containerd/containerd.sock"
image-endpoint: "unix:///run/containerd/containerd.sock"
timeout: 0
debug: false
pull-image-on-create: false
disable-pull-on-run: false
3)测试命令
[root@master crictl]# crictl version
Version: 0.1.0
RuntimeName: containerd
RuntimeVersion: v1.7.15
RuntimeApiVersion: v1
证书
官方参考文档:https://kubernetes.io/zh-cn/docs/tasks/tls/managing-tls-in-a-cluster/
Kubernetes中的证书通常用于安全连接和身份验证。同一套证书必须是同一个CA签署,因为要验证证书的一端,这一端通常只能指定一个ROOT CA(根证书)。但是不同套里的证书可以是同一个CA签署也可是不同的CA签署。使用同一套证书来搭建K8s一样可以生产运行,并且理清证书关系后,遇到证书错误时可以更方便的处理问题。
Kubernetes部署的时候用到较多的证书和比较多的配置参数,要理清证书的关系不要混乱否则后面组件的访问会出问题,配置参数就需要慢慢熟悉了。
证书及文件整理图:
1、上传证书创建工具
证书工具Github地址: https://github.com/cloudflare/cfssl/releases
上传证书创建工具:
添加可执行权限chmod 755
mkdir /usr/local/cfs && cp * /usr/local/cfs
ln -s /usr/local/cfs/cfssl_1.6.5_linux_amd64 /usr/local/bin/cfsslc
ln -s /usr/local/cfs/cfssl-certinfo_1.6.5_linux_amd64 /usr/local/bin/cfssl-certinfo
ln -s /usr/local/cfs/cfssljson_1.6.5_linux_amd64 /usr/local/bin/cfssljson
示例证书:
{
"CN": "kubernetes",
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"L": "ShenZhen",
"O": "kubernetes",
"OU": "Kubernetes-manual",
"ST": "GuangDong"
/* 执行时候需要删除注释内容
"C": "CN":表示证书的国家代码为中国CN。
"L": "ShenZhen":表示证书的地区(Locality)为深圳市。
"O": "k8s":表示证书的组织(Organization)为 k8s,这里可能表示 Kubernetes。
"OU": "System":表示证书的组织单元(Organizational Unit)为 System,通常表示该证书用于系统级别的操作。
"ST": "GuangDong":表示证书的州或省份(State or Province)为广东。
expiry: 指定了证书的到期时间,单位为小时。87600h表示证书的有效期为10年(365 天/年 * 24 小时/天 * 10 年)。
*/
}
],
"ca": {
"expiry": "87600h"
}
}
- 证书的"OU":配置为Kubernetes-manual配置出于安全或管理方面的考虑,以确保证书被正确地归类和管理。配置为"Kubernetes-manual"表示这些证书是手动创建或管理的,而不是由自动化流程生成的。
- 在聚合证书中"CN": 通常将"CN"字段配置为"front-proxy-client"。这是为了确保代理客户端的身份可以被正确识别和验证。在Kubernetes中,这些证书通常用于进行API请求的代理,以确保安全地传输数据,并确保只有经过授权的代理才能访问API服务器。
- xxx-csr.json:作用:用于定义证书签名请求(CSR)的参数和属性,用于创建 CA 或其他证书的 CSR。
内容:通常包含了证书的主题信息(如公用名称、组织、国家等)、密钥参数(如算法、大小等)以及其他配置参数(如证书到期时间等)。 - xx-config.json:作用:用于配置证书颁发机构(CA)的参数,定义了证书签名时使用的默认参数和配置文件。
内容:通常包含了默认的签名配置(如默认证书有效期、签名算法等)以及不同证书类型的配置文件(如服务器证书、客户端证书等)。
部署ETCD
ETCD的Github地址:https://github.com/etcd-io/etcd/tags
创建etcd证书
1) 创建ca-config.json文件
{
"signing": {
"default": {
"expiry": "87600h"
},
"profiles": {
"kubernetes": {
"expiry": "87600h",
"usages": ["signing", "key encipherment", "server auth", "client auth"]
}
}
}
}
xxx-csr.json作用:用于定义证书签名请求(CSR)的参数和属性,用于创建 CA 或其他证书的 CSR。
内容:通常包含了证书的主题信息(如公用名称、组织、国家等)、密钥参数(如算法、大小等)以及其他配置参数(如证书到期时间等)。
xx-config.json作用:用于配置证书颁发机构(CA)的参数,定义了证书签名时使用的默认参数和配置文件。
内容:通常包含了默认的签名配置(如默认证书有效期、签名算法等)以及不同证书类型的配置文件(如服务器证书、客户端证书等)。
生成ETDC证书:
生成跟证书:
cfssl gencert -initca etcd-ca-csr.json | cfssljson -bare /etc/etcd/ssl/etcd-ca
生成etcd证书:
cfsslc gencert -ca=/etc/etcd/ssl/etcd-ca.pem -ca-key=/etc/etcd/ssl/etcd-ca-key.pem -config=/home/pki/ca-config.json -profile=kubernetes etcd-csr.json | cfssljson -bare /etc/etcd/ssl/etcd
部署ETCD
三台服务均需要部署。启动的时同时启动,否则集群报错。
1) 下载上传ETCD
解压文件上传至服务:
tar zxf etcd-v3.5.10-linux-amd64.tar.gz -C /usr/local && mv etcd-v3.5.10-linux-amd64 etcd
ln -s /usr/local/etcd/etcd /usr/local/bin/etcd
ln -s /usr/local/etcd/etcdctl /usr/local/bin/etcdctl
ln -s /usr/local/etcd/etcdutl /usr/local/bin/etcdutl
2) 配置ETCD
配置文件从yam安装的etcd拷贝。ETCD配置文件:
#[Member]
#ETCD_CORS=""
ETCD_NAME="etcd01"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
#数据存储路径
ETCD_WAL_DIR="/var/log/etcd"
#WAL日志存储路径
ETCD_LISTEN_PEER_URLS="https://192.168.0.100:2380"
#指定etcd 监听来自其他 etcd 实例的对等节点连接的地址。在这个示例中,etcd 会监听本地地址 localhost:2380 上的连接请求
ETCD_LISTEN_CLIENT_URLS="https://192.168.0.100:2379,https://127.0.0.1:2379"
#E指定etcd监听来自客户端的连接请求的地址。在这个示例中,etcd会监听本地地址 本地:2379的连接请求。
#ETCD_MAX_SNAPSHOTS="5"
#ETCD_MAX_WALS="5"
#保存日志的数量
#ETCD_SNAPSHOT_COUNT="100000"
#ETCD_HEARTBEAT_INTERVAL="100"
#ETCD_ELECTION_TIMEOUT="1000"
#ETCD_QUOTA_BACKEND_BYTES="0"
#ETCD_MAX_REQUEST_BYTES="1572864"
#ETCD_GRPC_KEEPALIVE_MIN_TIME="5s"
#ETCD_GRPC_KEEPALIVE_INTERVAL="2h0m0s"
#ETCD_GRPC_KEEPALIVE_TIMEOUT="20s"
#
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.0.100:2380"
#指定每个etcd节点用于广播其对等节点 RL的地址。
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.0.100:2379"
#指定每个etcd节点用于广播其客户端 URL 的地址。
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.0.100:2380,etcd02=https://192.168.0.101:2380,etcd03=https://192.168.0.102:2380"
#指定 etcd 集群中每个节点的成员关系。每个节点都应列出集群中的所有节点及其对应的对等节点 URL。
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
#指定 etcd 集群的令牌。令牌用于在新的集群中区分不同的集群实例。在创建新的集群时,应为所有节点设置相同的令牌。
ETCD_INITIAL_CLUSTER_STATE="new"
#指定 etcd 集群的初始状态。在创建新的集群时,应将其设置为 "new"。在对现有集群进行重新配置时,应将其设置为 "existing"。
#ETCD_DISCOVERY=""
#ETCD_DISCOVERY_FALLBACK="proxy"
#ETCD_DISCOVERY_PROXY=""
#ETCD_DISCOVERY_SRV=""
#ETCD_STRICT_RECONFIG_CHECK="true"
#ETCD_ENABLE_V2="true"
#
#[Proxy]
#ETCD_PROXY="off"
#ETCD_PROXY_FAILURE_WAIT="5000"
#ETCD_PROXY_REFRESH_INTERVAL="30000"
#ETCD_PROXY_DIAL_TIMEOUT="1000"
#ETCD_PROXY_WRITE_TIMEOUT="5000"
#ETCD_PROXY_READ_TIMEOUT="0"
#
[Security]
ETCD_CERT_FILE="/etc/etcd/ssl/etcd.pem"
ETCD_KEY_FILE="/etc/etcd/ssl/etcd-key.pem"
ETCD_CLIENT_CERT_AUTH="true"
ETCD_TRUSTED_CA_FILE="/etc/etcd/ssl/etcd-ca.pem"
ETCD_AUTO_TLS="true"
ETCD_PEER_CERT_FILE="/etc/etcd/ssl/etcd.pem"
ETCD_PEER_KEY_FILE="/etc/etcd/ssl/etcd-key.pem"
ETCD_PEER_CLIENT_CERT_AUTH="true"
ETCD_PEER_TRUSTED_CA_FILE="/etc/etcd/ssl/etcd-ca.pem"
ETCD_PEER_AUTO_TLS="true"
#
#[Logging]
#ETCD_DEBUG="false"
#ETCD_LOG_PACKAGE_LEVELS=""
#ETCD_LOG_OUTPUT="default"
#
#[Unsafe]
#ETCD_FORCE_NEW_CLUSTER="false"
#
#[Version]
#ETCD_VERSION="false"
#ETCD_AUTO_COMPACTION_RETENTION="0"
#
#[Profiling]
#ETCD_ENABLE_PPROF="false"
#ETCD_METRICS="basic"
#
#[Auth]
#ETCD_AUTH_TOKEN="simple"
其他节点使用配置文件时候需要修改conf文件的etcd名字和ip地址。
3) 配置etcd.service
配置文件从yam安装的etcd拷贝。etcd.service配置文件:
[Unit]
Description=Etcd Server
After=network.target
After=network-online.target
Wants=network-online.target
[Service]
Type=notify
WorkingDirectory=/var/lib/etcd/
EnvironmentFile=-/etc/etcd/etcd.conf
#User=etcd
#set GOMAXPROCS to number of processors
ExecStart=/usr/local/bin/etcd
Restart=on-failure
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target
4)创建服务器环境
创建数据目录:mkdir -p /var/lib/etcd/default.etcd && chmod 700 /var/lib/etcd/default.etcd
#设置只有所有者具有读、写和执行权限,其他用户没有任何权限
创建日志目录:mkdir /var/log/etcd
创建配置文件目录:mkdir -p /etc/etcd/ssl
拷贝证书至/etc/etcd/ssl(证书会在etcd.service中调用)
5)启动Etcd检查集群状态
systemctl daemon-reload
systemctl start etcd.service
systemctl enable etcd.service
检查集群状态:
[root@master etcd]# etcdctl --write-out=table --cacert=/etc/etcd/ssl/etcd-ca.pem --cert=/etc/etcd/ssl/etcd.pem --key=/etc/etcd/ssl/etcd-key.pem --endpoints=https://192.168.0.100:2379,https://192.168.0.101:2379,https://192.168.0.102:2379 endpoint health
+----------------------------+--------+--------------+-------+
| ENDPOINT | HEALTH | TOOK | ERROR |
+----------------------------+--------+--------------+-------+
| https://192.168.0.101:2379 | true | 59.856898ms | |
| https://192.168.0.100:2379 | true | 61.297606ms | |
| https://192.168.0.102:2379 | true | 100.095228ms | |
+----------------------------+--------+--------------+-------+
[root@master pki]# etcdctl --write-out=table --cacert=/etc/etcd/ssl/etcd-ca.pem --cert=/etc/etcd/ssl/etcd.pem --key=/etc/etcd/ssl/etcd-key.pem --endpoints=https://192.168.0.100:2379,https://192.168.0.101:2379,https://192.168.0.102:2379 endpoint status --write-out=table 集群选举
+----------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
| ENDPOINT | ID | VERSION | DB SIZE | IS LEADER | IS LEARNER | RAFT TERM | RAFT INDEX | RAFT APPLIED INDEX | ERRORS |
+----------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
| https://192.168.0.100:2379 | 24e4f27b490ebdfb | 3.5.10 | 20 kB | false | false | 4 | 16 | 16 | |
| https://192.168.0.101:2379 | aeed280fbd4b48b | 3.5.10 | 20 kB | true | false | 4 | 16 | 16 | |
| https://192.168.0.102:2379 | 1e149427bfba9593 | 3.5.10 | 20 kB | false | false | 4 | 16 | 16 | |
+----------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
部署kubernetes
kubernetesGitHub下载地址:https://github.com/kubernetes/kubernetes/tags
此处部署的是:kubernetes1.28.7通过官方下载:https://dl.k8s.io/v1.28.7/kubernetes-server-linux-amd64.tar.gz
部署ApiServer组件
一、 生成kube-api证书
1、定义根证书签名请求文件:
{
"CN": "kubernetes",
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"L": "ShenZhen",
"O": "kubernetes",
"OU": "Kubernetes-manual",
"ST": "GuangDong"
/* 执行时候需要删除注释内容
"C": "CN":表示证书的国家代码为中国CN。
"L": "ShenZhen":表示证书的地区(Locality)为深圳市。
"O": "k8s":表示证书的组织(Organization)为 k8s,这里可能表示 Kubernetes。
"OU": "System":表示证书的组织单元(Organizational Unit)为 System,通常表示该证书用于系统级别的操作。
"ST": "GuangDong":表示证书的州或省份(State or Province)为广东。
expiry: 指定了证书的到期时间,单位为小时。87600h表示证书的有效期为10年(365 天/年 * 24 小时/天 * 10 年)。
*/
}
],
"ca": {
"expiry": "87600h"
}
}
生成根证书跟证书:
cfssl gencert -initca ca-csr.json | cfssljson -bare /etc/kubernetes/pki/ca
2、 创建api证书签名请求文件:
{
"CN": "kube-apiserver",
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"L": "ShenZhen",
"O": "Kubernetes",
"OU": "Kubernetes-manual",
"ST": "GuangDong"
}
]
}
生成api证书:
cfsslc gencert -ca=/etc/kubernetes/pki/ca.pem -ca-key=/etc/kubernetes/pki/ca-key.pem -config=/home/pki/ca-config.json --hostname=10.96.0.1,192.168.0.100,192.168.0.101,192.168.0.102,kubernetes,kubernetes.default,kubernetes.default.svc,kubernetes.default.svc.cluster,kubernetes.default.svc.cluster.com --profile=kubernetes kube-aip-csr.json | cfssljson -bare /etc/kubernetes/pki/kube-apiserver
-
hostname=10.96.0.1,192.168.0.36,127.0.0.1,fc00:43f4:1eea:1::10`:指定证书的主机名或IP地址列表,其中kubernetes,kubernetes.default,kubernetes.default.svc,kubernetes.default.svc.cluster,kubernetes.default.svc.cluster.com对应的是apiServer解析的A记录。在在api配置文件中会引用。
-
10.96.0.1为svc服务地址块的第一个地址。
二、生成api聚合证书:
1、定义api根证书签名请求文件:
{
"CN": "front-proxy-client",
"key": {
"algo": "rsa",
"size": 2048
}
}
创建api聚合证书根证书
cfsslc gencert -initca front-proxy-ca-csr.json | cfssljson -bare /etc/kubernetes/pki/front-proxy-ca
2、定义api聚合证书签名请求文件:
{
"CN": "front-proxy-client",
"key": {
"algo": "rsa",
"size": 2048
}
}
创建api聚合证书
cfsslc gencert -ca=/etc/kubernetes/pki/front-proxy-ca.pem -ca-key=/etc/kubernetes/pki/front-proxy-ca-key.pem -config=/home/pki/ca-config.json -profile=kubernetes front-proxy-client-csr.json | cfssljson -bare /etc/kubernetes/pki/front-proxy-client
三、生成签署服务账户令牌的密钥文件:
openssl genrsa -out /etc/kubernetes/pki/sa.key 2048
openssl rsa -in /etc/kubernetes/pki/sa.key -pubout -out /etc/kubernetes/pki/sa.pub
四、配置文件详情:
###
# kubernetes system config
#--anonymous-auth=false
# The following values are used to configure the kube-apiserver
#
KUBE_APISERVER_OPTS="--enable-admission-plugins=NamespaceLifecycle,NodeRestriction,LimitRanger,ServiceAccount,DefaultStorageClass,ResourceQuota \
--bind-address=0.0.0.0 \
--secure-port=6443 \
--advertise-address=192.168.0.100 \
--authorization-mode=Node,RBAC \
--enable-bootstrap-token-auth=true \
--runtime-config=api/all=true \
--enable-bootstrap-token-auth=true \
--service-cluster-ip-range=10.96.0.0/16 \
--service-node-port-range=30000-50000 \
--tls-cert-file=/etc/kubernetes/pki/kube-apiserver.pem \
--tls-private-key-file=/etc/kubernetes/pki/kube-apiserver-key.pem \
--client-ca-file=/etc/kubernetes/pki/ca.pem \
--kubelet-client-certificate=/etc/kubernetes/pki/kube-apiserver.pem \
--kubelet-client-key=/etc/kubernetes/pki/kube-apiserver-key.pem \
--service-account-key-file=/etc/kubernetes/pki/sa.pub \
--service-account-signing-key-file=/etc/kubernetes/pki/sa.key \
--service-account-issuer=https://kubernetes.default.svc.cluster.com \
--etcd-cafile=/etc/etcd/ssl/etcd-ca.pem \
--etcd-certfile=/etc/etcd/ssl/etcd.pem \
--etcd-keyfile=/etc/etcd/ssl/etcd-key.pem \
--etcd-servers=https://192.168.0.100:2379,https://192.168.0.101:2379,https://192.168.0.102:2379 \
--kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname \
--requestheader-client-ca-file=/etc/kubernetes/pki/front-proxy-ca.pem \
--proxy-client-cert-file=/etc/kubernetes/pki/front-proxy-client.pem \
--proxy-client-key-file=/etc/kubernetes/pki/front-proxy-client-key.pem \
--requestheader-group-headers=X-Remote-Group \
--requestheader-extra-headers-prefix=X-Remote-Extra- \
--requestheader-username-headers=X-Remote-User \
--requestheader-allowed-names=aggregator \
--enable-aggregator-routing=true \
--v=4"
配置文件释意:
--enable-admission-plugins:启用一系列准入插件。
NamespaceLifecycle: 确保命名空间的生命周期管理,包括创建、更新和删除。这可以防止用户对系统命名空间进行误操作。
NodeRestriction: 确保kubelet提交到 kube-apiserver 的节点资源请求与节点的标识一致,以加强节点的身份验证和安全性。
LimitRanger: 确保Pod和容器的资源限制和请求满足预定义的限制。这可以防止用户创建超出集群资源限制的Pod。
ServiceAccount: 确保每个Pod都具有关联的ServiceAccount。这是Kubernetes中访问API和其他服务的身份验证机制。
DefaultStorageClass:为没有指定存储类的PVC(PersistentVolumeClaim)提供默认存储类。这可以简化用户的工作流程,使其不需要手动指定存储类。
ResourceQuota: 确保命名空间中的资源使用不超过预定义的配额限制。这可以控制用户对集群资源的消耗,以防止资源耗尽或滥用。
DefaultTolerationSeconds 参数用于指定Pod的容忍时间,默认情况下,如果Pod在指定的节点上不能被调度,它将容忍一段时间(以秒为单位)后再次尝试被调度。这个参数的设置可以确保即使节点暂时不可用,Pod也能在一段时间后重新调度到其他可用节点上,从而提高系统的可靠性和容错性。
--anonymous-auth:禁用匿名访问
--bind-address:绑定APIServer监听的IP地址。它指定 APIServer监听的网络地址。默认0.0.0.0 表示APIServer 将监听所有可用的网络接口,这意味着可以从集群内部和外部的所有网络接口访问API Server。这对于需要从集群外部访问API Server 的场景非常有用,但同时也增加了安全风险。在生产环境中,通常建议将API Server仅绑定到内部网络接口,以减少潜在的攻击面。
--secure-port:指定API Server监听的安全端口。
--advertise-address:广播API Server的地址。是kube-apiserver的启动参数之一,它用于指定 API Server向客户端公布的网络地址。
--authorization-mode:指定API Server的授权模式。在这里Node和RBAC是两种不同的授权模式:
1、Node:这种授权模式基于节点的身份进行授权。当请求来自 Kubernetes 节点时,将使用节点的证书或其他标识信息进行授权。这使得可以根据节点的身份来限制它们对集群资源的访问和操作。
2、RBAC:这种授权模式基于角色的权限进行授权。通过 Role-Based Access Control(RBAC)可以定义各种角色和权限,从而精细地控制用户、服务账户和组的访问权限。这允许管理员根据实际需求来配置集群中不同用户和服务的权限。
--runtime-config: 配置运行时的API行为。在这里,api/all=true表示启用所有的API组和版本。这意味着API Server将支持 Kubernetes 支持的所有API组和版本,包括核心API组和自定义API组。通过启用所有的API组和版本,可以确保API Server对外提供了完整的Kubernetes API,并且可以满足各种不同的用户和应用程序的需求。这也增加了API Server的负载和安全风险,因此在生产环境中,建议根据实际需求仅启用必要的API组和版本,以减少潜在的攻击面。
--enable-bootstrap-token-auth:用于启用引导令牌认证机制。引导令牌是一种特殊的身份验证令牌,用于在 Kubernetes集群初始化期间进行身份验证。启用此参数后,API Server将允许使用引导令牌进行身份验证,并将检查请求中的令牌是否在引导令牌列表中。引导令牌通常用于初始化Kubernetes集群时,例如在使用 kubeadm 工具初始化集群时。它们允许管理员在集群启动时执行特定的操作,如创建初始的管理员账户、添加节点等。但是,在生产环境中建议禁用引导令牌认证,以减少潜在的安全风险。
--service-cluster-ip-range、--service-node-port-range: 指定服务CIDR范围和端口。
--tls-cert-file、--tls-private-key-file:指定服务端的证书,加密传输到API服务器的所有数据。
--client-ca-file、--kubelet-client-certificate、--kubelet-client-key:指定用于验证客户端证书的根证书文件的路径,客户端证书文件路径,客户端密钥文件路径
--service-account-key-file、--service-account-signing-key-file:服务账号密钥文件路径、服务账号签名密钥文件路径
--service-account-issuer:指定Kubernetes服务账号的发行者。在这种情况下,它指定了Kubernetes默认的服务账号发行者地址。服务账号发行者是负责签发服务账号令牌的实体。当服务账号需要获取访问Kubernetes API的权限时,它们向服务账号发行者请求令牌。Kubernetes使用此发行者地址来确定哪个实体负责签发令牌,并向其发送请求。如果您的集群中有其他服务账号发行者,可以将--service-account-issuer参数设置为相应的地址。这可以是您自己的服务账号发行者的地址,或者是由第三方提供的服务账号发行者的地址,只要它们符合Kubernetes服务账号的令牌签发和验证规范即可。
-etcd-cafile、--etcd-certfile、--etcd-keyfile、--etcd-servers:etcd的访问配置。--etcd-servers指定etcd集群的地址
--kubelet-preferred-address-types:指定kubelet通信时的首选地址类型。
--requestheader-client-ca-file:指定请求头中的客户端CA证书。验证连接到API Server的请求头中包含的客户端证书。
--proxy-client-cert-file、--proxy-client-key-file:指定代理客户端的证书和私钥。kube-proxy使用此证书与API Server进行安全通信
--requestheader-group-headers:指定请求头中的组头。
--requestheader-extra-headers-prefix:指定额外的请求头字段的前缀,用于传递额外的用户信息。
--requestheader-username-headers:指定请求头中用于表示用户名的字段。
--requestheader-allowed-names:指定允许提供用户名的客户端证书的公共名称列表。
--v=4 日志等级
--insecure-port=0 是 kube-apiserver 的启动参数之一,用于指定 API Server 监听的非安全端口号。在这里,将端口号设置为 0 表示禁用非安全端口的监听,即不允许非安全的 HTTP 请求连接到 API Server
五、 创建kube-apiserver.service
[Unit]
Description=Kubernetes API Server
Documentation=https://github.com/GoogleCloudPlatform/kubernetes
After=network.target
After=etcd.service
Wants=etcd.service
[Service]
EnvironmentFile=-/etc/kubernetes/conf/kube-api.conf
#User=kube
ExecStart=/usr/local/kubernetes/bin/kube-apiserver $KUBE_APISERVER_OPTS
Restart=on-failure
Type=notify
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target
启动服务:
systemctl daemon-reload && systemctl enable kube-apiserver.service && systemctl start kube-apiserver.service
部署controller组件
一、 生成kube-controller-manager配置文件。kube-controller-manager将调用配置文件中的授权信息访问API接口。
关于配置文件请参考:https://blog.csdn.net/qq42004/article/details/137725131?spm=1001.2014.3001.5501
1、定义证书签名请求文件:
{
"CN": "system:kube-controller-manager",
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"O": "system:kube-controller-manager",
"OU": "Kubernetes-manual",
"L": "ShenZhen",
"ST": "GuangDong"
}
]
}
2、生成授权文件controller-manage:
在kube-controller-manager的证书时,如果计划在不同的主机上部署kube-controller-manager,并且希望每个主机上的 kube-controller-manager都能够访问APIServer,则需要在证书的hosts字段中列出每个主机的IP地址或主机名。
生成控制节点证书:
cfsslc gencert -ca=/etc/kubernetes/pki/ca.pem -ca-key=/etc/kubernetes/pki/ca-key.pem -config=/home/pki/ca-config.json -profile=kubernetes manager-csr.json | cfssljson -bare /etc/kubernetes/pki/controller-manager
设置一个集群:
kubectl config set-cluster kubernetes --certificate-authority=/etc/kubernetes/pki/ca.pem --embed-certs=true --server=https://192.168.0.100:6443 --kubeconfig=/etc/kubernetes/controller-manager.kubeconfig
设置一个用户:
kubectl config set-credentials system:kube-controller-manager --client-certificate=/etc/kubernetes/pki/controller-manager.pem --client-key=/etc/kubernetes/pki/controller-manager-key.pem --embed-certs=true --kubeconfig=/etc/kubernetes/controller-manager.kubeconfig
设置一个上下文:
kubectl config set-context system:kube-controller-manager@kubernetes --cluster=kubernetes --user=system:kube-controller-manager --kubeconfig=/etc/kubernetes/controller-manager.kubeconfig
关联上下文,使用system:kube-controller-manager对k8s集群进行验证:
kubectl config use-context system:kube-controller-manager@kubernetes --kubeconfig=/etc/kubernetes/pki/controller-manager.kubeconfig
3、创建controller-manager配置文件
###
# The following values are used to configure the kubernetes controller-manager
# defaults from config and apiserver should be adequate
# Add your own!
KUBE_CONTROLLER_MANAGER_OPTS="--allocate-node-cidrs=true \
--controllers=*,bootstrapsigner,tokencleaner \
--use-service-account-credentials=true \
--node-monitor-period=5s \
--leader-elect=true \
--node-monitor-grace-period=40s \
--node-monitor-period=5s \
--bind-address=0.0.0.0 \
--cluster-signing-cert-file=/etc/kubernetes/pki/ca.pem \
--cluster-signing-key-file=/etc/kubernetes/pki/ca-key.pem \
--root-ca-file=/etc/kubernetes/pki/ca.pem \
--service-account-private-key-file=/etc/kubernetes/pki/sa.key \
--service-cluster-ip-range=10.96.0.0/16 \
--cluster-cidr=172.13.0.0/12 \
--node-cidr-mask-size-ipv4=24 \
--requestheader-client-ca-file=/etc/kubernetes/pki/front-proxy-ca.pem \
--kubeconfig=/etc/kubernetes/controller-manager.kubeconfig \
--v=4"
配置文件释意:
--allocate-node-cidrs:参数用于指定是否为集群中的每个节点分配Pod的CIDR范围。当设置为true时,Kubernetes将为每个节点分配一个CIDR范围,用于分配给该节点上运行的Pod.
--controllers:指定要启动的控制器列表。
--use-service-account-credentials:用于指示APIServer是否应该使用服务账户凭据来验证客户端请求。默认情况下APIServer需要客户端提供有效的身份验证凭据(例如证书或令牌)来访问其提供的API。这些凭据通常由用户或管理员提供,并用于验证客户端的身份。设置为true,APIServer将允许使用服务账户凭据来访问其API。
--node-monitor-period:用于指定节点监视器的轮询周期,定义了kube-controller-manager将多久检查一次节点的状态。
--node-monitor-grace-period:用于指定节点监视器的优雅停机期。该参数定义了kube-controller-manager在将节点标记为不可用之前等待节点状态变化的时间。
--node-monitor-period:用于指定节点监视器的检查间隔。该参数定义了kube-controller-manager定期检查节点状态的时间间隔。
--bind-address=192.168.0.100:绑定的IP地址,用于监听Kubernetes控制平面的请求,默认设置为0.0.0.0,表示监听所有网络接口上的请求。
--cluster-signing-cert-file、--cluster-signing-key-file:集群组件证书的证书文件路径,集群组件证书的密钥文件路径
--root-ca-file:指定根证书的文件路径,用于验证客户端和服务器证书。
--service-account-private-key-file:服务账户的私钥文件路径,用于签署服务账户的令牌。
--service-cluster-ip-range:指定Service的IP地址范围
--cluster-cidr:指定Pod网络CIDR范围。
--node-cidr-mask-size-ipv4:指定节点CIDR掩码大小。这个节点指的是实体服务器的节点。
--requestheader-client-ca-file:指定用于请求头的客户端CA文件路径,用于验证请求头中的客户端证书,访问api的验证证书。
4、 创建kube-controller-manager.service
[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/GoogleCloudPlatform/kubernetes
After=network.target
[Service]
EnvironmentFile=-/etc/kubernetes/conf/controller-manager.conf
#User=kube
ExecStart=/usr/local/bin/kube-controller-manager $KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target
启动服务:
systemctl daemon-reload && systemctl enable kube-controller-manager.service && systemctl start kube-controller-manager.service
部署scheduler组件
1、定义证书签名请求文件:
{
"CN": "system:kube-scheduler",
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"ST": "GuangDong",
"L": "ShenZhen",
"O": "system:kube-scheduler",
"OU": "Kubernetes-manual"
}
]
}
2、生成授权文件scheduler.kubeconfig:
生成scheduler证书:
cfsslc gencert -ca=/etc/kubernetes/pki/ca.pem -ca-key=/etc/kubernetes/pki/ca-key.pem -config=/home/pki/ca-config.json -profile=kubernetes kube-scheduler-csr.json| cfssljson -bare /etc/kubernetes/pki/scheduler
设置一个集群:
kubectl config set-cluster kubernetes --certificate-authority=/etc/kubernetes/pki/ca.pem --embed-certs=true --server=https://192.168.0.100:6443 --kubeconfig=/etc/kubernetes/scheduler.kubeconfig
设置一个用户项:
kubectl config set-credentials system:kube-scheduler --client-certificate=/etc/kubernetes/pki/scheduler.pem --client-key=/etc/kubernetes/pki/scheduler-key.pem --embed-certs=true --kubeconfig=/etc/kubernetes/scheduler.kubeconfig
设置一个上下文环境:
kubectl config set-context system:kube-scheduler@kubernetes --cluster=kubernetes --user=system:kube-scheduler --kubeconfig=/etc/kubernetes/scheduler.kubeconfig
关联上下文:
kubectl config use-context system:kube-scheduler@kubernetes --kubeconfig=/etc/kubernetes/scheduler.kubeconfig
3、创建scheduler配置文件:
###
# kubernetes scheduler config
# default config should be adequate
# Add your own!
KUBE_SCHEDULER_ARGS="--bind-address=0.0.0.0 --leader-elect=true --kubeconfig=/etc/kubernetes/scheduler.kubeconfig --v=4"
4、创建kube-scheduler.service
[Unit]
Description=Kubernetes Scheduler Plugin
Documentation=https://github.com/GoogleCloudPlatform/kubernetes
After=network.target
[Service]
EnvironmentFile=-/etc/kubernetes/conf/scheduler.conf
#User=kube
ExecStart=/usr/local/bin/kube-scheduler $KUBE_SCHEDULER_ARGS
Restart=on-failure
RestartSec=10s
[Install]
WantedBy=multi-user.target
启动服务:
systemctl daemon-reload && systemctl enable kube-scheduler.service && systemctl start kube-scheduler.service
部署kubelet组件
三台服务器均需部署
1、生成授权文件Bootstrapping自动颁发kubelet证书:
设置集群:
kubectl config set-cluster kubernetes --certificate-authority=/etc/kubernetes/pki/ca.pem --embed-certs=true --server=https://192.168.0.100:6443 --kubeconfig=/etc/kubernetes/bootstrap-kubelet.kubeconfig
设置用户项:
kubectl config set-credentials tls-bootstrap-token-user --token=bwking.loktarogarforsyl --kubeconfig=/etc/kubernetes/bootstrap-kubelet.kubeconfig
设置上下文环境:
kubectl config set-context tls-bootstrap-token-user@kubernetes --cluster=kubernetes --user=tls-bootstrap-token-user --kubeconfig=/etc/kubernetes/bootstrap-kubelet.kubeconfig
关联上下文:
kubectl config use-context tls-bootstrap-token-user@kubernetes --kubeconfig=/etc/kubernetes/bootstrap-kubelet.kubeconfig
此证书文件为kubelet赋权分发证书。赋权的方式是引用了一个自定义的token:bwking.loktarogarforsyl之后的bootstrap.secret.yaml文件对token赋权。
2、创建admin配置文件
定义admin证书签名请求文件:
{
"CN": "admin",
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"ST": "GuangDong",
"L": "ShenZhen",
"O": "system:masters",
"OU": "Kubernetes-manual"
}
]
}
master生成admin配置文件:
生成admin证书:
cfsslc gencert -ca=/etc/kubernetes/pki/ca.pem -ca-key=/etc/kubernetes/pki/ca-key.pem -config=/home/pki/ca-config.json -profile=kubernetes admin-scr.json| cfssljson -bare /etc/kubernetes/pki/admin
设置集群:
kubectl config set-cluster kubernetes --certificate-authority=/etc/kubernetes/pki/ca.pem --embed-certs=true --server=https://192.168.0.100:6443 --kubeconfig=/etc/kubernetes/kube-admin.kubeconfig
设置用户:
kubectl config set-credentials kube-admin --client-certificate=/etc/kubernetes/pki/admin.pem --client-key=/etc/kubernetes/pki/admin-key.pem --embed-certs=true --kubeconfig=/etc/kubernetes/kube-admin.kubeconfig
设置上下文:
kubectl config set-context kube-admin@kubernetes --cluster=kubernetes --user=kube-admin --kubeconfig=/etc/kubernetes/kube-admin.kubeconfig
关联上下文:
kubectl config use-context kube-admin@kubernetes --kubeconfig=/etc/kubernetes/kube-admin.kubeconfig
将创建mkdir /root/.kube && cp /etc/kubernetes/kube-admin.kubeconfig /root/.kube/config,kubectl管理需要调用其权限。
3、配置文件kubelet-conf.yaml:
参考官网:https://kubernetes.io/zh-cn/docs/reference/config-api/kubelet-config.v1beta1/
apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
address: 0.0.0.0
port: 10250
readOnlyPort: 10255
authentication:
anonymous:
enabled: false
webhook:
cacheTTL: 2m0s
enabled: true
x509:
clientCAFile: /etc/kubernetes/pki/ca.pem
authorization:
mode: Webhook
webhook:
cacheAuthorizedTTL: 5m0s
cacheUnauthorizedTTL: 30s
cgroupDriver: systemd
cgroupsPerQOS: true
clusterDNS:
- 10.96.0.10
clusterDomain: cluster.com
containerLogMaxFiles: 5
containerLogMaxSize: 10Mi
contentType: application/vnd.kubernetes.protobuf
cpuCFSQuota: true
cpuManagerPolicy: none
cpuManagerReconcilePeriod: 10s
enableControllerAttachDetach: true
enableDebuggingHandlers: true
enforceNodeAllocatable:
- pods
eventBurst: 10
eventRecordQPS: 5
evictionHard:
imagefs.available: 15%
memory.available: 100Mi
nodefs.available: 10%
nodefs.inodesFree: 5%
evictionPressureTransitionPeriod: 5m0s
failSwapOn: true
fileCheckFrequency: 20s
hairpinMode: promiscuous-bridge
healthzBindAddress: 127.0.0.1
healthzPort: 10248
httpCheckFrequency: 20s
imageGCHighThresholdPercent: 85
imageGCLowThresholdPercent: 80
imageMinimumGCAge: 2m0s
iptablesDropBit: 15
iptablesMasqueradeBit: 14
kubeAPIBurst: 10
kubeAPIQPS: 5
makeIPTablesUtilChains: true
maxOpenFiles: 1000000
maxPods: 110
nodeStatusUpdateFrequency: 10s
oomScoreAdj: -999
podPidsLimit: -1
registryBurst: 10
registryPullQPS: 5
resolvConf: /etc/resolv.conf
rotateCertificates: true
runtimeRequestTimeout: 2m0s
serializeImagePulls: true
staticPodPath: /etc/kubernetes/manifests
streamingConnectionIdleTimeout: 4h0m0s
syncFrequency: 1m0s
volumeStatsAggPeriod: 1m0s
4、赋权文件bootstrap.secret.yaml:
apiVersion: v1
kind: Secret
metadata:
name: bootstrap-token-bwking
namespace: kube-system
type: bootstrap.kubernetes.io/token
stringData:
description: "The default bootstrap token generated by 'kubelet '."
token-id: bwking
token-secret: loktarogarforsyl
usage-bootstrap-authentication: "true"
usage-bootstrap-signing: "true"
auth-extra-groups: system:bootstrappers:default-node-token,system:bootstrappers:worker,system:bootstrappers:ingress
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: kubelet-bootstrap
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: system:node-bootstrapper
subjects:
- apiGroup: rbac.authorization.k8s.io
kind: Group
name: system:bootstrappers:default-node-token
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: node-autoapprove-bootstrap
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: system:certificates.k8s.io:certificatesigningrequests:nodeclient
subjects:
- apiGroup: rbac.authorization.k8s.io
kind: Group
name: system:bootstrappers:default-node-token
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: node-autoapprove-certificate-rotation
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: system:certificates.k8s.io:certificatesigningrequests:selfnodeclient
subjects:
- apiGroup: rbac.authorization.k8s.io
kind: Group
name: system:nodes
---
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
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: kube-apiserver
4、kubelet配置文件:
###
# kubernetes scheduler config
# default config should be adequate
# Add your own!
KUBELET_CONF="--bootstrap-kubeconfig=/etc/kubernetes/bootstrap-kubelet.kubeconfig /
--kubeconfig=/etc/kubernetes/kubelet.kubeconfig /
--config=/etc/kubernetes/kubelet-conf.yaml /
--container-runtime-endpoint=unix:///run/containerd/containerd.sock /
--node-labels=node.kubernetes.io/node="
配置文件释意:
–kubeconfig=/etc/kubernetes/kubelet.kubeconfig 文件会自动生成
5、创建kubelet.service
[Unit]
Description=kubelet: The Kubernetes Node Agent
Documentation=https://kubernetes.io/docs/
Wants=network-online.target
After=network-online.target
[Service]
EnvironmentFile=-/etc/kubernetes/conf/kubelet.conf
ExecStart=/usr/local/bin/kubelet $KUBELET_CONF
Restart=always
StartLimitInterval=0
RestartSec=10
[Install]
WantedBy=multi-user.target
启动服务执行:
systemctl daemon-reload && systemctl enable kubelet.service && systemctl start kubelet.service
6、执行赋权文件:
mkdir /etc/bootstrap & cp bootstrap.secret.yaml /etc/bootstrap
kubectl apply -f bootstrap.secret.yaml
查看节点信息:(这个是部署完之后的截图正常的节点的STATUS非Ready状态,集群是正常,正常获取Runtime)
[root@master kubernetes]# kubectl get nodes
NAME STATUS ROLES AGE VERSION
master Ready <none> 16h v1.28.8
node01 Ready <none> 16h v1.28.8
node02 Ready <none> 16h v1.28.8
[root@master kubernetes]# kubectl get cs
Warning: v1 ComponentStatus is deprecated in v1.19+
NAME STATUS MESSAGE ERROR
scheduler Healthy ok
controller-manager Healthy ok
etcd-0 Healthy ok
[root@master kubernetes]# kubectl cluster-info
Kubernetes control plane is running at https://192.168.0.100:6443
To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.
[root@master kubernetes]# kubectl describe node | grep Runtime
Container Runtime Version: containerd://1.7.15
Container Runtime Version: containerd://1.7.15
Container Runtime Version: containerd://1.7.15
部署proxy组件
三台服务均需部署(证书要拷贝node节点)
1、定义证书签名请求文件:
{
"CN": "system:kube-proxy",
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"ST": "GuangDong",
"L": "ShenZhen",
"O": "system:kube-proxy",
"OU": "Kubernetes-manual"
}
]
}
2、生成授权文件
生成proxy证书:
cfsslc gencert -ca=/etc/kubernetes/pki/ca.pem -ca-key=/etc/kubernetes/pki/ca-key.pem -config=/home/pki/ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare /etc/kubernetes/pki/kube-proxy
设置集群
kubectl config set-cluster kubernetes --certificate-authority=/etc/kubernetes/pki/ca.pem --embed-certs=true --server=https://192.168.0.100:6443 --kubeconfig=/etc/kubernetes/kube-proxy.kubeconfig
设置用户:
kubectl config set-credentials system:kube-proxy --client-certificate=/etc/kubernetes/pki/kube-proxy.pem --client-key=/etc/kubernetes/pki/kube-proxy-key.pem --embed-certs=true --kubeconfig=/etc/kubernetes/kube-proxy.kubeconfig
设置上下文:
kubectl config set-context kube-proxy@kubernetes --cluster=kubernetes --user=system:kube-proxy --kubeconfig=/etc/kubernetes/kube-proxy.kubeconfig
关联上下文:
kubectl config use-context kube-proxy@kubernetes --kubeconfig=/etc/kubernetes/kube-proxy.kubeconfig
3、创建配置文件
apiVersion: kubeproxy.config.k8s.io/v1alpha1
bindAddress: 0.0.0.0
clientConnection:
acceptContentTypes: ""
burst: 10
contentType: application/vnd.kubernetes.protobuf
kubeconfig: /etc/kubernetes/kube-proxy.kubeconfig
qps: 5
clusterCIDR: 172.13.0.0/12
configSyncPeriod: 15m0s
conntrack:
max: null
maxPerCore: 32768
min: 131072
tcpCloseWaitTimeout: 1h0m0s
tcpEstablishedTimeout: 24h0m0s
enableProfiling: false
healthzBindAddress: 0.0.0.0:10256
hostnameOverride: ""
iptables:
masqueradeAll: false
masqueradeBit: 14
minSyncPeriod: 0s
syncPeriod: 30s
ipvs:
masqueradeAll: true
minSyncPeriod: 5s
scheduler: "rr"
syncPeriod: 30s
kind: KubeProxyConfiguration
metricsBindAddress: 127.0.0.1:10249
mode: "ipvs"
nodePortAddresses: null
oomScoreAdj: -999
portRange: ""
udpIdleTimeout: 250ms
配置文件修改clusterCIDR参数为自己定义的PodIp:172.13.0.0/12。
4、创建kube-proxy.service
[Unit]
Description=Kubernetes Kube Proxy
Documentation=https://github.com/kubernetes/kubernetes
After=network.target
[Service]
ExecStart=/usr/local/bin/kube-proxy --config=/etc/kubernetes/kube-proxy.yaml --v=4
Restart=always
RestartSec=10s
[Install]
WantedBy=multi-user.target
启动服务:
systemctl daemon-reload && systemctl enable kube-proxy.service && systemctl start kube-proxy.service
安装flannel插件
参考:https://blog.csdn.net/qq42004/article/details/136643557?spm=1001.2014.3001.5502