Kubernetes实战(一)-二进制部署Kubernetes集群

企业开发 2023-09-29 20:19:47 阅读次数: 0

1 组件版本和配置策略

1.1 组件版本

组件 版本 发布时间
kubernetes 1.16.6 2020-01-22
etcd 3.4.3 2019-10-24
containerd 1.3.3 2020-02-07
runc 1.0.0-rc10 2019-12-23
calico 3.12.0 2020-01-27
coredns 1.6.6 2019-12-20
dashboard v2.0.0-rc4 2020-02-06
k8s-prometheus-adapter 0.5.0 2019-04-03
prometheus-operator 0.35.0 2020-01-13
prometheus 2.15.2 2020-01-06
elasticsearch、kibana 7.2.0 2019-06-25
cni-plugins 0.8.5 2019-12-20
metrics-server 0.3.6 2019-10-15

1.2 主要配置策略

1.2.1 kube-apiserver：

  • 使用节点本地 nginx 4 层透明代理实现高可用；
  • 关闭非安全端口 8080 和匿名访问；
  • 在安全端口 6443 接收 https 请求；
  • 严格的认证和授权策略 (x509、token、RBAC)；
  • 开启 bootstrap token 认证，支持 kubelet TLS bootstrapping；
  • 使用 https 访问 kubelet、etcd，加密通信；

1.2.2 kube-controller-manager：

  • 3 节点高可用；
  • 关闭非安全端口，在安全端口 10252 接收 https 请求；
  • 使用 kubeconfig 访问 apiserver 的安全端口；
  • 自动 approve kubelet 证书签名请求 (CSR)，证书过期后自动轮转；
  • 各 controller 使用自己的 ServiceAccount 访问 apiserver；

1.2.3 kube-scheduler：

  • 3 节点高可用；
  • 使用 kubeconfig 访问 apiserver 的安全端口；

1.2.4 kubelet：

  • 使用 kubeadm 动态创建 bootstrap token，而不是在 apiserver 中静态配置；
  • 使用 TLS bootstrap 机制自动生成 client 和 server 证书，过期后自动轮转；
  • 在 KubeletConfiguration 类型的 JSON 文件配置主要参数；
  • 关闭只读端口，在安全端口 10250 接收 https 请求，对请求进行认证和授权，拒绝匿名访问和非授权访问；
  • 使用 kubeconfig 访问 apiserver 的安全端口；

1.2.5 kube-proxy：

  • 使用 kubeconfig 访问 apiserver 的安全端口；
  • 在 KubeProxyConfiguration 类型的 JSON 文件配置主要参数；
  • 使用 ipvs 代理模式；

1.2.6 集群插件：

  • DNS：使用功能、性能更好的 coredns；
  • Dashboard：支持登录认证；
  • Metric：metrics-server，使用 https 访问 kubelet 安全端口；
  • Log：Elasticsearch、Fluend、Kibana；
  • Registry 镜像库：docker-registry、harbor；

2 初始化系统和全局变量

2.1 集群规划

  • sre-master-node：10.12.5.60
  • sre-worker-node-1：10.12.5.61
  • sre-worker-node-2：10.12.5.62

三台机器混合部署本文档的 etcd、master 集群和 woker 集群。

2.2 设置主机名

# master node主机名设置为sre-master-node
$ hostnamectl set-hostname sre-master-node
# worker node 1主机名设置为sre-worker-node-1
$ hostnamectl set-hostname sre-worker-node-1
# worker node 2主机名设置为sre-worker-node-2
$ hostnamectl set-hostname sre-worker-node-2

如果 DNS 不支持主机名称解析，还需要在每台机器的 /etc/hosts 文件中添加主机名和 IP 的对应关系：

本操作所有节点均需要执行。

$ cat >> /etc/hosts <<EOF
10.12.5.60 sre-master-node
10.12.5.61 sre-worker-node-1
10.12.5.62 sre-worker-node-2
EOF

退出，重新登录 root 账号，可以看到主机名生效。

2.3 添加节点信任关系

本操作只需要在sre-master-node节点上进行。

设置 root 账户可以无密码登录所有节点：

$ ssh-keygen -t rsa 
$ ssh-copy-id root@sre-master-node
$ ssh-copy-id root@sre-worker-node-1
$ ssh-copy-id root@sre-worker-node-2

2.4 更新 PATH 变量

本操作所有节点均需要执行。

$ echo 'PATH=/opt/k8s/bin:$PATH' >>/root/.bashrc
$ source /root/.bashrc

/opt/k8s/bin 目录保存本文档下载安装的程序。 

2.5 安装依赖包

本操作所有节点均需要执行。

$ yum install -y epel-release
$ yum install -y chrony conntrack ipvsadm ipset jq iptables curl sysstat libseccomp wget socat git
  • 本文档的 kube-proxy 使用 ipvs 模式，ipvsadm 为 ipvs 的管理工具；
  • etcd 集群各机器需要时间同步，chrony 用于系统时间同步；

2.6 关闭防火墙

本操作所有节点均需要执行。

关闭防火墙，清理防火墙规则，设置默认转发策略：

$ systemctl stop firewalld
$ systemctl disable firewalld
$ iptables -F && iptables -X && iptables -F -t nat && iptables -X -t nat
$ iptables -P FORWARD ACCEPT

2.7 关闭 swap 分区

本操作所有节点均需要执行。

关闭 swap 分区，否则kubelet 会启动失败(可以设置 kubelet 启动参数 --fail-swap-on 为 false 关闭 swap 检查)：

$ swapoff -a
$ sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

2.8 关闭 SELinux

本操作所有节点均需要执行。

关闭 SELinux，否则 kubelet 挂载目录时可能报错 Permission denied：

$ setenforce 0
$ sed -i 's/^SELINUX=.*/SELINUX=disabled/' /etc/selinux/config

2.9 优化内核参数

本操作所有节点均需要执行。

$ cat > kubernetes.conf <<EOF
net.bridge.bridge-nf-call-iptables=1
net.bridge.bridge-nf-call-ip6tables=1
net.ipv4.ip_forward=1
net.ipv4.tcp_tw_recycle=0
net.ipv4.neigh.default.gc_thresh1=1024
net.ipv4.neigh.default.gc_thresh2=2048
net.ipv4.neigh.default.gc_thresh3=4096
vm.swappiness=0
vm.overcommit_memory=1
vm.panic_on_oom=0
fs.inotify.max_user_instances=8192
fs.inotify.max_user_watches=1048576
fs.file-max=52706963
fs.nr_open=52706963
net.ipv6.conf.all.disable_ipv6=1
net.netfilter.nf_conntrack_max=2310720
EOF
$ cp kubernetes.conf  /etc/sysctl.d/kubernetes.conf
$ sysctl -p /etc/sysctl.d/kubernetes.conf
  • 关闭 tcp_tw_recycle，否则与 NAT 冲突，可能导致服务不通；

2.10 设置系统时区

本操作所有节点均需要执行。

$ timedatectl set-timezone Asia/Shanghai

2.11 设置系统时钟同步

本操作所有节点均需要执行。

$ systemctl enable chronyd
$ systemctl start chronyd

查看同步状态：

$ timedatectl status

输出：

System clock synchronized: yes
              NTP service: active
          RTC in local TZ: no
  • System clock synchronized: yes，表示时钟已同步；
  • NTP service: active，表示开启了时钟同步服务；
# 将当前的 UTC 时间写入硬件时钟

$ timedatectl set-local-rtc 0
# 重启依赖于系统时间的服务

$ systemctl restart rsyslog 
$ systemctl restart crond

2.12 关闭无关的服务

本操作所有节点均需要执行。

$ systemctl stop postfix && systemctl disable postfix

2.13 创建相关目录

本操作所有节点均需要执行。

创建目录：

$ mkdir -p /opt/k8s/{bin,work} /etc/{kubernetes,etcd}/cert

2.14 分发集群配置参数脚本

本操作所有节点均需要执行。

后续使用的环境变量都定义在文件 environment.sh 中，请根据自己的机器、网络情况修改。然后拷贝到所有节点：

environment.sh

$ vim environment.sh
#!/usr/bin/bash

# 生成 EncryptionConfig 所需的加密 key
export ENCRYPTION_KEY=$(head -c 32 /dev/urandom | base64)

# 集群各机器 IP 数组
export NODE_IPS=(10.12.5.60 10.12.5.61 10.12.5.62)

# 集群各 IP 对应的主机名数组
export NODE_NAMES=(sre-master-node sre-worker-node-1 sre-worker-node-2)

# etcd 集群服务地址列表
export ETCD_ENDPOINTS="https://10.12.5.60:2379,https://10.12.5.61:2379,https://10.12.5.62:2379"

# etcd 集群间通信的 IP 和端口
export ETCD_NODES="sre-master-node=https://10.12.5.60:2380,sre-worker-node-1=https://10.12.5.61:2380,sre-worker-node-1=https://10.12.5.62:2380"

# kube-apiserver 的反向代理(kube-nginx)地址端口
export KUBE_APISERVER="https://127.0.0.1:8443"

# 节点间互联网络接口名称
export IFACE="eth0"

# etcd 数据目录
export ETCD_DATA_DIR="/data/k8s/etcd/data"

# etcd WAL 目录，建议是 SSD 磁盘分区，或者和 ETCD_DATA_DIR 不同的磁盘分区
export ETCD_WAL_DIR="/data/k8s/etcd/wal"

# k8s 各组件数据目录
export K8S_DIR="/data/k8s/k8s"

## DOCKER_DIR 和 CONTAINERD_DIR 二选一
# docker 数据目录
export DOCKER_DIR="/data/k8s/docker"

# containerd 数据目录
export CONTAINERD_DIR="/data/k8s/containerd"

## 以下参数一般不需要修改

# TLS Bootstrapping 使用的 Token，可以使用命令 head -c 16 /dev/urandom | od -An -t x | tr -d ' ' 生成
BOOTSTRAP_TOKEN="502c6e11a65946e3064e7a4b4658ec29"

# 最好使用 当前未用的网段 来定义服务网段和 Pod 网段

# 服务网段，部署前路由不可达，部署后集群内路由可达(kube-proxy 保证)
SERVICE_CIDR="192.168.0.0/16"

# Pod 网段，建议 /16 段地址，部署前路由不可达，部署后集群内路由可达(flanneld 保证)
CLUSTER_CIDR="172.16.0.0/16"

# 服务端口范围 (NodePort Range)
export NODE_PORT_RANGE="30000-32767"

# kubernetes 服务 IP (一般是 SERVICE_CIDR 中第一个IP)
export CLUSTER_KUBERNETES_SVC_IP="192.168.0.1"

# 集群 DNS 服务 IP (从 SERVICE_CIDR 中预分配)
export CLUSTER_DNS_SVC_IP="192.168.0.2"

# 集群 DNS 域名（末尾不带点号）
export CLUSTER_DNS_DOMAIN="cluster.local"

# 将二进制目录 /opt/k8s/bin 加到 PATH 中
export PATH=/opt/k8s/bin:$PATH

$ source environment.sh # 先修改
$ vim deploy-k8s.sh
#!/bin/bash
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    scp environment.sh root@${node_ip}:/opt/k8s/bin/
    ssh root@${node_ip} "chmod +x /opt/k8s/bin/*"
  done
$ sh deploy-k8s.sh

2.15 升级内核

本操作所有节点均需要执行。

CentOS 7.x 系统自带的 3.10.x 内核存在一些 Bugs，导致运行的 Docker、Kubernetes 不稳定，例如：

  1. 高版本的 docker(1.13 以后) 启用了 3.10 kernel 实验支持的 kernel memory account 功能(无法关闭)，当节点压力大如频繁启动和停止容器时会导致 cgroup memory leak；
  2. 网络设备引用计数泄漏，会导致类似于报错："kernel:unregister_netdevice: waiting for eth0 to become free. Usage count = 1";

解决方案如下：

  1. 升级内核到 4.4.X 以上；
  2. 或者，手动编译内核，disable CONFIG_MEMCG_KMEM 特性；
  3. 或者，安装修复了该问题的 Docker 18.09.1 及以上的版本。但由于 kubelet 也会设置 kmem（它 vendor 了 runc），所以需要重新编译 kubelet 并指定 GOFLAGS="-tags=nokmem"；
$ git clone --branch v1.14.1 --single-branch --depth 1 https://github.com/kubernetes/kubernetes
$ cd kubernetes
$ KUBE_GIT_VERSION=v1.14.1 ./build/run.sh make kubelet GOFLAGS="-tags=nokmem"

这里采用升级内核的解决办法：

$ rpm -Uvh http://www.elrepo.org/elrepo-release-7.0-3.el7.elrepo.noarch.rpm
# 安装完成后检查 /boot/grub2/grub.cfg 中对应内核 menuentry 中是否包含 initrd16 配置，如果没有，再安装一次！
$ yum --enablerepo=elrepo-kernel install -y kernel-lt
# 设置开机从新内核启动
$ grub2-set-default 0

重启机器：

$ sync
$ reboot

3 创建 CA 根证书和秘钥

为确保安全，kubernetes 系统各组件需要使用 x509 证书对通信进行加密和认证。

CA (Certificate Authority) 是自签名的根证书，用来签名后续创建的其它证书。

CA 证书是集群所有节点共享的，只需要创建一次，后续用它签名其它所有证书。

本章节使用 CloudFlare 的 PKI 工具集 cfssl 创建所有证书。

如果没有特殊指明，本文档的所有操作均在 sre-master-node节点上执行。

3.1 安装 cfssl 工具集

$ sudo mkdir -p /opt/k8s/cert && cd /opt/k8s/work

$ wget https://github.com/cloudflare/cfssl/releases/download/v1.4.1/cfssl_1.4.1_linux_amd64
$ mv cfssl_1.4.1_linux_amd64 /opt/k8s/bin/cfssl

$ wget https://github.com/cloudflare/cfssl/releases/download/v1.4.1/cfssljson_1.4.1_linux_amd64
$ mv cfssljson_1.4.1_linux_amd64 /opt/k8s/bin/cfssljson

$ wget https://github.com/cloudflare/cfssl/releases/download/v1.4.1/cfssl-certinfo_1.4.1_linux_amd64
$ mv cfssl-certinfo_1.4.1_linux_amd64 /opt/k8s/bin/cfssl-certinfo

$ chmod +x /opt/k8s/bin/*
$ export PATH=/opt/k8s/bin:$PATH

3.2 创建配置文件

CA 配置文件用于配置根证书的使用场景 (profile) 和具体参数 (usage，过期时间、服务端认证、客户端认证、加密等)：

$ cd /opt/k8s/work
$ cat > ca-config.json <<EOF
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "kubernetes": {
        "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ],
        "expiry": "876000h"
      }
    }
  }
}
EOF
  • signing：表示该证书可用于签名其它证书（生成的 ca.pem 证书中 CA=TRUE）；
  • server auth：表示 client 可以用该该证书对 server 提供的证书进行验证；
  • client auth：表示 server 可以用该该证书对 client 提供的证书进行验证；
  • "expiry": "876000h"：证书有效期设置为 100 年；

3.3 创建证书签名请求文件

$ cd /opt/k8s/work
$ cat > ca-csr.json <<EOF
{
  "CN": "kubernetes-ca",
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "ShangHai",
      "L": "ShangHai",
      "O": "k8s",
      "OU": "opsnull"
    }
  ],
  "ca": {
    "expiry": "876000h"
 }
}
EOF
  • CN：Common Name：kube-apiserver 从证书中提取该字段作为请求的用户名 (User Name)，浏览器使用该字段验证网站是否合法；
  • O：Organization：kube-apiserver 从证书中提取该字段作为请求用户所属的组 (Group)；
  • kube-apiserver 将提取的 User、Group 作为 RBAC 授权的用户标识；

注意：

  1. 不同证书 csr 文件的 CN、C、ST、L、O、OU 组合必须不同，否则可能出现 PEER'S CERTIFICATE HAS AN INVALID SIGNATURE 错误；
  2. 后续创建证书的 csr 文件时，CN 都不相同（C、ST、L、O、OU 相同），以达到区分的目的；

3.4 生成 CA 证书和私钥

$ cd /opt/k8s/work
$ cfssl gencert -initca ca-csr.json | cfssljson -bare ca
$ ls ca*

3.5 分发证书文件

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim deploy-ca.sh
#!/bin/bash
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "mkdir -p /etc/kubernetes/cert"
    scp ca*.pem ca-config.json root@${node_ip}:/etc/kubernetes/cert
  done
$ sh deploy-ca.sh

4 安装和配置 kubectl

  • 如果没有特殊指明，本文档的所有操作均在sre-master-node节点上执行；
  • 本文档只需要部署一次，生成的 kubeconfig 文件是通用的，可以拷贝到需要执行 kubectl 命令的机器的 ~/.kube/config 位置；

4.1 下载和分发 kubectl 二进制文件

$ cd /opt/k8s/work
$ wget https://dl.k8s.io/v1.16.6/kubernetes-client-linux-amd64.tar.gz # 自行解决翻墙下载问题
$ tar -xzvf kubernetes-client-linux-amd64.tar.gz

分发到所有使用 kubectl 工具的节点：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim deploy-kubectl.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    scp kubernetes/client/bin/kubectl root@${node_ip}:/opt/k8s/bin/
    ssh root@${node_ip} "chmod +x /opt/k8s/bin/*"
  done
$ sh deploy-kubectl.sh

4.2  创建 admin 证书和私钥

kubectl 使用 https 协议与 kube-apiserver 进行安全通信，kube-apiserver 对 kubectl 请求包含的证书进行认证和授权。

kubectl 后续用于集群管理，所以这里创建具有最高权限的 admin 证书。

创建证书签名请求：

$ cd /opt/k8s/work
$ cat > admin-csr.json <<EOF
{
  "CN": "admin",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "system:masters",
      "OU": "opsnull"
    }
  ]
}
EOF
  • O: system:masters：kube-apiserver 收到使用该证书的客户端请求后，为请求添加组（Group）认证标识 system:masters；
  • 预定义的 ClusterRoleBinding cluster-admin 将 Group system:masters 与 Role cluster-admin 绑定，该 Role 授予操作集群所需的最高权限；
  • 该证书只会被 kubectl 当做 client 证书使用，所以 hosts 字段为空；

生成证书和私钥：

$ cd /opt/k8s/work
$ cfssl gencert -ca=/opt/k8s/work/ca.pem \
  -ca-key=/opt/k8s/work/ca-key.pem \
  -config=/opt/k8s/work/ca-config.json \
  -profile=kubernetes admin-csr.json | cfssljson -bare admin
$ ls admin*
  • 忽略警告消息 [WARNING] This certificate lacks a "hosts" field.；

4.3 创建 kubeconfig 文件

kubectl 使用 kubeconfig 文件访问 apiserver，该文件包含 kube-apiserver 的地址和认证信息（CA 证书和客户端证书）：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh

# 设置集群参数
$ kubectl config set-cluster kubernetes \
  --certificate-authority=/opt/k8s/work/ca.pem \
  --embed-certs=true \
  --server=https://${NODE_IPS[0]}:6443 \
  --kubeconfig=kubectl.kubeconfig

# 设置客户端认证参数
$ kubectl config set-credentials admin \
  --client-certificate=/opt/k8s/work/admin.pem \
  --client-key=/opt/k8s/work/admin-key.pem \
  --embed-certs=true \
  --kubeconfig=kubectl.kubeconfig

# 设置上下文参数
$ kubectl config set-context kubernetes \
  --cluster=kubernetes \
  --user=admin \
  --kubeconfig=kubectl.kubeconfig



# 设置默认上下文
$ kubectl config use-context kubernetes --kubeconfig=kubectl.kubeconfig
  • --certificate-authority：验证 kube-apiserver 证书的根证书；
  • --client-certificate、--client-key：刚生成的 admin 证书和私钥，与 kube-apiserver https 通信时使用；
  • --embed-certs=true：将 ca.pem 和 admin.pem 证书内容嵌入到生成的 kubectl.kubeconfig 文件中(否则，写入的是证书文件路径，后续拷贝 kubeconfig 到其它机器时，还需要单独拷贝证书文件，不方便。)；
  • --server：指定 kube-apiserver 的地址，这里指向第一个节点上的服务；

4.4 分发 kubeconfig 文件

分发到所有使用 kubectl 命令的节点：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim deploy-kubeconfig.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "mkdir -p ~/.kube"
    scp kubectl.kubeconfig root@${node_ip}:~/.kube/config
  done
$ sh deploy-kubeconfig.sh

5 部署 etcd 集群

etcd 是基于 Raft 的分布式 KV 存储系统，由 CoreOS 开发，常用于服务发现、共享配置以及并发控制（如 leader 选举、分布式锁等）。

kubernetes 使用 etcd 集群持久化存储所有 API 对象、运行数据。

本章节介绍部署一个三节点高可用 etcd 集群的步骤：

  • 下载和分发 etcd 二进制文件；
  • 创建 etcd 集群各节点的 x509 证书，用于加密客户端(如 etcdctl) 与 etcd 集群、etcd 集群之间的通信；
  • 创建 etcd 的 systemd unit 文件，配置服务参数；
  • 检查集群工作状态；

etcd 集群节点名称和 IP 如下：

  • sre-master-node：10.12.5.60
  • sre-worker-node-1：10.12.5.61
  • sre-worker-node-2：10.12.5.62
  1. 如果没有特殊指明，本文档的所有操作均在sre-master-node节点上执行；
  2. flanneld 与本文档安装的 etcd v3.4.x 不兼容，如果要安装 flanneld（本文档使用 calio），则需要将 etcd 降级到 v3.3.x 版本；

5.1 下载和分发 etcd 二进制文件

到 etcd 的 release 页面 下载最新版本的发布包：

$ cd /opt/k8s/work
$ wget https://github.com/coreos/etcd/releases/download/v3.4.3/etcd-v3.4.3-linux-amd64.tar.gz
$ tar -xvf etcd-v3.4.3-linux-amd64.tar.gz

分发二进制文件到集群所有节点：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim deploy-etcd.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    scp etcd-v3.4.3-linux-amd64/etcd* root@${node_ip}:/opt/k8s/bin
    ssh root@${node_ip} "chmod +x /opt/k8s/bin/*"
  done
$ sh deploy-etcd.sh

5.2 创建 etcd 证书和私钥

创建证书签名请求：

$ cd /opt/k8s/work
$ cat > etcd-csr.json <<EOF
{
  "CN": "etcd",
  "hosts": [
    "127.0.0.1",
    "172.27.138.251",
    "172.27.137.229",
    "172.27.138.239"
  ],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "k8s",
      "OU": "opsnull"
    }
  ]
}
EOF
  • hosts：指定授权使用该证书的 etcd 节点 IP 列表，需要将 etcd 集群所有节点 IP 都列在其中；

生成证书和私钥：

$ cd /opt/k8s/work
$ cfssl gencert -ca=/opt/k8s/work/ca.pem \
    -ca-key=/opt/k8s/work/ca-key.pem \
    -config=/opt/k8s/work/ca-config.json \
    -profile=kubernetes etcd-csr.json | cfssljson -bare etcd
$ ls etcd*pem

分发生成的证书和私钥到各 etcd 节点：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim deploy-etcd-pem.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "mkdir -p /etc/etcd/cert"
    scp etcd*.pem root@${node_ip}:/etc/etcd/cert/
  done
$ sh deploy-etcd-pem.sh

5.3 创建 etcd 的 systemd unit 模板文件

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ cat > etcd.service.template <<EOF
[Unit]
Description=Etcd Server
After=network.target
After=network-online.target
Wants=network-online.target
Documentation=https://github.com/coreos

[Service]
Type=notify
WorkingDirectory=${ETCD_DATA_DIR}
ExecStart=/opt/k8s/bin/etcd \\
  --data-dir=${ETCD_DATA_DIR} \\
  --wal-dir=${ETCD_WAL_DIR} \\
  --name=##NODE_NAME## \\
  --cert-file=/etc/etcd/cert/etcd.pem \\
  --key-file=/etc/etcd/cert/etcd-key.pem \\
  --trusted-ca-file=/etc/kubernetes/cert/ca.pem \\
  --peer-cert-file=/etc/etcd/cert/etcd.pem \\
  --peer-key-file=/etc/etcd/cert/etcd-key.pem \\
  --peer-trusted-ca-file=/etc/kubernetes/cert/ca.pem \\
  --peer-client-cert-auth \\
  --client-cert-auth \\
  --listen-peer-urls=https://##NODE_IP##:2380 \\
  --initial-advertise-peer-urls=https://##NODE_IP##:2380 \\
  --listen-client-urls=https://##NODE_IP##:2379,http://127.0.0.1:2379 \\
  --advertise-client-urls=https://##NODE_IP##:2379 \\
  --initial-cluster-token=etcd-cluster-0 \\
  --initial-cluster=${ETCD_NODES} \\
  --initial-cluster-state=new \\
  --auto-compaction-mode=periodic \\
  --auto-compaction-retention=1 \\
  --max-request-bytes=33554432 \\
  --quota-backend-bytes=6442450944 \\
  --heartbeat-interval=250 \\
  --election-timeout=2000
Restart=on-failure
RestartSec=5
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF
  • WorkingDirectory、--data-dir：指定工作目录和数据目录为 ${ETCD_DATA_DIR}，需在启动服务前创建这个目录；
  • --wal-dir：指定 wal 目录，为了提高性能，一般使用 SSD 或者和 --data-dir 不同的磁盘；
  • --name：指定节点名称，当 --initial-cluster-state 值为 new 时，--name 的参数值必须位于 --initial-cluster 列表中；
  • --cert-file、--key-file：etcd server 与 client 通信时使用的证书和私钥；
  • --trusted-ca-file：签名 client 证书的 CA 证书，用于验证 client 证书；
  • --peer-cert-file、--peer-key-file：etcd 与 peer 通信使用的证书和私钥；
  • --peer-trusted-ca-file：签名 peer 证书的 CA 证书，用于验证 peer 证书；

5.3 为各节点创建和分发 etcd systemd unit 文件

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

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

分发生成的 systemd unit 文件：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim set-system-service.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    scp etcd-${node_ip}.service root@${node_ip}:/etc/systemd/system/etcd.service
  done
$ sh set-system-service.sh

5.4 启动 etcd 服务

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim start-system-etcd.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "mkdir -p ${ETCD_DATA_DIR} ${ETCD_WAL_DIR}"
    ssh root@${node_ip} "systemctl daemon-reload && systemctl enable etcd && systemctl restart etcd " &
  done
$ sh start-system-etcd.sh
  • 必须先创建 etcd 数据目录和工作目录;
  • etcd 进程首次启动时会等待其它节点的 etcd 加入集群，命令 systemctl start etcd 会卡住一段时间，为正常现象；

5.5 检查启动结果

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim get-etcd-status.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "systemctl status etcd|grep Active"
  done
$ sh get-etcd-status.sh

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

$ journalctl -u etcd

5.6 验证服务状态

部署完 etcd 集群后，在任一 etcd 节点上执行如下命令：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim check-etcd-health.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    /opt/k8s/bin/etcdctl \
    --endpoints=https://${node_ip}:2379 \
    --cacert=/etc/kubernetes/cert/ca.pem \
    --cert=/etc/etcd/cert/etcd.pem \
    --key=/etc/etcd/cert/etcd-key.pem endpoint health
  done
$ sh check-etcd-health.sh
  • 3.4.3 版本的 etcd/etcdctl 默认启用了 V3 API，所以执行 etcdctl 命令时不需要再指定环境变量 ETCDCTL_API=3；
  • 从 K8S 1.13 开始，不再支持 v2 版本的 etcd；

预期输出：

>>> 10.12.5.60
https://10.12.5.60:2379 is healthy: successfully committed proposal: took = 2.756451ms
>>> 10.12.5.61
https://10.12.5.61:2379 is healthy: successfully committed proposal: took = 2.025018ms
>>> 10.12.5.62
https://10.12.5.62:2379 is healthy: successfully committed proposal: took = 2.335097ms

输出均为 healthy 时表示集群服务正常。

5.7 查看当前的 leader

$ source /opt/k8s/bin/environment.sh
$ vim get-etcd-leader.sh
/opt/k8s/bin/etcdctl \
  -w table --cacert=/etc/kubernetes/cert/ca.pem \
  --cert=/etc/etcd/cert/etcd.pem \
  --key=/etc/etcd/cert/etcd-key.pem \
  --endpoints=${ETCD_ENDPOINTS} endpoint status 
$ sh get-etcd-leader.sh

输出：

+-------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
|        ENDPOINT         |        ID        | VERSION | DB SIZE | IS LEADER | IS LEARNER | RAFT TERM | RAFT INDEX | RAFT APPLIED INDEX | ERRORS |
+-------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
| https://10.12.5.60:2379 |  8e3b68d01403704 |   3.4.3 |   20 kB |      true |      false |        44 |          9 |                  9 |        |
| https://10.12.5.61:2379 | c93b34cd00fd858b |   3.4.3 |   20 kB |     false |      false |        44 |          9 |                  9 |        |
| https://10.12.5.62:2379 | cb9f139b0cd73f5f |   3.4.3 |   16 kB |     false |      false |        44 |          9 |                  9 |        |
  • 可见，当前的 leader 为 10.12.5.60。

6 部署 master 节点

kubernetes master 节点运行如下组件：

  • kube-apiserver
  • kube-scheduler
  • kube-controller-manager

kube-apiserver、kube-scheduler 和 kube-controller-manager 均以多实例模式运行：

  1. kube-scheduler 和 kube-controller-manager 会自动选举产生一个 leader 实例，其它实例处于阻塞模式，当 leader 挂了后，重新选举产生新的 leader，从而保证服务可用性；
  2. kube-apiserver 是无状态的，可以通过 kube-nginx 进行代理访问，从而保证服务可用性；

如果没有特殊指明，本文档的所有操作均在 sre-master-node节点上执行。

6.1 下载最新版本二进制文件

从 CHANGELOG 页面 下载二进制 tar 文件并解压：

$ cd /opt/k8s/work
$ wget https://dl.k8s.io/v1.16.6/kubernetes-server-linux-amd64.tar.gz  # 自行解决翻墙问题
$ tar -xzvf kubernetes-server-linux-amd64.tar.gz
$ cd kubernetes
$ tar -xzvf  kubernetes-src.tar.gz

将二进制文件拷贝到所有节点：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim scp-k8s.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    scp kubernetes/server/bin/{apiextensions-apiserver,kube-apiserver,kube-controller-manager,kube-proxy,kube-scheduler,kubeadm,kubectl,kubelet,mounter} root@${node_ip}:/opt/k8s/bin/
    ssh root@${node_ip} "chmod +x /opt/k8s/bin/*"
  done
$ sh scp-k8s.sh

 6.2 部署 kube-apiserver 集群

本章节讲解部署一个三实例 kube-apiserver 集群的步骤.

如果没有特殊指明，本文档的所有操作均在sre-master-node节点上执行。

6.2.1 创建 kubernetes-master 证书和私钥

创建证书签名请求：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ cat > kubernetes-csr.json <<EOF
{
  "CN": "kubernetes-master",
  "hosts": [
    "10.12.5.60",
    "10.12.5.61",
    "10.12.5.62",
    "${CLUSTER_KUBERNETES_SVC_IP}",
    "kubernetes",
    "kubernetes.default",
    "kubernetes.default.svc",
    "kubernetes.default.svc.cluster",
    "kubernetes.default.svc.cluster.local.",
    "kubernetes.default.svc.${CLUSTER_DNS_DOMAIN}."
  ],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "k8s",
      "OU": "opsnull"
    }
  ]
}
EOF
  • hosts 字段指定授权使用该证书的 IP 和域名列表，这里列出了 master 节点 IP、kubernetes 服务的 IP 和域名；

生成证书和私钥：

$ cfssl gencert -ca=/opt/k8s/work/ca.pem \
  -ca-key=/opt/k8s/work/ca-key.pem \
  -config=/opt/k8s/work/ca-config.json \
  -profile=kubernetes kubernetes-csr.json | cfssljson -bare kubernetes
$ ls kubernetes*pem

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

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim k8s_cert.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "mkdir -p /etc/kubernetes/cert"
    scp kubernetes*.pem root@${node_ip}:/etc/kubernetes/cert/
  done
$ sh k8s_cert.sh

6.2.2 创建加密配置文件

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ cat > encryption-config.yaml <<EOF
kind: EncryptionConfig
apiVersion: v1
resources:
  - resources:
      - secrets
    providers:
      - aescbc:
          keys:
            - name: key1
              secret: ${ENCRYPTION_KEY}
      - identity: {}
EOF

将加密配置文件拷贝到 master 节点的 /etc/kubernetes 目录下：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim encryption-config.sh 
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    scp encryption-config.yaml root@${node_ip}:/etc/kubernetes/
  done
$ sh encryption-config.sh

6.2.3 创建审计策略文件

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ cat > audit-policy.yaml <<EOF
apiVersion: audit.k8s.io/v1beta1
kind: Policy
rules:
  # The following requests were manually identified as high-volume and low-risk, so drop them.
  - level: None
    resources:
      - group: ""
        resources:
          - endpoints
          - services
          - services/status
    users:
      - 'system:kube-proxy'
    verbs:
      - watch

  - level: None
    resources:
      - group: ""
        resources:
          - nodes
          - nodes/status
    userGroups:
      - 'system:nodes'
    verbs:
      - get

  - level: None
    namespaces:
      - kube-system
    resources:
      - group: ""
        resources:
          - endpoints
    users:
      - 'system:kube-controller-manager'
      - 'system:kube-scheduler'
      - 'system:serviceaccount:kube-system:endpoint-controller'
    verbs:
      - get
      - update

  - level: None
    resources:
      - group: ""
        resources:
          - namespaces
          - namespaces/status
          - namespaces/finalize
    users:
      - 'system:apiserver'
    verbs:
      - get

  # Don't log HPA fetching metrics.
  - level: None
    resources:
      - group: metrics.k8s.io
    users:
      - 'system:kube-controller-manager'
    verbs:
      - get
      - list

  # Don't log these read-only URLs.
  - level: None
    nonResourceURLs:
      - '/healthz*'
      - /version
      - '/swagger*'

  # Don't log events requests.
  - level: None
    resources:
      - group: ""
        resources:
          - events

  # node and pod status calls from nodes are high-volume and can be large, don't log responses
  # for expected updates from nodes
  - level: Request
    omitStages:
      - RequestReceived
    resources:
      - group: ""
        resources:
          - nodes/status
          - pods/status
    users:
      - kubelet
      - 'system:node-problem-detector'
      - 'system:serviceaccount:kube-system:node-problem-detector'
    verbs:
      - update
      - patch

  - level: Request
    omitStages:
      - RequestReceived
    resources:
      - group: ""
        resources:
          - nodes/status
          - pods/status
    userGroups:
      - 'system:nodes'
    verbs:
      - update
      - patch

  # deletecollection calls can be large, don't log responses for expected namespace deletions
  - level: Request
    omitStages:
      - RequestReceived
    users:
      - 'system:serviceaccount:kube-system:namespace-controller'
    verbs:
      - deletecollection

  # Secrets, ConfigMaps, and TokenReviews can contain sensitive & binary data,
  # so only log at the Metadata level.
  - level: Metadata
    omitStages:
      - RequestReceived
    resources:
      - group: ""
        resources:
          - secrets
          - configmaps
      - group: authentication.k8s.io
        resources:
          - tokenreviews
  # Get repsonses can be large; skip them.
  - level: Request
    omitStages:
      - RequestReceived
    resources:
      - group: ""
      - group: admissionregistration.k8s.io
      - group: apiextensions.k8s.io
      - group: apiregistration.k8s.io
      - group: apps
      - group: authentication.k8s.io
      - group: authorization.k8s.io
      - group: autoscaling
      - group: batch
      - group: certificates.k8s.io
      - group: extensions
      - group: metrics.k8s.io
      - group: networking.k8s.io
      - group: policy
      - group: rbac.authorization.k8s.io
      - group: scheduling.k8s.io
      - group: settings.k8s.io
      - group: storage.k8s.io
    verbs:
      - get
      - list
      - watch

  # Default level for known APIs
  - level: RequestResponse
    omitStages:
      - RequestReceived
    resources:
      - group: ""
      - group: admissionregistration.k8s.io
      - group: apiextensions.k8s.io
      - group: apiregistration.k8s.io
      - group: apps
      - group: authentication.k8s.io
      - group: authorization.k8s.io
      - group: autoscaling
      - group: batch
      - group: certificates.k8s.io
      - group: extensions
      - group: metrics.k8s.io
      - group: networking.k8s.io
      - group: policy
      - group: rbac.authorization.k8s.io
      - group: scheduling.k8s.io
      - group: settings.k8s.io
      - group: storage.k8s.io
      
  # Default level for all other requests.
  - level: Metadata
    omitStages:
      - RequestReceived
EOF

分发审计策略文件：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim audit-policy.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    scp audit-policy.yaml root@${node_ip}:/etc/kubernetes/audit-policy.yaml
  done
$ sh audit-policy.sh

6.2.4 创建后续访问 metrics-server 或 kube-prometheus 使用的证书

创建证书签名请求:

$ cd /opt/k8s/work
$ cat > proxy-client-csr.json <<EOF
{
  "CN": "aggregator",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "k8s",
      "OU": "opsnull"
    }
  ]
}
EOF
  • CN 名称需要位于 kube-apiserver 的 --requestheader-allowed-names 参数中，否则后续访问 metrics 时会提示权限不足。

生成证书和私钥：

$ cfssl gencert -ca=/etc/kubernetes/cert/ca.pem \
  -ca-key=/etc/kubernetes/cert/ca-key.pem  \
  -config=/etc/kubernetes/cert/ca-config.json  \
  -profile=kubernetes proxy-client-csr.json | cfssljson -bare proxy-client
$ ls proxy-client*.pem

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

$ source /opt/k8s/bin/environment.sh
$ vim proxy-client.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    scp proxy-client*.pem root@${node_ip}:/etc/kubernetes/cert/
  done
$ sh proxy-client.sh

6.2.5 创建 kube-apiserver systemd unit 模板文件

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ cat > kube-apiserver.service.template <<EOF
[Unit]
Description=Kubernetes API Server
Documentation=https://github.com/GoogleCloudPlatform/kubernetes
After=network.target

[Service]
WorkingDirectory=${K8S_DIR}/kube-apiserver
ExecStart=/opt/k8s/bin/kube-apiserver \\
  --advertise-address=##NODE_IP## \\
  --default-not-ready-toleration-seconds=360 \\
  --default-unreachable-toleration-seconds=360 \\
  --feature-gates=DynamicAuditing=true \\
  --max-mutating-requests-inflight=2000 \\
  --max-requests-inflight=4000 \\
  --default-watch-cache-size=200 \\
  --delete-collection-workers=2 \\
  --encryption-provider-config=/etc/kubernetes/encryption-config.yaml \\
  --etcd-cafile=/etc/kubernetes/cert/ca.pem \\
  --etcd-certfile=/etc/kubernetes/cert/kubernetes.pem \\
  --etcd-keyfile=/etc/kubernetes/cert/kubernetes-key.pem \\
  --etcd-servers=${ETCD_ENDPOINTS} \\
  --bind-address=##NODE_IP## \\
  --secure-port=6443 \\
  --tls-cert-file=/etc/kubernetes/cert/kubernetes.pem \\
  --tls-private-key-file=/etc/kubernetes/cert/kubernetes-key.pem \\
  --insecure-port=0 \\
  --audit-dynamic-configuration \\
  --audit-log-maxage=15 \\
  --audit-log-maxbackup=3 \\
  --audit-log-maxsize=100 \\
  --audit-log-truncate-enabled \\
  --audit-log-path=${K8S_DIR}/kube-apiserver/audit.log \\
  --audit-policy-file=/etc/kubernetes/audit-policy.yaml \\
  --profiling \\
  --anonymous-auth=false \\
  --client-ca-file=/etc/kubernetes/cert/ca.pem \\
  --enable-bootstrap-token-auth \\
  --requestheader-allowed-names="aggregator" \\
  --requestheader-client-ca-file=/etc/kubernetes/cert/ca.pem \\
  --requestheader-extra-headers-prefix="X-Remote-Extra-" \\
  --requestheader-group-headers=X-Remote-Group \\
  --requestheader-username-headers=X-Remote-User \\
  --service-account-key-file=/etc/kubernetes/cert/ca.pem \\
  --authorization-mode=Node,RBAC \\
  --runtime-config=api/all=true \\
  --enable-admission-plugins=NodeRestriction \\
  --allow-privileged=true \\
  --apiserver-count=3 \\
  --event-ttl=168h \\
  --kubelet-certificate-authority=/etc/kubernetes/cert/ca.pem \\
  --kubelet-client-certificate=/etc/kubernetes/cert/kubernetes.pem \\
  --kubelet-client-key=/etc/kubernetes/cert/kubernetes-key.pem \\
  --kubelet-https=true \\
  --kubelet-timeout=10s \\
  --proxy-client-cert-file=/etc/kubernetes/cert/proxy-client.pem \\
  --proxy-client-key-file=/etc/kubernetes/cert/proxy-client-key.pem \\
  --service-cluster-ip-range=${SERVICE_CIDR} \\
  --service-node-port-range=${NODE_PORT_RANGE} \\
  --logtostderr=true \\
  --v=2
Restart=on-failure
RestartSec=10
Type=notify
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF
  • --advertise-address：apiserver 对外通告的 IP（kubernetes 服务后端节点 IP）；
  • --default-*-toleration-seconds：设置节点异常相关的阈值；
  • --max-*-requests-inflight：请求相关的最大阈值；
  • --etcd-*：访问 etcd 的证书和 etcd 服务器地址；
  • --bind-address： https 监听的 IP，不能为 127.0.0.1，否则外界不能访问它的安全端口 6443；
  • --secret-port：https 监听端口；
  • --insecure-port=0：关闭监听 http 非安全端口(8080)；
  • --tls-*-file：指定 apiserver 使用的证书、私钥和 CA 文件；
  • --audit-*：配置审计策略和审计日志文件相关的参数；
  • --client-ca-file：验证 client (kue-controller-manager、kube-scheduler、kubelet、kube-proxy 等)请求所带的证书；
  • --enable-bootstrap-token-auth：启用 kubelet bootstrap 的 token 认证；
  • --requestheader-*：kube-apiserver 的 aggregator layer 相关的配置参数，proxy-client & HPA 需要使用；
  • --requestheader-client-ca-file：用于签名 --proxy-client-cert-file 和 --proxy-client-key-file 指定的证书；在启用了 metric aggregator 时使用；
  • --requestheader-allowed-names：不能为空，值为逗号分割的 --proxy-client-cert-file 证书的 CN 名称，这里设置为 "aggregator"；
  • --service-account-key-file：签名 ServiceAccount Token 的公钥文件，kube-controller-manager 的 --service-account-private-key-file 指定私钥文件，两者配对使用；
  • --runtime-config=api/all=true： 启用所有版本的 APIs，如 autoscaling/v2alpha1；
  • --authorization-mode=Node,RBAC、--anonymous-auth=false： 开启 Node 和 RBAC 授权模式，拒绝未授权的请求；
  • --enable-admission-plugins：启用一些默认关闭的 plugins；
  • --allow-privileged：运行执行 privileged 权限的容器；
  • --apiserver-count=3：指定 apiserver 实例的数量；
  • --event-ttl：指定 events 的保存时间；
  • --kubelet-*：如果指定，则使用 https 访问 kubelet APIs；需要为证书对应的用户(上面 kubernetes*.pem 证书的用户为 kubernetes) 用户定义 RBAC 规则，否则访问 kubelet API 时提示未授权；
  • --proxy-client-*：apiserver 访问 metrics-server 使用的证书；
  • --service-cluster-ip-range： 指定 Service Cluster IP 地址段；
  • --service-node-port-range： 指定 NodePort 的端口范围；

如果 kube-apiserver 机器没有运行 kube-proxy，则还需要添加 --enable-aggregator-routing=true 参数；

关于 --requestheader-XXX 相关参数，参考：

  1. --requestheader-client-ca-file 指定的 CA 证书，必须具有 client auth and server auth；
  2. 如果 --requestheader-allowed-names 不为空,且 --proxy-client-cert-file 证书的 CN 名称不在 allowed-names 中，则后续查看 node 或 pods 的 metrics 失败，提示：
$ kubectl top nodes
Error from server (Forbidden): nodes.metrics.k8s.io is forbidden: User "aggregator" cannot list resource "nodes" in API group "metrics.k8s.io" at the cluster scope

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

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

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim modify-kube-apiserver.sh
for (( i=0; i < 3; i++ ))
  do
    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 
  done
ls kube-apiserver*.service
$ sh modify-kube-apiserver.sh
  • NODE_NAMES 和 NODE_IPS 为相同长度的 bash 数组，分别为节点名称和对应的 IP；

分发生成的 systemd unit 文件：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim scp-kube-apiserver.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    scp kube-apiserver-${node_ip}.service root@${node_ip}:/etc/systemd/system/kube-apiserver.service
  done
$ sh scp-kube-apiserver.sh

6.2.7 启动 kube-apiserver 服务

$ vim source /opt/k8s/bin/environment.sh
$ vim start-k8s-apiserver.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "mkdir -p ${K8S_DIR}/kube-apiserver"
    ssh root@${node_ip} "systemctl daemon-reload && systemctl enable kube-apiserver && systemctl restart kube-apiserver"
  done
$ sh start-k8s-apiserver.sh

6.2.8 检查 kube-apiserver 运行状态

$ source /opt/k8s/bin/environment.sh
$ vim check-spiserver.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "systemctl status kube-apiserver |grep 'Active:'"
  done
$ sh check-spiserver.sh

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

$ journalctl -u kube-apiserver

6.2.9 检查集群状态

$ kubectl cluster-info
Kubernetes master is running at https://10.12.5.60:6443

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.

$ kubectl get all --all-namespaces
NAMESPACE   NAME                 TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)   AGE
default     service/kubernetes   ClusterIP   192.168.0.1   <none>        443/TCP   22s

$ kubectl get componentstatuses
NAME                 AGE
controller-manager   <unknown>
scheduler            <unknown>
etcd-1               <unknown>
etcd-0               <unknown>
etcd-2               <unknown>
  • Kubernetes 1.16.6 存在 Bugs 导致返回结果一直为 <unknown>，但 kubectl get cs -o yaml 可以返回正确结果；

6.2.10 检查 kube-apiserver 监听的端口

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

6.3 部署高可用 kube-controller-manager 集群

本章节介绍部署高可用 kube-controller-manager 集群的步骤。

该集群包含 3 个节点，启动后将通过竞争选举机制产生一个 leader 节点，其它节点为阻塞状态。当 leader 节点不可用时，阻塞的节点将再次进行选举产生新的 leader 节点，从而保证服务的可用性。

为保证通信安全，本章节先生成 x509 证书和私钥，kube-controller-manager 在如下两种情况下使用该证书：

  1. 与 kube-apiserver 的安全端口通信;
  2. 在安全端口(https，10252) 输出 prometheus 格式的 metrics；

如果没有特殊指明，本文档的所有操作均在 sre-master-node节点上执行。

6.3.1 创建 kube-controller-manager 证书和私钥

创建证书签名请求：

$ cd /opt/k8s/work
$ cat > kube-controller-manager-csr.json <<EOF
{
    "CN": "system:kube-controller-manager",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "hosts": [
      "10.12.5.60",
      "10.12.5.61",
      "10.12.5.62"
    ],
    "names": [
      {
        "C": "CN",
        "ST": "BeiJing",
        "L": "BeiJing",
        "O": "system:kube-controller-manager",
        "OU": "opsnull"
      }
    ]
}
EOF
  • hosts 列表包含所有 kube-controller-manager 节点 IP；
  • CN 和 O 均为 system:kube-controller-manager，kubernetes 内置的 ClusterRoleBindings system:kube-controller-manager 赋予 kube-controller-manager 工作所需的权限。

生成证书和私钥：

$ cd /opt/k8s/work
$ cfssl gencert -ca=/opt/k8s/work/ca.pem \
  -ca-key=/opt/k8s/work/ca-key.pem \
  -config=/opt/k8s/work/ca-config.json \
  -profile=kubernetes kube-controller-manager-csr.json | cfssljson -bare kube-controller-manager
$ ls kube-controller-manager*pem

将生成的证书和私钥分发到所有 master 节点：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim kube-controller-manager.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    scp kube-controller-manager*.pem root@${node_ip}:/etc/kubernetes/cert/
  done
$ sh kube-controller-manager.sh

6.3.2 创建和分发 kubeconfig 文件

kube-controller-manager 使用 kubeconfig 文件访问 apiserver，该文件提供了 apiserver 地址、嵌入的 CA 证书和 kube-controller-manager 证书等信息：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh

$ kubectl config set-cluster kubernetes \
  --certificate-authority=/opt/k8s/work/ca.pem \
  --embed-certs=true \
  --server="https://10.12.5.60:6443" \
  --kubeconfig=kube-controller-manager.kubeconfig

$ kubectl config set-credentials system:kube-controller-manager \
  --client-certificate=kube-controller-manager.pem \
  --client-key=kube-controller-manager-key.pem \
  --embed-certs=true \
  --kubeconfig=kube-controller-manager.kubeconfig

$ kubectl config set-context system:kube-controller-manager \
  --cluster=kubernetes \
  --user=system:kube-controller-manager \
  --kubeconfig=kube-controller-manager.kubeconfig

$ kubectl config use-context system:kube-controller-manager --kubeconfig=kube-controller-manager.kubeconfig
  • kube-controller-manager 与 kube-apiserver 混布，故直接通过节点 IP 访问 kube-apiserver；

分发 kubeconfig 到所有 master 节点：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
# vim kube-controller-manager.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    sed -e "s/##NODE_IP##/${node_ip}/" kube-controller-manager.kubeconfig > kube-controller-manager-${node_ip}.kubeconfig
    scp kube-controller-manager-${node_ip}.kubeconfig root@${node_ip}:/etc/kubernetes/kube-controller-manager.kubeconfig
  done
$ sh kube-controller-manager.sh

6.3.3 创建 kube-controller-manager systemd unit 模板文件 

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ cat > kube-controller-manager.service.template <<EOF
[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/GoogleCloudPlatform/kubernetes

[Service]
WorkingDirectory=${K8S_DIR}/kube-controller-manager
ExecStart=/opt/k8s/bin/kube-controller-manager \\
  --profiling \\
  --cluster-name=kubernetes \\
  --controllers=*,bootstrapsigner,tokencleaner \\
  --kube-api-qps=1000 \\
  --kube-api-burst=2000 \\
  --leader-elect \\
  --use-service-account-credentials\\
  --concurrent-service-syncs=2 \\
  --bind-address=10.12.5.60 \\
  --secure-port=10252 \\
  --tls-cert-file=/etc/kubernetes/cert/kube-controller-manager.pem \\
  --tls-private-key-file=/etc/kubernetes/cert/kube-controller-manager-key.pem \\
  --port=0 \\
  --authentication-kubeconfig=/etc/kubernetes/kube-controller-manager.kubeconfig \\
  --client-ca-file=/etc/kubernetes/cert/ca.pem \\
  --requestheader-allowed-names="aggregator" \\
  --requestheader-client-ca-file=/etc/kubernetes/cert/ca.pem \\
  --requestheader-extra-headers-prefix="X-Remote-Extra-" \\
  --requestheader-group-headers=X-Remote-Group \\
  --requestheader-username-headers=X-Remote-User \\
  --authorization-kubeconfig=/etc/kubernetes/kube-controller-manager.kubeconfig \\
  --cluster-signing-cert-file=/etc/kubernetes/cert/ca.pem \\
  --cluster-signing-key-file=/etc/kubernetes/cert/ca-key.pem \\
  --experimental-cluster-signing-duration=876000h \\
  --horizontal-pod-autoscaler-sync-period=10s \\
  --concurrent-deployment-syncs=10 \\
  --concurrent-gc-syncs=30 \\
  --node-cidr-mask-size=24 \\
  --service-cluster-ip-range=${SERVICE_CIDR} \\
  --pod-eviction-timeout=6m \\
  --terminated-pod-gc-threshold=10000 \\
  --root-ca-file=/etc/kubernetes/cert/ca.pem \\
  --service-account-private-key-file=/etc/kubernetes/cert/ca-key.pem \\
  --kubeconfig=/etc/kubernetes/kube-controller-manager.kubeconfig \\
  --logtostderr=true \\
  --v=2
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target
EOF
  • --port=0：关闭监听非安全端口（http），同时 --address 参数无效，--bind-address 参数有效；
  • --secure-port=10252、--bind-address=0.0.0.0: 在所有网络接口监听 10252 端口的 https /metrics 请求；
  • --kubeconfig：指定 kubeconfig 文件路径，kube-controller-manager 使用它连接和验证 kube-apiserver；
  • --authentication-kubeconfig 和 --authorization-kubeconfig：kube-controller-manager 使用它连接 apiserver，对 client 的请求进行认证和授权。kube-controller-manager 不再使用 --tls-ca-file 对请求 https metrics 的 Client 证书进行校验。如果没有配置这两个 kubeconfig 参数，则 client 连接 kube-controller-manager https 端口的请求会被拒绝(提示权限不足)。
  • --cluster-signing-*-file：签名 TLS Bootstrap 创建的证书；
  • --experimental-cluster-signing-duration：指定 TLS Bootstrap 证书的有效期；
  • --root-ca-file：放置到容器 ServiceAccount 中的 CA 证书，用来对 kube-apiserver 的证书进行校验；
  • --service-account-private-key-file：签名 ServiceAccount 中 Token 的私钥文件，必须和 kube-apiserver 的 --service-account-key-file 指定的公钥文件配对使用；
  • --service-cluster-ip-range ：指定 Service Cluster IP 网段，必须和 kube-apiserver 中的同名参数一致；
  • --leader-elect=true：集群运行模式，启用选举功能；被选为 leader 的节点负责处理工作，其它节点为阻塞状态；
  • --controllers=*,bootstrapsigner,tokencleaner：启用的控制器列表，tokencleaner 用于自动清理过期的 Bootstrap token；
  • --horizontal-pod-autoscaler-*：custom metrics 相关参数，支持 autoscaling/v2alpha1；
  • --tls-cert-file、--tls-private-key-file：使用 https 输出 metrics 时使用的 Server 证书和秘钥；
  • --use-service-account-credentials=true: kube-controller-manager 中各 controller 使用 serviceaccount 访问 kube-apiserver；

6.3.4 为各节点创建和分发 kube-controller-mananger systemd unit 文件

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

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim modify-kube-controller-manager.service.sh
for (( i=0; i < 3; i++ ))
  do
    sed -e "s/##NODE_NAME##/${NODE_NAMES[i]}/" -e "s/##NODE_IP##/${NODE_IPS[i]}/" kube-controller-manager.service.template > kube-controller-manager-${NODE_IPS[i]}.service 
  done
$ sh modify-kube-controller-manager.service.sh 
$ ls kube-controller-manager*.service

分发到所有 master 节点：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim scp-kube-controller-manager.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    scp kube-controller-manager-${node_ip}.service root@${node_ip}:/etc/systemd/system/kube-controller-manager.service
  done
$ sh scp-kube-controller-manager.sh

6.3.5 启动 kube-controller-manager 服务

$ source /opt/k8s/bin/environment.sh
$ vim start-kube-controller-manager.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "mkdir -p ${K8S_DIR}/kube-controller-manager"
    ssh root@${node_ip} "systemctl daemon-reload && systemctl enable kube-controller-manager && systemctl restart kube-controller-manager"
  done
$ sh start-kube-controller-manager.sh

6.3.6 检查服务运行状态

$ source /opt/k8s/bin/environment.sh
$ vim check-kube-controller-manager.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "systemctl status kube-controller-manager|grep Active"
  done
$ sh check-kube-controller-manager.sh

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

$ journalctl -u kube-controller-manager

kube-controller-manager 监听 10252 端口，接收 https 请求：

$ sudo netstat -lnpt | grep kube-cont
tcp        0      0 172.27.138.251:10252    0.0.0.0:*               LISTEN      108977/kube-control

6.3.7 查看输出的 metrics

注意：以下命令在 kube-controller-manager 节点上执行。

$ curl -s --cacert /opt/k8s/work/ca.pem --cert /opt/k8s/work/admin.pem --key /opt/k8s/work/admin-key.pem https://10.12.5.60:10252/metrics |head
# HELP apiserver_audit_event_total [ALPHA] Counter of audit events generated and sent to the audit backend.
# TYPE apiserver_audit_event_total counter
apiserver_audit_event_total 0
# HELP apiserver_audit_requests_rejected_total [ALPHA] Counter of apiserver requests rejected due to an error in audit logging backend.
# TYPE apiserver_audit_requests_rejected_total counter
apiserver_audit_requests_rejected_total 0
# HELP apiserver_client_certificate_expiration_seconds [ALPHA] Distribution of the remaining lifetime on the certificate used to authenticate a request.
# TYPE apiserver_client_certificate_expiration_seconds histogram
apiserver_client_certificate_expiration_seconds_bucket{le="0"} 0
apiserver_client_certificate_expiration_seconds_bucket{le="1800"} 0

6.3.8 查看当前的 leader

$ kubectl get endpoints kube-controller-manager --namespace=kube-system  -o yaml
apiVersion: v1
kind: Endpoints
metadata:
  annotations:
    control-plane.alpha.kubernetes.io/leader: '{"holderIdentity":"sre-master-node_ee20e02b-4c54-4622-94ff-b4acd7b4ce67","leaseDurationSeconds":15,"acquireTime":"2023-09-18T14:01:07Z","renewTime":"2023-09-18T14:20:22Z","leaderTransitions":1}'
  creationTimestamp: "2023-09-18T13:56:33Z"
  name: kube-controller-manager
  namespace: kube-system
  resourceVersion: "30117"
  selfLink: /api/v1/namespaces/kube-system/endpoints/kube-controller-manager
  uid: b636f6d2-35b9-4951-9fcf-e0bd07c977ff

可见，当前的 leader 为 sre-master-node节点。

6.3.9 测试 kube-controller-manager 集群的高可用

停掉一个或两个节点的 kube-controller-manager 服务，观察其它节点的日志，看是否获取了 leader 权限。

案例：停掉 sre-master-node节点的 kube-controller-manager 服务，leader转移到sre-worker-node-2节点上。

$ systemctl stop kube-controller-manager
$ kubectl get endpoints kube-controller-manager --namespace=kube-system  -o yaml
apiVersion: v1
kind: Endpoints
metadata:
  annotations:
    control-plane.alpha.kubernetes.io/leader: '{"holderIdentity":"sre-worker-node-2_e50f0e97-7cfb-4dec-9069-aeed6cad7115","leaseDurationSeconds":15,"acquireTime":"2023-09-19T14:40:25Z","renewTime":"2023-09-19T14:40:29Z","leaderTransitions":2}'
  creationTimestamp: "2023-09-18T13:56:33Z"
  name: kube-controller-manager
  namespace: kube-system
  resourceVersion: "100329"
  selfLink: /api/v1/namespaces/kube-system/endpoints/kube-controller-manager
  uid: b636f6d2-35b9-4951-9fcf-e0bd07c977ff

6.4 部署高可用 kube-scheduler 集群

本章节介绍部署高可用 kube-scheduler 集群的步骤。

该集群包含 3 个节点，启动后将通过竞争选举机制产生一个 leader 节点，其它节点为阻塞状态。当 leader 节点不可用后，剩余节点将再次进行选举产生新的 leader 节点，从而保证服务的可用性。

为保证通信安全，本章节先生成 x509 证书和私钥，kube-scheduler 在如下两种情况下使用该证书：

  1. 与 kube-apiserver 的安全端口通信;
  2. 在安全端口(https，10251) 输出 prometheus 格式的 metrics；

如果没有特殊指明，本文档的所有操作均在sre-master-node节点上执行

6.4.1 创建 kube-scheduler 证书和私钥

创建证书签名请求：

$ cd /opt/k8s/work
$ cat > kube-scheduler-csr.json <<EOF
{
    "CN": "system:kube-scheduler",
    "hosts": [
      "10.12.5.60",
      "10.12.5.61",
      "10.12.5.62"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
      {
        "C": "CN",
        "ST": "BeiJing",
        "L": "BeiJing",
        "O": "system:kube-scheduler",
        "OU": "opsnull"
      }
    ]
}
EOF
  • hosts 列表包含所有 kube-scheduler 节点 IP；
  • CN 和 O 均为 system:kube-scheduler，kubernetes 内置的 ClusterRoleBindings system:kube-scheduler 将赋予 kube-scheduler 工作所需的权限；

生成证书和私钥：

$ cd /opt/k8s/work
$ cfssl gencert -ca=/opt/k8s/work/ca.pem \
  -ca-key=/opt/k8s/work/ca-key.pem \
  -config=/opt/k8s/work/ca-config.json \
  -profile=kubernetes kube-scheduler-csr.json | cfssljson -bare kube-scheduler
$ ls kube-scheduler*pem

将生成的证书和私钥分发到所有 master 节点：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim kube-scheduler-pem.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    scp kube-scheduler*.pem root@${node_ip}:/etc/kubernetes/cert/
  done
$ sh kube-scheduler-pem.sh

6.4.2 创建和分发 kubeconfig 文件

kube-scheduler 使用 kubeconfig 文件访问 apiserver，该文件提供了 apiserver 地址、嵌入的 CA 证书和 kube-scheduler 证书：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ kubectl config set-cluster kubernetes \
  --certificate-authority=/opt/k8s/work/ca.pem \
  --embed-certs=true \
  --server="https://10.12.5.60:6443" \
  --kubeconfig=kube-scheduler.kubeconfig

$ kubectl config set-credentials system:kube-scheduler \
  --client-certificate=kube-scheduler.pem \
  --client-key=kube-scheduler-key.pem \
  --embed-certs=true \
  --kubeconfig=kube-scheduler.kubeconfig

$ kubectl config set-context system:kube-scheduler \
  --cluster=kubernetes \
  --user=system:kube-scheduler \
  --kubeconfig=kube-scheduler.kubeconfig

$ kubectl config use-context system:kube-scheduler --kubeconfig=kube-scheduler.kubeconfig

分发 kubeconfig 到所有 master 节点：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim kube-scheduler.kubeconfig.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    sed -e "s/##NODE_IP##/${node_ip}/" kube-scheduler.kubeconfig > kube-scheduler-${node_ip}.kubeconfig
    scp kube-scheduler-${node_ip}.kubeconfig root@${node_ip}:/etc/kubernetes/kube-scheduler.kubeconfig
  done
$ sh kube-scheduler.kubeconfig.sh

6.4.3 创建 kube-scheduler 配置文件

$ cd /opt/k8s/work
$ cat >kube-scheduler.yaml.template <<EOF
apiVersion: kubescheduler.config.k8s.io/v1alpha1
kind: KubeSchedulerConfiguration
bindTimeoutSeconds: 600
clientConnection:
  burst: 200
  kubeconfig: "/etc/kubernetes/kube-scheduler.kubeconfig"
  qps: 100
enableContentionProfiling: false
enableProfiling: true
hardPodAffinitySymmetricWeight: 1
healthzBindAddress: ##NODE_IP##:10251
leaderElection:
  leaderElect: true
metricsBindAddress: ##NODE_IP##:10251
EOF
  • --kubeconfig：指定 kubeconfig 文件路径，kube-scheduler 使用它连接和验证 kube-apiserver；
  • --leader-elect=true：集群运行模式，启用选举功能；被选为 leader 的节点负责处理工作，其它节点为阻塞状态；

替换模板文件中的变量：

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

分发 kube-scheduler 配置文件到所有 master 节点：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim deploy-kube-scheduler.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    scp kube-scheduler-${node_ip}.yaml root@${node_ip}:/etc/kubernetes/kube-scheduler.yaml
  done
$ sh deploy-kube-scheduler.sh
  • 重命名为 kube-scheduler.yaml;

6.4.4 创建 kube-scheduler systemd unit 模板文件

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ cat > kube-scheduler.service.template <<EOF
[Unit]
Description=Kubernetes Scheduler
Documentation=https://github.com/GoogleCloudPlatform/kubernetes

[Service]
WorkingDirectory=${K8S_DIR}/kube-scheduler
ExecStart=/opt/k8s/bin/kube-scheduler \\
  --config=/etc/kubernetes/kube-scheduler.yaml \\
  --bind-address=10.12.5.60 \\
  --secure-port=10259 \\
  --port=0 \\
  --tls-cert-file=/etc/kubernetes/cert/kube-scheduler.pem \\
  --tls-private-key-file=/etc/kubernetes/cert/kube-scheduler-key.pem \\
  --authentication-kubeconfig=/etc/kubernetes/kube-scheduler.kubeconfig \\
  --client-ca-file=/etc/kubernetes/cert/ca.pem \\
  --requestheader-allowed-names="" \\
  --requestheader-client-ca-file=/etc/kubernetes/cert/ca.pem \\
  --requestheader-extra-headers-prefix="X-Remote-Extra-" \\
  --requestheader-group-headers=X-Remote-Group \\
  --requestheader-username-headers=X-Remote-User \\
  --authorization-kubeconfig=/etc/kubernetes/kube-scheduler.kubeconfig \\
  --logtostderr=true \\
  --v=2
Restart=always
RestartSec=5
StartLimitInterval=0

[Install]
WantedBy=multi-user.target
EOF

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

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

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim modifyip.sh
for (( i=0; i < 3; i++ ))
  do
    sed -e "s/##NODE_IP##/${NODE_IPS[i]}/g" kube-scheduler.service.template > kube-scheduler-${NODE_IPS[i]}.service 
  done
$ sh modifyip.sh
$ ls kube-scheduler*.service

分发 systemd unit 文件到所有 master 节点：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim scp_kube_scheduler.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    scp kube-scheduler-${node_ip}.service root@${node_ip}:/etc/systemd/system/kube-scheduler.service
  done
$ sh scp_kube_scheduler.sh

6.4.6 启动 kube-scheduler 服务

$ source /opt/k8s/bin/environment.sh
$ vim start_kube-scheduler.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "mkdir -p ${K8S_DIR}/kube-scheduler"
    ssh root@${node_ip} "systemctl daemon-reload && systemctl enable kube-scheduler && systemctl restart kube-scheduler"
  done
$ sh start_kube-scheduler.sh

6.4.7 检查服务运行状态

$ source /opt/k8s/bin/environment.sh
$ vim check_kube_scheduler.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "systemctl status kube-scheduler|grep Active"
  done
$ sh check_kube_scheduler.sh

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

$ journalctl -u kube-scheduler

6.4.8 查看输出的 metrics

以下命令在 kube-scheduler 节点上执行。

kube-scheduler 监听 10251 和 10259 端口：

  • 10251：接收 http 请求，非安全端口，不需要认证授权；
  • 10259：接收 https 请求，安全端口，需要认证授权；

两个接口都对外提供 /metrics 和 /healthz 的访问。

$ sudo netstat -lnpt |grep kube-sch
tcp        0      0 172.27.138.251:10251    0.0.0.0:*               LISTEN      114702/kube-schedul
tcp        0      0 172.27.138.251:10259    0.0.0.0:*               LISTEN      114702/kube-schedul

$ curl -s http://10.12.5.60:10251/metrics |head
# HELP apiserver_audit_event_total Counter of audit events generated and sent to the audit backend.
# TYPE apiserver_audit_event_total counter
apiserver_audit_event_total 0
# HELP apiserver_audit_requests_rejected_total Counter of apiserver requests rejected due to an error in audit logging backend.
# TYPE apiserver_audit_requests_rejected_total counter
apiserver_audit_requests_rejected_total 0
# HELP apiserver_client_certificate_expiration_seconds Distribution of the remaining lifetime on the certificate used to authenticate a request.
# TYPE apiserver_client_certificate_expiration_seconds histogram
apiserver_client_certificate_expiration_seconds_bucket{le="0"} 0
apiserver_client_certificate_expiration_seconds_bucket{le="1800"} 0
$ curl -s --cacert /opt/k8s/work/ca.pem --cert /opt/k8s/work/admin.pem --key /opt/k8s/work/admin-key.pem https://10.12.5.60:10259/metrics |head
# HELP apiserver_audit_event_total Counter of audit events generated and sent to the audit backend.
# TYPE apiserver_audit_event_total counter
apiserver_audit_event_total 0
# HELP apiserver_audit_requests_rejected_total Counter of apiserver requests rejected due to an error in audit logging backend.
# TYPE apiserver_audit_requests_rejected_total counter
apiserver_audit_requests_rejected_total 0
# HELP apiserver_client_certificate_expiration_seconds Distribution of the remaining lifetime on the certificate used to authenticate a request.
# TYPE apiserver_client_certificate_expiration_seconds histogram
apiserver_client_certificate_expiration_seconds_bucket{le="0"} 0
apiserver_client_certificate_expiration_seconds_bucket{le="1800"} 0

6.4.9 查看当前的 leader

$ kubectl get endpoints kube-scheduler --namespace=kube-system  -o yaml
apiVersion: v1
kind: Endpoints
metadata:
  annotations:
    control-plane.alpha.kubernetes.io/leader: '{"holderIdentity":"sre-master-node_db4abcee-ed07-494a-8807-c372614f1166","leaseDurationSeconds":15,"acquireTime":"2023-09-21T14:07:58Z","renewTime":"2023-09-21T14:26:24Z","leaderTransitions":0}'
  creationTimestamp: "2023-09-21T14:07:58Z"
  name: kube-scheduler
  namespace: kube-system
  resourceVersion: "238704"
  selfLink: /api/v1/namespaces/kube-system/endpoints/kube-scheduler
  uid: c842d6a8-79a6-4f4c-8fdc-a9e1514b12c0

可见，当前的 leader 为sre-master-node节点。

6.4.10 测试 kube-scheduler 集群的高可用

随便找一个或两个 master 节点，停掉 kube-scheduler 服务，看其它节点是否获取了 leader 权限。

# 停掉sre-master-node的kube-scheduler
$ systemctl stop kube-scheduler
$ kubectl get endpoints kube-scheduler --namespace=kube-system  -o yaml
apiVersion: v1
kind: Endpoints
metadata:
  annotations:
    control-plane.alpha.kubernetes.io/leader: '{"holderIdentity":"sre-worker-node-1_f56cd8ea-0cab-4f96-90e2-1258422d0a86","leaseDurationSeconds":15,"acquireTime":"2023-09-21T14:27:15Z","renewTime":"2023-09-21T14:27:17Z","leaderTransitions":1}'
  creationTimestamp: "2023-09-21T14:07:58Z"
  name: kube-scheduler
  namespace: kube-system
  resourceVersion: "238768"
  selfLink: /api/v1/namespaces/kube-system/endpoints/kube-scheduler
  uid: c842d6a8-79a6-4f4c-8fdc-a9e1514b12c0
# leader主节点切换到了sre-worker-node-1

7 部署worker节点

kubernetes worker 节点运行如下组件：

  • containerd
  • kubelet
  • kube-proxy
  • calico
  • kube-nginx

如果没有特殊指明，本文档的所有操作均在sre-master-node节点上执行。

7.1 安装依赖包

$ source /opt/k8s/bin/environment.sh
$ vim install_base_pkg.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "yum install -y epel-release" &
    ssh root@${node_ip} "yum install -y chrony conntrack ipvsadm ipset jq iptables curl sysstat libseccomp wget socat git" &
  done
$ sh install_base_pkg.sh

7.2 apiserver高可用

本章节讲解使用 nginx 4 层透明代理功能实现 Kubernetes worker 节点组件高可用访问 kube-apiserver 集群的步骤。

如果没有特殊指明，本文档的所有操作均在sre-master-node节点上执行。

7.2.1 基于nginx代理的kube-apiserver高可用方案

  • 控制节点的 kube-controller-manager、kube-scheduler 是多实例部署且连接本机的 kube-apiserver，所以只要有一个实例正常，就可以保证高可用；
  • 集群内的 Pod 使用 K8S 服务域名 kubernetes 访问 kube-apiserver， kube-dns 会自动解析出多个 kube-apiserver 节点的 IP，所以也是高可用的；
  • 在每个节点起一个 nginx 进程，后端对接多个 apiserver 实例，nginx 对它们做健康检查和负载均衡；
  • kubelet、kube-proxy 通过本地的 nginx（监听 127.0.0.1）访问 kube-apiserver，从而实现 kube-apiserver 的高可用；

7.2.2 下载和编译nginx

下载源码：

$ cd /opt/k8s/work
$ wget http://nginx.org/download/nginx-1.15.3.tar.gz
$ tar -xzvf nginx-1.15.3.tar.gz

配置编译参数：

$ cd /opt/k8s/work/nginx-1.15.3
$ mkdir -p /opt/k8s/work/nginx
$ yum install -y gcc make
$ ./configure --with-stream --without-http --prefix=/opt/k8s/work/nginx --without-http_uwsgi_module --without-http_scgi_module --without-http_fastcgi_module
  • --with-stream：开启 4 层透明转发(TCP Proxy)功能；
  • --without-xxx：关闭所有其他功能，这样生成的动态链接二进制程序依赖最小；

输出：

Configuration summary
  + PCRE library is not used
  + OpenSSL library is not used
  + zlib library is not used

  nginx path prefix: "/opt/k8s/work/nginx"
  nginx binary file: "/opt/k8s/work/nginx/sbin/nginx"
  nginx modules path: "/opt/k8s/work/nginx/modules"
  nginx configuration prefix: "/opt/k8s/work/nginx/conf"
  nginx configuration file: "/opt/k8s/work/nginx/conf/nginx.conf"
  nginx pid file: "/opt/k8s/work/nginx/logs/nginx.pid"
  nginx error log file: "/opt/k8s/work/nginx/logs/error.log"
  nginx http access log file: "/opt/k8s/work/nginx/logs/access.log"
  nginx http client request body temporary files: "client_body_temp"
  nginx http proxy temporary files: "proxy_temp"

编译和安装：

cd /opt/k8s/work/nginx-1.15.3
make && make install

7.2.3 验证编译的nginx

$ cd /opt/k8s/work/nginx
$ ./sbin/nginx -v

输出：

nginx version: nginx/1.15.3

7.2.4 配置nginx

配置 nginx，开启 4 层透明转发功能：

$ cd /opt/k8s/work/nginx/conf
$ cat > nginx.conf << \EOF
worker_processes 1;

events {
    worker_connections  1024;
}

stream {
    upstream backend {
        hash $remote_addr consistent;
        server 10.12.5.60:6443        max_fails=3 fail_timeout=30s;
        server 10.12.5.61:6443        max_fails=3 fail_timeout=30s;
        server 10.12.5.62:6443        max_fails=3 fail_timeout=30s;
    }

    server {
        listen 127.0.0.1:8443;
        proxy_connect_timeout 1s;
        proxy_pass backend;
    }
}
EOF
  • upstream backend 中的 server 列表为集群中各 kube-apiserver 的节点 IP，需要根据实际情况修改；

分发配置文件：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim nginx_conf.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    scp nginx.conf  root@${node_ip}:/opt/k8s/nginx/conf/nginx.conf
  done
$ sh nginx_conf.sh

7.2.5 配置systemd unit 文件，启动服务

配置 kube-nginx systemd unit 文件：

$ cd /opt/k8s/work
$ cat > nginx.service <<EOF
[Unit]
Description=kube-apiserver nginx proxy
After=network.target
After=network-online.target
Wants=network-online.target

[Service]
Type=forking
ExecStartPre=/opt/k8s/work/nginx/sbin/nginx -c /opt/k8s/work/nginx/conf/nginx.conf -p /opt/k8s/work/nginx -t
ExecStart=/opt/k8s/work/nginx/sbin/nginx -c /opt/k8s/work/nginx/conf/nginx.conf -p /opt/k8s/work/nginx
ExecReload=/opt/k8s/work/nginx/sbin/nginx -c /opt/k8s/work/nginx/conf/nginx.conf -p /opt/k8s/work/nginx -s reload
PrivateTmp=true
Restart=always
RestartSec=5
StartLimitInterval=0
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF

分发 systemd unit 文件：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim scp_kube_nginx.sh 
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    scp nginx.service  root@${node_ip}:/etc/systemd/system/
  done
$ sh scp_kube_nginx.sh

启动 kube-nginx 服务：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim start_kube_nginx.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "systemctl daemon-reload && systemctl enable nginx && systemctl restart nginx"
  done
$ sh start_kube_nginx.sh

7.2.6 检查nginx的状态

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim check_nginx.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "systemctl status nginx |grep 'Active:'"
  done
$ sh check_nginx.sh

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

$ journalctl -u kube-nginx

7.3 部署containerd组件

containerd 实现了 kubernetes 的 Container Runtime Interface (CRI) 接口，提供容器运行时核心功能，如镜像管理、容器管理等，相比 dockerd 更加简单、健壮和可移植。

  1. 如果没有特殊指明，本章节的所有操作均在节点上sre-master-node执行。
  2. 如果想使用 docker，请参考附件 F.部署docker.md；
  3. docker 需要与 flannel 配合使用，且先安装 flannel；

7.3.1 下载二进制文件

下载二进制文件：

$ cd /opt/k8s/work
$ wget https://github.com/kubernetes-sigs/cri-tools/releases/download/v1.17.0/crictl-v1.17.0-linux-amd64.tar.gz \
  https://github.com/opencontainers/runc/releases/download/v1.0.0-rc10/runc.amd64 \
  https://github.com/containernetworking/plugins/releases/download/v0.8.5/cni-plugins-linux-amd64-v0.8.5.tgz \
  https://github.com/containerd/containerd/releases/download/v1.3.3/containerd-1.3.3.linux-amd64.tar.gz

解压：

$ cd /opt/k8s/work
$ mkdir containerd
$ tar -xvf containerd-1.3.3.linux-amd64.tar.gz -C containerd
$ tar -xvf crictl-v1.17.0-linux-amd64.tar.gz

$ mkdir cni-plugins
$ sudo tar -xvf cni-plugins-linux-amd64-v0.8.5.tgz -C cni-plugins

$ sudo mv runc.amd64 runc

7.3.2 分发二进制文件

分发二进制文件到所有 worker 节点

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim scp_containerd.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    scp containerd/bin/*  crictl  cni-plugins/*  runc  root@${node_ip}:/opt/k8s/bin
    ssh root@${node_ip} "chmod a+x /opt/k8s/bin/* && mkdir -p /etc/cni/net.d"
  done
$ sh scp_containerd.sh

7.3.2 创建分发containerd配置文件

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ cat << EOF | sudo tee containerd-config.toml
version = 2
root = "${CONTAINERD_DIR}/root"
state = "${CONTAINERD_DIR}/state"
[plugins]
  [plugins."io.containerd.grpc.v1.cri"]
    sandbox_image = "registry.cn-beijing.aliyuncs.com/zhoujun/pause-amd64:3.1"
    [plugins."io.containerd.grpc.v1.cri".cni]
      bin_dir = "/opt/k8s/bin"
      conf_dir = "/etc/cni/net.d"
  [plugins."io.containerd.runtime.v1.linux"]
    shim = "containerd-shim"
    runtime = "runc"
    runtime_root = ""
    no_shim = false
    shim_debug = false
EOF
$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim containerd-config.sh 
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "mkdir -p /etc/containerd/ ${CONTAINERD_DIR}/{root,state}"
    scp containerd-config.toml root@${node_ip}:/etc/containerd/config.toml
  done
$ sh containerd-config.sh

7.3.4 创建containerd systemd unit文件 

$ cd /opt/k8s/work
$ cat <<EOF | sudo tee containerd.service
[Unit]
Description=containerd container runtime
Documentation=https://containerd.io
After=network.target
[Service]
Environment="PATH=/opt/k8s/bin:/bin:/sbin:/usr/bin:/usr/sbin"
ExecStartPre=/sbin/modprobe overlay
ExecStart=/opt/k8s/bin/containerd
Restart=always
RestartSec=5
Delegate=yes
KillMode=process
OOMScoreAdjust=-999
LimitNOFILE=1048576
LimitNPROC=infinity
LimitCORE=infinity
[Install]
WantedBy=multi-user.target
EOF

7.3.5 启动containerd

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim containerd_service.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    scp containerd.service root@${node_ip}:/etc/systemd/system
    ssh root@${node_ip} "systemctl enable containerd && systemctl restart containerd"
  done
$ sh containerd_service.sh

7.3.6 创建和分发crictl配置文件

crictl 是兼容 CRI 容器运行时的命令行工具，提供类似于 docker 命令的功能。具体参考官方文档。

$ cd /opt/k8s/work
$ cat << EOF | sudo tee crictl.yaml
runtime-endpoint: unix:///run/containerd/containerd.sock
image-endpoint: unix:///run/containerd/containerd.sock
timeout: 10
debug: false
EOF

分发到所有 worker 节点：

$ cd /opt/k8s/work
$ source /opt/k8s/bin/environment.sh
$ vim crictl_yaml.sh
for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    scp crictl.yaml root@${node_ip}:/etc/crictl.yaml
  done
$ sh crictl_yaml.sh

7.4 部署kubelet

kubelet 运行在每个 worker 节点上，接收 kube-apiserver 发送的请求，管理 Pod 容器，执行交互式命令，如 exec、run、logs 等。

kubelet 启动时自动向 kube-apiserver 注册节点信息，内置的 cadvisor 统计和监控节点的资源使用情况。

为确保安全，部署时关闭了 kubelet 的非安全 http 端口，对请求进行认证和授权，拒绝未授权的访问(如 apiserver、heapster 的请求)。

如果没有特殊指明，本文档的所有操作均在sre-master-node节点上执行。

7.4.1 下载和分发kubelet二进制文件

参考章节6.1-下载最新版本二进制文件。

7.4.2创建kubelet bootstrap kubeconfig 文件

猜你喜欢

转载自blog.csdn.net/ygq13572549874/article/details/132782080
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
周排行
Python环境安装与基础语法（1）——计算机基础知识
IMU预积分
ADAS中的LDW、FCW、BSD、LCA、ACC、AEB、APA、DMS代表的含义
B站笔试两道题
skyeye arm 硬件虚拟机环境的搭建
Web前端静态页面示例
数组-合并排序数组 II-简单
springcloud之版本问题启动报错
面向对象-------------匿名对象(六)
输入URL到页面呈现中间发生了什么？
每日归档
更多
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022