k8s单节点部署（master ，node部分）
k8s单节点部署（master ，node部分）
目录
- 1 部署master 组件
- 2 部署worker node组件
- 2.1 将master01 上的kubelet ,kube-proxy 拷贝到node 节点
- 2.2 将node.zip包上传到 node01的/opt目录中
- 2.3 mater01上 生成kublet配置文件
- 2.4 在master01 上，将刚刚生成的kublet配置文件拷贝到node节点，并进行RBAC授权
- 2.5 在master01上查看角色和已授权角色
- 2.6 在node01 上使用kubelet.sh 脚本启动kubelet
- 2.7 mater01 节点上通过kubelet的csr 请求
- 2.8 node01 节点上配置kube-proxy
- 2.9 部署node 02
- 2.9.3 在master01上通过csr请求
- 3 测试
要先安装etcd和flannel网络
https://www.cnblogs.com/zhijiyiyu/p/15497119.html
1 部署master 组件
1.1 master01 上创建kubernetes 工作目录，创建ca证书，相关组件证书，私钥目录
1.1.1 将master.zip， k8s-cert.sh 包上传到 /opt/k8s目录中
#将 master.zip， k8s-cert.sh 包上传到 /opt/k8s目录中
[root@master01 ~]# cd /opt/k8s/
[root@master01 k8s]# ls master.zip
master.zip
[root@master01 k8s]# unzip master.zip
Archive: master.zip
inflating: apiserver.sh
inflating: controller-manager.sh
inflating: scheduler.sh
[root@master01 k8s]# chmod +x *.sh
[root@master01 k8s]# vim k8s-cert.sh
#!/bin/bash
#配置证书生成策略，让 CA 软件知道颁发有什么功能的证书，生成用来签发其他组件证书的根证书
cat > ca-config.json <<EOF
{
"signing": {
"default": {
"expiry": "87600h"
},
"profiles": {
"kubernetes": {
"expiry": "87600h",
"usages": [
"signing",
"key encipherment",
"server auth",
"client auth"
]
}
}
}
}
EOF
#生成CA证书和私钥（根证书和私钥）
cat > ca-csr.json <<EOF
{
"CN": "kubernetes",
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"L": "Beijing",
"ST": "Beijing",
"O": "k8s",
"OU": "System"
}
]
}
EOF
cfssl gencert -initca ca-csr.json | cfssljson -bare ca -
#-----------------------
#生成 apiserver 的证书和私钥（apiserver和其它k8s组件通信使用）
#hosts中将所有可能作为 apiserver 的 ip 添加进去，后面 keepalived 使用的 VIP 也要加入
cat > apiserver-csr.json <<EOF
{
"CN": "kubernetes",
"hosts": [
"10.0.0.1",
"127.0.0.1",
"192.168.23.103",
"192.168.23.10",
"192.168.23.18",
"192.168.23.11",
"192.168.23.12",
"kubernetes",
"kubernetes.default",
"kubernetes.default.svc",
"kubernetes.default.svc.cluster",
"kubernetes.default.svc.cluster.local"
],
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"L": "BeiJing",
"ST": "BeiJing",
"O": "k8s",
"OU": "System"
}
]
}
EOF
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes apiserver-csr.json | cfssljson -bare apiserver
#-----------------------
#生成 kubectl 的证书和私钥，具有admin权限
cat > admin-csr.json <<EOF
{
"CN": "admin",
"hosts": [],
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"L": "BeiJing",
"ST": "BeiJing",
"O": "system:masters",
"OU": "System"
}
]
}
EOF
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes admin-csr.json | cfssljson -bare admin
#-----------------------
#生成 kube-proxy 的证书和私钥
cat > kube-proxy-csr.json <<EOF
{
"CN": "system:kube-proxy",
"hosts": [],
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"L": "BeiJing",
"ST": "BeiJing",
"O": "k8s",
"OU": "System"
}
]
}
EOF
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy
1.1.2 创建kubernetes工作目录，生成证书
#创建kubernetes工作目录
[root@master01 k8s]# mkdir -p /opt/kubernetes/{cfg,bin,ssl}
#创建用于生成CA证书,相关组件的证书和私钥的目录
[root@master01 k8s]# mkdir /opt/k8s/k8s-cert
[root@master01 k8s]# mv /opt/k8s/k8s-cert.sh /opt/k8s/k8s-cert/
[root@master01 k8s]# cd !$
cd /opt/k8s/k8s-cert/
[root@master01 k8s-cert]# pwd
/opt/k8s/k8s-cert
#生成CA证书，相关组件的证书和私钥
[root@master01 k8s-cert]# ./k8s-cert.sh
[root@master01 k8s-cert]# ls *pem
admin-key.pem admin.pem apiserver-key.pem apiserver.pem ca-key.pem ca.pem kube-proxy-key.pem kube-proxy.pem
#复制ca证书，apiserver相关证书和私钥到kubernetes工作目录的ssl子目录中
[root@master01 k8s-cert]# cp ca*pem apiserver*pem /opt/kubernetes/ssl/
默认情况下，k8s有两个端口 8080端口和 6443端口。master组件可以用这两个端口通信。使用证书加密通信，就使用 6443端口。
因为master的组件（controller manage 和scheduler 和 api-server）都在一个服务器上，ontroller-manager 和kube-scheduler 设置为只调用当前机器的apiserver，使用127.0.0.1:8080通信。因此不需要签发证书
1.2 复制master组件的关键命令文件到kubernetes工作目录的bin子目录中
#上传kubernetes-server-linux-amd64.tar.gz到/opt/k8s/目录中
[root@master01 k8s-cert]# cd /opt/k8s/
[root@master01 k8s]# ls kubernetes-server-linux-amd64.tar.gz
kubernetes-server-linux-amd64.tar.gz
[root@master01 k8s]# tar xf kubernetes-server-linux-amd64.tar.gz
#复制master组件的关键命令文件到kubernetes工作目录的bin子目录中
[root@master01 bin]# cp kube-apiserver kubectl kube-controller-manager kube-scheduler /opt/kubernetes/bin/
[root@master01 bin]# ln -s /opt/kubernetes/bin/* /usr/local/bin/
1.3 创建bootstrap token 认证文件
创建bootstrap token认证文件,apiserver 启动时会调用，然后就相当于在集群内创建了一个这个用户，接下来可以用RBAC给他授权。
[root@master01 bin]# cd /opt/k8s/
[root@master01 k8s]# vim token.sh
#!/bin/bash
#获取随机数的前16个字节内容，以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
[root@master01 k8s]# chmod +x token.sh
[root@master01 k8s]# ./token.sh
1.4开启apiserver服务
1.4.1 开启apiserver服务
[root@master01 k8s]# cd /opt/k8s/
#$1为master的ip， https://..... 为etcd集群的位置
[root@master01 k8s]# ./apiserver.sh 192.168.23.103 \
https://192.168.23.103:2379,https://192.168.23.104:2379,http://192.168.23.105:2379
1.4.2 检查进程是否成功开启
[root@master01 k8s]# ps aux | grep kube-apiserver
1.4.3 查看6443和8080端口
- k8s通过kube-server这个进程提供服务，该进程运行在单个master节点上。默认有6443和8080
- 安全端口6443用于接收https请求，用于基于Token文件或客户端证书认证
- 本地端口8080用于接收http请求，非认证或者授权的http请求通过该端口访问API Server
[root@master01 k8s]# netstat -natp | egrep '6443|8080'
tcp 0 0 192.168.23.103:6443 0.0.0.0:* LISTEN 5055/kube-apiserver
tcp 0 0 127.0.0.1:8080 0.0.0.0:* LISTEN 5055/kube-apiserver
tcp 0 0 192.168.23.103:40466 192.168.23.103:6443 ESTABLISHED 5055/kube-apiserver
tcp 0 0 192.168.23.103:58080 192.168.23.103:2379 ESTABLISHED 5055/kube-apiserver
tcp 0 0 192.168.23.103:2379 192.168.23.103:58080 ESTABLISHED 879/etcd
tcp 0 0 192.168.23.103:6443 192.168.23.103:40466 ESTABLISHED 5055/kube-apiserver
1.4.4 查看版本信息
必须保证apiserver启动正常，不然无法查询到server的版本信息
[root@master01 k8s]# kubectl version
1.5 启动scheduler 和 controller-manager 服务
#启动scheduler 服务
[root@master01 k8s]# cd /opt/k8s/
[root@master01 k8s]#vim scheduler.sh
#!/bin/bash
#创建 kube-scheduler 启动参数配置文件
MASTER_ADDRESS=$1
cat >/opt/kubernetes/cfg/kube-scheduler <<EOF
KUBE_SCHEDULER_OPTS="--logtostderr=true \\
--v=4 \\
--master=${MASTER_ADDRESS}:8080 \\
--leader-elect=true"
EOF
#--master：监听 apiserver 的地址和8080端口
#--leader-elect=true：启动 leader 选举
#k8s中Controller-Manager和Scheduler的选主逻辑：k8s中的etcd是整个集群所有状态信息的存储，涉及数据的读写和多个etcd之间数据的同步，对数据的一致性要求严格，所以使用较复杂的 raft 算法来选择用于提交数据的主节点。而 apiserver 作为集群入口，本身是无状态的web服务器，多个 apiserver 服务之间直接负载请求并不需要做选主。Controller-Manager 和 Scheduler 作为任务类型的组件，比如 controller-manager 内置的 k8s 各种资源对象的控制器实时的 watch apiserver 获取对象最新的变化事件做期望状态和实际状态调整，调度器watch未绑定节点的pod做节点选择，显然多个这些任务同时工作是完全没有必要的，所以 controller-manager 和 scheduler 也是需要选主的，但是选主逻辑和 etcd 不一样的，这里只需要保证从多个 controller-manager 和 scheduler 之间选出一个 leader 进入工作状态即可，而无需考虑它们之间的数据一致和同步。
#创建 kube-scheduler.service 服务管理文件
cat >/usr/lib/systemd/system/kube-scheduler.service <<EOF
[Unit]
Description=Kubernetes Scheduler
Documentation=https://github.com/kubernetes/kubernetes
[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-scheduler
ExecStart=/opt/kubernetes/bin/kube-scheduler \$KUBE_SCHEDULER_OPTS
Restart=on-failure
[Install]
WantedBy=multi-user.target
EOF
systemctl daemon-reload
systemctl enable kube-scheduler
systemctl restart kube-scheduler
[root@master01 k8s]# ./scheduler.sh 127.0.0.1
[root@master01 k8s]# ps aux | grep kube-scheduler
[root@master01 k8s]# vim controller-manager.sh
#!/bin/bash
#创建 kube-controller-manager 启动参数配置文件
MASTER_ADDRESS=$1
cat >/opt/kubernetes/cfg/kube-controller-manager <<EOF
KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=true \\
--v=4 \\
--master=${MASTER_ADDRESS}:8080 \\
--leader-elect=true \\
--address=127.0.0.1 \\
--service-cluster-ip-range=10.0.0.0/24 \\
--cluster-name=kubernetes \\
--cluster-signing-cert-file=/opt/kubernetes/ssl/ca.pem \\
--cluster-signing-key-file=/opt/kubernetes/ssl/ca-key.pem \\
--root-ca-file=/opt/kubernetes/ssl/ca.pem \\
--service-account-private-key-file=/opt/kubernetes/ssl/ca-key.pem \\
--experimental-cluster-signing-duration=87600h0m0s"
EOF
#--cluster-name=kubernetes：集群名称，与CA证书里的CN匹配
#--cluster-signing-cert-file：指定签名的CA机构根证书，用来签名为 TLS BootStrapping 创建的证书和私钥
#--root-ca-file：指定根CA证书文件路径，用来对 kube-apiserver 证书进行校验，指定该参数后，才会在 Pod 容器的 ServiceAccount 中放置该 CA 证书文件
#--experimental-cluster-signing-duration：设置为 TLS BootStrapping 签署的证书有效时间为10年，默认为1年
#创建 kube-controller-manager.service 服务管理文件
cat >/usr/lib/systemd/system/kube-controller-manager.service <<EOF
[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/kubernetes/kubernetes
[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-controller-manager
ExecStart=/opt/kubernetes/bin/kube-controller-manager \$KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure
[Install]
WantedBy=multi-user.target
EOF
systemctl daemon-reload
systemctl enable kube-controller-manager
systemctl restart kube-controller-manager
#启动controller-manager
[root@master01 k8s]# ./controller-manager.sh 127.0.0.1
[root@master01 k8s]# ps aux | grep controller
[root@master01 k8s]# systemctl status kube-scheduler.service
[root@master01 k8s]# systemctl status kube-controller-manager.service
1.6 将kubectl 和管理员权限绑定
[root@master01 k8s]# chmod +x admin.sh
[root@master01 k8s]# ./admin.sh
[root@master01 k8s]# vim admin.sh
#!/bin/bash
mkdir /root/.kube
KUBE_CONFIG="/root/.kube/config"
KUBE_APISERVER="https://192.168.23.103:6443"
cd /opt/k8s/k8s-cert/
kubectl config set-cluster kubernetes \
--certificate-authority=/opt/kubernetes/ssl/ca.pem \
--embed-certs=true \
--server=${KUBE_APISERVER} \
--kubeconfig=${KUBE_CONFIG}
kubectl config set-credentials cluster-admin \
--client-certificate=./admin.pem \
--client-key=./admin-key.pem \
--embed-certs=true \
--kubeconfig=${KUBE_CONFIG}
kubectl config set-context default \
--cluster=kubernetes \
--user=cluster-admin \
--kubeconfig=${KUBE_CONFIG}
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}
1.7 查看master节点状态
root@master01 k8s]# kubectl get cs
NAME STATUS MESSAGE ERROR
scheduler Healthy ok
etcd-2 Healthy {"health":"true"}
etcd-1 Healthy {"health":"true"}
etcd-0 Healthy {"health":"true"}
controller-manager Healthy ok
2 部署worker node组件
2.1 将master01 上的kubelet ,kube-proxy 拷贝到node 节点
[root@master01 kubernetes]# cd /opt/k8s/kubernetes/server/bin/
[root@master01 bin]# scp kubelet kube-proxy 192.168.23.104:/opt/kubernetes/bin
[root@master01 bin]# scp kubelet kube-proxy 192.168.23.105:/opt/kubernetes/bin
2.2 将node.zip包上传到 node01的/opt目录中
[root@node01 opt]# cd /opt/
[root@node01 opt]# ls node.zip
node.zip
[root@node01 opt]# unzip node.zip
Archive: node.zip
inflating: proxy.sh
inflating: kubelet.sh
2.3 mater01上 生成kublet配置文件
#创建用于生成kubelet的配置文件目录
[root@master01 bin]# mkdir /opt/k8s/kubeconfig
#上传kubeconfig.sh 文件到 /opt/k8s/kubeconfig目录
[root@master01 bin]# cd /opt/k8s/kubeconfig/
[root@master01 kubeconfig]# ls kubeconfig.sh
kubeconfig.sh
[root@master01 kubeconfig]#vim kubeconfig.sh
#!/bin/bash
#example: kubeconfig 192.168.80.10 /opt/k8s/k8s-cert/
#创建bootstrap.kubeconfig文件
#该文件中内置了 token.csv 中用户的 Token，以及 apiserver CA 证书；kubelet 首次启动会加载此文件，使用 apiserver CA 证书建立与 apiserver 的 TLS 通讯，使用其中的用户 Token 作为身份标识向 apiserver 发起 CSR 请求
BOOTSTRAP_TOKEN=$(awk -F ',' '{print $1}' /opt/kubernetes/cfg/token.csv)
APISERVER=$1
SSL_DIR=$2
export KUBE_APISERVER="https://$APISERVER:6443"
# 设置集群参数
kubectl config set-cluster kubernetes \
--certificate-authority=$SSL_DIR/ca.pem \
--embed-certs=true \
--server=${KUBE_APISERVER} \
--kubeconfig=bootstrap.kubeconfig
#--embed-certs=true：表示将ca.pem证书写入到生成的bootstrap.kubeconfig文件中
# 设置客户端认证参数，kubelet 使用 bootstrap token 认证
kubectl config set-credentials kubelet-bootstrap \
--token=${BOOTSTRAP_TOKEN} \
--kubeconfig=bootstrap.kubeconfig
# 设置上下文参数
kubectl config set-context default \
--cluster=kubernetes \
--user=kubelet-bootstrap \
--kubeconfig=bootstrap.kubeconfig
# 使用上下文参数生成 bootstrap.kubeconfig 文件
kubectl config use-context default --kubeconfig=bootstrap.kubeconfig
#----------------------
#创建kube-proxy.kubeconfig文件
# 设置集群参数
kubectl config set-cluster kubernetes \
--certificate-authority=$SSL_DIR/ca.pem \
--embed-certs=true \
--server=${KUBE_APISERVER} \
--kubeconfig=kube-proxy.kubeconfig
# 设置客户端认证参数，kube-proxy 使用 TLS 证书认证
kubectl config set-credentials kube-proxy \
--client-certificate=$SSL_DIR/kube-proxy.pem \
--client-key=$SSL_DIR/kube-proxy-key.pem \
--embed-certs=true \
--kubeconfig=kube-proxy.kubeconfig
# 设置上下文参数
kubectl config set-context default \
--cluster=kubernetes \
--user=kube-proxy \
--kubeconfig=kube-proxy.kubeconfig
# 使用上下文参数生成 kube-proxy.kubeconfig 文件
kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig
[root@master01 kubeconfig]# chmod +x kubeconfig.sh
#生成kubelet配置文件
[root@master01 kubeconfig]# ./kubeconfig.sh 192.168.23.103 /opt/k8s/k8s-cert/
[root@master01 kubeconfig]# ls
bootstrap.kubeconfig kubeconfig.sh kube-proxy.kubeconfig
kubeconfig.sh文件包含集群参数(CA证书、API Server地址) ,客户端参数(上面生成的证书和私钥),集群context上下文参数(集群名称、用户名) 。
Kubenetes组件(如kubelet, kube-proxy)通过启动时指定不同的kubeconfig文件可以切换到不同的集群,连接到apiserver
2.4 在master01 上，将刚刚生成的kublet配置文件拷贝到node节点，并进行RBAC授权
#将bootstrap.kubeconfig kube-proxy.kubeconfig文件拷贝到node节点
[root@master01 kubeconfig]# scp bootstrap.kubeconfig kube-proxy.kubeconfig 192.168.23.104:/opt/kubernetes/cfg/
[root@master01 kubeconfig]# scp bootstrap.kubeconfig kube-proxy.kubeconfig 192.168.23.105:/opt/kubernetes/cfg/
#RBAC授权，将预设用户kubelet-bootstrap与内置的clusterRole system:node-bootstrapper 绑定在一起，使其能够发起CSR请求
#kublet 第一次发起csr请求，想要请求证书，首先需要获得授权
[root@master01 kubeconfig]# kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap
kubelet采用TLS Bootstrapping机制, 自动完成到kube-apiserver的注册,在node节点量较大或者后期自动扩容时非常有用。Master apiserver启用TLs认证后, node节点kubelet组件想要加入集群,必须使用cA签发的有效证书才能与apiserver通信,当node节点很多时,签署证书是一件很繁琐的事情。因此Kubernetes引入了TLs bootstraping机制来自动颁发客户端证书, kubelet会以一个低权限用户自动向apiserver申请证书, kubelet的证书由apiserver动态签署。
kubelet首次启动通过加载bootstrap.kubeconfig中的用户Token和apiserver CA证书发起首次CSR请求,这个Token被预先内置在apiserver节点的token.csv中,其身份为kubelet-bootstrap用户和system: kubelet-bootstrap用户组;想要首次CSR
请求能成功(即不会被apiserver 401拒绝) ,则需要先创建一个clusterRoleBinding,将kubelet-bootstrap用户和
system: node-bootstrapper内置clusterRole绑定(通过kubectl get clusterroles可查询) ,使其能够发起CSR认证请求
TLs bootstrapping时的证书实际是由kube-controller-manager组件来签署的,也就是说证书有效期是kube-controller-manager
组件控制的; kube-controller-manager组件提供了一个--experimental-cluster-signing-duration参数来设置签署的证书有效时间;默认为8760h0mos,将其改为87600h0mos,即10年后再进行TLs bootstrapping签署证书即可
也就是说kubelet首次访问API Server时,是使用token做认证,通过后, controller Manager公为kubelet生成一个证书,以后的访问都是用证书做认证了
2.5 在master01上查看角色和已授权角色
#查看角色
[root@master01 kubeconfig]# kubectl get clusterroles | grep system:node-bootstrapper
system:node-bootstrapper 80m
#查看已授权角色
[root@master01 kubeconfig]# kubectl get clusterrolebinding
2.6 在node01 上使用kubelet.sh 脚本启动kubelet
[root@node01 opt]# cd /opt/
[root@node01 opt]# ls kubelet.sh
kubelet.sh
[root@node01 opt]# vim kubelet.sh
#!/bin/bash
NODE_ADDRESS=$1
DNS_SERVER_IP=${2:-"10.0.0.2"}
#创建 kubelet 启动参数配置文件
cat >/opt/kubernetes/cfg/kubelet <<EOF
KUBELET_OPTS="--logtostderr=true \\
--v=4 \\
--hostname-override=${NODE_ADDRESS} \\
--kubeconfig=/opt/kubernetes/cfg/kubelet.kubeconfig \\
--bootstrap-kubeconfig=/opt/kubernetes/cfg/bootstrap.kubeconfig \\
--config=/opt/kubernetes/cfg/kubelet.config \\
--cert-dir=/opt/kubernetes/ssl \\
--pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google-containers/pause-amd64:3.0"
EOF
#--hostname-override：指定kubelet节点在集群中显示的主机名或IP地址，默认使用主机hostname；kube-proxy和kubelet的此项参数设置必须完全一致
#--kubeconfig：指定kubelet.kubeconfig文件位置，用于如何连接到apiserver，里面含有kubelet证书，master授权完成后会在node节点上生成 kubelet.kubeconfig 文件
#--bootstrap-kubeconfig：指定连接 apiserver 的 bootstrap.kubeconfig 文件
#--config：指定kubelet配置文件的路径，启动kubelet时将从此文件加载其配置
#--cert-dir：指定master颁发的客户端证书和密钥保存位置
#--pod-infra-container-image：指定Pod基础容器（Pause容器）的镜像。Pod启动的时候都会启动一个这样的容器，每个pod之间相互通信需要Pause的支持，启动Pause需要Pause基础镜像
#----------------------
#创建kubelet配置文件（该文件实际上就是一个yml文件，语法非常严格，不能出现tab键，冒号后面必须要有空格，每行结尾也不能有空格）
cat >/opt/kubernetes/cfg/kubelet.config <<EOF
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: ${NODE_ADDRESS}
port: 10250
readOnlyPort: 10255
cgroupDriver: cgroupfs
clusterDNS:
- ${DNS_SERVER_IP}
clusterDomain: cluster.local.
failSwapOn: false
authentication:
anonymous:
enabled: true
EOF
#PS：当命令行参数与此配置文件（kubelet.config）有相同的值时，就会覆盖配置文件中的该值。
#----------------------
#创建 kubelet.service 服务管理文件
cat >/usr/lib/systemd/system/kubelet.service <<EOF
[Unit]
Description=Kubernetes Kubelet
After=docker.service
Requires=docker.service
[Service]
EnvironmentFile=/opt/kubernetes/cfg/kubelet
ExecStart=/opt/kubernetes/bin/kubelet \$KUBELET_OPTS
Restart=on-failure
KillMode=process
[Install]
WantedBy=multi-user.target
EOF
systemctl daemon-reload
systemctl enable kubelet
systemctl restart kubelet
[root@node01 opt]# chmod +x kubelet.sh
#使用脚本启动kubelet服务
oot@node01 opt]# ./kubelet.sh 192.168.23.104
[root@node01 opt]# ps aux | grep kubelet
#此时还没有生成证书
[root@node01 opt]# ls /opt/kubernetes/ssl/
kubelet-client.key.tmp kubelet.crt kubelet.key
2.7 mater01 节点上通过kubelet的csr 请求
#检查到node01 节点的kubelet发起的CSR请求，Pending表示等待集群给该节点签发证书
[root@master01 opt]# kubectl get csr
NAME AGE REQUESTOR CONDITION
node-csr-0uON9h27bA3I03O59M3wUUuFMn9VyEAKxsXV93ftsoA 3m25s kubelet-bootstrap Pending
#通过csr请求状态
[root@master01 opt]# kubectl certificate approve node-csr-0uON9h27bA3I03O59M3wUUuFMn9VyEAKxsXV93ftsoA
#再次查看csr请求状态
[root@master01 opt]# kubectl get csr
NAME AGE REQUESTOR CONDITION
node-csr-0uON9h27bA3I03O59M3wUUuFMn9VyEAKxsXV93ftsoA 6m15s kubelet-bootstrap Approved,Issued
#查看集群节点状态。
root@master01 opt]# kubectl get nodes
NAME STATUS ROLES AGE VERSION
192.168.23.104 Ready <none> 14m v1.12.3
2.8 node01 节点上配置kube-proxy
[root@node01 opt]# ls /opt/kubernetes/cfg/kubelet.kubeconfig
/opt/kubernetes/cfg/kubelet.kubeconfig
[root@node01 opt]# ls /opt/kubernetes/ssl/
kubelet-client-2021-10-28-16-53-41.pem kubelet-client-current.pem kubelet.crt kubelet.key
#加载ip_vs 模块
[root@node01 opt]# for i in $(ls /usr/lib/modules/$(uname -r)/kernel/net/netfilter/ipvs|grep -o "^[^.]*");\
do echo $i; /sbin/modinfo -F filename $i >/dev/null 2>&1 && /sbin/modprobe $i;done
[root@node01 opt]# cd /opt/
[root@node01 opt]# ls proxy.sh
proxy.sh
[root@node01 opt]# vim proxy.sh
#!/bin/bash
NODE_ADDRESS=$1
#创建 kube-proxy 启动参数配置文件
cat >/opt/kubernetes/cfg/kube-proxy <<EOF
KUBE_PROXY_OPTS="--logtostderr=true \\
--v=4 \\
--hostname-override=${NODE_ADDRESS} \\
--cluster-cidr=172.17.0.0/16 \\
--proxy-mode=ipvs \\
--kubeconfig=/opt/kubernetes/cfg/kube-proxy.kubeconfig"
EOF
#--hostnameOverride: 参数值必须与 kubelet 的值一致，否则 kube-proxy 启动后会找不到该 Node，从而不会创建任何 ipvs 规则
#--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 模式
#--kubeconfig: 指定连接 apiserver 的 kubeconfig 文件
#----------------------
#创建 kube-proxy.service 服务管理文件
cat >/usr/lib/systemd/system/kube-proxy.service <<EOF
[Unit]
Description=Kubernetes Proxy
After=network.target
[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-proxy
ExecStart=/opt/kubernetes/bin/kube-proxy \$KUBE_PROXY_OPTS
Restart=on-failure
[Install]
WantedBy=multi-user.target
EOF
systemctl daemon-reload
systemctl enable kube-proxy
systemctl restart kube-proxy
[root@node01 opt]# chmod +x proxy.sh #使用proxy.sh 脚本启动proxy服务[root@node01 opt]# ./proxy.sh 192.168.23.104 [root@node01 opt]# systemctl status kube-proxy.service
2.9 部署node 02
2.9.1 在node01 节点上将kubelet.sh ,proxy.sh文件拷贝到node02 节点
[root@node01 opt]# cd /opt/
[root@node01 opt]# scp kubelet.sh proxy.sh 192.168.23.105:/opt/
2.9.2 在node02 上使用kubelet.sh 启动kubelet服务
[root@node02 opt]# cd /opt/
[root@node02 opt]# chmod +x kubelet.sh
[root@node02 opt]# ./kubelet.sh 192.168.23.105
2.9.3 在master01上通过csr请求
#查看请求
[root@master01 kubeconfig]# kubectl get csr
NAME AGE REQUESTOR CONDITION
node-csr-0uON9h27bA3I03O59M3wUUuFMn9VyEAKxsXV93ftsoA 35m kubelet-bootstrap Approved,Issued
node-csr-pN1MUK5bEta9052ytVLFHASMiLxWoQ4CPeaD3b32kS8 74s kubelet-bootstrap Pending
#通过请求
[root@master01 kubeconfig]# kubectl certificate approve node-csr-pN1MUK5bEta9052ytVLFHASMiLxWoQ4CPeaD3b32kS8
certificatesigningrequest.certificates.k8s.io/node-csr-pN1MUK5bEta9052ytVLFHASMiLxWoQ4CPeaD3b32kS8 approved
#再次查看你，状态为已通过
[root@master01 kubeconfig]# kubectl get csr
NAME AGE REQUESTOR CONDITION
node-csr-0uON9h27bA3I03O59M3wUUuFMn9VyEAKxsXV93ftsoA 36m kubelet-bootstrap Approved,Issued
node-csr-pN1MUK5bEta9052ytVLFHASMiLxWoQ4CPeaD3b32kS8 103s kubelet-bootstrap Approved,Issued
2.9.4 查看集群中节点的状态
[root@master01 kubeconfig]# kubectl get nodesNAME STATUS ROLES AGE VERSION192.168.23.104 Ready <none> 32m v1.12.3192.168.23.105 Ready <none> 2m28s v1.12.3
2.9.5 在node02上加载ipvs模块
[root@node02 opt]# for i in $(ls /usr/lib/modules/$(uname -r)/kernel/net/netfilter/ipvs|grep -o "^[^.]*");\
do echo $i; /sbin/modinfo -F filename $i >/dev/null 2>&1 && /sbin/modprobe $i;don
2.9.6 使用proxy.sh 启动proxy服务
[root@node02 opt]# cd /opt/
[root@node02 opt]# chmod +x proxy.sh
[root@node02 opt]# ./proxy.sh 192.168.23.105
Created symlink from /etc/systemd/system/multi-user.target.wants/kube-proxy.service to /usr/lib/systemd/system/kube-proxy.service.
[root@node02 opt]# systemctl status kube-proxy.service
3 测试
3.1 创建资源
#创建deployment资源，名为nginx-test. 使用镜像 nginx:1.14
[root@master01 opt]# kubectl create deployment nginx-test --image=nginx:1.14
3.2 查看pod状态
[root@master01 opt]# kubectl get pod
NAME READY STATUS RESTARTS AGE
nginx-test-7dc4f9dcc9-9pxdf 1/1 Running 0 3m30s
3.3 查看pod的详细状态
[root@master01 opt]# kubectl describe pod nginx-test
[root@master01 opt]# kubectl get pod -o wide
NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE
nginx-test-7dc4f9dcc9-9pxdf 1/1 Running 0 11m 172.17.4.2 192.168.23.104 <none>
ne>
