Kubernetes节点服务搭建————二进制部署|单master节点配置（master组件部署|node组件部署）

Posted 他和晚风一样温柔

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Kubernetes节点服务搭建————二进制部署|单master节点配置（master组件部署|node组件部署）相关的知识，希望对你有一定的参考价值。

文章目录

部署Master组件

Master节点上操作

上传master.zip和k8s-cert.sh到 /opt/k8s 目录中，解压master.zip压缩包
master.zip软件包,k8s-cert.sh脚本文件

cd /opt/k8s

unzip master.zip
chmod +x *.sh

创建kubernetes工作目录

mkdir -p /opt/kubernetes/{cfg,bin,ssl}

创建用于生成CA证书、相关组件的证书和私钥的目录

mkdir /opt/k8s/k8s-cert
mv /opt/k8s/k8s-cert.sh /opt/k8s/k8s-cert
cd /opt/k8s/k8s-cert/

vim k8s-cert.sh
./k8s-cert.sh

ls



证书生成脚本文件

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.111.80",		#master01
      "192.168.111.70",		#master02
      "192.168.111.60",		#vip，后面 keepalived 使用
      "192.168.111.30.",		#load balancer01（master）
      "192.168.111.40",		#load balancer02（backup）
      "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

复制CA证书、apiserver相关证书和私钥到kubernetes工作目录的ssl目录中

cp ca*pem apiserver*pem /opt/kubernetes/ssl/

上传 kubernetes-server-linux-amd64.tar.gz到/opt/k8s/目录中，解压 kubernetes压缩包

kubernetes-server软件包

cd /opt/k8s

tar zxvf kubernetes-server-linux-amd64.tar.gz


复制master组件的关键命令文件到kubernetes工作目录的 bin子目录中，创建链接文件，让系统服务识别

cd /opt/k8s/kubernetes/server/bin/
cp kube-apiserver kubectl kube-controller-manager kube-scheduler /opt/kubernetes/bin/
ln -s /opt/kubernetes/bin/* /usr/local/bin/

创建bootstrap token认证文件

head -c 16 /dev/urandom | od -An -t x | tr -d ' '
f9b1ffaf037a57848f167b05a0060201

vim /opt/kubernetes/cfg/token.csv
f9b1ffaf037a57848f167b05a0060201,kubelet-bootstrap,10001,"system:kubelet-bootstrap"


启动api-server，查看端口服务有没有启动

cd /opt/k8s
./apiserver.sh 192.168.111.80 https://192.168.111.80:2379,https://192.168.111.90:2379,https://192.168.111.100:2379

systemctl status kube-apiserver.service

//k8s通过kube apiserver这 个进程提供服务，该进程运行在单个master节点上。默认有两个端口6443和8080
//安全端口6443用于接收HTTPS请求，用于基于Token文件或客户端证书等认证
netstat -natp | grep 6443

//本地端口8080用于接收HTTP请求，非认证或授权的HTTP请求通过该端口访问APT Server
netstat -natp | grep 8080

启动scheduler服务

cd /opt/k8s/
./scheduler.sh 127.0.0.1

启动controller-manager服务

cd /opt/k8s/
./controller-manager.sh 127.0.0.1

查看Master节点状态

kubectl get cs

部署node组件

在master节点上操作

把kubelet和kube-proxy拷贝到node节点

cd /opt/k8s/kubernetes/server/bin
scp kubelet kube-proxy root@192.168.111.90:/opt/kubernetes/bin/
scp kubelet kube-proxy root@192.168.111.100:/opt/kubernetes/bin/

在node01节点上操作

上传node.zip 到/opt目录中，解压 node.zip压缩包，获得kubelet.sh、proxy.sh
node.zip软件包

cd /opt

unzip node.zip

在master节点上操作

创建用于生成kubelet的配置文件的目录

mkdir /opt/k8s/kubeconfig

上传kubeconfig.sh文件到/opt/k8s / kubeconfig目录中

kubeconfig.sh文件

cd /opt/k8s/kubeconfig

chmod +x kubeconfig.sh


vim kubeconfig.sh
#!/bin/bash
#example: kubeconfig 192.168.73.188 /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

执行kubeconfig.sh文件生成kubelet的配置文件

./kubeconfig.sh 192.168.111.80 /opt/k8s/k8s-cert/

把配置文件bootstrap.kubeconfig和kube-proxy.kubeconfig拷贝到node节点

scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.111.90:/opt/kubernetes/cfg/
scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.111.100:/opt/kubernetes/cfg/

RBAC授权

1.kubelet采用TLS Bootstrapping 机制，自动完成到kube-apiserver 的注册，在node节点量较大或者后期自动扩容时非常有用
2.Master apiserver 启用TLS 认证后，node 节点kubelet 组件想要加入集群，必须使用CA签发的有效证书才能与apiserver通信，当node节点很多时，签署证书是一件很繁琐的事情。因此Kubernetes引入了TLS bootstraping机制来自动颁发客户端证书，kubelet会以一个低权限用户自动向apiserver 申请证书，kubelet 的证书由 apiserver 动态签署。
3.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认证请求。
4.TLS bootstrapping 时的证书实际是由kube-controller-manager 组件来签署的，也就是说证书有效期是kube-controller-manager组件控制的; kube-controller-manager组件提供了一个–experimental-cluster-signing-duration参数来设置签署的证书有效时间;默认为8760h0m0s， 将其改为87600h0m0s， 即10年后再进行TLS bootstrapping 签署证书即可。
5.也就是说kubelet 首次访问API Server时，是使用token 做认证，通过后，Controller Manager 会为kubelet生成一个证书，以后的访问都是用证书做认证了。

将预设用户kubelet-bootstrap与内置的ClusterRole system:node-bootstrapper绑定到一起，使其能够发起CSR请求

kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap


查看角色信息

kubectl get clusterroles | grep system:node-bootstrapper


查看已授权的角色

kubectl get clusterrolebinding

在node01节点上操作

使用Kubelet.sh脚本启动kubelet服务

cd /opt	
chmod +x kubelet.sh
./kubelet.sh 192.168.111.90

检查kueblet服务
ps aux | grep kubelet


Master01上操作

检查到node01节点的kubelet 发起的CSR请求，Pending 表示等待集群给该节点签发证书

kubectl get csr
NAME                                                   AGE   REQUESTOR           CONDITION
node-csr-TM4SIBrsuOvNBdRYXjUzzmoaWLUPMfTPohbj1MCmbB8   9m8s   kubelet-bootstrap   Pending

通过CSR请求

kubectl certificate approve node-csr-TM4SIBrsuOvNBdRYXjUzzmoaWLUPMfTPohbj1MCmbB8


查看集群节点状态

kubectl get nodes


在node1节点上操作

自动生成了证书和kubelet.kubeconfig文件

ls /opt/kubernetes/cfg/kubelet.kubeconfig
ls /opt/kubernetes/ssl/

加载 ip_vs 模块

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


使用proxy.sh脚本启动proxy服务

cd /opt
chmod +x proxy.sh
./proxy.sh 192.168.111.90

systemctl status kube-proxy.service

将node01节点上将kubelet.sh、proxy.sh文件拷贝到node02节点中

scp kubelet.sh proxy.sh root@192.168.111.100:/opt/

在node02节点上开启服务

执行kubelet.sh文件开启服务

以上是关于Kubernetes节点服务搭建————二进制部署|单master节点配置（master组件部署|node组件部署）的主要内容，如果未能解决你的问题，请参考以下文章

Kubernetes节点服务搭建————二进制部署多节点服务搭建Dashboard UI部署

Kubernetes节点服务搭建————二进制部署多节点服务搭建Dashboard UI部署

Kubernetes节点服务搭建————二进制部署|单master节点配置（master组件部署|node组件部署）

Kubernetes节点服务搭建————二进制部署|单master节点配置（master组件部署|node组件部署）

Kubernetes节点服务搭建————二进制部署|单master节点配置（master组件部署|node组件部署）

Kubernetes节点服务搭建————二进制部署|单master节点配置（一)(etcd和flannel)