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

第一节 实践环境准备

1.1 服务器说明

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

系统类型IP地址节点角色CPUMemoryHostname
centos-7.8192.168.242.136master>=2>=2Gm1
centos-7.8192.168.242.137master>=2>=2Gm2
centos-7.8192.168.242.138master>=2>=2Gm3
centos-7.8192.168.242.130worker>=2>=2Gs1
centos-7.8192.168.242.131worker>=2>=2Gs2

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版本的部署说明
                                                                                                  参考地址
                                                                                                # 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要删除,不删除也会报错

                                                                                                # kubernetes # docker
                                                                                                Logo
                                                                                                K8S/Kubernetes

                                                                                                K8S/Kubernetes社区为您提供最前沿的新闻资讯和知识内容

                                                                                                更多推荐

                                                                                                【深度】阿里巴巴万级规模 K8s 集群全局高可用体系之美

                                                                                                作者 |  韩堂、柘远、沉醉来源 | 阿里巴巴云原生公众号​前言台湾作家林清玄在接受记者采访的时候，如此评价自己 30 多年写作生涯：“第一个十年我才华横溢，‘贼光闪现’，令周边黯然失色；第二个十年，我终于‘宝光现形’，不再去抢风头，反而与身边的美丽相得益彰；进入第三个十年，繁华落尽见真醇，我进入了‘醇光初现’的阶段，真正体味到了境界之美”。​长夜有穷，真水无香。领略过了 K8s“身在江

                                                                                                avatar K8S/Kubernetes

                                                                                                如何基于 K8s 构建下一代 DevOps 平台？

                                                                                                作者 | 孙健波（天元）导读：当前云原生 DevOps 体系现状如何？面临哪些挑战？如何通过 OAM 解决云原生 DevOps 场景下的诸多问题？云原生开发应用模型 OAM(Open Application Model) 社区核心成员孙健波将为大家一一解答，并分享如何基于 OAM 和 Kubernetes 打造无限能力的下一代 DevOps 平台。什么是 DevOps？为什么基于 Kub

                                                                                                avatar K8S/Kubernetes

                                                                                                k8s 火了！

                                                                                                2020，上云之年，产品云端化成为一种趋势。在一线城市，很多公司都已经构建了自己的私有云环境，比如阿里云、网易云、华为云等。而Kubernetes 作为基于容器编排领域的王者，具备扩展...

                                                                                                avatar K8S/Kubernetes