k8s高可用集群搭建（二进制方式）

男娘i 2023-01-21 13:29 9阅读 0赞

有关搭建中可能遇到的问题在最后有说明，提前看一下

## 第一节 实践环境准备 ##

### 1.1 服务器说明 ###

我们这里使用的是五台centos-7.8的虚拟机三台主节点和一个从节点，具体信息如下表：

<table> 
 <thead> 
  <tr> 
   <th align="center">系统类型</th> 
   <th align="center">IP地址</th> 
   <th align="center">节点角色</th> 
   <th align="center">CPU</th> 
   <th align="center">Memory</th> 
   <th align="center">Hostname</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">centos-7.8</td> 
   <td align="center">192.168.242.136</td> 
   <td align="center">master</td> 
   <td align="center">&gt;=2</td> 
   <td align="center">&gt;=2G</td> 
   <td align="center">m1</td> 
  </tr> 
  <tr> 
   <td align="center">centos-7.8</td> 
   <td align="center">192.168.242.137</td> 
   <td align="center">master</td> 
   <td align="center">&gt;=2</td> 
   <td align="center">&gt;=2G</td> 
   <td align="center">m2</td> 
  </tr> 
  <tr> 
   <td align="center">centos-7.8</td> 
   <td align="center">192.168.242.138</td> 
   <td align="center">master</td> 
   <td align="center">&gt;=2</td> 
   <td align="center">&gt;=2G</td> 
   <td align="center">m3</td> 
  </tr> 
  <tr> 
   <td align="center">centos-7.8</td> 
   <td align="center">192.168.242.130</td> 
   <td align="center">worker</td> 
   <td align="center">&gt;=2</td> 
   <td align="center">&gt;=2G</td> 
   <td align="center">s1</td> 
  </tr> 
  <tr> 
   <td align="center">centos-7.8</td> 
   <td align="center">192.168.242.131</td> 
   <td align="center">worker</td> 
   <td align="center">&gt;=2</td> 
   <td align="center">&gt;=2G</td> 
   <td align="center">s2</td> 
  </tr> 
 </tbody> 
</table>

### 1.2 系统设置（所有节点） ###

1.  设置主机名。主机名必须每个节点都不一样，并且保证所有点之间可以通过hostname互相访问。

# 查看主机名
    hostname
    # 修改主机名
    hostnamectl set-hostname <your_hostname>
    # 配置host，使所有节点之间可以通过hostname互相访问
    vi /etc/hosts
    echo -e "\n192.168.242.136 m1\n192.168.242.137 m2\n192.168.242.138 m3\n192.168.242.130 s1\n192.168.242.131 s2" >> /etc/hosts
    # <node-ip> <node-hostname>

1.  安装依赖包

# 更新yum
    yum update
    # 安装依赖包
    yum install -y conntrack ipvsadm ipset jq sysstat curl iptables libseccomp git vim net-tools wget

1.  关闭防火墙、swap，重置iptables

# 关闭防火墙
    systemctl stop firewalld && systemctl disable firewalld
    # 重置iptables
    iptables -F && iptables -X && iptables -F -t nat && iptables -X -t nat && iptables -P FORWARD ACCEPT
    # 关闭swap
    # 使用下面的命令对文件/etc/fstab操作，注释 /dev/mapper/centos_master-swap swap swap defaults 0 0 这行
    swapoff -a && sed -i 's/.*swap.*/#&/' /etc/fstab
    # 关闭selinux
    setenforce 0 && sed -i 's/^SELINUX=.*/SELINUX=disabled/' /etc/selinux/config
    # 查看selinux状态
    sestatus
    # 关闭dnsmasq(否则可能导致docker容器无法解析域名)
    service dnsmasq stop && systemctl disable dnsmasq

1.  系统参数设置

# 制作配置文件
    cat > /etc/sysctl.d/kubernetes.conf <<EOF net.bridge.bridge-nf-call-iptables=1 net.bridge.bridge-nf-call-ip6tables=1 net.ipv4.ip_forward=1 vm.swappiness=0 vm.overcommit_memory=1 vm.panic_on_oom=0 fs.inotify.max_user_watches=89100 EOF
    # 生效文件
    sysctl -p /etc/sysctl.d/kubernetes.conf
    # 执行sysctl -p 时出现下面的错误
    # sysctl: cannot stat /proc/sys/net/bridge/bridge-nf-call-ip6tables: No such file or directory
    # sysctl: cannot stat /proc/sys/net/bridge/bridge-nf-call-iptables: No such file or directory
    # 解决方法：运行命令 modprobe br_netfilter 然后再执行 sysctl -p /etc/sysctl.d/kubernetes.conf
    modprobe br_netfilter
    # 查看
    ls /proc/sys/net/bridge
    bridge-nf-call-arptables bridge-nf-filter-pppoe-tagged
    bridge-nf-call-ip6tables bridge-nf-filter-vlan-tagged
    bridge-nf-call-iptables bridge-nf-pass-vlan-input-dev

### 1.3 安装docker（所有节点） ###

# 1. 方法一: 通过yum源的方式安装
    # 创建所需目录
    mkdir -p /opt/kubernetes/docker && cd /opt/kubernetes/docker
    # 清理原有版本, 如果系统没有安装过跳过
    yum remove -y docker* container-selinux
    # 安装依赖包
    yum install -y yum-utils device-mapper-persistent-data lvm2
    # 设置yum源
    yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
    # 可以查看所有仓库中所有docker版本，并选择特定版本安装：
    yum list docker-ce --showduplicates | sort -r
    # 安装指定版本docker, 如果不指定版本号，将安装最新版本的docker
    # sudo yum install -y docker-ce-<VERSION_STRING> docker-ce-cli-<VERSION_STRING> containerd.io
    # 示例-安装docker版本是: 19.03.8
    yum install -y docker-ce-19.03.8 docker-ce-cli-19.03.8 containerd.io
    # 开机启动
    systemctl enable docker && systemctl start docker

\# 设置参数  
\# 1.查看磁盘挂载  
df \-h  
\# 2.设置docker启动参数  
\# - 设置docker数据目录：选择比较大的分区（我这里是根目录就不需要配置了，默认为/var/lib/docker）  
\# - 设置cgroup driver, 防止文件驱动不一致，导致镜像无法启动（默认是cgroupfs，主要目的是与kubelet配置统一，这里也可以不设置后面在kubelet中指定cgroupfs）  
\# docker info 可以查看到cgroup driver的类型  
cat <<EOF > /etc/docker/daemon.json  
\{   
“exec-opts”: \[“native.cgroupdriver=systemd”\],  
“registry-mirrors”: \[  
“https://registry.cn-hangzhou.aliyuncs.com”,  
“https://fz5yth0r.mirror.aliyuncs.com”,  
“https://dockerhub.mirrors.nwafu.edu.cn/”,  
“https://mirror.ccs.tencentyun.com”,  
“https://docker.mirrors.ustc.edu.cn/”,  
“https://reg-mirror.qiniu.com”,  
“http://hub-mirror.c.163.com/”,  
“https://registry.docker-cn.com”  
\]  
\}  
EOF  
\# 启动docker服务  
systemctl restart docker

\# daemon.json 详细配置示例  
\{   
“debug”: false,  
“experimental”: false,  
“graph”: “/home/docker-data”,  
“exec-opts”: \[“native.cgroupdriver=systemd”\],  
“registry-mirrors”: \[  
“https://fy707np5.mirror.aliyuncs.com”  
\],  
“insecure-registries”: \[  
“hub.zy.com”,  
“172.16.249.159:8082”  
\]  
\}  
\# 启动docker服务  
systemctl restart docker

### 1.4 下载二进制文件（所有节点） ###

1.  下载二进制文件
    
     *  官方下载地址（在CHANGELOG链接里面）： https://github.com/kubernetes/kubernetes/releases
     *  点击这个：CHANGELOG/CHANGELOG-1.18.md。选择master和worker的二进制文件。
     *  kubernetes-server-linux-amd64.tar.gz 主节点二进制文件
     *  kubernetes-node-linux-amd64.tar.gz worker节点二进制文件
2.  分发文件并设置好PATH

# 把文件copy到每个节点上（注意替换自己的文件目录）
    # 这里也可以把wget https://github.com/coreos/etcd/releases/download/v3.2.18/etcd-v3.2.18-linux-amd64.tar.gz etcd复制过去
    mkdir -p /opt/kubernetes/bin
    # 复制中转换节点的master文件夹下到master节点 worker文件到worker节点
    scp master/* <user>@<master-ip>:/opt/kubernetes/bin/
    scp worker/* <user>@<worker-ip>:/opt/kubernetes/bin/

\# 给每个节点设置PATH  
echo ‘PATH=/opt/kubernetes/bin:$PATH’ >>~/.bashrc  
\# 重新登陆终端生效 或执行  
source ~/.bash\_profile  
\# 看是否可用  
kubectl

### 1.5准备配置文件（任意节点） ###

1.  下载配置文件。我这准备了一个项目，专门为大家按照自己的环境生成配置的。它只是帮助大家尽量的减少了机械化的重复工作。它并不会帮你设置系统环境，不会给你安装软件。总之就是会减少你的部署工作量，但不会耽误你对整个系统的认识和把控。

cd ~ && git clone https://gitee.com/qnhyn/kubernetes-ha-binary.git
    # 看看git内容
    ls -l kubernetes-ha-kubeadm
    addons/
    configs/
    scripts/
    init.sh
    global-configs.properties

1.  文件目录说明

*  **addons**

> kubernetes的插件，比如calico和dashboard。

*  **configs**

> 包含了部署集群过程中用到的各种配置文件。

*  **scripts**

> 包含部署集群过程中用到的脚本，如keepalive检查脚本。

*  **global-configs.properties**

> 全局配置，包含各种易变的配置内容。

*  **init.sh**

> 初始化脚本，配置好global-config之后，会自动生成所有配置文件。

1.  生成配置。这里会根据大家各自的环境生成kubernetes部署过程需要的配置文件。

> 此脚本不支持MACOS系统，切记不要使用MACOS来运行 init.sh

# cd到之前下载的git代码目录
    cd kubernetes-ha-binary

\# 编辑属性配置（根据文件注释中的说明填写好每个key-value）  
vi global-config.properties

\# 生成配置文件，确保执行过程没有异常信息  
./init.sh

\# 查看生成的配置文件，确保脚本执行成功  
find target/ -type f

> **执行init.sh常见问题：**
> 
> 1.  Syntax error: “(” unexpected
> 
>  *  bash版本过低，运行：bash -version查看版本，如果小于4需要升级
>  *  不要使用 sh init.sh的方式运行（sh和bash可能不一样哦）
> 
> 1.  global-config.properties文件填写错误，需要重新生成  
>     再执行一次./init.sh即可，不需要手动删除target

## 第二节 高可用集群部署 ##

### 2.1 CA证书（任意节点） ###

1.  安装cfssl。cfssl是非常好用的CA工具，我们用它来生成证书和秘钥文件。安装过程如下：

# 下载
    mkdir -p ~/bin
    wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -O ~/bin/cfssl
    wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 -O ~/bin/cfssljson
    wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 -O ~/bin/cfssl-certinfo

\# 修改为可执行权限  
chmod \+x ~/bin/cfssl ~/bin/cfssljson ~/bin/cfssl-certinfo

\# 设置PATH  
echo ‘PATH=/home/bin:$PATH’ >>~/.bashrc  
source ~/.bash\_profile

\# 验证  
cfssl version

1.  生成根证书。根证书是集群所有节点共享的，只需要创建一个 CA 证书，后续创建的所有证书都由它签名。

# 生成证书和私钥
    cd ~/kubernetes-ha-binary/target/pki
    cfssl gencert -initca ca-csr.json | cfssljson -bare ca

\# 生成完成后会有以下文件（我们最终想要的就是ca-key.pem和ca.pem，一个秘钥，一个证书）  
ls  
ca-config.json ca.csr ca-csr.json ca-key.pem ca.pem

\# 三个主节点上创建目录  
mkdir \-p /etc/kubernetes/pki/

\# 分发到每个主节点  
scp ca\*.pem <user>@<node-ip>:/etc/kubernetes/pki/

### 2.2部署etcd集群（master节点） ###

1.  下载etcd

wget https://github.com/coreos/etcd/releases/download/v3.2.18/etcd-v3.2.18-linux-amd64.tar.gz

1.  生成证书和私钥

# 中转节点生成证书、私钥
    cd ~/kubernetes-ha-binary/target/pki/etcd
    cfssl gencert -ca=../ca.pem \
        -ca-key=../ca-key.pem \
        -config=../ca-config.json \
        -profile=kubernetes etcd-csr.json | cfssljson -bare etcd

\# 分发到每个etcd节点  
$ scp etcd\*.pem <user>@<node-ip>:/etc/kubernetes/pki/

1.  创建service文件

# scp配置文件到每个master节点
    scp target/192.168.242.136/services/etcd.service root@m1:/etc/systemd/system/
    scp target/192.168.242.137/services/etcd.service root@m2:/etc/systemd/system/
    scp target/192.168.242.138/services/etcd.service root@m3:/etc/systemd/system/

\# 创建数据和工作目录  
mkdir \-p /var/lib/etcd

1.  启动服务。etcd 进程首次启动时会等待其它节点的 etcd 加入集群，命令 systemctl start etcd 会卡住一段时间，为正常现象。

#启动服务
    systemctl daemon-reload && systemctl enable etcd && systemctl restart etcd

\#查看状态  
service etcd status

\#查看启动日志  
journalctl -f -u etcd

*  ### 2.2 部署api-server（master节点） ###
    
    1.  生成证书和私钥
    
        # 生成证书、私钥
        cd  ~/kubernetes-ha-binary/target/pki/apiserver
        cfssl gencert -ca=../ca.pem \
          -ca-key=../ca-key.pem \
          -config=../ca-config.json \
          -profile=kubernetes kubernetes-csr.json | cfssljson -bare kubernetes

\# 分发到每个master节点  
scp kubernetes\*.pem root@m1:/etc/kubernetes/pki/  
scp kubernetes\*.pem root@m2:/etc/kubernetes/pki/  
scp kubernetes\*.pem root@m3:/etc/kubernetes/pki/

1.  创建service文件

# scp配置文件到每个master节点
    cd  ~/kubernetes-ha-binary/
    scp target/192.168.242.136/services/kube-apiserver.service root@m1:/etc/systemd/system/
    scp target/192.168.242.137/services/kube-apiserver.service root@m2:/etc/systemd/system/
    scp target/192.168.242.138/services/kube-apiserver.service root@m3:/etc/systemd/system/

\# 创建日志目录  
mkdir \-p /var/log/kubernetes

1.  启动服务

#启动服务
    systemctl daemon-reload && systemctl enable kube-apiserver && systemctl restart kube-apiserver

\#查看运行状态  
service kube-apiserver status

\# 如果启动不成功 用下面方法查看错误并解决  
journalctl -f -u kube-apiserver  
cat /var/log/messages|grep kube-apiserver|grep \-i error

\# 这里配置多了个 --runtime-config=api/all   
vi /etc/systemd/system/kube-apiserver.service

\#查看日志  
journalctl -f -u kube-apiserver

\#检查监听端口  
netstat \-ntlp

### 2.3 部署keepalived - apiserver高可用（master节点） ###

1.  安装keepalived

# 在两主节点上安装keepalived（一主两备）
    yum install -y keepalived

1.  创建keepalived配置文件

# 创建目录 主备都创建
    mkdir -p /etc/keepalived

\# 分发配置文件 主节点和备节点不同  
scp target/configs/keepalived-master.conf <user>@<master-ip>:/etc/keepalived/keepalived.conf  
scp target/configs/keepalived-backup.conf <user>@<backup-ip>:/etc/keepalived/keepalived.conf

\# 分发监测脚本  
scp target/configs/check-apiserver.sh <user>@<master-ip>:/etc/keepalived/

1.  启动keepalived

# 分别在master和backup上启动服务
    systemctl enable keepalived && service keepalived start

\# 检查状态  
service keepalived status

\# 查看日志  
journalctl -f -u keepalived

\# 访问测试  
curl \--insecure https://192.168.242.140:6443/

### 2.4 部署kubectl（任意节点） ###

1.  kubectl 是 kubernetes 集群的命令行管理工具，它默认从 ~/.kube/config 文件读取 kube-apiserver 地址、证书、用户名等信息。
2.  创建 admin 证书和私钥
    
     *  kubectl 与 apiserver https 安全端口通信，apiserver 对提供的证书进行认证和授权。
     *  kubectl 作为集群的管理工具，需要被授予最高权限。这里创建具有最高权限的 admin 证书。

# 创建证书、私钥
    cd ~/kubernetes-ha-binary/target/pki/admin
    cfssl gencert -ca=../ca.pem \
      -ca-key=../ca-key.pem \
      -config=../ca-config.json \
      -profile=kubernetes admin-csr.json | cfssljson -bare admin

1.  创建kubeconfig配置文件
    
     *  kubeconfig 为 kubectl 的配置文件，包含访问 apiserver 的所有信息，如 apiserver 地址、CA 证书和自身使用的证书

# 设置集群参数 虚拟vip
    kubectl config set-cluster kubernetes \
      --certificate-authority=../ca.pem \
      --embed-certs=true \
      --server=https://192.168.242.140:6443 \
      --kubeconfig=kube.config

\# 设置客户端认证参数  
kubectl config set-credentials admin  
–client-certificate=admin.pem  
–client-key=admin-key.pem  
–embed-certs=true  
–kubeconfig=kube.config

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

\# 设置默认上下文  
kubectl config use-context kubernetes --kubeconfig=kube.config

\# 分发到目标节点  
scp kube.config <user>@<node-ip>:~/.kube/config

1.  kubernetes 证书访问 kubelet API 的权限
    
     *  在执行 kubectl exec、run、logs 等命令时，apiserver 会转发到 kubelet。这里定义 RBAC 规则，授权 apiserver 调用 kubelet API。

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

1.  测试一下

# 查看集群信息
    kubectl cluster-info
    kubectl get all --all-namespaces
    kubectl get componentstatuses

### 2.5部署controller-manager（master节点） ###

1.  controller-manager启动后将通过竞争选举机制产生一个 leader 节点，其它节点为阻塞状态。当 leader 节点不可用后，剩余节点将再次进行选举产生新的 leader 节点，从而保证服务的可用性。
2.  创建证书和私钥

# 生成证书、私钥
    cd ~/kubernetes-ha-binary/target/pki/controller-manager
    cfssl gencert -ca=../ca.pem \
      -ca-key=../ca-key.pem \
      -config=../ca-config.json \
      -profile=kubernetes controller-manager-csr.json | cfssljson -bare controller-manager
    # 分发到每个master节点
    scp controller-manager*.pem <user>@<node-ip>:/etc/kubernetes/pki/

1.  创建controller-manager的kubeconfig

# 创建kubeconfig 虚拟ip
    kubectl config set-cluster kubernetes \
      --certificate-authority=../ca.pem \
      --embed-certs=true \
      --server=https://192.168.242.140:6443 \
      --kubeconfig=controller-manager.kubeconfig

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

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

kubectl config use-context system:kube-controller-manager --kubeconfig=controller-manager.kubeconfig

\# 分发controller-manager.kubeconfig  
scp controller-manager.kubeconfig <user>@<node-ip>:/etc/kubernetes/

1.  创建service文件

# scp配置文件到每个master节点
    scp target/services/kube-controller-manager.service <user>@<node-ip>:/etc/systemd/system/

1.  启动服务

# 启动服务
    systemctl daemon-reload && systemctl enable kube-controller-manager && systemctl restart kube-controller-manager

\# 检查状态  
service kube-controller-manager status

\# 查看日志  
journalctl -f -u kube-controller-manager

\# 查看leader  
kubectl get endpoints kube-controller-manager --namespace=kube-system -o yaml

### 2.6 部署scheduler（master节点） ###

1.  scheduler启动后将通过竞争选举机制产生一个 leader 节点，其它节点为阻塞状态。当 leader 节点不可用后，剩余节点将再次进行选举产生新的 leader 节点，从而保证服务的可用性。
2.  创建证书和私钥

# 生成证书、私钥
    cd ~/kubernetes-ha-binary/target/pki/scheduler
    cfssl gencert -ca=../ca.pem \
      -ca-key=../ca-key.pem \
      -config=../ca-config.json \
      -profile=kubernetes scheduler-csr.json | cfssljson -bare kube-scheduler

1.  创建scheduler的kubeconfig

# 创建kubeconfig
    kubectl config set-cluster kubernetes \
      --certificate-authority=../ca.pem \
      --embed-certs=true \
      --server=https://192.168.242.140: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  
scp kube-scheduler.kubeconfig <user>@<node-ip>:/etc/kubernetes/

1.  创建service文件

# scp配置文件到每个master节点
    scp target/services/kube-scheduler.service <user>@<node-ip>:/etc/systemd/system/

1.  启动服务

# 启动服务
    systemctl daemon-reload && systemctl enable kube-scheduler && systemctl restart kube-scheduler

\# 检查状态  
service kube-scheduler status

\# 查看日志  
journalctl -f -u kube-scheduler

\# 查看leader  
kubectl get endpoints kube-scheduler --namespace=kube-system -o yaml

### 2.7. 部署kubelet（worker节点） ###

1.  预先下载需要的镜像

# 预先下载镜像到所有节点（由于镜像下载的速度过慢，我给大家提供了阿里云仓库的镜像）
    scp target/configs/download-images.sh <user>@<node-ip>:~

\# 在目标节点上执行脚本下载镜像  
sh ~/download-images.sh

1.  创建bootstrap配置文件

# 创建 token
    cd ~/kubernetes-ha-binary/target/pki/admin
    export BOOTSTRAP_TOKEN=$(kubeadm token create \ --description kubelet-bootstrap-token \ --groups system:bootstrappers:worker \ --kubeconfig kube.config)

\# 设置集群参数  
kubectl config set-cluster kubernetes  
–certificate-authority=…/ca.pem  
–embed-certs=true  
–server=https://192.168.242.140:6443  
–kubeconfig=kubelet-bootstrap.kubeconfig

\# 设置客户端认证参数  
kubectl config set-credentials kubelet-bootstrap  
–token=$\{BOOTSTRAP\_TOKEN\}  
–kubeconfig=kubelet-bootstrap.kubeconfig

\# 设置上下文参数  
kubectl config set-context default  
–cluster=kubernetes  
–user=kubelet-bootstrap  
–kubeconfig=kubelet-bootstrap.kubeconfig

\# 设置默认上下文  
kubectl config use-context default --kubeconfig=kubelet-bootstrap.kubeconfig

\# 把生成的配置copy到每个 worker节点上  
scp kubelet-bootstrap.kubeconfig <user>@<node-ip>:/etc/kubernetes/kubelet-bootstrap.kubeconfig

\# 先在worker节点上创建目录  
mkdir \-p /etc/kubernetes/pki

\# 把ca分发到每个worker节点  
scp target/pki/ca.pem <user>@<node-ip>:/etc/kubernetes/pki/

1.  kubelet配置文件。把kubelet配置文件分发到每个worker节点上

scp target/worker-<node-ip>/kubelet.config.json <user>@<node-ip>:/etc/kubernetes/

1.  kubelet服务文件。把kubelet服务文件分发到每个worker节点上

scp target/worker-<node-ip>/kubelet.service <user>@<node-ip>:/etc/systemd/system/

1.  启动服务
    
     *  kublet 启动时查找配置的 --kubeletconfig 文件是否存在，如果不存在则使用 --bootstrap-kubeconfig 向 kube-apiserver 发送证书签名请求 (CSR)。
     *  kube-apiserver 收到 CSR 请求后，对其中的 Token 进行认证（事先使用 kubeadm 创建的 token），认证通过后将请求的 user 设置为 system:bootstrap:，group 设置为system:bootstrappers，这就是Bootstrap Token Auth。

# bootstrap附权
    kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --group=system:bootstrappers

\# 启动服务  
mkdir \-p /var/lib/kubelet  
systemctl daemon-reload && systemctl enable kubelet && systemctl restart kubelet

\# 在master上Approve bootstrap请求  
kubectl get csr  
\# 模拟通过  
kubectl certificate approve <name>

\# 查看服务状态 1.15之后版本kubelet.service中的–allow-privileged删除 如果报错看下配置文件中的systemd  
service kubelet status

\# 查看日志  
journalctl -f -u kubelet

### 2.8 部署kube-proxy（worker节点） ###

1.  创建证书和私钥

cd ~/kubernetes-ha-binary/target/pki/proxy
    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.  创建和分发 kubeconfig 文件

# 创建kube-proxy.kubeconfig
    kubectl config set-cluster kubernetes \
      --certificate-authority=../ca.pem \
      --embed-certs=true \
      --server=https://192.168.242.140:6443 \
      --kubeconfig=kube-proxy.kubeconfig
    kubectl config set-credentials kube-proxy \
      --client-certificate=kube-proxy.pem \
      --client-key=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
    kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig

\# 分发kube-proxy.kubeconfig  
scp kube-proxy.kubeconfig <user>@<node-ip>:/etc/kubernetes/

1.  分发kube-proxy.config

scp target/worker-<node-ip>/kube-proxy.config.yaml <user>@<node-ip>:/etc/kubernetes/

1.  分发kube-proxy服务文件

scp target/services/kube-proxy.service <user>@<node-ip>:/etc/systemd/system/

1.  启动服务

# 创建依赖目录
    mkdir -p /var/lib/kube-proxy && mkdir -p /var/log/kubernetes

\# 启动服务  
systemctl daemon-reload && systemctl enable kube-proxy && systemctl restart kube-proxy

\# 查看状态  
service kube-proxy status

\# 查看日志  
journalctl -f -u kube-proxy

### 2.9 部署CNI插件 - calico ###

1.  我们使用calico官方的安装方式来部署。

# 创建目录（在配置了kubectl的节点上执行）
    mkdir -p /etc/kubernetes/addons

\# curl https://docs.projectcalico.org/manifests/calico-typha.yaml -o calico.yaml  
scp target/addons/calico\* <user>@<node-ip>:/etc/kubernetes/addons/

\# 部署calico  
kubectl create -f /etc/kubernetes/addons/calico.yaml

\# 查看状态  
kubectl get pods -n kube-system

### 2.10 部署DNS插件 - coredns ###

wget http://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
    rpm -ivh epel-release-latest-7.noarch.rpm
    yum repolist
    yum install jq -y
    # 下载 CoreDNS 项目
    git clone https://github.com/coredns/deployment.git
    cd coredns/deployment/kubernetes
    # CLUSTER_DNS_IP 是自动获取kube-dns的集群ip的，但是由于没有部署kube-dns所以只能手动指定一个集群ip
    # 10.254.0.2使我们前面设置好的 就会生成一个yaml文件
    ./deploy.sh -i 10.254.0.2 > coredns.yaml
    kubectl apply -f coredns.yaml

\# 这里也可以使用自己生成好的配置文件  
scp target/addons/coredns.yaml <user>@<node-ip>:/etc/kubernetes/addons/

\# 部署coredns  
kubectl create -f /etc/kubernetes/addons/coredns.yaml

## 第三节 集群可用性测试 ##

### 3.1 创建nginx的ds ###

# 写入配置
    cat > nginx-ds.yml <<EOF apiVersion: v1 kind: Service metadata: name: nginx-ds labels: app: nginx-ds spec: type: NodePort selector: app: nginx-ds ports: - name: http port: 80 targetPort: 80 --- apiVersion: apps/v1 kind: DaemonSet metadata: name: nginx-ds labels: addonmanager.kubernetes.io/mode: Reconcile spec: selector: matchLabels: app: nginx-ds template: metadata: labels: app: nginx-ds spec: containers: - name: my-nginx image: nginx:1.17 ports: - containerPort: 80 EOF

\# 创建ds  
kubectl create -f nginx-ds.yml

### 3.2 检查各种ip连通性 ###

# 检查各 Node 上的 Pod IP 连通性
    kubectl get pods  -o wide

\# 在每个worker节点上ping pod ip  
ping <pod-ip>

\# 检查service可达性  
kubectl get svc

\# 在每个worker节点上访问服务  
curl <service-ip>:<port>

\# 在worker节点检查node-port可用性 每个ip和虚拟ip都可以加NodePort  
curl <node-ip>:<NodePort>  
netstat \-ntlp|grep 8648  
curl 192.168.242.130:8648

### 3.3 检查dns可用性 ###

# 创建一个nginx pod
    cat > pod-nginx.yaml <<EOF apiVersion: v1 kind: Pod metadata: name: nginx spec: containers: - name: nginx image: nginx:1.17 ports: - containerPort: 80 EOF

\# 创建pod  
kubectl create -f pod-nginx.yaml

\# 进入pod，查看dns  
kubectl exec nginx -i -t – /bin/bash

\# 查看dns配置  
root@nginx:/\# cat /etc/resolv.conf

\# 查看名字是否可以正确解析  
root@nginx:/\# ping nginx-ds

## 第四节 部署dashboard ##

### 4.1 部署dashboard 2.x版本 ###

1.  Dashboard 分为 1.x版本 和 2.x版本， k8s 使用的是1.18.2 故部署2.x版本的

# dashboard 2.x版本的部署
    # 上传dashboard配置
    scp target/addons/recommended.yaml <user>@<node-ip>:/etc/kubernetes/addons/
    # 进行部署
    kubectl apply -f /etc/kubernetes/addons/recommended.yaml
    # 查看服务运行情况
    kubectl get deployment kubernetes-dashboard -n kubernetes-dashboard
    kubectl -n kubernetes-dashboard get pods -o wide
    kubectl get services kubernetes-dashboard -n kubernetes-dashboard
    netstat -ntlp|grep NodePort端口

1.  部署dashboard 2.x版本的部署说明  
    [参考地址][Link 1]

# 1. 下载配置文件, 可能需要翻墙，如果不能科学上网访问
    # https://github.com/kubernetes/dashboard/blob/master/aio/deploy/recommended.yaml 拷贝出文件内容
    wget https://raw.githubusercontent.com/kubernetes/dashboard/v2.0.1/aio/deploy/recommended.yaml

# 2. 修改配置文件（大约在32行Service段） 在spec 中加入 type: NodePort, nodePort: 30005 配置
    kind: Service
    apiVersion: v1
    metadata:
      labels:
        k8s-app: kubernetes-dashboard
      name: kubernetes-dashboard
      namespace: kubernetes-dashboard
    spec:
      type: NodePort
      ports:
        - port: 443
          targetPort: 8443
          nodePort: 30005
      selector:
        k8s-app: kubernetes-dashboard

# 2. 进行部署
    kubectl apply -f recommended.yaml

### 4.2 访问dashboard ###

1.  为了集群安全，从 1.7 开始，dashboard 只允许通过 https 访问，我们使用nodeport的方式暴露服务，可以使用 https://192.168.242.130:8888地址访问
2.  关于自定义证书
    
     *  默认dashboard的证书是自动生成的，肯定是非安全的证书，如果大家有域名和对应的安全证书可以自己替换掉。使用安全的域名方式访问dashboard。
     *  在dashboard-all.yaml中增加dashboard启动参数，可以指定证书文件，其中证书文件是通过secret注进来的。

> \- –tls-cert-file  
> \- dashboard.cer  
> \- –tls-key-file  
> \- dashboard.key

### 4.3 登录dashboard 2.x ###

1.  Dashboard 默认只支持 token 认证，所以如果使用 KubeConfig 文件，需要在该文件中指定 token，我们这里使用token的方式登录

# 创建service account
    kubectl create sa dashboard-admin -n kubernetes-dashboard

\# 创建角色绑定关系  
kubectl create clusterrolebinding dashboard-admin --clusterrole=cluster-admin --serviceaccount=kubernetes-dashboard:dashboard-admin

\# 查看dashboard-admin的secret名字  
ADMIN\_SECRET=$(kubectl get secrets -n kubernetes-dashboard | grep dashboard-admin | awk ‘\{print $1\}’)

\# 打印secret的token  
kubectl describe secret -n kubernetes-dashboard $\{ADMIN\_SECRET\} | grep \-E ‘^token’ | awk ‘\{print $2\}’

### 4.4 谷歌浏览器访问 ###

用谷歌浏览器（chrome）访问 https://NodeIP:NodePort 地址， 此时浏览器打开后提示证书不授信。复制上面证书。

### 搭建中可能会遇到的问题如下: ###

1. /root/kubernetes-ha-binary/target/pki/apiserver/kubernetes-csr.json中的变量换成自己对应的IP,否则后面master1上面搭建的kubectl会找不到IP

2.两台work节点的kubelet配置文件/etc/kubernetes/kubelet.config.json需要修改 “cgroupDriver”: “systemd”,这里的systemd是和上面docker的daemon.json的exec-opts”: \[“native.cgroupdriver=systemd”\]保持一直，否则启动work节点的kubelet失败 ,1.15之后版本kubelet.service中的–allow-privileged要删除,不删除也会报错

[Link 1]: https://github.com/kubernetes/dashboard/releases%5B