Kubernetes容器叢集管理環境 - 完整部署（上篇）

Kubernetes（通常稱為"K8S"）是Google開源的容器叢集管理系統。其設計目标是在主機叢集之間提供一個能夠自動化部署、可拓展、應用容器可營運的平台。Kubernetes通常結合docker容器工具工作，并且整合多個運作着docker容器的主機叢集，Kubernetes不僅僅支援Docker，還支援Rocket，這是另一種容器技術。Kubernetes是一個用于容器叢集的自動化部署、擴容以及運維的開源平台。通過Kubernetes, 可以快速有效地響應使用者需求：

->  快速而有預期地部署應用；

->  極速地擴充你的應用；

->  無縫對接新的應用功能；

->  節省資源，優化硬體資源的使用；

Kubernetes功能特性：

->  自動化容器部署與複制

->  随時擴充或收縮容器規模

->  組織容器成組，提供容器間的負載均衡

->  快速更新及復原容器版本

->  提供彈性伸縮，如果某個容器失效就進行替換

Kubernetes重要元件：

1）Master元件

Master節點上面主要由四個子產品組成：APIServer、scheduler、controller manager、etcd

->  APIServer: 負責對外提供RESTful的Kubernetes API服務，它是系統管理指令的統一入口，任何對資源進行增删改查的操作都要交給APIServer處理後再送出給etcd。kubectl（k8s提供的用戶端工具，該工具内部就是對Kubernetes API的調用）是直接和APIServer互動的。

->  schedule: 它的職責很明确，就是負責排程pod到合适的Node上。如果把scheduler看成一個黑匣子，那麼它的輸入是pod和由多個Node組成的清單，輸出是Pod和一個Node的綁定，即将這個pod部署到這個Node上。Kubernetes目前提供了排程算法，但是同樣也保留了接口，使用者可以根據自己的需求定義自己的排程算法。

->  controller manager: 如果說APIServer做的是“前台”的工作的話，那controller manager就是負責“背景”的。每個資源一般都對應有一個控制器，而controller manager就是負責管理這些控制器的。比如我們通過APIServer建立一個pod，當這個pod建立成功後，APIServer的任務就算完成了。而後面保證Pod的狀态始終和我們預期的一樣的重任就由controller manager去保證了。

-> etcd: 它是一個高可用的鍵值存儲系統，Kubernetes使用它來存儲各個資源的狀态，進而實作了Restful的API。

2）Node元件

每個Node節點主要由三個子產品組成：kubelet、kube-proxy、runtime。

runtime。runtime指的是容器運作環境，目前Kubernetes支援docker和rkt兩種容器。

-> kubelet:Kubelet是Master在每個Node節點上面的agent，是Node節點上面最重要的子產品，它負責維護和管理該Node上面的所有容器，但是如果容器不是通過Kubernetes建立的，它并不會管理。本質上，它負責使Pod得運作狀态與期望的狀态一緻。

-> kube-proxy:該子產品實作了Kubernetes中的服務發現和反向代理功能。反向代理方面：kube-proxy支援TCP和UDP連接配接轉發，預設基于Round Robin算法将用戶端流量轉發到與service對應的一組後端pod。服務發現方面，kube-proxy使用etcd的watch機制，監控叢集中service和endpoint對象資料的動态變化，并且維護一個service到endpoint的映射關系，進而保證了後端pod的IP變化不會對通路者造成影響。另外kube-proxy還支援session affinity。

3）Pod

Pod是k8s進行資源排程的最小機關，每個Pod中運作着一個或多個密切相關的業務容器，這些業務容器共享這個Pause容器的IP和Volume，我們以這個不易死亡的Pause容器作為Pod的根容器，以它的狀态表示整個容器組的狀态。一個Pod一旦被建立就會放到Etcd中存儲，然後由Master排程到一個Node綁定，由這個Node上的Kubelet進行執行個體化。每個Pod會被配置設定一個單獨的Pod IP，Pod IP + ContainerPort 組成了一個Endpoint。

4）Service

Service其功能使應用暴露，Pods 是有生命周期的，也有獨立的 IP 位址，随着 Pods 的建立與銷毀，一個必不可少的工作就是保證各個應用能夠感覺這種變化。這就要提到 Service 了，Service 是 YAML 或 JSON 定義的由 Pods 通過某種政策的邏輯組合。更重要的是，Pods 的獨立 IP 需要通過 Service 暴露到網絡中。

K8s叢集可以幫助培育出一個元件及工具的生态，幫助減輕在公有雲及私有雲上運作應用的負擔。之前已經詳細介紹了Kubernetes的概念和原理， 對Kubernetes叢集部署做一整理和記錄，友善後續作為手冊來用（參考來源）。

搭建Kubernetes叢集環境有以下三種方式：

1. Minikube安裝方式

Minikube是一個工具，可以在本地快速運作一個單點的Kubernetes，嘗試Kubernetes或日常開發的使用者使用。但是這種方式僅可用于學習和測試部署，不能用于生産環境。

2. Kubeadm安裝方式

kubeadm是一個kubernetes官方提供的快速安裝和初始化擁有最佳實踐（best practice）的kubernetes叢集的工具，提供kubeadm init和kubeadm join，用于快速部署Kubernetes叢集。目前kubeadm還處于beta 和alpha狀态，不推薦用在生産環境，但是可以通過學習這種部署方法來體會一些官方推薦的kubernetes最佳實踐的設計和思想。

kubeadm的目标是提供一個最小可用的可以通過Kubernetes一緻性測試的叢集，是以并不會安裝任何除此之外的非必須的addon。kubeadm預設情況下并不會安裝一個網絡解決方案，是以用kubeadm安裝完之後，需要自己來安裝一個網絡的插件。是以說，目前的kubeadm是不能用于生産環境的

3. 二進制包安裝方式（生産部署的推薦方式）

從官方下載下傳發行版的二進制包，手動部署每個元件，組成Kubernetes叢集，這種方式符合企業生産環境标準的Kubernetes叢集環境的安裝，可用于生産方式部署。

一、基礎資訊

使用Kubernetes1.14.2，所有節點機作業系統是Centos7.5。本文檔部署中所需kubernetes相關安裝包和鏡像可提前在FQ伺服器上下載下傳，然後同步到k8s部署機器上。具體資訊如下:

ip位址	主機名	角色
172.16.60.241	k8s-master01	主節點1、etc節點1
172.16.60.242	k8s-master02	主節點2、etc節點2
172.16.60.243	k8s-master03	主節點3、etc節點3
172.16.60.244	k8s-node01	工作節點1
172.16.60.245	k8s-node02	工作節點2
172.16.60.246	k8s-node03	工作節點3
172.16.60.247	k8s-ha01	nginx節點1、harbor節點1
172.16.60.248	k8s-ha02	nginx節點2、harbor節點2

本套Kubernetes叢集環境版本

-  Kubernetes 1.14.2

-  Docker 18.09.6-ce

-  Etcd 3.3.13

-  Flanneld 0.11.0

插件：

-  Coredns

-  Dashboard

-  Metrics-server

鏡像倉庫：

-  harbor（兩個倉庫互相同步，對外提供統一入口VIP位址）

主要配置政策

kube-apiserver高可用（Nginx負載層）：

- 使用Nginx+Keepalived實作高可用, VIP1：172.16.60.250；

- 關閉非安全端口 8080 和匿名通路；

- 在安全端口 6443 接收 https 請求；

- 嚴格的認證和授權政策 (x509、token、RBAC)；

- 開啟 bootstrap token 認證，支援 kubelet TLS bootstrapping；

- 使用 https 通路 kubelet、etcd，加密通信；

kube-controller-manager高可用：

-  3節點高可用；

-  關閉非安全端口，在安全端口 10252 接收 https 請求；

-  使用 kubeconfig 通路 apiserver 的安全端口；

-  自動 approve kubelet 證書簽名請求 (CSR)，證書過期後自動輪轉；

-  各controller 使用自己的 ServiceAccount 通路 apiserver；

kube-scheduler高可用：

kubelet：

-  使用 kubeadm 動态建立 bootstrap token，而不是在 apiserver 中靜态配置；

-  使用TLS bootstrap機制自動生成 client 和 server 證書，過期後自動輪轉；

-  在 kubeletConfiguration 類型的 JSON 檔案配置主要參數；

-  關閉隻讀端口，在安全端口 10250 接收 https 請求，對請求進行認證和授權，拒絕匿名通路和非授權通路；

kube-proxy：

-  使用kubeconfig 通路 apiserver 的安全端口；

-  在KubeProxyConfiguration 類型的 JSON 檔案配置主要參數；

-  使用ipvs代理模式；

叢集插件：

-  DNS：使用功能、性能更好的 coredns；

-  Dashboard：支援登入認證；

-  Metric：metrics-server，使用 https 通路 kubelet 安全端口；

-  Log：Elasticsearch、Fluend、Kibana；

-  Registry 鏡像庫：Harbor私有倉庫，兩個節點互相同步；

kubernetes叢集部署中生成的證書檔案如下：

ca-key.pem                       根私鑰（controller-manager配置的時候，跟上--service-account-private-key-file）

ca.pem                              根證書（apiserver配置的時候，跟上--service-account-key-file）

kubernetes-key.pem         叢集私鑰

kubernetes.pem                叢集證書

kube-proxy.pem                 proxy證書-node節點進行認證

kube-proxy-key.pem           proxy私鑰-node節點進行認證

admin.pem                         管理者證書-主要用于kubectl認證

admin-key.pem                   管理者私鑰-主要用于kubectl認證

TLS作用：就是對通訊加密，防止中間人竊聽；同時如果證書不信任的話根本就無法與 apiserver 建立連接配接，更不用提有沒有權限向 apiserver 請求指定内容。

RBAC作用：RBAC 中規定了一個使用者或者使用者組(subject)具有請求哪些 api 的權限；在配合 TLS 加密的時候，實際上 apiserver 讀取用戶端證書的 CN 字段作為使用者名，讀取 O 字段作為使用者組。

總之想要與apiserver通訊就必須采用由apiserver CA簽發的證書，這樣才能形成信任關系，建立TLS連接配接；另外可通過證書的CN、O字段來提供RBAC所需使用者與使用者組。

kubernetes叢集會預設開啟RABC（角色通路控制機制），這裡提前了解幾個重要概念：

- DRBC

K8S 1.6引進，是讓使用者能夠通路K8S API資源的授權方式（不授權就沒有資格通路K8S的資源）

- 使用者

K8S有兩種使用者：User 和 Service Account。其中，User給使用者使用，Service Account給程序使用，讓程序有相關權限。如Dashboard就是一個程序，可以建立一個Service Account給它使用。

- 角色

Role是一系列權限的集合，例如一個Role可包含讀取和列出Pod的權限（ClusterRole和Role類似，其權限範圍是整個叢集）

- 角色綁定

RoleBinding把角色映射到使用者，進而讓這些使用者擁有該角色的權限（ClusterRoleBinding和RoleBinding類似，可讓使用者擁有ClusteRole的權限）

- Secret

Secret是一個包含少量敏感資訊如密碼，令牌或密鑰的對象。把這些資訊儲存在Secret對象中，可以在這些資訊被使用時加以控制，并可以減低資訊洩露的風險。

二、環境初始化準備

Kubernetes叢集部署過程均需要使用root賬号操作，下面初始化操作在k8s的master和node節點上操作。

這裡先以k8s-master01節點為例，其他節點類似操作。
  
1）主機名修改
[root@k8s-master01 ~]# hostnamectl set-hostname k8s-master01
    
如果DNS不支援解析主機名稱，則需要修改/etc/hosts檔案，添加主機名和IP的對應關系：
[root@k8s-master01 ~]# cat >> /etc/hosts <<EOF
172.16.60.241   k8s-master01
172.16.60.242   k8s-master02
172.16.60.243   k8s-master03
172.16.60.241   k8s-etcd01
172.16.60.242   k8s-etcd02
172.16.60.243   k8s-etcd03
172.16.60.244   k8s-node01
172.16.60.245   k8s-node02
172.16.60.246   k8s-node03
EOF
  
2) 添加docker賬戶
[root@k8s-master01 ~]# useradd -m docker
  
3) 無密碼ssh信任關系
本篇部署文檔有很有操作都是在k8s-master01節點上執行，然後遠端分發檔案到其他節點機器上并遠端執行指令，是以需要添加該節點到其它節點的ssh信任關系。
[root@k8s-master01 ~]# ssh-keygen -t rsa
[root@k8s-master01 ~]# cp /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys
[root@k8s-master01 ~]# ssh-copy-id -i /root/.ssh/id_rsa.pub -p22 root@k8s-master01
[root@k8s-master01 ~]# ssh-copy-id -i /root/.ssh/id_rsa.pub -p22 root@k8s-master02
[root@k8s-master01 ~]# ssh-copy-id -i /root/.ssh/id_rsa.pub -p22 root@k8s-master03
[root@k8s-master01 ~]# ssh-copy-id -i /root/.ssh/id_rsa.pub -p22 root@k8s-node01
[root@k8s-master01 ~]# ssh-copy-id -i /root/.ssh/id_rsa.pub -p22 root@k8s-node02
[root@k8s-master01 ~]# ssh-copy-id -i /root/.ssh/id_rsa.pub -p22 root@k8s-node03
  
以上信任關系設定後，最好手動驗證下本節點登陸到其他節點的ssh無密碼信任關系
  
4) 更新PATH變量，将可執行檔案目錄添加到PATH環境變量中
将可執行檔案目錄添加到PATH環境變量中
[root@k8s-master01 ~]# echo 'PATH=/opt/k8s/bin:$PATH' >>/root/.bashrc
[root@k8s-master01 ~]# source /root/.bashrc
    
5) 安裝依賴包
[root@k8s-master01 ~]# yum install -y epel-release
[root@k8s-master01 ~]# yum install -y conntrack ntpdate ntp ipvsadm ipset jq iptables curl sysstat libseccomp wget lsof telnet
    
關閉無關的服務
[root@k8s-master01 ~]# systemctl stop postfix && systemctl disable postfix
    
6）關閉防火牆
在每台機器上關閉防火牆，清理防火牆規則，設定預設轉發政策：
[root@k8s-master01 ~]# systemctl stop firewalld
[root@k8s-master01 ~]# systemctl disable firewalld
[root@k8s-master01 ~]# iptables -F && iptables -X && iptables -F -t nat && iptables -X -t nat
[root@k8s-master01 ~]# iptables -P FORWARD ACCEPT
[root@k8s-master01 ~]# firewall-cmd --state
not running
  
7) 關閉SELinux
關閉SELinux，否則後續K8S挂載目錄時可能報錯 Permission denied：
[root@k8s-master01 ~]# setenforce 0
[root@k8s-master01 ~]# sed -i 's/^SELINUX=.*/SELINUX=disabled/' /etc/selinux/config
    
8) 關閉swap分區
如果開啟了swap分區，kubelet會啟動失敗(可以通過将參數 --fail-swap-on 設定為false來忽略swap on)，故需要在每個node節點機器上關閉swap分區。
這裡索性将所有節點的swap分區都關閉，同時注釋/etc/fstab中相應的條目，防止開機自動挂載swap分區：
[root@k8s-master01 ~]# swapoff -a
[root@k8s-master01 ~]# sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
    
9) 關閉dnsmasq
linux系統開啟了dnsmasq後(如 GUI 環境)，将系統DNS Server設定為 127.0.0.1，這會導緻docker容器無法解析域名，需要關閉它 (centos7系統可能預設沒有安裝這個服務)
[root@k8s-node01 ~]# systemctl stop dnsmasq
[root@k8s-node01 ~]# systemctl disable dnsmasq
    
10）加載核心子產品
[root@k8s-master01 ~]# modprobe ip_vs_rr
[root@k8s-master01 ~]# modprobe br_netfilter
    
11）優化核心參數
[root@k8s-master01 ~]# 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  #由于tcp_tw_recycle與kubernetes的NAT沖突，必須關閉！否則會導緻服務不通。
vm.swappiness=0            #禁止使用 swap 空間，隻有當系統 OOM 時才允許使用它
vm.overcommit_memory=1     #不檢查實體記憶體是否夠用
vm.panic_on_oom=0          #開啟 OOM
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  #關閉不使用的ipv6協定棧，防止觸發docker BUG.
net.netfilter.nf_conntrack_max=2310720
EOF
    
[root@k8s-master01 ~]# cp kubernetes.conf  /etc/sysctl.d/kubernetes.conf
[root@k8s-master01 ~]# sysctl -p /etc/sysctl.d/kubernetes.conf
    
這裡需要注意：
必須關閉 tcp_tw_recycle，否則和 NAT 沖突，會導緻服務不通；
關閉 IPV6，防止觸發 docker BUG；
    
12）設定系統時區
# 調整系統 TimeZone
[root@k8s-master01 ~]# timedatectl set-timezone Asia/Shanghai
    
# 将目前的 UTC 時間寫入硬體時鐘
[root@k8s-master01 ~]# timedatectl set-local-rtc 0
    
# 重新開機依賴于系統時間的服務
[root@k8s-master01 ~]# systemctl restart rsyslog
[root@k8s-master01 ~]# systemctl restart crond
    
13）設定rsyslogd 和systemd journald (每台節點機都要操作)
systemd 的 journald 是 Centos 7 預設的日志記錄工具，它記錄了所有系統、核心、Service Unit 的日志。相比 systemd，journald 記錄的日志有如下優勢：
-> 可以記錄到記憶體或檔案系統；(預設記錄到記憶體，對應的位置為 /run/log/jounal)；
-> 可以限制占用的磁盤空間、保證磁盤剩餘空間；
-> 可以限制日志檔案大小、儲存的時間；
-> journald 預設将日志轉發給 rsyslog，這會導緻日志寫了多份，/var/log/messages 中包含了太多無關日志，不友善後續檢視，同時也影響系統性能。
    
[root@k8s-master01 ~]# mkdir /var/log/journal           #持久化儲存日志的目錄
[root@k8s-master01 ~]# mkdir /etc/systemd/journald.conf.d
[root@k8s-master01 ~]# cat > /etc/systemd/journald.conf.d/99-prophet.conf <<EOF
[Journal]
# 持久化儲存到磁盤
Storage=persistent
    
# 壓縮曆史日志
Compress=yes
    
SyncIntervalSec=5m
RateLimitInterval=30s
RateLimitBurst=1000
    
# 最大占用空間 10G
SystemMaxUse=10G
    
# 單日志檔案最大 200M
SystemMaxFileSize=200M
    
# 日志儲存時間 2 周
MaxRetentionSec=2week
    
# 不将日志轉發到 syslog
ForwardToSyslog=no
EOF
    
[root@k8s-master01 ~]# systemctl restart systemd-journald
    
14) 建立k8s相關目錄 (每台節點機都要操作)
[root@k8s-master01 ~]# mkdir -p /opt/k8s/{bin,work} /etc/{kubernetes,etcd}/cert
    
15) 更新核心 (每台節點機都要操作)
CentOS 7.x系統自帶的3.10.x核心存在一些Bugs，導緻運作的Docker、Kubernetes不穩定，例如：
-> 高版本的 docker(1.13 以後) 啟用了3.10 kernel實驗支援的kernel memory account功能(無法關閉)，當節點壓力大如頻繁啟動和停止容器時會導緻 cgroup memory leak；
-> 網絡裝置引用計數洩漏，會導緻類似于報錯："kernel:unregister_netdevice: waiting for eth0 to become free. Usage count = 1";
    
解決方案如下：
-> 更新核心到 4.4.X 以上；
-> 或者，手動編譯核心，disable CONFIG_MEMCG_KMEM 特性；
-> 或者安裝修複了該問題的 Docker 18.09.1 及以上的版本。但由于 kubelet 也會設定 kmem（它 vendor 了 runc），是以需要重新編譯 kubelet 并指定 GOFLAGS="-tags=nokmem"；
    
這裡更新核心方法：
[root@k8s-master01 ~]# uname  -r
3.10.0-862.el7.x86_64
    
[root@k8s-master01 ~]# rpm -Uvh http://www.elrepo.org/elrepo-release-7.0-3.el7.elrepo.noarch.rpm
    
安裝完成後檢查 /boot/grub2/grub.cfg 中對應核心 menuentry 中是否包含 initrd16 配置，如果沒有，再安裝一次！
[root@k8s-master01 ~]# yum --enablerepo=elrepo-kernel install -y kernel-lt
    
設定開機從新核心啟動
[root@k8s-master01 ~]# grub2-set-default 0
    
重新開機機器
[root@k8s-master01 ~]# init 6
    
安裝核心源檔案（在更新完核心并重新開機機器後執行，也可以不用執行這一步。可選）:
[root@k8s-master01 ~]# yum --enablerepo=elrepo-kernel install kernel-lt-devel-$(uname -r) kernel-lt-headers-$(uname -r)
    
[root@k8s-master01 ~]# uname -r
4.4.180-2.el7.elrepo.x86_64
    
====================================================================================================================================
或者也可以采用下面更新核心的方法：
# 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"
# init 6
====================================================================================================================================
    
16) 關閉NUMA
[root@k8s-master01 ~]# cp /etc/default/grub{,.bak}
[root@k8s-master01 ~]# vim /etc/default/grub    
.........
GRUB_CMDLINE_LINUX="...... numa=off"      # 即添加"numa=0ff"内容
    
重新生成 grub2 配置檔案：
# cp /boot/grub2/grub.cfg{,.bak}
# grub2-mkconfig -o /boot/grub2/grub.cfg
  
17) 變量腳本檔案 （這一步很關鍵）
[root@k8s-master01 ~]# vim /opt/k8s/bin/environment.sh
#!/usr/bin/bash
   
# 生成 EncryptionConfig 所需的加密 key
export ENCRYPTION_KEY=$(head -c 32 /dev/urandom | base64)
   
# 叢集中所有節點機器IP數組（master,node,etcd節點）
export NODE_ALL_IPS=(172.16.60.241 172.16.60.242 172.16.60.243 172.16.60.244 172.16.60.245 172.16.60.246)
# 叢集中所有節點IP對應的主機名數組
export NODE_ALL_NAMES=(k8s-master01 k8s-master02 k8s-master03 k8s-node01 k8s-node02 k8s-node03)
  
# 叢集中所有master節點叢集IP數組
export NODE_MASTER_IPS=(172.16.60.241 172.16.60.242 172.16.60.243)
# 叢集中master節點IP對應的主機名數組
export NODE_MASTER_NAMES=(k8s-master01 k8s-master02 k8s-master03)
  
# 叢集中所有node節點叢集IP數組
export NODE_NODE_IPS=(172.16.60.244 172.16.60.245 172.16.60.246)
# 叢集中node節點IP對應的主機名數組
export NODE_NODE_NAMES=(k8s-node01 k8s-node02 k8s-node03)
  
# 叢集中所有etcd節點叢集IP數組
export NODE_ETCD_IPS=(172.16.60.241 172.16.60.242 172.16.60.243)
# 叢集中etcd節點IP對應的主機名數組(這裡是和master三節點機器共用)
export NODE_ETCD_NAMES=(k8s-etcd01 k8s-etcd02 k8s-etcd03)
  
# etcd 叢集服務位址清單
export ETCD_ENDPOINTS="https://172.16.60.241:2379,https://172.16.60.242:2379,https://172.16.60.243:2379"
   
# etcd 叢集間通信的 IP 和端口
export ETCD_NODES="k8s-etcd01=https://172.16.60.241:2380,k8s-etcd02=https://172.16.60.242:2380,k8s-etcd03=https://172.16.60.243:2380"
   
# kube-apiserver 的反向代理(位址端口.這裡也就是nginx代理層的VIP位址
export KUBE_APISERVER="https://172.16.60.250:8443"
   
# 節點間網際網路絡接口名稱. 這裡我所有的centos7節點機的網卡裝置是ens192，而不是eth0
export IFACE="ens192"
   
# 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 資料目錄
export DOCKER_DIR="/data/k8s/docker"
   
## 以下參數一般不需要修改
   
# TLS Bootstrapping 使用的 Token，可以使用指令 head -c 16 /dev/urandom | od -An -t x | tr -d ' ' 生成
BOOTSTRAP_TOKEN="41f7e4ba8b7be874fcff18bf5cf41a7c"
   
# 最好使用 目前未用的網段 來定義服務網段和 Pod 網段
   
# 服務網段，部署前路由不可達，部署後叢集内路由可達(kube-proxy 保證)
SERVICE_CIDR="10.254.0.0/16"
   
# Pod 網段，建議 /16 段位址，部署前路由不可達，部署後叢集内路由可達(flanneld 保證)
CLUSTER_CIDR="172.30.0.0/16"
   
# 服務端口範圍 (NodePort Range)
export NODE_PORT_RANGE="30000-32767"
   
# flanneld 網絡配置字首
export FLANNEL_ETCD_PREFIX="/kubernetes/network"
   
# kubernetes 服務 IP (一般是 SERVICE_CIDR 中第一個IP)
export CLUSTER_KUBERNETES_SVC_IP="10.254.0.1"
   
# 叢集 DNS 服務 IP (從 SERVICE_CIDR 中預配置設定)
export CLUSTER_DNS_SVC_IP="10.254.0.2"
   
# 叢集 DNS 域名（末尾不帶點号）
export CLUSTER_DNS_DOMAIN="cluster.local"
   
# 将二進制目錄 /opt/k8s/bin 加到 PATH 中
export PATH=/opt/k8s/bin:$PATH      

三、建立叢集中需要的CA憑證和秘鑰

為確定安全，kubernetes 系統各元件需要使用 x509 證書對通信進行加密和認證。CA (Certificate Authority) 是自簽名的根證書，用來簽名後續建立的其它證書。這裡使用 CloudFlare 的 PKI 工具集 cfssl 建立所有證書。下面部署指令均在k8s-master01節點上執行，然後遠端分發檔案和執行指令。

1）安裝cfssl工具集
[root@k8s-master01 ~]# mkdir -p /opt/k8s/work && cd /opt/k8s/work
[root@k8s-master01 work]# wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64
[root@k8s-master01 work]# mv cfssl_linux-amd64 /opt/k8s/bin/cfssl
  
[root@k8s-master01 work]# wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64
[root@k8s-master01 work]# mv cfssljson_linux-amd64 /opt/k8s/bin/cfssljson
  
[root@k8s-master01 work]# wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64
[root@k8s-master01 work]# mv cfssl-certinfo_linux-amd64 /opt/k8s/bin/cfssl-certinfo
  
[root@k8s-master01 work]# chmod +x /opt/k8s/bin/*
[root@k8s-master01 work]# export PATH=/opt/k8s/bin:$PATH
  
2）建立根證書 (CA)
CA 證書是叢集所有節點共享的，隻需要建立一個 CA 證書，後續建立的所有證書都由它簽名。
2.1）建立配置檔案
CA 配置檔案用于配置根證書的使用場景 (profile) 和具體參數 (usage，過期時間、服務端認證、用戶端認證、加密等)，後續在簽名其它證書時需要指定特定場景。
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# cat > ca-config.json <<EOF
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "kubernetes": {
        "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ],
        "expiry": "87600h"
      }
    }
  }
}
EOF
  
配置說明：
signing：表示該證書可用于簽名其它證書，生成的 ca.pem 證書中 CA=TRUE；
server auth：表示 client 可以用該該證書對 server 提供的證書進行驗證；
client auth：表示 server 可以用該該證書對 client 提供的證書進行驗證；
  
2.2）建立證書簽名請求檔案
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# cat > ca-csr.json <<EOF
{
  "CN": "kubernetes",
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "k8s",
      "OU": "4Paradigm"
    }
  ]
}
EOF
  
配置說明：
CN：Common Name，kube-apiserver 從證書中提取該字段作為請求的使用者名 (User Name)，浏覽器使用該字段驗證網站是否合法；
O：Organization，kube-apiserver 從證書中提取該字段作為請求使用者所屬的組 (Group)；
kube-apiserver 将提取的 User、Group 作為 RBAC 授權的使用者辨別；
  
2.3）生成 CA 證書和私鑰
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# cfssl gencert -initca ca-csr.json | cfssljson -bare ca
[root@k8s-master01 work]# ls ca*
ca-config.json  ca.csr  ca-csr.json  ca-key.pem  ca.pem
[root@k8s-master01 work]#
  
3）分發證書檔案
将生成的 CA 證書、秘鑰檔案、配置檔案拷貝到所有節點的 /etc/kubernetes/cert 目錄下：
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# for node_all_ip in ${NODE_ALL_IPS[@]}
  do
    echo ">>> ${node_all_ip}"
    ssh root@${node_all_ip} "mkdir -p /etc/kubernetes/cert"
    scp ca*.pem ca-config.json root@${node_all_ip}:/etc/kubernetes/cert
  done
      

四、部署kubectl指令行工具

kubectl 是 kubernetes 叢集的指令行管理工具. kubectl 預設從 ~/.kube/config 檔案讀取kube-apiserver位址和認證資訊，如果沒有配置，執行kubectl指令時就會報錯！kubectl隻需要部署一次，生成的kubeconfig檔案是通用的，可以拷貝到需要執行kubectl指令的節點機器，重命名為 ~/.kube/config；這裡我将kubectl節點隻部署到三個master節點機器上，其他節點不部署kubectl指令。也就是說後續進行kubectl指令管理就隻能在master節點上操作。下面部署指令均在k8s-master01節點上執行，然後遠端分發檔案和執行指令。

如果沒有部署kubectl工具，則執行時會報錯說沒有該指令：
[root@k8s-master01 ~]# kubectl get pods
-bash: kubectl: command not found
 
1）下載下傳和分發kubectl二進制檔案
二進制包下載下傳位址：https://pan.baidu.com/s/1HUWFqKVLyxIzoX2LDQSEBg
提取密碼：7kaf
[root@k8s-master01 ~]# cd /opt/k8s/work
[root@k8s-master01 work]# wget https://dl.k8s.io/v1.14.2/kubernetes-client-linux-amd64.tar.gz
[root@k8s-master01 work]# tar -xzvf kubernetes-client-linux-amd64.tar.gz
 
分發到所有使用kubectl的節點，這裡隻分發到三個master節點
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# for node_master_ip in ${NODE_MASTER_IPS[@]}
do
  echo ">>> ${node_master_ip}"
  scp kubernetes/client/bin/kubectl root@${node_master_ip}:/opt/k8s/bin/
  ssh root@${node_master_ip} "chmod +x /opt/k8s/bin/*"
done
 
2) 建立admin證書和私鑰
kubectl與apiserver https安全端口通信，apiserver 對提供的證書進行認證和授權。
kubectl作為叢集的管理工具，需要被授予最高權限，這裡建立具有最高權限的 admin 證書。
建立證書簽名請求：
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 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": "4Paradigm"
    }
  ]
}
EOF
 
配置說明：
O為system:masters，kube-apiserver 收到該證書後将請求的 Group 設定為 system:masters；
預定義的 ClusterRoleBinding cluster-admin 将Group system:masters 與 Role cluster-admin 綁定，該 Role 授予所有 API的權限；
該證書隻會被kubectl當做client證書使用，是以hosts字段為空；
 
生成證書和私鑰：
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 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
 
[root@k8s-master01 work]# ls admin*
admin.csr  admin-csr.json  admin-key.pem  admin.pem
 
3）建立 kubeconfig 檔案
kubeconfig 為 kubectl 的配置檔案，包含通路 apiserver 的所有資訊，如 apiserver 位址、CA 證書和自身使用的證書；
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
 
設定叢集參數
[root@k8s-master01 work]# kubectl config set-cluster kubernetes \
  --certificate-authority=/opt/k8s/work/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=kubectl.kubeconfig
 
設定用戶端認證參數
[root@k8s-master01 work]# 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
 
設定上下文參數
[root@k8s-master01 work]# kubectl config set-context kubernetes \
  --cluster=kubernetes \
  --user=admin \
  --kubeconfig=kubectl.kubeconfig
 
設定預設上下文
[root@k8s-master01 work]# kubectl config use-context kubernetes --kubeconfig=kubectl.kubeconfig
 
配置說明：
--certificate-authority：驗證 kube-apiserver 證書的根證書；
--client-certificate、--client-key：剛生成的 admin 證書和私鑰，連接配接 kube-apiserver 時使用；
--embed-certs=true：将 ca.pem 和 admin.pem 證書内容嵌入到生成的 kubectl.kubeconfig 檔案中(不加時，寫入的是證書檔案路徑，
後續拷貝 kubeconfig 到其它機器時，還需要單獨拷貝證書檔案，這就很不友善了)
 
4）分發 kubeconfig 檔案, 儲存的檔案名為 ~/.kube/config；
分發到所有使用 kubectl 指令的節點，即分發到三個master節點上
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# for node_master_ip in ${NODE_MASTER_IPS[@]}
do
  echo ">>> ${node_master_ip}"
  ssh root@${node_master_ip} "mkdir -p ~/.kube"
  scp kubectl.kubeconfig root@${node_master_ip}:~/.kube/config
done
      

五、部署etcd叢集

etcd是基于Raft的分布式key-value存儲系統，由CoreOS開發，常用于服務發現、共享配置以及并發控制（如leader選舉、分布式鎖等）。kubernetes使用etcd存儲所有運作資料。需要注意的是：由于etcd是負責存儲，是以不建議搭建單點叢集，如zookeeper一樣，由于存在選舉政策，是以一般推薦奇數個叢集，如3，5，7。隻要叢集半數以上的結點存活，那麼叢集就可以正常運作，否則叢集可能無法正常使用。下面部署指令均在k8s-master01節點上執行，然後遠端分發檔案和執行指令。

1）下載下傳和分發etcd二進制檔案
[root@k8s-master01 ~]# cd /opt/k8s/work
[root@k8s-master01 work]# wget https://github.com/coreos/etcd/releases/download/v3.3.13/etcd-v3.3.13-linux-amd64.tar.gz
[root@k8s-master01 work]# tar -xvf etcd-v3.3.13-linux-amd64.tar.gz
  
分發二進制檔案到etcd叢集所有節點：
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# for node_etcd_ip in ${NODE_ETCD_IPS[@]}
  do
    echo ">>> ${node_etcd_ip}"
    scp etcd-v3.3.13-linux-amd64/etcd* root@${node_etcd_ip}:/opt/k8s/bin
    ssh root@${node_etcd_ip} "chmod +x /opt/k8s/bin/*"
  done
  
2) 建立etcd證書和私鑰
建立證書簽名請求：
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# cat > etcd-csr.json <<EOF
{
  "CN": "etcd",
  "hosts": [
    "127.0.0.1",
    "172.16.60.241",
    "172.16.60.242",
    "172.16.60.243"
  ],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "k8s",
      "OU": "4Paradigm"
    }
  ]
}
EOF
  
配置說明：
hosts 字段指定授權使用該證書的 etcd 節點 IP 或域名清單，需要将 etcd 叢集的三個節點 IP 都列在其中；
  
生成證書和私鑰
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 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
  
[root@k8s-master01 work]# ls etcd*pem
etcd-key.pem  etcd.pem
  
分發生成的證書和私鑰到各etcd節點
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# for node_etcd_ip in ${NODE_ETCD_IPS[@]}
  do
    echo ">>> ${node_etcd_ip}"
    ssh root@${node_etcd_ip} "mkdir -p /etc/etcd/cert"
    scp etcd*.pem root@${node_etcd_ip}:/etc/etcd/cert/
  done
  
3) 建立etcd的systemd unit模闆檔案
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# 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_ETCD_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_ETCD_IP##:2380 \\
  --initial-advertise-peer-urls=https://##NODE_ETCD_IP##:2380 \\
  --listen-client-urls=https://##NODE_ETCD_IP##:2379,http://127.0.0.1:2379 \\
  --advertise-client-urls=https://##NODE_ETCD_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 證書；
  
4）為各etcd節點建立和分發 etcd systemd unit 檔案
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# for (( i=0; i < 3; i++ ))
  do
    sed -e "s/##NODE_ETCD_NAME##/${NODE_ETCD_NAMES[i]}/" -e "s/##NODE_ETCD_IP##/${NODE_ETCD_IPS[i]}/" etcd.service.template > etcd-${NODE_ETCD_IPS[i]}.service
  done
  
[root@k8s-master01 work]# ls *.service                 
etcd-172.16.60.241.service  etcd-172.16.60.242.service  etcd-172.16.60.243.service
  
最好手動檢視其中一個etcd節點的啟動檔案裡的--name名稱和ip是否都已修改過來了
[root@k8s-master01 work]# cat etcd-172.16.60.241.service
.......
--name=k8s-etcd01 \
.......
  --listen-peer-urls=https://172.16.60.241:2380 \
  --initial-advertise-peer-urls=https://172.16.60.241:2380 \
  --listen-client-urls=https://172.16.60.241:2379,http://127.0.0.1:2379 \
  --advertise-client-urls=https://172.16.60.241:2379 \
  --initial-cluster-token=etcd-cluster-0 \
  --initial-cluster=k8s-etcd01=https://172.16.60.241:2380,k8s-etcd02=https://172.16.60.242:2380,k8s-etcd03=https://172.16.60.243:2380 \
.......
  
配置說明：
NODE_ETCD_NAMES 和 NODE_ETCD_IPS 為相同長度的bash數組，分别為etcd叢集節點名稱和對應的IP；
  
分發生成的 systemd unit 檔案：
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# for node_etcd_ip in ${NODE_ETCD_IPS[@]}
  do
    echo ">>> ${node_etcd_ip}"
    scp etcd-${node_etcd_ip}.service root@${node_etcd_ip}:/etc/systemd/system/etcd.service
  done
  
配置說明： 檔案重命名為 etcd.service;
  
5）啟動 etcd 服務
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# for node_etcd_ip in ${NODE_ETCD_IPS[@]}
  do
    echo ">>> ${node_etcd_ip}"
    ssh root@${node_etcd_ip} "mkdir -p ${ETCD_DATA_DIR} ${ETCD_WAL_DIR}"
    ssh root@${node_etcd_ip} "systemctl daemon-reload && systemctl enable etcd && systemctl restart etcd " &
  done
  
配置說明：
必須先建立 etcd 資料目錄和工作目錄;
etcd 程序首次啟動時會等待其它節點的 etcd 加入叢集，指令 systemctl start etcd 會卡住一段時間，為正常現象；
  
6）檢查etcd服務啟動結果
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# for node_etcd_ip in ${NODE_ETCD_IPS[@]}
  do
    echo ">>> ${node_etcd_ip}"
    ssh root@${node_etcd_ip} "systemctl status etcd|grep Active"
  done
  
預期輸出結果為：
>>> 172.16.60.241
   Active: active (running) since Tue 2019-06-04 19:55:32 CST; 7min ago
>>> 172.16.60.242
   Active: active (running) since Tue 2019-06-04 19:55:32 CST; 7min ago
>>> 172.16.60.243
   Active: active (running) since Tue 2019-06-04 19:55:32 CST; 7min ago
  
確定狀态均為為active (running)，否則檢視日志，确認原因 (可以執行"journalctl -u etcd"指令檢視啟動失敗原因）
  
6）驗證服務狀态
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# for node_etcd_ip in ${NODE_ETCD_IPS[@]}
  do
    echo ">>> ${node_etcd_ip}"
    ssh root@${node_etcd_ip} "
    ETCDCTL_API=3 /opt/k8s/bin/etcdctl \
    --endpoints=https://${node_etcd_ip}:2379 \
    --cacert=/etc/kubernetes/cert/ca.pem \
    --cert=/etc/etcd/cert/etcd.pem \
    --key=/etc/etcd/cert/etcd-key.pem endpoint health "
  done
  
預期輸出結果為：
https://172.16.60.241:2379 is healthy: successfully committed proposal: took = 2.44394ms
>>> 172.16.60.242
https://172.16.60.242:2379 is healthy: successfully committed proposal: took = 7.044349ms
>>> 172.16.60.243
https://172.16.60.243:2379 is healthy: successfully committed proposal: took = 1.865713ms
  
輸出均為 healthy 時表示叢集服務正常。
  
7）檢視目前etcd叢集中的leader
在三台etcd節點中的任意一個節點機器上執行下面指令：
[root@k8s-etcd03 ~]# source /opt/k8s/bin/environment.sh
[root@k8s-etcd03 ~]# ETCDCTL_API=3 /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
  
預期輸出結果為：
+----------------------------+------------------+---------+---------+-----------+-----------+------------+
|          ENDPOINT          |        ID        | VERSION | DB SIZE | IS LEADER | RAFT TERM | RAFT INDEX |
+----------------------------+------------------+---------+---------+-----------+-----------+------------+
| https://172.16.60.241:2379 | 577381f5de0f4495 |  3.3.13 |   16 kB |     false |         2 |          8 |
| https://172.16.60.242:2379 | bf4ce221cdf39fb0 |  3.3.13 |   16 kB |     false |         2 |          8 |
| https://172.16.60.243:2379 |  3bc2e49bc639590 |  3.3.13 |   16 kB |      true |         2 |          8 |
+----------------------------+------------------+---------+---------+-----------+-----------+------------+
  
由上面結果可見，目前的leader節點為172.16.60.243
      

六、Flannel容器網絡方案部署

kubernetes要求叢集内各節點(這裡指master和node節點)能通過Pod網段互聯互通。flannel使用vxlan技術為各節點建立一個可以互通的Pod網絡，使用的端口為UDP 8472（需要開放該端口，如公有雲AWS等）。flanneld第一次啟動時，從etcd擷取配置的Pod網段資訊，為本節點配置設定一個未使用的位址段，然後建立flannedl.1網絡接口（也可能是其它名稱，如flannel1等）。flannel将配置設定給自己的Pod網段資訊寫入/run/flannel/docker檔案，docker後續使用這個檔案中的環境變量設定docker0網橋，進而從這個位址段為本節點的所有Pod容器配置設定IP。下面部署指令均在k8s-master01節點上執行，然後遠端分發檔案和執行指令。

1) 下載下傳和分發 flanneld 二進制檔案
從flannel的release頁面(https://github.com/coreos/flannel/releases)下載下傳最新版本的安裝包：
[root@k8s-master01 ~]# cd /opt/k8s/work
[root@k8s-master01 work]# mkdir flannel
[root@k8s-master01 work]# wget https://github.com/coreos/flannel/releases/download/v0.11.0/flannel-v0.11.0-linux-amd64.tar.gz
[root@k8s-master01 work]# tar -zvxf flannel-v0.11.0-linux-amd64.tar.gz -C flannel

分發二進制檔案到叢集所有節點：
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# for node_all_ip in ${NODE_ALL_IPS[@]}
  do
    echo ">>> ${node_all_ip}"
    scp flannel/{flanneld,mk-docker-opts.sh} root@${node_all_ip}:/opt/k8s/bin/
    ssh root@${node_all_ip} "chmod +x /opt/k8s/bin/*"
  done

2) 建立 flannel 證書和私鑰
flanneld 從 etcd 叢集存取網段配置設定資訊，而 etcd 叢集啟用了雙向 x509 證書認證，是以需要為 flanneld 生成證書和私鑰。
建立證書簽名請求：
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# cat > flanneld-csr.json <<EOF
{
  "CN": "flanneld",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "k8s",
      "OU": "4Paradigm"
    }
  ]
}
EOF

該證書隻會被 kubectl 當做 client 證書使用，是以 hosts 字段為空；

生成證書和私鑰：
[root@k8s-master01 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 flanneld-csr.json | cfssljson -bare flanneld

将生成的證書和私鑰分發到所有節點（master 和 node）：
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# for node_all_ip in ${NODE_ALL_IPS[@]}
  do
    echo ">>> ${node_all_ip}"
    ssh root@${node_all_ip} "mkdir -p /etc/flanneld/cert"
    scp flanneld*.pem root@${node_all_ip}:/etc/flanneld/cert
  done

3）向 etcd 寫入叢集 Pod 網段資訊 （注意：本步驟隻需執行一次）
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# etcdctl \
  --endpoints=${ETCD_ENDPOINTS} \
  --ca-file=/opt/k8s/work/ca.pem \
  --cert-file=/opt/k8s/work/flanneld.pem \
  --key-file=/opt/k8s/work/flanneld-key.pem \
  mk ${FLANNEL_ETCD_PREFIX}/config '{"Network":"'${CLUSTER_CIDR}'", "SubnetLen": 21, "Backend": {"Type": "vxlan"}}'

解決說明：
flanneld 目前版本 (v0.11.0) 不支援 etcd v3，故使用 etcd v2 API 寫入配置 key 和網段資料；
寫入的 Pod 網段 ${CLUSTER_CIDR} 位址段（如 /16）必須小于 SubnetLen，必須與 kube-controller-manager 的 --cluster-cidr 參數值一緻；

4）建立 flanneld 的 systemd unit 檔案
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# cat > flanneld.service << EOF
[Unit]
Description=Flanneld overlay address etcd agent
After=network.target
After=network-online.target
Wants=network-online.target
After=etcd.service
Before=docker.service

[Service]
Type=notify
ExecStart=/opt/k8s/bin/flanneld \\
  -etcd-cafile=/etc/kubernetes/cert/ca.pem \\
  -etcd-certfile=/etc/flanneld/cert/flanneld.pem \\
  -etcd-keyfile=/etc/flanneld/cert/flanneld-key.pem \\
  -etcd-endpoints=${ETCD_ENDPOINTS} \\
  -etcd-prefix=${FLANNEL_ETCD_PREFIX} \\
  -iface=${IFACE} \\
  -ip-masq
ExecStartPost=/opt/k8s/bin/mk-docker-opts.sh -k DOCKER_NETWORK_OPTIONS -d /run/flannel/docker
Restart=always
RestartSec=5
StartLimitInterval=0

[Install]
WantedBy=multi-user.target
RequiredBy=docker.service
EOF

解決說明：
mk-docker-opts.sh 腳本将配置設定給 flanneld 的 Pod 子網段資訊寫入 /run/flannel/docker 檔案，後續 docker 啟動時使用這個檔案中的環境變量配置 docker0 網橋；
flanneld 使用系統預設路由所在的接口與其它節點通信，對于有多個網絡接口（如内網和公網）的節點，可以用 -iface 參數指定通信接口;
flanneld 運作時需要 root 權限；
-ip-masq: flanneld 為通路 Pod 網絡外的流量設定 SNAT 規則，同時将傳遞給 Docker 的變量 --ip-masq（/run/flannel/docker 檔案中）設定為 false，這樣 Docker 将不再建立 SNAT 規則； Docker 的 --ip-masq 為 true 時，建立的 SNAT 規則比較“暴力”：将所有本節點 Pod 發起的、通路非 docker0 接口的請求做 SNAT，這樣通路其他節點 Pod 的請求來源 IP 會被設定為 flannel.1 接口的 IP，導緻目的 Pod 看不到真實的來源 Pod IP。 flanneld 建立的 SNAT 規則比較溫和，隻對通路非 Pod 網段的請求做 SNAT。

5）分發 flanneld systemd unit 檔案到所有節點
[root@k8s-master01 work]# cd /opt/k8s/work
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# for node_all_ip in ${NODE_ALL_IPS[@]}
  do
    echo ">>> ${node_all_ip}"
    scp flanneld.service root@${node_all_ip}:/etc/systemd/system/
  done

6）啟動 flanneld 服務
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# for node_all_ip in ${NODE_ALL_IPS[@]}
  do
    echo ">>> ${node_all_ip}"
    ssh root@${node_all_ip} "systemctl daemon-reload && systemctl enable flanneld && systemctl restart flanneld"
  done

6）檢查啟動結果
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# for node_all_ip in ${NODE_ALL_IPS[@]}
  do
    echo ">>> ${node_all_ip}"
    ssh root@${node_all_ip} "systemctl status flanneld|grep Active"
  done

確定狀态為 active (running)，否則檢視日志，确認原因"journalctl -u flanneld"

7) 檢查配置設定給各 flanneld 的 Pod 網段資訊
檢視叢集 Pod 網段(/16)：
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# etcdctl \
  --endpoints=${ETCD_ENDPOINTS} \
  --ca-file=/etc/kubernetes/cert/ca.pem \
  --cert-file=/etc/flanneld/cert/flanneld.pem \
  --key-file=/etc/flanneld/cert/flanneld-key.pem \
  get ${FLANNEL_ETCD_PREFIX}/config

預期輸出： {"Network":"172.30.0.0/16", "SubnetLen": 21, "Backend": {"Type": "vxlan"}}

檢視已配置設定的 Pod 子網段清單(/24):
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# etcdctl \
  --endpoints=${ETCD_ENDPOINTS} \
  --ca-file=/etc/kubernetes/cert/ca.pem \
  --cert-file=/etc/flanneld/cert/flanneld.pem \
  --key-file=/etc/flanneld/cert/flanneld-key.pem \
  ls ${FLANNEL_ETCD_PREFIX}/subnets

預期輸出：
/kubernetes/network/subnets/172.30.40.0-21
/kubernetes/network/subnets/172.30.88.0-21
/kubernetes/network/subnets/172.30.56.0-21
/kubernetes/network/subnets/172.30.72.0-21
/kubernetes/network/subnets/172.30.232.0-21
/kubernetes/network/subnets/172.30.152.0-21

檢視某一 Pod 網段對應的節點 IP 和 flannel 接口位址:
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# etcdctl \
  --endpoints=${ETCD_ENDPOINTS} \
  --ca-file=/etc/kubernetes/cert/ca.pem \
  --cert-file=/etc/flanneld/cert/flanneld.pem \
  --key-file=/etc/flanneld/cert/flanneld-key.pem \
  get ${FLANNEL_ETCD_PREFIX}/subnets/172.30.40.0-21

預期輸出：{"PublicIP":"172.16.60.243","BackendType":"vxlan","BackendData":{"VtepMAC":"f2:de:47:06:4b:d3"}}

解決說明：
172.30.40.0/21 被配置設定給節點k8s-master03（172.16.60.243）；
VtepMAC 為k8s-master03節點的 flannel.1 網卡 MAC 位址；

8）檢查節點 flannel 網絡資訊 （比如k8s-master01節點）
[root@k8s-master01 work]# ip addr show
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
2: ens192: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
    link/ether 00:50:56:ac:7c:81 brd ff:ff:ff:ff:ff:ff
    inet 172.16.60.241/24 brd 172.16.60.255 scope global ens192
       valid_lft forever preferred_lft forever
3: flannel.1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1450 qdisc noqueue state UNKNOWN group default 
    link/ether 7a:2a:36:99:75:5f brd ff:ff:ff:ff:ff:ff
    inet 172.30.232.0/32 scope global flannel.1
       valid_lft forever preferred_lft forever

注意： flannel.1 網卡的位址為配置設定的 Pod 子網段的第一個 IP（.0），且是 /32 的位址；

[root@k8s-master01 work]# ip route show |grep flannel.1
172.30.40.0/21 via 172.30.40.0 dev flannel.1 onlink 
172.30.56.0/21 via 172.30.56.0 dev flannel.1 onlink 
172.30.72.0/21 via 172.30.72.0 dev flannel.1 onlink 
172.30.88.0/21 via 172.30.88.0 dev flannel.1 onlink 
172.30.152.0/21 via 172.30.152.0 dev flannel.1 onlink 

到其它節點 Pod 網段請求都被轉發到 flannel.1 網卡；
flanneld 根據 etcd 中子網段的資訊，如 ${FLANNEL_ETCD_PREFIX}/subnets/172.30.232.0-21 ，來決定進請求發送給哪個節點的互聯 IP；

9）驗證各節點能通過 Pod 網段互通
在各節點上部署 flannel 後，檢查是否建立了 flannel 接口(名稱可能為 flannel0、flannel.0、flannel.1 等)：
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# for node_all_ip in ${NODE_ALL_IPS[@]}
  do
    echo ">>> ${node_all_ip}"
    ssh ${node_all_ip} "/usr/sbin/ip addr show flannel.1|grep -w inet"
  done

預期輸出：
>>> 172.16.60.241
    inet 172.30.232.0/32 scope global flannel.1
>>> 172.16.60.242
    inet 172.30.152.0/32 scope global flannel.1
>>> 172.16.60.243
    inet 172.30.40.0/32 scope global flannel.1
>>> 172.16.60.244
    inet 172.30.88.0/32 scope global flannel.1
>>> 172.16.60.245
    inet 172.30.56.0/32 scope global flannel.1
>>> 172.16.60.246
    inet 172.30.72.0/32 scope global flannel.1

在各節點上 ping 所有 flannel 接口 IP，確定能通：
[root@k8s-master01 work]# source /opt/k8s/bin/environment.sh
[root@k8s-master01 work]# for node_all_ip in ${NODE_ALL_IPS[@]}
  do
    echo ">>> ${node_all_ip}"
    ssh ${node_all_ip} "ping -c 1 172.30.232.0"
    ssh ${node_all_ip} "ping -c 1 172.30.152.0"
    ssh ${node_all_ip} "ping -c 1 172.30.40.0"
    ssh ${node_all_ip} "ping -c 1 172.30.88.0"
    ssh ${node_all_ip} "ping -c 1 172.30.56.0"
    ssh ${node_all_ip} "ping -c 1 172.30.72.0"
  done
      

七、基于nginx 四層代理環境

這裡采用nginx 4 層透明代理功能實作 K8S 節點( master 節點和 worker 節點)高可用通路 kube-apiserver。控制節點的 kube-controller-manager、kube-scheduler 是多執行個體(3個)部署，是以隻要有一個執行個體正常，就可以保證高可用；搭建nginx+keepalived環境，對外提供一個統一的vip位址，後端對接多個 apiserver 執行個體，nginx 對它們做健康檢查和負載均衡；kubelet、kube-proxy、controller-manager、scheduler 通過vip位址通路 kube-apiserver，進而實作 kube-apiserver 的高可用；

一、安裝和配置nginx，下面操作在172.16.60.247、172.16.60.247兩個節點機器上操作

1）下載下傳和編譯 nginx 
[root@k8s-ha01 ~]# yum -y install gcc pcre-devel zlib-devel openssl-devel wget lsof
[root@k8s-ha01 ~]# cd /opt/k8s/work
[root@k8s-ha01 work]# wget http://nginx.org/download/nginx-1.15.3.tar.gz
[root@k8s-ha01 work]# tar -xzvf nginx-1.15.3.tar.gz
[root@k8s-ha01 work]# cd nginx-1.15.3
[root@k8s-ha01 nginx-1.15.3]# mkdir nginx-prefix
[root@k8s-ha01 nginx-1.15.3]# ./configure --with-stream --without-http --prefix=$(pwd)/nginx-prefix --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: "/root/tmp/nginx-1.15.3/nginx-prefix"
  nginx binary file: "/root/tmp/nginx-1.15.3/nginx-prefix/sbin/nginx"
  nginx modules path: "/root/tmp/nginx-1.15.3/nginx-prefix/modules"
  nginx configuration prefix: "/root/tmp/nginx-1.15.3/nginx-prefix/conf"
  nginx configuration file: "/root/tmp/nginx-1.15.3/nginx-prefix/conf/nginx.conf"
  nginx pid file: "/root/tmp/nginx-1.15.3/nginx-prefix/logs/nginx.pid"
  nginx error log file: "/root/tmp/nginx-1.15.3/nginx-prefix/logs/error.log"
  nginx http access log file: "/root/tmp/nginx-1.15.3/nginx-prefix/logs/access.log"
  nginx http client request body temporary files: "client_body_temp"
  nginx http proxy temporary files: "proxy_temp"

繼續編譯和安裝：
[root@k8s-ha01 nginx-1.15.3]# make && make install

2）驗證編譯的 nginx
[root@k8s-ha01 nginx-1.15.3]# ./nginx-prefix/sbin/nginx -v
nginx version: nginx/1.15.3

檢視 nginx 動态連結的庫：
[root@k8s-ha01 nginx-1.15.3]# ldd ./nginx-prefix/sbin/nginx
        linux-vdso.so.1 =>  (0x00007ffc7e0ef000)
        libdl.so.2 => /lib64/libdl.so.2 (0x00007f00b5c2d000)
        libpthread.so.0 => /lib64/libpthread.so.0 (0x00007f00b5a11000)
        libc.so.6 => /lib64/libc.so.6 (0x00007f00b5644000)
        /lib64/ld-linux-x86-64.so.2 (0x00007f00b5e31000)

由于隻開啟了 4 層透明轉發功能，是以除了依賴 libc 等作業系統核心 lib 庫外，沒有對其它 lib 的依賴(如 libz、libssl 等)，這樣可以友善部署到各版本作業系統中；

3）安裝和部署 nginx
[root@k8s-ha01 ~]# cp /opt/k8s/work/nginx-1.15.3/nginx-prefix/sbin/nginx /opt/k8s/kube-nginx/sbin/kube-nginx
[root@k8s-ha01 ~]# chmod a+x /opt/k8s/kube-nginx/sbin/*
[root@k8s-ha01 ~]# mkdir -p /opt/k8s/kube-nginx/{conf,logs,sbin}

配置 nginx，開啟 4 層透明轉發功能：
[root@k8s-ha01 ~]# vim /opt/k8s/kube-nginx/conf/kube-nginx.conf
worker_processes 2;

events {
    worker_connections  65525;
}

stream {
    upstream backend {
        hash $remote_addr consistent;
        server 172.16.60.241:6443        max_fails=3 fail_timeout=30s;
        server 172.16.60.242:6443        max_fails=3 fail_timeout=30s;
        server 172.16.60.243:6443        max_fails=3 fail_timeout=30s;
    }

    server {
        listen 8443;
        proxy_connect_timeout 1s;
        proxy_pass backend;
    }
}

[root@k8s-ha01 ~]# ulimit -n 65525
[root@k8s-ha01 ~]# vim /etc/security/limits.conf     # 檔案底部添加下面四行内容
* soft nofile 65525
* hard nofile 65525
* soft nproc 65525
* hard nproc 65525

4) 配置 systemd unit 檔案，啟動服務
[root@k8s-ha01 ~]# vim /etc/systemd/system/kube-nginx.service 
[Unit]
Description=kube-apiserver nginx proxy
After=network.target
After=network-online.target
Wants=network-online.target

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

[Install]
WantedBy=multi-user.target

[root@k8s-ha01 ~]# systemctl daemon-reload && systemctl enable kube-nginx && systemctl restart kube-nginx
[root@k8s-ha01 ~]# lsof -i:8443
COMMAND     PID   USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
kube-ngin 31980   root    5u  IPv4 145789      0t0  TCP localhost:pcsync-https (LISTEN)
kube-ngin 31981 nobody    5u  IPv4 145789      0t0  TCP localhost:pcsync-https (LISTEN)
kube-ngin 31982 nobody    5u  IPv4 145789      0t0  TCP localhost:pcsync-https (LISTEN)

測試下8443代理端口連通性
[root@k8s-ha01 ~]# telnet 172.16.60.250 8443
Trying 172.16.60.250...
Connected to 172.16.60.250.
Escape character is '^]'.
Connection closed by foreign host.

這是因為三個kube-apiserver服務還沒有部署，即後端三個apiserver執行個體的6443端口還沒有起來。

二、安裝和配置keepalived 
1）編譯安裝keepalived （兩個節點上同樣操作）
[root@k8s-ha01 ~]# cd /opt/k8s/work/
[root@k8s-ha01 work]# wget https://www.keepalived.org/software/keepalived-2.0.16.tar.gz
[root@k8s-ha01 work]# tar -zvxf keepalived-2.0.16.tar.gz 
[root@k8s-ha01 work]# cd keepalived-2.0.16
[root@k8s-ha01 keepalived-2.0.16]# ./configure 
[root@k8s-ha01 keepalived-2.0.16]# make && make install

[root@k8s-ha01 keepalived-2.0.16]# cp keepalived/etc/init.d/keepalived /etc/rc.d/init.d/
[root@k8s-ha01 keepalived-2.0.16]# cp /usr/local/etc/sysconfig/keepalived /etc/sysconfig/
[root@k8s-ha01 keepalived-2.0.16]# mkdir /etc/keepalived
[root@k8s-ha01 keepalived-2.0.16]# cp /usr/local/etc/keepalived/keepalived.conf /etc/keepalived/
[root@k8s-ha01 keepalived-2.0.16]# cp /usr/local/sbin/keepalived /usr/sbin/
[root@k8s-ha01 keepalived-2.0.16]# echo "/etc/init.d/keepalived start" >> /etc/rc.local

2) 配置keepalived
172.16.60.207節點上的keepalived配置内容
[root@k8s-ha01 ~]# cp /etc/keepalived/keepalived.conf /etc/keepalived/keepalived.conf.bak
[root@k8s-ha01 ~]# >/etc/keepalived/keepalived.conf
[root@k8s-ha01 ~]# vim /etc/keepalived/keepalived.conf
! Configuration File for keepalived     
  
global_defs {
notification_email {     
[email protected]  
[email protected]
}
  
notification_email_from [email protected]  
smtp_server 127.0.0.1      
smtp_connect_timeout 30    
router_id master-node     
}
  
vrrp_script chk_http_port {      
    script "/opt/chk_nginx.sh"  
    interval 2                   
    weight -5                   
    fall 2               
    rise 1                  
}
  
vrrp_instance VI_1 {    
    state MASTER    
    interface ens192      
    mcast_src_ip 172.16.60.247
    virtual_router_id 51         
    priority 101                
    advert_int 1                 
    authentication {            
        auth_type PASS          
        auth_pass 1111          
    }
    virtual_ipaddress {        
        172.16.60.250
    }
 
track_script {                      
   chk_http_port                    
}
}

另一個節點172.16.60.248上的keepalived配置内容為：
[root@k8s-ha02 ~]# cp /etc/keepalived/keepalived.conf /etc/keepalived/keepalived.conf.bak
[root@k8s-ha02 ~]# >/etc/keepalived/keepalived.conf
[root@k8s-ha02 ~]# vim /etc/keepalived/keepalived.conf
! Configuration File for keepalived     
  
global_defs {
notification_email {     
[email protected]  
[email protected]
}
  
notification_email_from [email protected]  
smtp_server 127.0.0.1      
smtp_connect_timeout 30    
router_id slave-node     
}
  
vrrp_script chk_http_port {      
    script "/opt/chk_nginx.sh"  
    interval 2                   
    weight -5                   
    fall 2               
    rise 1                  
}
  
vrrp_instance VI_1 {    
    state MASTER    
    interface ens192      
    mcast_src_ip 172.16.60.248
    virtual_router_id 51         
    priority 99               
    advert_int 1                 
    authentication {            
        auth_type PASS          
        auth_pass 1111          
    }
    virtual_ipaddress {        
        172.16.60.250
    }
 
track_script {                      
   chk_http_port                    
}
}

2) 配置兩個節點的nginx監控腳本（該腳本會在keepalived.conf配置中被引用）
[root@k8s-ha01 ~]# vim /opt/chk_nginx.sh
#!/bin/bash
counter=$(ps -ef|grep -w kube-nginx|grep -v grep|wc -l)
if [ "${counter}" = "0" ]; then
    systemctl start kube-nginx
    sleep 2
    counter=$(ps -ef|grep kube-nginx|grep -v grep|wc -l)
    if [ "${counter}" = "0" ]; then
        /etc/init.d/keepalived stop
    fi
fi

[root@k8s-ha01 ~]# chmod 755 /opt/chk_nginx.sh

3) 啟動兩個節點的keepalived服務
[root@k8s-ha01 ~]# /etc/init.d/keepalived start
Starting keepalived (via systemctl):                       [  OK  ]

[root@k8s-ha01 ~]# ps -ef|grep keepalived
root      5358     1  0 00:32 ?        00:00:00 /usr/local/sbin/keepalived -D
root      5359  5358  0 00:32 ?        00:00:00 /usr/local/sbin/keepalived -D
root      5391 29606  0 00:32 pts/0    00:00:00 grep --color=auto keepalived

檢視vip情況. 發現vip預設起初會在master節點上
[root@k8s-ha01 ~]# ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
2: ens192: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
    link/ether 00:50:56:ac:3a:a6 brd ff:ff:ff:ff:ff:ff
    inet 172.16.60.247/24 brd 172.16.60.255 scope global ens192
       valid_lft forever preferred_lft forever
    inet 172.16.60.250/32 scope global ens192
       valid_lft forever preferred_lft forever
    inet6 fe80::250:56ff:feac:3aa6/64 scope link 
       valid_lft forever preferred_lft forever

4) 測試vip故障轉移
參考：https://www.cnblogs.com/kevingrace/p/6138185.html

當master節點的keepalived服務挂掉，vip會自動漂移到slave節點上
當master節點的keepliaved服務恢複後，從将vip資源從slave節點重新搶占回來（keepalived配置檔案中的priority優先級決定的）
當兩個節點的nginx挂掉後，keepaived會引用nginx監控腳本自啟動nginx服務，如啟動失敗，則強殺keepalived服務，進而實作vip轉移。      

*************** 當你發現自己的才華撐不起野心時，就請安靜下來學習吧！***************