06-2.部署 kube-apiserver 集群

本文档讲解部署一个单 master 的部署，对应的节点 IP 为环境变量 ${MASTER_IP}。

准备工作

下载最新版本的二进制文件、安装和配置 flanneld 参考：06-0.部署master节点.md

创建 kubernetes 证书和私钥

创建证书签名请求：

  1. cd /opt/k8s/work
  2. source /opt/k8s/bin/environment.sh
  3. cat > kubernetes-csr.json <<EOF
  4. {
  5.   "CN": "kubernetes",
  6.   "hosts": [
  7.     "127.0.0.1",
  8.     "172.27.136.1",
  9.     "172.27.136.2",
  10.     "172.27.136.3",
  11.     "${MASTER_VIP}",
  12.     "${CLUSTER_KUBERNETES_SVC_IP}",
  13.     "kubernetes",
  14.     "kubernetes.default",
  15.     "kubernetes.default.svc",
  16.     "kubernetes.default.svc.cluster",
  17.     "kubernetes.default.svc.cluster.local"
  18.   ],
  19.   "key": {
  20.     "algo": "rsa",
  21.     "size": 2048
  22.   },
  23.   "names": [
  24.     {
  25.       "C": "CN",
  26.       "ST": "BeiJing",
  27.       "L": "BeiJing",
  28.       "O": "k8s",
  29.       "OU": "4Paradigm"
  30.     }
  31.   ]
  32. }
  33. EOF
  • hosts 字段指定授权使用该证书的 IP 或域名列表，这里列出了 VIP 、apiserver 节点 IP、kubernetes 服务 IP 和域名；
  • 域名最后字符不能是 .(如不能为 kubernetes.default.svc.cluster.local.)，否则解析时失败，提示： x509: cannot parse dnsName "kubernetes.default.svc.cluster.local."；
  • 如果使用非 cluster.local 域名，如 opsnull.com，则需要修改域名列表中的最后两个域名为：kubernetes.default.svc.opsnull、kubernetes.default.svc.opsnull.com

  • kubernetes 服务 IP 是 apiserver 自动创建的，一般是 --service-cluster-ip-range 参数指定的网段的第一个IP，后续可以通过如下命令获取：

    1. $ kubectl get svc kubernetes
    2. NAME         CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
    3. kubernetes   10.254.0.1   <none>        443/TCP   1d

生成证书和私钥：

  1. cd /opt/k8s/work
  2. cfssl gencert -ca=/opt/k8s/work/ca.pem \
  3.   -ca-key=/opt/k8s/work/ca-key.pem \
  4.   -config=/opt/k8s/work/ca-config.json \
  5.   -profile=kubernetes kubernetes-csr.json | cfssljson -bare kubernetes
  6. ls kubernetes*pem

将生成的证书和私钥文件拷贝到 master 节点：

  1. cd /opt/k8s/work
  2. source /opt/k8s/bin/environment.sh
  3. for node_ip in ${NODE_IPS[@]}
  4.   do
  5.     echo ">>> ${node_ip}"
  6.     ssh root@${node_ip} "mkdir -p /etc/kubernetes/cert/"
  7.     scp kubernetes*.pem root@${node_ip}:/etc/kubernetes/cert/
  8.   done

创建 kube-apiserver 使用的客户端 token 文件

kubelet 首次启动时向 kube-apiserver 发送 TLS Bootstrapping 请求，kube-apiserver 验证 kubelet 请求中的 token 是否与它配置的 token.csv 一致，如果一致则自动为 kubelet生成证书和秘钥。

  1. cd /opt/k8s/work
  2. source /opt/k8s/bin/environment.sh
  3. cat > token.csv <<EOF
  4. ${BOOTSTRAP_TOKEN},kubelet-bootstrap,10001,"system:kubelet-bootstrap"
  5. EOF
  6. for node_ip in ${NODE_IPS[@]}
  7.   do
  8.     echo ">>> ${node_ip}"
  9.     scp token.csv root@${node_ip}:/etc/kubernetes/
  10.   done

创建 kube-apiserver systemd unit 模板文件

  1. cd /opt/k8s/work
  2. source /opt/k8s/bin/environment.sh
  3. cat > kube-apiserver.service.template <<EOF
  4. [Unit]
  5. Description=Kubernetes API Server
  6. Documentation=https://github.com/GoogleCloudPlatform/kubernetes
  7. After=network.target
  9. [Service]
  10. WorkingDirectory=${K8S_DIR}/kube-apiserver
  11. ExecStart=/opt/k8s/bin/kube-apiserver \\
  12.   --admission-control=NamespaceLifecycle,NodeRestriction,LimitRanger,ServiceAccount,DefaultStorageClass,ResourceQuota \\
  13.   --anonymous-auth=false \\
  14.   --advertise-address=##NODE_IP## \\
  15.   --bind-address=##NODE_IP## \\
  16.   --feature-gates=RotateKubeletClientCertificate=true,RotateKubeletServerCertificate=true,Accelerators=true,DevicePlugins=true \\
  17.   --insecure-port=0 \\
  18.   --authorization-mode=Node,RBAC \\
  19.   --runtime-config=api/all \\
  20.   --enable-bootstrap-token-auth \\
  21.   --token-auth-file=/etc/kubernetes/token.csv \\
  22.   --service-cluster-ip-range=${SERVICE_CIDR} \\
  23.   --service-node-port-range=${NODE_PORT_RANGE} \\
  24.   --tls-cert-file=/etc/kubernetes/cert/kubernetes.pem \\
  25.   --tls-private-key-file=/etc/kubernetes/cert/kubernetes-key.pem \\
  26.   --client-ca-file=/etc/kubernetes/cert/ca.pem \\
  27.   --kubelet-client-certificate=/etc/kubernetes/cert/kubernetes.pem \\
  28.   --kubelet-client-key=/etc/kubernetes/cert/kubernetes-key.pem \\
  29.   --service-account-key-file=/etc/kubernetes/cert/ca-key.pem \\
  30.   --etcd-cafile=/etc/kubernetes/cert/ca.pem \\
  31.   --etcd-certfile=/etc/kubernetes/cert/kubernetes.pem \\
  32.   --etcd-keyfile=/etc/kubernetes/cert/kubernetes-key.pem \\
  33.   --etcd-servers=${ETCD_ENDPOINTS} \\
  34.   --enable-swagger-ui=true \\
  35.   --allow-privileged=true \\
  36.   --max-mutating-requests-inflight=2000 \\
  37.   --max-requests-inflight=4000 \\
  38.   --apiserver-count=3 \\
  39.   --audit-log-maxage=30 \\
  40.   --audit-log-maxbackup=3 \\
  41.   --audit-log-maxsize=100 \\
  42.   --audit-log-path=${K8S_DIR}/kube-apiserver/audit.log \\
  43.   --event-ttl=168h \\
  44.   --logtostderr=true \\
  45.   --v=2
  46. Restart=always
  47. RestartSec=5
  48. StartLimitInterval=0
  49. Type=notify
  50. LimitNOFILE=65536
  52. [Install]
  53. WantedBy=multi-user.target
  54. EOF
  • --authorization-mode=Node,RBAC： 开启 Node 和 RBAC 授权模式，拒绝未授权的请求；
  • --admission-control：启用 ServiceAccount 和 NodeRestriction；
  • --service-account-key-file：签名 ServiceAccount Token 的公钥文件，kube-controller-manager 的 --service-account-private-key-file 指定私钥文件，两者配对使用；
  • --tls-*-file：指定 apiserver 使用的证书、私钥和 CA 文件。--client-ca-file 用于验证 client (kue-controller-manager、kube-scheduler、kubelet、kube-proxy 等)请求所带的证书；
  • --kubelet-client-certificate、--kubelet-client-key：如果指定，则使用 https 访问 kubelet APIs；需要为证书对应的用户(上面 kubernetes*.pem 证书的用户为 kubernetes) 用户定义 RBAC 规则，否则访问 kubelet API 时提示未授权；
  • --bind-address： 不能为 127.0.0.1，否则外界不能访问它的安全端口 6443；
  • --feature-gates=Accelerators=true,DevicePlugins=true：支持 GPU 加速功能；
  • --insecure-port=0：关闭监听非安全端口(8080)；
  • --service-cluster-ip-range： 指定 Service Cluster IP 地址段；
  • --service-node-port-range： 指定 NodePort 的端口范围；
  • --runtime-config=api/all=true： 启用所有版本的 APIs，如 autoscaling/v2alpha1；
  • --enable-bootstrap-token-auth：启用 kubelet bootstrap 的 token 认证；
  • --apiserver-count=3：指定集群运行模式，多台 kube-apiserver 会通过 leader 选举产生一个工作节点，其它节点处于阻塞状态；

为各节点创建和分发 kube-apiserver systemd unit 文件

替换模板文件中的变量，为各节点创建 systemd unit 文件：

  1. cd /opt/k8s/work
  2. source /opt/k8s/bin/environment.sh
  3. for (( i=0; i < 3; i++ ))
  4.   do
  5.     sed -e "s/##NODE_NAME##/${NODE_NAMES[i]}/" -e "s/##NODE_IP##/${NODE_IPS[i]}/" kube-apiserver.service.template > kube-apiserver-${NODE_IPS[i]}.service 
  6.   done
  7. ls kube-apiserver*.service
  • NODE_NAMES 和 NODE_IPS 为相同长度的 bash 数组，分别为节点名称和对应的 IP；

分发生成的 systemd unit 文件：

  1. cd /opt/k8s/work
  2. source /opt/k8s/bin/environment.sh
  3. for node_ip in ${NODE_IPS[@]}
  4.   do
  5.     echo ">>> ${node_ip}"
  6.     ssh root@${node_ip} "mkdir -p ${K8S_DIR}/kube-apiserver"
  7.     scp kube-apiserver-${node_ip}.service root@${node_ip}:/etc/systemd/system/kube-apiserver.service
  8.   done
  • 必须先创建日志目录；
  • 文件重命名为 kube-apiserver.service;

替换后的 unit 文件：kube-apiserver.service

启动 kube-apiserver 服务

  1. source /opt/k8s/bin/environment.sh
  2. for node_ip in ${NODE_IPS[@]}
  3.   do
  4.     echo ">>> ${node_ip}"
  5.     ssh root@${node_ip} "systemctl daemon-reload && systemctl enable kube-apiserver && systemctl restart kube-apiserver"
  6.   done

检查 kube-apiserver 运行状态

  1. source /opt/k8s/bin/environment.sh
  2. for node_ip in ${NODE_IPS[@]}
  3.   do
  4.     echo ">>> ${node_ip}"
  5.     ssh root@${node_ip} "systemctl status kube-apiserver |grep 'Active:'"
  6.   done

确保状态为 active (running)，否则到 master 节点查看日志，确认原因：

  1. journalctl -u kube-apiserver

打印 kube-apiserver 写入 etcd 的数据

  1. source /opt/k8s/bin/environment.sh
  2. ETCDCTL_API=3 etcdctl \
  3.     --endpoints=${ETCD_ENDPOINTS} \
  4.     --cacert=/opt/k8s/work/ca.pem \
  5.     --cert=/etc/etcd/cert/etcd.pem \
  6.     --key=/etc/etcd/cert/etcd-key.pem \
  7.     get /registry/ --prefix --keys-only

检查集群信息

  1. $ kubectl cluster-info
  2. Kubernetes master is running at https://172.27.128.252:8443
  4. To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.
  6. $ kubectl get all --all-namespaces
  7. NAMESPACE   NAME             TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
  8. default     svc/kubernetes   ClusterIP   10.254.0.1   <none>        443/TCP   44s
  10. $ kubectl get componentstatuses
  11. NAME                 STATUS      MESSAGE                                                                                        ERROR
  12. scheduler            Unhealthy   Get http://127.0.0.1:10251/healthz: dial tcp 127.0.0.1:10251: getsockopt: connection refused
  13. controller-manager   Unhealthy   Get http://127.0.0.1:10252/healthz: dial tcp 127.0.0.1:10252: getsockopt: connection refused
  14. etcd-0               Healthy     {"health":"true"}
  15. etcd-1               Healthy     {"health":"true"}
  16. etcd-2               Healthy     {"health":"true"}

注意：

  1. 如果执行 kubectl 命令式时输出如下错误信息，则说明使用的 ~/.kube/config 文件不对，请切换到正确的账户后再执行该命令：

    The connection to the server localhost:8080 was refused - did you specify the right host or port?

  2. 执行 kubectl get componentstatuses 命令时，apiserver 默认向 127.0.0.1 发送请求。当 controller-manager、scheduler 以集群模式运行时，有可能和 kube-apiserver 不在一台机器上，这时 controller-manager 或 scheduler 的状态为 Unhealthy，但实际上它们工作正常。

检查 kube-apiserver 监听的端口

  1. $ sudo netstat -lnpt|grep kube
  2. tcp        0      0 172.27.136.1:6443      0.0.0.0:*               LISTEN      7003/kube-apiserver
  • 6443: 接收 https 请求的安全端口，对所有请求做认证和授权；
  • 由于关闭了非安全端口，故没有监听 8080；

授予 kubernetes 证书访问 kubelet API 的权限

在执行 kubectl exec、run、logs 等命令时，apiserver 会转发到 kubelet。这里定义 RBAC 规则，授权 apiserver 调用 kubelet API。

定义 ClusterRole system:kubelet-api-admin 授予访问 kubelet 所有 API 的权限：

  1. cd /opt/k8s/work
  2. cat > kubelet-api-admin.yaml <<EOF
  3. apiVersion: rbac.authorization.k8s.io/v1
  4. kind: ClusterRole
  5. metadata:
  6.   annotations:
  7.     rbac.authorization.kubernetes.io/autoupdate: "true"
  8.   labels:
  9.     kubernetes.io/bootstrapping: rbac-defaults
  10.   name: system:kubelet-api-admin
  11. rules:
  12. - apiGroups:
  13.   - ""
  14.   resources:
  15.   - nodes
  16.   verbs:
  17.   - get
  18.   - list
  19.   - watch
  20. - apiGroups:
  21.   - ""
  22.   resources:
  23.   - nodes
  24.   verbs:
  25.   - proxy
  26. - apiGroups:
  27.   - ""
  28.   resources:
  29.   - nodes/log
  30.   - nodes/metrics
  31.   - nodes/proxy
  32.   - nodes/spec
  33.   - nodes/stats
  34.   verbs:
  35.   - '*'
  36. EOF
  37. kubectl create -f kubelet-api-admin.yaml

授予 kubernetes 证书访问 kubelet API 的权限：

  1. kubectl create clusterrolebinding kube-apiserver:kubelet-apis --clusterrole=system:kubelet-api-admin --user kubernetes

查看 ClusterRole 结果：

  1. kubectl describe clusterrole system:kubelet-api-admin

输出：

  1. Name:         system:kubelet-api-admin
  2. Labels:       kubernetes.io/bootstrapping=rbac-defaults
  3. Annotations:  rbac.authorization.kubernetes.io/autoupdate=true
  4. PolicyRule:
  5.   Resources      Non-Resource URLs  Resource Names  Verbs
  6.   ---------      -----------------  --------------  -----
  7.   nodes          []                 []              [get list watch proxy]
  8.   nodes/log      []                 []              [*]
  9.   nodes/metrics  []                 []              [*]
  10.   nodes/proxy    []                 []              [*]
  11.   nodes/spec     []                 []              [*]
  12.   nodes/stats    []                 []              [*]

参考

  1. 关于证书域名最后字符不能是 . 的问题，实际和 Go 的版本有关，1.9 不支持这种类型的证书：https://github.com/kubernetes/ingress-nginx/issues/2188