kubernetes1.28版本的二进制安装

安的木偶游戏

已于 2024-04-21 10:54:41 修改

阅读量798

点赞数 20

分类专栏： kubernetes 文章标签： kubernetes 容器云原生二进制配置 1.28

于 2024-04-20 23:33:20 首次发布

本文链接：https://blog.csdn.net/qq42004/article/details/138014469

版权

kubernetes 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

前言

二进制部署 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= $CONTAINERD_PATH/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

安的木偶游戏

关注

20
点赞
踩
29

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录