Kubernetes部署通用手冊 (支持版本1.19,1.18,1.17,1.16)

2020 年 7 月 12 日
筆記
Kubernetes

操作環境

rbac 劃分（HA高可用雙master部署實例）

本文穿插了ha 高可用部署的實例，當前章節設計的是ha部署雙master 部署

內網ip	角色	安裝軟件
192.168.0.10	master01	etcd,kube-apiserver,kube-controller-manager,kube-scheduler
192.168.0.12	master02	etcd,kube-apiserver,kube-controller-manager,kube-scheduler
192.168.0.7	node01	docker,kubelet,kube-proxy,flannel
192.168.0.8	node02	docker,kubelet,kube-proxy,flannel
192.168.0.4	slb master	etcd，nginx
192.168.0.9
192.168.0.200	keepalived上的VIP

注意

flannel可以只安裝node上，flannel只是跨機器宿主機和容器通訊使用
docker可以只安裝node上，master上可以不安裝
etcd 鍵值對的數據庫，是獨立三台機器。不要復用。
192.168.0.200是keepalived上的vip

自簽SSL證書

k8s安裝包下載

//github.com/kubernetes

部署網絡說明

Kubernetes 網絡架構圖

Overlay Network：覆蓋網絡，在基礎網絡上疊加的一種虛擬網絡技術模式，該網絡中的主機通過虛擬鏈路連接起來。

VXLAN：將源數據包封裝到UDP中，並使用基礎網絡的IP/MAC作為外層報文頭進行封裝，然後在以太網上傳輸，到達目的地後由隧道端點解封裝並將數據發送給目標地址。

Flannel：是Overlay網絡的一種，也是將源數據包封裝在另一種網絡包裏面進行路由轉發和通信，目前已經支持UDP、VXLAN、AWS VPC和GCE路由等數據轉發方式。

Flannel網絡架構圖

數據從源容器中發出後，經由所在主機的docker0虛擬網卡轉發到flannel0虛擬網卡，這是個P2P的虛擬網卡，flanneld服務監聽在網卡的另外一端。
Flannel通過Etcd服務維護了一張節點間的路由表，在稍後的配置部分我們會介紹其中的內容。
源主機的flanneld服務將原本的數據內容UDP封裝後根據自己的路由表投遞給目的節點的flanneld服務，數據到達以後被解包，然後直接進入目的節點的flannel0虛擬網卡，
然後被轉發到目的主機的docker0虛擬網卡，最後就像本機容器通信一下的有docker0路由到達目標容器。

Kubernetes基本工作流程

客戶端創建pod 流程：

首先管理員創建 Pod 的請求默認是通過kubectl 客戶端管理命令 api server 組件進行交互的，默認會將請求發送給 API Server 集群統一入口。
API Server 會根據請求的類型選擇用何種 REST API 對請求作出處理（比如：創建 Pod 時 Storage 類型是 Pods 時，其對應的就是 REST Storage API）。
REST Storage API 會對請求作相應的處理並將處理的結果存入高可用鍵值存儲系統 Etcd 中。
同時Scheduler會檢測到etcd集群的變化，Scheduler 會根據ETCD集群中運行 Pod情況及 Node 信息進行判斷，將需要創建的 Pod 分發到可用的 Node 節點上。然後根據一組相關規則將pod分配到可以運行它們的節點上，並更新etcd數據庫，記錄pod分配情況。
Node節點上Kubelet監控etcd數據庫變化，管理創建pod，kubelet在Node節點上面開始創建新的pod，就會進行docker組件的啟動，docker組件會啟動對應的容器（pod），會在該節點上運行這個新pod。
kube-proxy運行在集群各個節點主機上，管理網絡通信，如服務發現、負載均衡。例如當有數據發送到主機時，將其路由到正確的pod或容器。對於從主機上發出的數據，它可以基於請求地址發現遠程服務器，並將數據正確路由，在某些情況下會使用輪訓調度算法(Round-robin)將請求發送到集群中的多個實例。

集群功能各模塊功能描述：

Master節點：

Master節點上面主要由四個模塊組成，APIServer，schedule,controller-manager,etcd.

APIServer: APIServer負責對外提供RESTful的kubernetes API的服務，它是系統管理指令的統一接口，任何對資源的增刪該查都要交給APIServer處理後再交給etcd，如圖，kubectl(kubernetes提供的客戶端工具，該工具內部是對kubernetes API的調用）是直接和APIServer交互的。
schedule: schedule負責調度Pod到合適的Node上，如果把scheduler看成一個黑匣子，那麼它的輸入是pod和由多個Node組成的列表，輸出是Pod和一個Node的綁定。 kubernetes目前提供了調度算法，同樣也保留了接口。用戶根據自己的需求定義自己的調度算法。
controller manager: 如果APIServer做的是前台的工作的話，那麼controller manager就是負責後台的。每一個資源都對應一個控制器。而controller manager就是負責管理這些控制器的，比如我們通過APIServer創建了一個Pod，當這個Pod創建成功後，APIServer的任務就算完成了。
etcd：etcd是一個高可用的鍵值存儲系統，kubernetes使用它來存儲各個資源的狀態，從而實現了Restful的API。

Node節點：

每個Node節點主要由三個模板組成：kublet, kube-proxy,Docker

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。
kublet：kublet是Master在每個Node節點上面的agent，是Node節點上面最重要的模塊，它負責維護和管理該Node上的所有容器，但是如果容器不是通過kubernetes創建的，它並不會管理。本質上，它負責使Pod的運行狀態與期望的狀態一致。
Docker:進行容器生成、配置和使用，作為pod節點的重要支撐。

Kubernetes單節點安裝及配置

前面劃分的ha 高可用雙master部署 K8S ，先以單master實例進行演示，後續增加master，但是不衝突，後續增加LB 節點、和master高可用既可以。

ip	操作系統	角色	安裝軟件
192.168.0.10	centos7.6_x64	master01	docker，etcd
192.168.0.7	centos7.6_x64	node01	docker
192.168.0.8	centos7.6_x64	node02	docker

本教程以安裝Centos7 mini版本為系統鏡像安裝

初始化環境

設置關閉防火牆及SELINUX

systemctl stop firewalld && systemctl disable firewalld
setenforce 0
yum install yum-utils -y 
vi /etc/selinux/config
SELINUX=disabled

關閉Swap

swapoff -a && sysctl -w vm.swappiness=0
vi /etc/fstab
UUID=7bff6243-324c-4587-b550-55dc34018ebf swap                    swap    defaults        0 0

設置Docker所需參數（未做）

cat << EOF | tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1                                                                 
net.ipv4.ip_forward = 1
EOF

sysctl -p  /etc/sysctl.d/k8s.conf

在node節點上安裝 Docker

1. 安裝好docker
yum-config-manager --add-repo //mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
yum list docker-ce --showduplicates | soft -r
yum install docker-ce -y
systemctl start docker && systemctl enable docker

2. 配置docker加速器
curl -sSL //get.daocloud.io/daotools/set_mirror.sh | sh -s //f1361db2.m.daocloud.io && systemctl restart docker

創建安裝目錄

mkdir /data/soft/etcd/{bin,cfg,ssl} -p
mkdir /data/soft/kubernetes/{bin,cfg,ssl} -p

安裝及配置CFSSL

使用cfssl來生成自簽證書，先下載cfssl工具：
wget //pkg.cfssl.org/R1.2/cfssl_linux-amd64
wget //pkg.cfssl.org/R1.2/cfssljson_linux-amd64
wget //pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64

chmod +x cfssl_linux-amd64 cfssljson_linux-amd64 cfssl-certinfo_linux-amd64
mv cfssl_linux-amd64 /usr/local/bin/cfssl
mv cfssljson_linux-amd64 /usr/local/bin/cfssljson
mv cfssl-certinfo_linux-amd64 /usr/bin/cfssl-certinfo

部署ETCD

創建etcd集群認證證書

創建 ETCD 證書

創建以下三個文件：

首先創建一個etcd-cert證書存儲目錄目錄，命令如下

mkdir  /data/www/etcd-cert 
cd 	   /data/www/etcd-cert

創建 ETCD 證書生成策略配置文件

cat << EOF | tee etcd-ca-config.json
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "www": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
EOF

# 參數詳解
ca-config.json：可以定義多個 profiles，分別指定不同的過期時間、使用場景等參數；後續在簽名證書時使用某個 profile；
signing：	   表示該證書可用於簽名其它證書；生成的 ca.pem 證書中 CA=TRUE；
server auth：   表示client可以用該 CA 對server提供的證書進行驗證；
client auth：   表示server可以用該CA對client提供的證書進行驗證；

創建 ETCD CA 證書籤名請求

cat << EOF | tee etcd-ca-csr.json
{
    "CN": "etcd CA",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Shenzhen",
            "ST": "Shenzhen"
        }
    ]
}
EOF

參數詳解：
CN：Common Name，kube-apiserver 從證書中提取該字段作為請求的用戶名 (User Name)；瀏覽器使用該字段驗證網站是否合法；

names中的字段：
C : country，國家
ST: state，州或省份
L：location，城市
O：organization，組織，kube-apiserver 從證書中提取該字段作為請求用戶所屬的組 (Group)
OU：organization unit,組織單位

創建 ETCD SERVER 證書籤名請求

cat << EOF | tee etcd-server-csr.json
{
    "CN": "etcd",
    "hosts": [
    "192.168.0.10",
    "192.168.0.12",
    "192.168.0.4"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Shenzhen",
            "ST": "Shenzhen"
        }
    ]
}
EOF


hosts：指定授權使用該證書的 etcd 節點 IP 列表，需要將 etcd 集群所有節點 IP 都列在其中；

生成 ETCD CA 證書和私鑰

cfssl gencert -initca etcd-ca-csr.json | cfssljson -bare etcd-ca 
cfssl gencert -ca=etcd-ca.pem -ca-key=etcd-ca-key.pem -config=etcd-ca-config.json -profile=www etcd-server-csr.json | cfssljson -bare etcd-server 

# cfssl參數詳解
gencert: 生成新的key(密鑰)和簽名證書
	-initca：初始化一個新ca
	-ca：指明ca的證書
	-ca-key：指明ca的私鑰文件
	-config：指明請求證書的json文件
	-profile：與-config中的profile對應，是指根據config中的profile段來生成證書的相關信息

查看cert(證書信息):
cfssl certinfo -cert ca.pem

查看CSR(證書籤名請求)信息：
cfssl certinfo -csr ca.csr

# cfssljson
	-bare 來自CFSSL的返回值，使用cert，csr和key字段拆分成JSON格式以生成文件。

ssh-key認證

# ssh-keygen
Generating **public**/**private** rsa key pair.
Enter file **in** which to save the **key** (/root/.ssh/id_rsa): 
Created directory '/root/.ssh'.
Enter **passphrase** (empty **for** no passphrase): 
Enter same passphrase again: 
Your identification has been saved **in** /root/.ssh/id_rsa.
Your **public** key has been saved **in** /root/.ssh/id_rsa.pub.
The key fingerprint **is**:
SHA256:FQjjiRDp8IKGT+UDM+GbQLBzF3DqDJ+pKnMIcHGyO/o root@qas-k8s-master01
The key's randomart image **is**:
+---[RSA 2048]----+
|o.==o o. ..      |
|ooB+o+ o.  .     |
|B++@o o   .      |
|=X**o    .       |
|o=O. .  S        |
|..+              |
|oo .             |
|* .              |
|o+E              |
+----[SHA256]-----+

# ssh-copy-id 192.168.0.10**
# ssh-copy-id 192.168.0.12**
# ssh-copy-id 192.168.0.4**
# ssh-copy-id 192.168.0.7**
# ssh-copy-id 192.168.0.8**
# ssh-copy-id 192.168.0.9**

**master主節點要和node節點做免密，方便拷貝文件**

解壓etcd安裝文件

以下部署步驟在規劃的三個etcd節點操作一樣，唯一不同的是etcd配置文件中的服務器IP要寫當前的服務器：

tar -xvf etcd-v3.3.10-linux-amd64.tar.gz
cd etcd-v3.3.10-linux-amd64/
\cp etcd etcdctl /data/soft/etcd/bin/


cat << EOF | tee /data/soft/etcd/cfg/etcd
#[Member]
ETCD_NAME="etcd01"
ETCD_DATA_DIR="/data/www/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="//192.168.0.10:2380"
ETCD_LISTEN_CLIENT_URLS="//192.168.0.10:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="//192.168.0.10:2380"
ETCD_ADVERTISE_CLIENT_URLS="//192.168.0.10:2379"
ETCD_INITIAL_CLUSTER="etcd01=//192.168.0.10:2380,etcd02=//192.168.0.12:2380,etcd03=//192.168.0.4:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
EOF

配置文件詳解：

ETCD_NAME 節點名稱
ETCD_DATA_DIR 數據目錄
ETCD_LISTEN_PEER_URLS 集群通信監聽地址
ETCD_LISTEN_CLIENT_URLS 客戶端訪問監聽地址
ETCD_INITIAL_ADVERTISE_PEER_URLS 集群通告地址
ETCD_ADVERTISE_CLIENT_URLS 客戶端通告地址
ETCD_INITIAL_CLUSTER 集群節點地址
ETCD_INITIAL_CLUSTER_TOKEN 集群Token
ETCD_INITIAL_CLUSTER_STATE 加入集群的當前狀態，new是新集群，existing表示加入已有集群

創建 etcd的 etcd.service文件

vim /usr/lib/systemd/system/etcd.service
[Unit]
Description=Etcd Server
After=network.target
After=network-online.target
Wants=network-online.target

[Service]
User=www
Group=www
Type=notify
EnvironmentFile=/data/soft/etcd/cfg/etcd
ExecStart=/data/soft/etcd/bin/etcd \
--name=${ETCD_NAME} \
--data-dir=${ETCD_DATA_DIR} \
--listen-peer-urls=${ETCD_LISTEN_PEER_URLS} \
--listen-client-urls=${ETCD_LISTEN_CLIENT_URLS},//127.0.0.1:2379 \
--advertise-client-urls=${ETCD_ADVERTISE_CLIENT_URLS} \
--initial-advertise-peer-urls=${ETCD_INITIAL_ADVERTISE_PEER_URLS} \
--initial-cluster=${ETCD_INITIAL_CLUSTER} \
--initial-cluster-token=${ETCD_INITIAL_CLUSTER_TOKEN} \
--initial-cluster-state=new \
--cert-file=/data/soft/etcd/ssl/etcd-server.pem \
--key-file=/data/soft/etcd/ssl/etcd-server-key.pem \
--peer-cert-file=/data/soft/etcd/ssl/etcd-server.pem \
--peer-key-file=/data/soft/etcd/ssl/etcd-server-key.pem \
--trusted-ca-file=/data/soft/etcd/ssl/etcd-ca.pem \
--peer-trusted-ca-file=/data/soft/etcd/ssl/etcd-ca.pem
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target


# 參數詳解：

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 通信時使用的證書和私鑰；
--peer-cert-file、--peer-key-file：etcd 與 peer 通信使用的證書和私鑰；
--trusted-ca-file：簽名 client 證書的 CA 證書，用於驗證 client 證書；
--peer-trusted-ca-file：簽名 peer 證書的 CA 證書，用於驗證 peer 證書；

拷貝證書文件

把剛才生成的證書拷貝到配置文件中的位置：

另外兩台etcd集群也要創建目錄
mkdir /data/soft/etcd/{bin,cfg,ssl} -p
mkdir /data/soft/kubernetes/{bin,cfg,ssl} -p

cd /data/www/etcd-cert
cp etcd-ca.pem etcd-server.pem etcd-server-key.pem /data/soft/etcd/ssl/
scp -P 12525 etcd-ca.pem etcd-server.pem  etcd-server-key.pem [email protected]:/data/soft/etcd/ssl/
scp -P 12525 etcd-ca.pem etcd-server.pem  etcd-server-key.pem [email protected]:/data/soft/etcd/ssl/

將啟動文件、配置文件拷貝到節點1、節點2

cd /data/soft/ 

scp -P 12525 -r etcd [email protected]:/data/soft
scp -P 12525 -r etcd [email protected]:/data/soft

scp -P 12525 -r /usr/lib/systemd/system/etcd.service  [email protected]:/usr/lib/systemd/system/etcd.service
scp -P 12525 -r /usr/lib/systemd/system/etcd.service  [email protected]:/usr/lib/systemd/system/etcd.service

192.168.0.12 node01配置文件修改

cat << EOF | tee /data/soft/etcd/cfg/etcd 
#[Member]
ETCD_NAME="etcd02"
ETCD_DATA_DIR="/data/www/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="//192.168.0.12:2380"
ETCD_LISTEN_CLIENT_URLS="//192.168.0.12:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="//192.168.0.12:2380"
ETCD_ADVERTISE_CLIENT_URLS="//192.168.0.12:2379"
ETCD_INITIAL_CLUSTER="etcd01=//192.168.0.10:2380,etcd02=//192.168.0.12:2380,etcd03=//192.168.0.4:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
EOF

192.168.0.4 node02配置文件修改

cat << EOF | tee /data/soft/etcd/cfg/etcd
#[Member]
ETCD_NAME="etcd03"
ETCD_DATA_DIR="/data/www/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="//192.168.0.4:2380"
ETCD_LISTEN_CLIENT_URLS="//192.168.0.4:2379"
 

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="//192.168.0.4:2380"
ETCD_ADVERTISE_CLIENT_URLS="//192.168.0.4:2379"
ETCD_INITIAL_CLUSTER="etcd01=//192.168.0.10:2380,etcd02=//192.168.0.12:2380,etcd03=//192.168.0.4:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
EOF

啟動ETCD服務

systemctl daemon-reload
systemctl enable etcd
systemctl restart etcd

#etcd 進程首次啟動時會等待其它節點的 etcd 加入集群，命令 systemctl start etcd 會卡住一段時間，為正常現象；

驗證ETCD集群是否正常運行

/data/soft/etcd/bin/etcdctl \
--ca-file=/data/soft/etcd/ssl/ca.pem \
--cert-file=/data/soft/etcd/ssl/server.pem \
--key-file=/data/soft/etcd/ssl/server-key.pem \
--endpoints="//192.168.0.10:2379,\
//192.168.0.12:2379,\
//192.168.0.4:2379" cluster-health
member b8fffb7f5b2f26e is healthy: got healthy result from //192.168.0.12:2379
member 5ac283d796e472ba is healthy: got healthy result from //192.168.0.4:2379
member a569e0ee3b34eefa is healthy: got healthy result from //192.168.0.10:2379
cluster is healthy


注意：
啟動ETCD集群同時最少啟動二個節點，啟動一個節點集群是無法正常啟動的；

常見etcd配置問題

etcd啟動不起來

錯誤1：因為etcd之間https通訊是基於證書的。我證書中的IP地址有錯誤。

etcd啟動後不加入集群

錯誤2：現象: Apr 18 10:34:45 k8s-master01 etcd: request cluster ID mismatch (got cf138cda9790f1d0 want 8732ef518b18f052)

解決方法：
此時etcd節點都已經啟動，但是無法連接，發現有request cluster ID mismatch報錯。找到etcd數據存儲目錄
[www@k8s-master01 ssl]# grep -i ETCD_DATA_DIR /data/soft/etcd/cfg/etcd 
ETCD_DATA_DIR="/data/www/etcd/default.etcd"
刪除各節點/data/www/etcd/default.etcd，重啟etcd即可解決。
由於刪除的是數據存儲目錄，不是新建etcd集群，或者有重要數據的不可直接刪除。
可以通過 journalctl -xefu etcd來詳細排查問題。

etcd排查思路

排查思路，如下：
1. iptables防火牆、Selinux問題。
2. 時間是否同步。
3. 二進制文件是否存在
4. 檢查日誌journalctl -xefu 或者是查詢/var/log/message 或者 日誌目錄
4. 配置文件沒修改完或者多個空格？
5. 目錄是否存在
6. 證書是否存在,且是否正確[初始化的時候需要指定三台etcd機器，我就搞錯了，第一次錯誤，證書問題搞了好久]

新機器加入etc集群
//github.com/k8sp/sextant/issues/333

部署Flannel網絡

Kubernetes網絡模型設計基本要求

一個Pod一個IP
每個Pod獨立IP，Pod內所有容器共享網絡（同一個IP）
所有容器都可以與所有其他容器通信
所有節點都可以與所有容器通信

網絡模型實現

flannel
calico
weaveworks
ovs
contiv
romana
cilium

前兩個比較用的多。flannel小規模[百台以下]，calcio基於BGP[路由表]適合大規模。但是維護成本高[上百台以上]。當前我們配置是flannel網絡。

ip	操作系統	角色	安裝軟件
192.168.0.10	centos7.6_x64	master1	docker，etcd
192.168.0.7	centos7.6_x64	node1	docker
192.168.0.8	centos7.6_x64	node2	docker

flannel 只需要部署在node節點上，master不用部署

以下部署步驟在規劃的每個node節點都操作。

安裝好docker

yum install -y yum-utils device-mapper-persistent-data lvm2 && yum-config-manager --add-repo //download.docker.com/linux/centos/docker-ce.repo && yum list docker-ce --showduplicates | soft -r &&  yum install docker-ce -y && systemctl start docker && systemctl enable docker

配置docker加速器

cat > /etc/docker/daemon.json<<EOF
{
"registry-mirrors":["//registry.docker-cn.com"]
}
EOF

service docker restart

部署Flannel 網絡

向 master寫入集群 Pod 網段信息(etcd主節點上操作)

cd /data/soft/etcd/ssl/
/data/soft/etcd/bin/etcdctl \
--ca-file=etd-ca.pem --cert-file=etd-server.pem \
--key-file=etd-server-key.pem \
--endpoints="//192.168.0.10:2379,//192.168.0.12:2379,//192.168.0.4:2379" \
set /coreos.com/network/config  '{ "Network": "172.18.0.0/16", "Backend": {"Type": "vxlan"}}'


返回寫入結果：
{ "Network": "172.18.0.0/16", "Backend": {"Type": "vxlan"}}

注意：

Falnnel要用etcd存儲自身一個子網信息，所以要保證能成功連接Etcd，寫入預定義子網段：
flanneld 當前版本 (v0.10.0) 不支持 etcd v3，故使用 etcd v2 API 寫入配置 key 和網段數據；
寫入的 Pod 網段 ${CLUSTER_CIDR} 必須是 /16 段地址，必須與 kube-controller-manager 的 –cluster-cidr 參數值一致；

解壓安裝

tar -xvf flannel-v0.11.0-linux-amd64.tar.gz
mv flanneld mk-docker-opts.sh /data/soft/kubernetes/bin/

配置Flannel

cat << EOF | tee /data/soft/kubernetes/cfg/flanneld
FLANNEL_OPTIONS="--etcd-endpoints=//192.168.0.10:2379,//192.168.0.12:2379,//192.168.0.4:2379 -etcd-cafile=/data/soft/etcd/ssl/etcd-ca.pem -etcd-certfile=/data/soft/etcd/ssl/etcd-server.pem -etcd-keyfile=/data/soft/etcd/ssl/etcd-server-key.pem"
EOF

注意：
這裡是定義一個FLANNEL_OPTIONS的變量：指定etcd的位置和連接etcd集群的證書，好讓flannel網絡讀取etcd

創建 flanneld 的 flanneld.service 文件，配置所有node節點

vim /usr/lib/systemd/system/flanneld.service
[Unit]
Description=Flanneld overlay address etcd agent
After=network-online.target network.target
Before=docker.service
 

[Service]
Type=notify
EnvironmentFile=/data/soft/kubernetes/cfg/flanneld
ExecStart=/data/soft/kubernetes/bin/flanneld --ip-masq $FLANNEL_OPTIONS
ExecStartPost=/data/soft/kubernetes/bin/mk-docker-opts.sh -k DOCKER_NETWORK_OPTIONS -d /run/flannel/subnet.env
Restart=on-failure

[Install]
WantedBy=multi-user.target

注意：

mk-docker-opts.sh 腳本將分配給 flanneld 的 Pod 子網網段信息寫入 /run/flannel/docker 文件，後續 docker 啟動時使用這個文件中的環境變量配置 docker0 網橋；
flanneld 使用系統缺省路由所在的接口與其它節點通信，對於有多個網絡接口（如內網和公網）的節點，可以用 -iface 參數指定通信接口，如上面的 eth0 接口;
flanneld 運行時需要 root 權限；

配置Docker啟動指定子網段，所有node節點

vim /usr/lib/systemd/system/docker.service 
[Unit]
Description=Docker Application Container Engine
Documentation=//docs.docker.com
After=network-online.target firewalld.service
Wants=network-online.target

[Service]
Type=notify
EnvironmentFile=/run/flannel/subnet.env
ExecStart=/usr/bin/dockerd $DOCKER_NETWORK_OPTIONS
ExecReload=/bin/kill -s HUP $MAINPID
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
TimeoutStartSec=0
Delegate=yes
KillMode=process
Restart=on-failure
StartLimitBurst=3
StartLimitInterval=60s

[Install]
WantedBy=multi-user.target

將flanneld systemd unit 文件到所有節點

cd /data/soft/
scp -P 12525 -r kubernetes [email protected]:/data/soft/
scp -P 12525 -r kubernetes [email protected]:/data/soft/
scp -P 12525 /data/soft/kubernetes/cfg/flanneld [email protected]:/data/soft/kubernetes/cfg/flanneld
scp -P 12525 /data/soft/kubernetes/cfg/flanneld [email protected]:/data/soft/kubernetes/cfg/flanneld
scp /usr/lib/systemd/system/docker.service  192.168.0.7:/usr/lib/systemd/system/docker.service 
scp /usr/lib/systemd/system/docker.service  192.168.0.8:/usr/lib/systemd/system/docker.service
scp /usr/lib/systemd/system/flanneld.service  192.168.0.7:/usr/lib/systemd/system/flanneld.service 
scp /usr/lib/systemd/system/flanneld.service  192.168.0.8:/usr/lib/systemd/system/flanneld.service

Node節點啟動服務

systemctl daemon-reload
systemctl start flanneld
systemctl enable flanneld
systemctl restart docker

查看flannel網絡是否生效

node1 回顯：
---
ip add
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
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
    link/ether 00:16:3e:00:e9:96 brd ff:ff:ff:ff:ff:ff
    inet 192.168.0.7/24 brd 192.168.0.255 scope global dynamic eth0
       valid_lft 290352654sec preferred_lft 290352654sec
3: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default 
    link/ether 02:42:9d:2d:f5:46 brd ff:ff:ff:ff:ff:ff
    inet 172.18.39.1/24 brd 172.18.39.255 scope global docker0
       valid_lft forever preferred_lft forever
4: flannel.1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1450 qdisc noqueue state UNKNOWN group default 
    link/ether 0e:4e:b2:09:66:59 brd ff:ff:ff:ff:ff:ff
    inet 172.18.39.0/32 scope global flannel.1
       valid_lft forever preferred_lft forever




node2 回顯：
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
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
    link/ether 00:16:3e:00:1a:5b brd ff:ff:ff:ff:ff:ff
    inet 192.168.0.8/24 brd 192.168.0.255 scope global dynamic eth0
       valid_lft 290352443sec preferred_lft 290352443sec
3: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default 
    link/ether 02:42:0c:6d:3f:30 brd ff:ff:ff:ff:ff:ff
    inet 172.18.98.1/24 brd 172.18.98.255 scope global docker0
       valid_lft forever preferred_lft forever
4: flannel.1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1450 qdisc noqueue state UNKNOWN group default 
    link/ether 86:2f:59:3b:1f:88 brd ff:ff:ff:ff:ff:ff
    inet 172.18.98.0/32 scope global flannel.1
       valid_lft forever preferred_lft forever

確保docker0與flannel.1在同一網段。測試不同節點互通，在當前節點訪問另一個Node節點docker0 IP。

# ping 172.17.58.1
PING 172.17.58.1 (172.17.58.1) 56(84) bytes of data.
64 bytes from 172.17.58.1: icmp_seq=1 ttl=64 time=0.263 ms
64 bytes from 172.17.58.1: icmp_seq=2 ttl=64 time=0.204 ms

可以使用創建一個容器的方法，分別在node節點上面創建一個容器測試容器是否通信正常，命令如下

docker run -it busybox sh，雙方節點各開啟容器進行互ping 測試

並保證互ping 全網通信

如果能通說明Flannel部署成功。如果不通檢查下日誌：journalctl -u flannel，檢查node節點是否開啟端口轉發。

部署 master 節點

kubernetes master 節點運行如下組件：

kube-apiserver
kube-scheduler
kube-controller-manager

kube-scheduler 和 kube-controller-manager 可以以集群模式運行，通過 leader 選舉產生一個工作進程，其它進程處於阻塞模式。

創建 Kubernetes Apiserver CA 證書

首先創建一個api-cert證書存儲目錄目錄，(當前實戰是把api-server所需證書和kube-proxy所需證書和kuber-controller-manager都存儲在api-cert目錄中)，kube-controller-manager和kube-scheduler當前使用的是apiserver生成的證書，也可以單獨生成。

命令如下：

mkdir  /data/www/api-cert 
cd     /data/www/api-cert

創建 Kubernetes apiserver 證書生成策略配置文件

cat << EOF | tee api-ca-config.json
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "kubernetes": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
EOF

# 參數詳解
ca-config.json：可以定義多個 profiles，分別指定不同的過期時間、使用場景等參數；後續在簽名證書時使用某個 profile；
signing：	   表示該證書可用於簽名其它證書；生成的 ca.pem 證書中 CA=TRUE；
server auth：   表示client可以用該 CA 對server提供的證書進行驗證；
client auth：   表示server可以用該CA對client提供的證書進行驗證；

# 上面生成的這個ca config文件只是

創建 Kubernetes Apiserver CA 證書籤名請求

cat << EOF | tee api-ca-csr.json
{
    "CN": "kubernetes",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Shenzhen",
            "ST": "Shenzhen",
            "O": "k8s",
            "OU": "System"
        }
    ]
}
EOF

參數詳解：
CN：Common Name，kube-apiserver 從證書中提取該字段作為請求的用戶名 (User Name)；瀏覽器使用該字段驗證網站是否合法；

names中的字段：
C : country，國家
ST: state，州或省份
L：location，城市
O：organization，組織，kube-apiserver 從證書中提取該字段作為請求用戶所屬的組 (Group)
OU：organization unit,組織單位

cfssl gencert -initca api-ca-csr.json | cfssljson -bare api-ca

生成Kubernetes Apiserver 證書配置文件

cat << EOF | tee api-server-csr.json
{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
      "127.0.0.1",
      "192.168.0.10",
      "192.168.0.12",
      "192.168.0.7",
      "192.168.0.8",
      "192.168.0.4",
      "192.168.0.9",
      "192.168.0.200",
      "kubernetes",
      "kubernetes.default",
      "kubernetes.default.svc",
      "kubernetes.default.svc.cluster",
      "kubernetes.default.svc.cluster.local"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Shenzhen",
            "ST": "Shenzhen",
            "O": "k8s",
            "OU": "System"
        }
    ]
}
EOF

參數詳解：
CN：Common Name，kube-apiserver 從證書中提取該字段作為請求的用戶名 (User Name)；瀏覽器使用該字段驗證網站是否合法；

names中的字段：
C : country，國家
ST: state，州或省份
L：location，城市
O：organization，組織，kube-apiserver 從證書中提取該字段作為請求用戶所屬的組 (Group)
OU：organization unit,組織單位

cfssl gencert -ca=api-ca.pem -ca-key=api-ca-key.pem -config=api-ca-config.json -profile=kubernetes api-server-csr.json | cfssljson -bare api-server

# cfssl參數詳解
gencert: 生成新的key(密鑰)和簽名證書
	-initca：初始化一個新ca
	-ca：指明ca的證書
	-ca-key：指明ca的私鑰文件
	-config：指明請求證書的json文件
	-profile：與-config中的profile對應，是指根據config中的profile段來生成證書的相關信息

查看cert(證書信息):
cfssl certinfo -cert ca.pem

查看CSR(證書籤名請求)信息：
cfssl certinfo -csr ca.csr

# cfssljson
	-bare 來自CFSSL的返回值，使用cert，csr和key字段拆分成JSON格式以生成文件。

創建 Kubernetes Proxy 證書

cat << EOF | tee kube-proxy-csr.json
{
  "CN": "system:kube-proxy",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "Shenzhen",
      "ST": "Shenzhen",
      "O": "k8s",
      "OU": "System"
    }
  ]
}
EOF

cfssl gencert -ca=api-ca.pem -ca-key=api-ca-key.pem -config=api-ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy

# 這個地方利用apiserver 的 ca證書機構頒發kube-proxy的證書請求，生成kube-proxy-key.pem和kube-proxy.pem文件給kube-proxy組件使用，因為kube-proxy 要連接apiserver進行kubernetes網絡設置

# cfssl參數詳解
gencert: 生成新的key(密鑰)和簽名證書
	-initca：初始化一個新ca
	-ca：指明ca的證書
	-ca-key：指明ca的私鑰文件
	-config：指明請求證書的json文件
	-profile：與-config中的profile對應，是指根據config中的profile段來生成證書的相關信息

查看cert(證書信息):
cfssl certinfo -cert ca.pem

查看CSR(證書籤名請求)信息：
cfssl certinfo -csr ca.csr

# cfssljson
	-bare 來自CFSSL的返回值，使用cert，csr和key字段拆分成JSON格式以生成文件。

最終生成以下證書文件：

ls -l /data/www/api-cert/*pem

-rw------- 1 www www 1675 Apr 19 21:34 /data/www/api-cert/api-ca-key.pem
-rw-rw-r-- 1 www www 1363 Apr 19 21:34 /data/www/api-cert/api-ca.pem
-rw------- 1 www www 1679 Apr 19 21:36 /data/www/api-cert/kube-proxy-key.pem
-rw-rw-r-- 1 www www 1407 Apr 19 21:36 /data/www/api-cert/kube-proxy.pem
-rw------- 1 www www 1679 Apr 19 21:35 /data/www/api-cert/api-server-key.pem
-rw-rw-r-- 1 www www 1667 Apr 19 21:35 /data/www/api-cert/api-server.pem

將二進制文件解壓拷貝到master 節點

tar -xvf kubernetes-server-linux-amd64.tar.gz 
cd kubernetes/server/bin/
cp kube-scheduler kube-apiserver kube-controller-manager kubectl /data/soft/kubernetes/bin/

拷貝認證

cp /data/www/api-cert/*pem   /data/soft/kubernetes/ssl/

部署 kube-apiserver 組件

創建 TLS Bootstrapping Token

# 生成隨機字符串
# head -c 16 /dev/urandom | od -An -t x | tr -d ' '
2366a641f656a0a025abb4aabda4511b

vim /data/soft/kubernetes/cfg/token.csv
2366a641f656a0a025abb4aabda4511b,kubelet-bootstrap,10001,"system:kubelet-bootstrap"


# token.csv是kubelet加入集群時候頒發證書使用
第一列：隨機字符串，自己可生成
第二列：用戶名
第三列：UID
第四列：用戶組

創建apiserver配置文件

vim /data/soft/kubernetes/cfg/kube-apiserver 
KUBE_APISERVER_OPTS="--logtostderr=true \
--v=4 \
--etcd-servers=//192.168.0.10:2379,//192.168.0.12:2379,//192.168.0.4:2379 \
--bind-address=192.168.0.10 \
--secure-port=6443 \
--advertise-address=192.168.0.10 \
--allow-privileged=true \
--service-cluster-ip-range=10.0.0.0/24 \
--enable-admission-plugins=NamespaceLifecycle,LimitRanger,SecurityContextDeny,ServiceAccount,ResourceQuota,NodeRestriction \
--authorization-mode=RBAC,Node \
--enable-bootstrap-token-auth \
--token-auth-file=/data/soft/kubernetes/cfg/token.csv \
--service-node-port-range=30000-50000 \
--tls-cert-file=/data/soft/kubernetes/ssl/api-server.pem  \
--tls-private-key-file=/data/soft/kubernetes/ssl/api-server-key.pem \
--client-ca-file=/data/soft/kubernetes/ssl/api-ca.pem \
--service-account-key-file=/data/soft/kubernetes/ssl/api-ca-key.pem \
--etcd-cafile=/data/soft/etcd/ssl/etcd-ca.pem \
--etcd-certfile=/data/soft/etcd/ssl/etcd-server.pem \
--etcd-keyfile=/data/soft/etcd/ssl/etcd-server-key.pem"

配置好前面生成的etcd證書，確保能連接etcd，apiserver要隨時去向etcd存取集群數據。

參數說明( 號代表通配符說明參數相同的有多個)：*

--advertise-address：apiserver 對外通告的 IP（kubernetes 服務後端節點 IP）；
--default-*-toleration-seconds：設置節點異常相關的閾值；
--max-*-requests-inflight：請求相關的最大閾值；
--etcd-*：訪問 etcd 的證書和 etcd 服務器地址；
--bind-address： https 監聽的 IP，不能為 127.0.0.1，否則外界不能訪問它的安全端口 6443；
--secret-port：https 監聽端口；
--insecure-port=0：關閉監聽 http 非安全端口(8080)；
--tls-*-file：指定 apiserver 使用的證書、私鑰和 CA 文件；
--audit-*：配置審計策略和審計日誌文件相關的參數；
--client-ca-file：驗證 client (kue-controller-manager、kube-scheduler、kubelet、kube-proxy 等)請求所帶的證書；
--enable-bootstrap-token-auth：啟用 kubelet bootstrap 的 token 認證；
--requestheader-*：kube-apiserver 的 aggregator layer 相關的配置參數，proxy-client & HPA 需要使用；
--requestheader-client-ca-file：用於簽名 --proxy-client-cert-file 和 --proxy-client-key-file 指定的證書；在啟用了 metric aggregator 時使用；
--requestheader-allowed-names：不能為空，值為逗號分割的 --proxy-client-cert-file 證書的 CN 名稱，這裡設置為 “aggregator”；
--service-account-key-file：簽名 ServiceAccount Token 的公鑰文件，kube-controller-manager 的 --service-account-private-key-file 指定私鑰文件，兩者配對使用；
--runtime-config=api/all=true：啟用所有版本的 APIs，如 autoscaling/v2alpha1；
--authorization-mode=Node,RBAC、--anonymous-auth=false：開啟 Node 和 RBAC 授權模式，拒絕未授權的請求；
--enable-admission-plugins：啟用一些默認關閉的 plugins；
--allow-privileged：運行執行 privileged 權限的容器；
--apiserver-count=3：指定 apiserver 實例的數量；
--event-ttl：指定 events 的保存時間；
--kubelet-*：如果指定，則使用 https 訪問 kubelet APIs；需要為證書對應的用戶(上面 kubernetes*.pem 證書的用戶為 kubernetes) 用戶定義 RBAC 規則，否則訪問 kubelet API 時提示未授權；
--proxy-client-*：apiserver 訪問 metrics-server 使用的證書；
--service-cluster-ip-range：指定 Service Cluster IP 地址段；
--service-node-port-range：指定 NodePort 的端口範圍；

如果 kube-apiserver 機器沒有運行 kube-proxy，則還需要添加 --enable-aggregator-routing=true 參數；

關於 --requestheader-XXX 相關參數，參考：

注意：

--requestheader-client-ca-file 指定的 CA 證書，必須具有 client auth and server auth；
如果–requestheader-allowed-names不為空,且–proxy-client-cert-file證書的 CN 名稱不在 allowed-names 中，則後續查看 node 或 pods 的 metrics 失敗，會提示：
```
$ kubectl top nodes
Error from server (Forbidden): nodes.metrics.k8s.io is forbidden: User "aggregator" cannot list 
```

創建 kube-apiserver 的kube-apiserver.service文件

vim /usr/lib/systemd/system/kube-apiserver.service 
[Unit]
Description=Kubernetes API Server
Documentation=//github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=/data/soft/kubernetes/cfg/kube-apiserver
ExecStart=/data/soft/kubernetes/bin/kube-apiserver $KUBE_APISERVER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target

啟動服務

systemctl daemon-reload
systemctl enable kube-apiserver
systemctl restart kube-apiserver

查看apiserver是否運行

ps -ef |grep kube-apiserver

root      76300      1 45 08:57 ?        00:00:14 /data/soft/kubernetes/bin/kube-apiserver --logtostderr=true --v=4 --etcd-servers=//192.168.0.10:2379,//192.168.0.12:2379,//192.168.0.4:2379 --bind-address=192.168.0.10 --secure-port=6443 --advertise-address=172.16.9.51 --allow-privileged=true --service-cluster-ip-range=10.0.0.0/24 --enable-admission-plugins=NamespaceLifecycle,LimitRanger,SecurityContextDeny,ServiceAccount,ResourceQuota,NodeRestriction --authorization-mode=RBAC,Node --enable-bootstrap-token-auth --token-auth-file=/data/soft/kubernetes/cfg/token.csv --service-node-port-range=30000-50000 --tls-cert-file=/data/soft/kubernetes/ssl/api-server.pem --tls-private-key-file=/data/soft/kubernetes/ssl/api-server-key.pem --client-ca-file=/data/soft/kubernetes/ssl/api-ca.pem --service-account-key-file=/data/soft/kubernetes/ssl/api-ca-key.pem --etcd-cafile=/data/soft/etcd/ssl/etcd-ca.pem --etcd-certfile=/data/soft/etcd/ssl/etcd-server.pem --etcd-keyfile=/data/soft/etcd/ssl/etcd-server-key.pem

root      76357   4370  0 08:58 pts/1    00:00:00 grep --color=auto kube-apiserver

部署kube-scheduler

創建kube-scheduler配置文件

vim  /data/soft/kubernetes/cfg/kube-scheduler 
KUBE_SCHEDULER_OPTS="--logtostderr=true --v=4 --master=127.0.0.1:8080 --leader-elect=true"

參數說明：

--address：在 127.0.0.1:10251 端口接收 http /metrics 請求；kube-scheduler 目前還不支持接收 https 請求；
--master 連接本地apiserver
--kubeconfig：指定 kubeconfig 文件路徑，kube-scheduler 使用它連接和驗證 kube-apiserver；
--leader-elect=true：集群運行模式，啟用選舉功能；被選為 leader 的節點負責處理工作，其它節點為阻塞狀態；當該組件啟動多個時，自動選舉（HA）

創建kube-scheduler的kube-scheduler.service 文件

vim /usr/lib/systemd/system/kube-scheduler.service 
[Unit]
Description=Kubernetes Scheduler
Documentation=//github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=-/data/soft/kubernetes/cfg/kube-scheduler
ExecStart=/data/soft/kubernetes/bin/kube-scheduler $KUBE_SCHEDULER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target

啟動服務

systemctl daemon-reload
systemctl enable kube-scheduler.service 
systemctl restart kube-scheduler.service

查看kube-scheduler是否運行

# ps -ef |grep kube-scheduler 
root      77854      1  8 09:17 ?        00:00:02 /data/soft/kubernetes/bin/kube-scheduler --logtostderr=true --v=4 --master=127.0.0.1:8080 --leader-elect
root      77901   1305  0 09:18 pts/0    00:00:00 grep --color=auto kube-scheduler

# systemctl status kube-scheduler.service 
● kube-scheduler.service - Kubernetes Scheduler
   Loaded: loaded (/usr/lib/systemd/system/kube-scheduler.service; disabled; vendor preset: disabled)
   Active: active (running) since 三 2018-12-05 09:17:43 CST; 29s ago
     Docs: https:*//github.com/kubernetes/kubernetes*
 Main PID: 77854 (kube-scheduler)
    Tasks: 13
   Memory: 10.9M
   CGroup: /system.slice/kube-scheduler.service
           └─77854 /data/soft/kubernetes/bin/kube-scheduler --logtostderr=true --v=4 --master=127.0.0.1:8080 --leader-elect

12月 05 09:17:45 qas-k8s-master01 kube-scheduler[77854]: I1205 09:17:45.642632   77854 shared_informer.go:123] caches populated
12月 05 09:17:45 qas-k8s-master01 kube-scheduler[77854]: I1205 09:17:45.743297   77854 shared_informer.go:123] caches populated
12月 05 09:17:45 qas-k8s-master01 kube-scheduler[77854]: I1205 09:17:45.844554   77854 shared_informer.go:123] caches populated
12月 05 09:17:45 qas-k8s-master01 kube-scheduler[77854]: I1205 09:17:45.945332   77854 shared_informer.go:123] caches populated
12月 05 09:17:45 qas-k8s-master01 kube-scheduler[77854]: I1205 09:17:45.945434   77854 controller_utils.go:1027] Waiting **for** caches to sync **for** scheduler controller
12月 05 09:17:46 qas-k8s-master01 kube-scheduler[77854]: I1205 09:17:46.046385   77854 shared_informer.go:123] caches populated
12月 05 09:17:46 qas-k8s-master01 kube-scheduler[77854]: I1205 09:17:46.046427   77854 controller_utils.go:1034] Caches are synced **for** scheduler controller
12月 05 09:17:46 qas-k8s-master01 kube-scheduler[77854]: I1205 09:17:46.046574   77854 leaderelection.go:205] attempting to acquire leader lease  kube-system/kube-scheduler...
12月 05 09:17:46 qas-k8s-master01 kube-scheduler[77854]: I1205 09:17:46.063185   77854 leaderelection.go:214] successfully acquired lease kube-system/kube-scheduler
12月 05 09:17:46 qas-k8s-master01 kube-scheduler[77854]: I1205 09:17:46.164498   77854 shared_informer.go:123] caches populated

部署kube-controller-manager

創建kube-controller-manager配置文件

vim /data/soft/kubernetes/cfg/kube-controller-manager
KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=true \
--v=4 \
--master=127.0.0.1:8080 \
--leader-elect=true \
--address=127.0.0.1 \
--service-cluster-ip-range=10.0.0.0/24 \
--cluster-name=kubernetes \
--cluster-signing-cert-file=/data/soft/kubernetes/ssl/api-ca.pem \
--cluster-signing-key-file=/data/soft/kubernetes/ssl/api-ca-key.pem  \
--root-ca-file=/data/soft/kubernetes/ssl/api-ca.pem \
--service-account-private-key-file=/data/soft/kubernetes/ssl/api-ca-key.pem"

# 證書配置這塊使用的是apiserver的證書進行連接集群

配置參數詳解：

--port=0：關閉監聽非安全端口（http），同時 --address 參數無效，--bind-address 參數有效；
--secure-port=10252、--bind-address=0.0.0.0: 在所有網絡接口監聽 10252 端口的 https /metrics 請求；
--kubeconfig：指定 kubeconfig 文件路徑，kube-controller-manager 使用它連接和驗證 kube-apiserver；
--authentication-kubeconfig 和 --authorization-kubeconfig：kube-controller-manager 使用它連接 apiserver，對 client 的請求進行認證和授權。kube-controller-manager 不再使用 --tls-ca-file 對請求 https metrics 的 Client 證書進行校驗。如果沒有配置這兩個 kubeconfig 參數，則 client 連接 kube-controller-manager https 端口的請求會被拒絕(提示權限不足)。
--cluster-signing-*-file：簽名 TLS Bootstrap 創建的證書；
--experimental-cluster-signing-duration：指定 TLS Bootstrap 證書的有效期；
--root-ca-file：放置到容器 ServiceAccount 中的 CA 證書，用來對 kube-apiserver 的證書進行校驗；
--service-account-private-key-file：簽名 ServiceAccount 中 Token 的私鑰文件，必須和 kube-apiserver 的 --service-account-key-file 指定的公鑰文件配對使用；
--service-cluster-ip-range ：指定 Service Cluster IP 網段，必須和 kube-apiserver 中的同名參數一致；
--leader-elect=true：集群運行模式，啟用選舉功能；被選為 leader 的節點負責處理工作，其它節點為阻塞狀態；
--controllers=*,bootstrapsigner,tokencleaner：啟用的控制器列表，tokencleaner 用於自動清理過期的 Bootstrap token；
--horizontal-pod-autoscaler-*：custom metrics 相關參數，支持 autoscaling/v2alpha1；
--tls-cert-file、--tls-private-key-file：使用 https 輸出 metrics 時使用的 Server 證書和秘鑰；
--use-service-account-credentials=true: kube-controller-manager 中各 controller 使用 serviceaccount 訪問 kube-apiserver；

創建kube-controller-manager systemd unit 文件

vim /usr/lib/systemd/system/kube-controller-manager.service 
[Unit]
Description=Kubernetes Controller Manager
Documentation=//github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=-/data/soft/kubernetes/cfg/kube-controller-manager
ExecStart=/data/soft/kubernetes/bin/kube-controller-manager $KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target

啟動服務

systemctl daemon-reload
systemctl enable kube-controller-manager
systemctl restart kube-controller-manager

查看kube-controller-manager是否運行

systemctl status kube-controller-manager
● kube-controller-manager.service - Kubernetes Controller Manager
   Loaded: loaded (/usr/lib/systemd/system/kube-controller-manager.service; enabled; vendor preset: disabled)
   Active: active (running) since 三 2018-12-05 09:35:00 CST; 3s ago
     Docs: https:*//github.com/kubernetes/kubernetes*
 Main PID: 79191 (kube-controller)
    Tasks: 8
   Memory: 15.2M
   CGroup: /system.slice/kube-controller-manager.service
           └─79191 /data/soft/kubernetes/bin/kube-controller-manager --logtostderr=true --v=4 --master=127.0.0.1:8080 --leader-elect=true --address=127.0.0.1 --service-cluster-ip-range=10.0.0....

查看進程文件

# ps -ef |grep kube-controller-manager
root      79191      1 10 09:35 ?        00:00:01 /data/soft/kubernetes/bin/kube-controller-manager --logtostderr=true --v=4 --master=127.0.0.1:8080 --leader-elect=true --address=127.0.0.1 --service-cluster-ip-range=10.0.0.0/24 --cluster-name=kubernetes --cluster-signing-cert-file=/data/soft/kubernetes/ssl/ca.pem --cluster-signing-key-file=/data/soft/kubernetes/ssl/ca-key.pem --root-ca-file=/data/soft/kubernetes/ssl/ca.pem --service-account-**private**-key-file=/data/soft/kubernetes/ssl/ca-key.pem
root      79220   1305  0 09:35 pts/0    00:00:00 grep --color=**auto** kube-controller-manager

將可執行文件路/data/soft/kubernetes/ 添加到 PATH 變量中

vim /etc/profile
PATH=/data/soft/kubernetes/bin:$PATH:$HOME/bin
source /etc/profile

查看master集群狀態

所有組件都已經啟動成功，通過kubectl工具查看當前集群組件狀態：

# kubectl get cs,nodes
NAME                                 STATUS    MESSAGE             ERROR
componentstatus/scheduler            Healthy   ok                  
componentstatus/etcd-2               Healthy   {"health":"true"}   
componentstatus/etcd-1               Healthy   {"health":"true"}   
componentstatus/etcd-0               Healthy   {"health":"true"}   
componentstatus/controller-manager   Healthy   ok

部署node 節點

kubernetes work 節點運行如下組件：

docker 前面已經部署
kubelet
kube-proxy

部署 kubelet 組件

kublet 運行在每個 worker 節點上，接收 kube-apiserver 發送的請求，管理 Pod 容器，執行交互式命令，如exec、run、logs 等;

kublet 啟動時自動向 kube-apiserver 註冊節點信息，內置的 cadvisor 統計和監控節點的資源使用情況;

為確保安全，本文檔只開啟接收 https 請求的安全端口，對請求進行認證和授權，拒絕未授權的訪問(如apiserver、heapster)。

Master apiserver啟用TLS認證後，Node節點kubelet組件想要加入集群，必須使用CA簽發的有效證書才能與apiserver通信，當Node節點很多時，簽署證書是一件很繁瑣的事情，因此有了TLS Bootstrapping機制，kubelet會以一個低權限用戶自動向apiserver申請證書，kubelet的證書由apiserver動態簽署。

認證大致工作流程如圖所示：

ip	操作系統	角色	安裝軟件
192.168.0.10	centos7.6_x64	master1	docker，etcd
192.168.0.7	centos7.6_x64	node1	docker
192.168.0.8	centos7.6_x64	node2	docker

node節點安裝好docker

yum-config-manager --add-repo //mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
yum list docker-ce --showduplicates | soft -r
yum install docker-ce -y
systemctl start docker && systemctl enable docker

配置docker加速器

curl -sSL //get.daocloud.io/daotools/set_mirror.sh | sh -s //f1361db2.m.daocloud.io \
&& systemctl restart docker

將kubelet 二進制文件拷貝node節點

cd /data/upload/kubernetes/server/bin
[root@localhost bin]# pwd 
/data/upload/kubernetes/server/bin
\cp kubelet kube-proxy /data/soft/kubernetes/bin/

scp -P 12525 -r kubelet kube-proxy [email protected]:/data/soft/kubernetes/bin/
scp -P 12525 -r kubelet kube-proxy [email protected]:/data/soft/kubernetes/bin/

創建 kubelet bootstrap kubeconfig 文件

在生成kubernetes證書的目錄下執行以下命令生成kubeconfig文件：

創建腳本快速執行文件時，需要進入/data/soft/kubernetes/ssl/目錄中去執行

cd /data/soft/kubernetes/ssl/

vim  environment.sh
# 創建 kubelet bootstrapping kubeconfig
BOOTSTRAP_TOKEN=2366a641f656a0a025abb4aabda4511b

KUBE_APISERVER="//192.168.0.10:6443"
# kuber-apiserver啟動參數中的token.csv和kubelet啟動參數中指定的bootstrap文件bootstrap.kubeconfig中的token值是否一致，此外該token必須為實際數值，不能使用變量代替

# 設置集群參數
kubectl config set-cluster kubernetes \
  --certificate-authority=./ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=bootstrap.kubeconfig

# 設置客戶端認證參數

kubectl config set-credentials kubelet-bootstrap \
  --token=${BOOTSTRAP_TOKEN} \
  --kubeconfig=bootstrap.kubeconfig

# 設置上下文參數

kubectl config set-context default \
  --cluster=kubernetes \
  --user=kubelet-bootstrap \
  --kubeconfig=bootstrap.kubeconfig

# 設置默認上下文

kubectl config use-context default --kubeconfig=bootstrap.kubeconfig

#----------------------
# 創建kube-proxy kubeconfig文件
kubectl config set-cluster kubernetes \
  --certificate-authority=./ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --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

執行該腳本

bash  environment.sh

將bootstrap.kubeconfig kube-proxy.kubeconfig 文件拷貝到所有 nodes節點

cp bootstrap.kubeconfig kube-proxy.kubeconfig /data/soft/kubernetes/cfg/
scp -P 12525 -r bootstrap.kubeconfig kube-proxy.kubeconfig [email protected]:/data/soft/kubernetes/cfg/
scp -P 12525 -r bootstrap.kubeconfig kube-proxy.kubeconfig [email protected]:/data/soft/kubernetes/cfg/

node節點配置kubelet

注意：創建kubelet 參數配置文件拷貝到所有nodes節點，這裡只列舉了其中一個node 的配置，其他的node配置可以參考這個配置，修改下本機ip地址既可

創建 kubelet 參數配置模板文件：

vim /data/soft/kubernetes/cfg/kubelet.config
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: 192.168.0.7
port: 10250
readOnlyPort: 10255
cgroupDriver: cgroupfs
clusterDNS: ["10.0.0.2"]
clusterDomain: cluster.local.
failSwapOn: false
authentication:
  anonymous:
enabled: true

參數說明：

address: 授權綁定的ip地址（node本地ip）

創建kubelet配置文件

vim /data/soft/kubernetes/cfg/kubelet
KUBELET_OPTS="--logtostderr=true \
--v=4 \
--hostname-override=192.168.0.7 \
--kubeconfig=/data/soft/kubernetes/cfg/kubelet.kubeconfig \
--bootstrap-kubeconfig=/data/soft/kubernetes/cfg/bootstrap.kubeconfig \
--config=/data/soft/kubernetes/cfg/kubelet.config \
--cert-dir=/data/soft/kubernetes/ssl \
--pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google-containers/pause-amd64:3.0"

參數說明：

--hostname-override 在集群中顯示的主機名（node本機ip）
--kubeconfig 指定kubeconfig文件位置，會自動生成
--bootstrap-kubeconfig 指定剛才生成的bootstrap.kubeconfig文件
--cert-dir 頒發證書存放位置
--pod-infra-container-image 管理Pod網絡的鏡像

創建kubelet的kubelet.service 文件

vim /usr/lib/systemd/system/kubelet.service 
[Unit]
Description=Kubernetes Kubelet
After=docker.service
Requires=docker.service

[Service]
EnvironmentFile=/data/soft/kubernetes/cfg/kubelet
ExecStart=/data/soft/kubernetes/bin/kubelet $KUBELET_OPTS
Restart=on-failure
KillMode=process

[Install]
WantedBy=multi-user.target

將kubelet.config kubelet 文件拷貝到所有 nodes節點

cd /data/soft/kubernetes/cfg/
\cp kubelet.config   kubelet /data/soft/kubernetes/cfg/
scp -P 12525 -r kubelet.config   kubelet [email protected]:/data/soft/kubernetes/cfg/
scp -P 12525 -r kubelet.config   kubelet [email protected]:/data/soft/kubernetes/cfg/
scp -P 12525 -r /usr/lib/systemd/system/kubelet.service [email protected]:/usr/lib/systemd/system/kubelet.service
scp -P 12525 -r /usr/lib/systemd/system/kubelet.service [email protected]:/usr/lib/systemd/system/kubelet.service

將kubelet-bootstrap用戶綁定到系統集群角色,master 執行

/data/soft/kubernetes/bin/kubectl create clusterrolebinding kubelet-bootstrap \
--clusterrole=system:node-bootstrapper \
--user=kubelet-bootstrap

node啟動服務kubelet

systemctl daemon-reload
systemctl enable kubelet
systemctl restart kubelet

master節點approve kubelet CSR 請求處理

可以手動或自動 approve CSR 請求。推薦使用自動的方式，因為從 v1.8 版本開始，可以自動輪轉approve csr 後生成的證書。

這裡採用手動 approve CSR 請求，在Master節點查看請求籤名的Node：

查看 CSR 列表：

# kubectl get csr
NAME                                                   AGE    REQUESTOR           CONDITION
node-csr-An1VRgJ7FEMMF_uyy6iPjyF5ahuLx6tJMbk2SMthwLs   39m    kubelet-bootstrap   Pending
node-csr-dWPIyP_vD1w5gBS4iTZ6V5SJwbrdMx05YyybmbW3U5s   5m5s   kubelet-bootstrap   Pending

# kubectl certificate approve node-csr-An1VRgJ7FEMMF_uyy6iPjyF5ahuLx6tJMbk2SMthwLs

certificatesigningrequest.certificates.k8s.io/node-csr-An1VRgJ7FEMMF_uyy6iPjyF5ahuLx6tJMbk2SMthwLs

# kubectl certificate approve node-csr-dWPIyP_vD1w5gBS4iTZ6V5SJwbrdMx05YyybmbW3U5s  
certificatesigningrequest.certificates.k8s.io/node-csr-dWPIyP_vD1w5gBS4iTZ6V5SJwbrdMx05YyybmbW3U5s approved

# kubectl get csr
NAME                                                   AGE     REQUESTOR           CONDITION
node-csr-An1VRgJ7FEMMF_uyy6iPjyF5ahuLx6tJMbk2SMthwLs   41m     kubelet-bootstrap   Approved,Issued
node-csr-dWPIyP_vD1w5gBS4iTZ6V5SJwbrdMx05YyybmbW3U5s   7m32s   kubelet-bootstrap   Approved,Issued


Requesting User：請求 CSR 的用戶，kube-apiserver 會對它進行認證和授權；
Subject：請求籤名的證書信息；
證書的 CN 是 system:node:kube-node2， Organization 是 system:nodes，kube-apiserver 的 Node 授權模式會授予該證書的相關權限；

查看集群狀態

# kubectl get nodes
NAME           STATUS   ROLES    AGE   VERSION
192.168.0.7   Ready    <none>   25s   v1.16.0
192.168.0.8   Ready    <none>   13s   v1.16.0

Node上部署 kube-proxy 組件

kube-proxy 運行在所有 node節點上，它監聽 apiserver 中 service 和 Endpoint 的變化情況，創建路由規則來進行服務負載均衡，這裡只列舉了其中一個node 的配置，其他的node配置可以參考這個配置，修改下本機ip地址既可。

創建 kube-proxy 配置文件

vim /data/soft/kubernetes/cfg/kube-proxy
KUBE_PROXY_OPTS="--logtostderr=true \
--v=4 \
--hostname-override=192.168.0.7 \
--cluster-cidr=10.0.0.0/24 \
--proxy-mode=ipvs \
--masquerade-all=true \
--kubeconfig=/data/soft/kubernetes/cfg/kube-proxy.kubeconfig"

參數詳解：

bindAddress: 監聽地址（node本機ip）；
clientConnection.kubeconfig: 連接 apiserver 的 kubeconfig 文件；
clusterCIDR: kube-proxy 根據 --cluster-cidr 判斷集群內部和外部流量，指定 --cluster-cidr 或 --masquerade-all 選項後 kube-proxy 才會對訪問 Service IP 的請求做 SNAT；
hostnameOverride: 參數值必須與 kubelet 的值一致，否則 kube-proxy 啟動後會找不到該 Node，從而不會創建任何 ipvs 規則；
mode: 使用 ipvs 模式；

創建kube-proxy systemd unit 文件

vim /usr/lib/systemd/system/kube-proxy.service 
[Unit]
Description=Kubernetes Proxy
After=network.tarsget

[Service]
EnvironmentFile=/data/soft/kubernetes/cfg/kube-proxy
ExecStart=/data/soft/kubernetes/bin/kube-proxy $KUBE_PROXY_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target

將kubelet.config kubelet 文件拷貝到所有 nodes節點

cd /data/soft/kubernetes/cfg/
\cp kube-proxy /data/soft/kubernetes/cfg/
scp -P 12525 -r kube-proxy [email protected]:/data/soft/kubernetes/cfg/
scp -P 12525 -r kube-proxy [email protected]:/data/soft/kubernetes/cfg/
scp -P 12525 -r /usr/lib/systemd/system/kube-proxy.service [email protected]:/usr/lib/systemd/system/kube-proxy.service
scp -P 12525 -r /usr/lib/systemd/system/kube-proxy.service [email protected]:/usr/lib/systemd/system/kube-proxy.service

啟動服務

systemctl daemon-reload
systemctl enable kube-proxy
systemctl restart kube-proxy

ps -ef|grep kube-proxy
root      8719     1  1 12:39 ?        00:00:00 /data/soft/kubernetes/bin/kube-proxy --logtostderr=true --v=4 --hostname-override=192.168.0.8 --cluster-cidr=10.0.0.0/24 --proxy-mode=ipvs --masquerade-all=true --kubeconfig=/data/soft/kubernetes/cfg/kube-prox.kubeconfig

其他node節點配置一樣，可以使用scp 拷貝過去然後部署。

查看集群狀態(master)

打node 或者master 節點的標籤

kubectl label node 192.168.0.7  node-role.kubernetes.io/node='node'
kubectl label node 192.168.0.8  node-role.kubernetes.io/node='node'

# kubectl get node,cs
NAME               STATUS   ROLES    AGE    VERSION
node/192.168.0.7   Ready    node     114m   v1.13.0
node/192.168.0.8   Ready    node     93m    v1.13.0

 

NAME                                 STATUS    MESSAGE             ERROR

componentstatus/controller-manager   Healthy   ok                  

componentstatus/scheduler            Healthy   ok                  

componentstatus/etcd-0               Healthy   {"health":"true"}   

componentstatus/etcd-1               Healthy   {"health":"true"}   

componentstatus/etcd-2               Healthy   {"health":"true"}

運行一個Nginx 測試示例

創建一個Nginx Web，測試集群是否正常工作：

# kubectl run nginx --image=nginx --replicas=3
# kubectl expose deployment nginx --port=80 --target-port=80 --type=NodePort

查看Pod，Service：

# kubectl get pods
NAME                     READY     STATUS    RESTARTS   AGE
nginx-64f497f8fd-fjgt2   1/1       Running   3          1d
nginx-64f497f8fd-gmstq   1/1       Running   3          1d
nginx-64f497f8fd-q6wk9   1/1       Running   3          1d

# kubectl get svc
NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)                        AGE
kubernetes   ClusterIP   10.0.0.1     <none>        443/TCP                        28d
nginx        NodePort    10.0.0.175   <none>        88:38696/TCP                   28d

訪問集群中部署的Nginx，打開瀏覽器輸入：//192.168.0.7:38696

Kubernets Apiserver HA SLB

準備環境

內網ip	角色	安裝軟件
192.168.0.10	master01	etcd,kube-apiserver,kube-controller-manager,kube-scheduler
192.168.0.12	master02	etcd,kube-apiserver,kube-controller-manager,kube-scheduler
192.168.0.7	node01	docker,kubelet,kube-proxy,flannel
192.168.0.8	node02	docker,kubelet,kube-proxy,flannel
192.168.0.4	slb master	etcd,keeaplived，nginx
192.168.0.9	slb backup	keeaplived，nginx
192.168.0.200	keepalived上的VIP

我們使用兩台機器，當前是使用nginx+keepalived軟件進行apiserver 6443接口的負載均衡，實現apiserver高可用。

部署nginx和keepalived

這裡我們採用Nginx作為負載均衡軟件，現在流量大的apiserver 也可以採用haproxy 作為負載均衡軟件，也可以使用。

nginx 配置

yum install -y nginx
k8s-lb01，k8s-lb02都要安裝
centos7要是沒有nginx源，添加nginx的源

cat > /etc/yum.repos.d/nginx.repo << EOF
[nginx]
name=nginx repo
baseurl=//nginx.org/packages/centos/7/\$basearch/
gpgcheck=0
EOF

nginx 主配置文件

[root@k8s-lb02 nginx]# egrep -v '#|^$' /etc/nginx/nginx.conf
user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log;
pid /run/nginx.pid;
include /usr/share/nginx/modules/*.conf;
events {
    worker_connections 1024;
}
stream {
    log_format main '$remote_addr $upstream_addr - [$time_local] $status $upstream_bytes_sent';
    access_log /var/log/nginx/k8s-access.log main; 
    upstream k8s-apiserver {
        server 192.168.0.10:6443;
        server 192.168.0.12:6443;
    }
    server {
        listen 6443;
        proxy_pass k8s-apiserver;
    }

}
http {
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
    access_log  /var/log/nginx/access.log  main;
    sendfile            on;
    tcp_nopush          on;
    tcp_nodelay         on;
    keepalive_timeout   65;
    types_hash_max_size 2048;
    include             /etc/nginx/mime.types;
    default_type        application/octet-stream;
    include /etc/nginx/conf.d/*.conf;
    server {
        listen       80 default_server;
        listen       [::]:80 default_server;
        server_name  _;
        root         /usr/share/nginx/html;
        include /etc/nginx/default.d/*.conf;
        location / {
        }
        error_page 404 /404.html;
            location = /40x.html {
        }
        error_page 500 502 503 504 /50x.html;
            location = /50x.html {
        }
    }
}

# 兩台nginx的配置文件一樣

[root@k8s-lb01 nginx]# nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
[root@k8s-lb01 nginx]# systemctl start nginx

Keepalived配置

安裝keepalived

yum install -y keepalived

主keepalived.conf

[root@k8s-lb01 ~]# cat /etc/keepalived/keepalived.conf 
! Configuration File for keepalived 
global_defs { 
   notification_email { 
     [email protected] 
     [email protected] 
     [email protected] 
   } 
   notification_email_from [email protected]  
   smtp_server 127.0.0.1 
   smtp_connect_timeout 30 
   router_id NGINX_MASTER 
} 

vrrp_script check_nginx {
    script "/etc/nginx/check_nginx.sh"
}

vrrp_instance VI_1 { 
    state MASTER 
    interface eth0       # 網卡名
    virtual_router_id 51  # VRRP 路由 ID實例，每個實例是唯一的 
    priority 100          # 優先級，備服務器設置 90 
    advert_int 1          # 指定VRRP 心跳包通告間隔時間，默認1秒 
    authentication { 
        auth_type PASS      
        auth_pass 1111 
    }  
    virtual_ipaddress { 
        192.168.0.200/24 # vip地址
    } 
    track_script {
        check_nginx        # 監控腳本
    } 
}

從keepalived.conf

[root@k8s-lb02 nginx]# cat /etc/keepalived/keepalived.conf 
! Configuration File for keepalived 
global_defs { 
   notification_email { 
     [email protected] 
     [email protected] 
     [email protected] 
   } 
   notification_email_from [email protected]  
   smtp_server 127.0.0.1 
   smtp_connect_timeout 30 
   router_id NGINX_MASTER 
} 
 
vrrp_script check_nginx {
    script "/etc/nginx/check_nginx.sh"
}

vrrp_instance VI_1 { 
    state BACKUP 
    interface eth0       # 網卡名
    virtual_router_id 51  # VRRP 路由 ID實例，每個實例是唯一的 
    priority 90           # 優先級，備服務器設置 90 
    advert_int 1          # 指定VRRP 心跳包通告間隔時間，默認1秒 
    authentication { 
        auth_type PASS      
        auth_pass 1111 
    }  
    virtual_ipaddress { 
        192.168.0.200/24 # vip地址
    } 
    track_script {
        check_nginx        # 監控腳本
    } 
}

編寫check_nginx.sh

#!/bin/bash
count=$(ps -ef |grep nginx |egrep -cv "grep|$$")
if [ "$count" -eq 0 ];then
    systemctl stop keepalived
fi

keepalived 主備就優先和state 不一樣，主備的check_nginx.sh內容一樣。

[root@k8s-lb01 ~]# cat /etc/nginx/check_nginx.sh 
#!/bin/bash
count=$(ps -ef |grep nginx |egrep -cv "grep|$$")
if [ "$count" -eq 0 ];then
    systemctl stop keepalived
fi
[root@k8s-lb01 ~]# systemctl start keepalived

# 查看vip

[root@k8s-lb01 ~]# ip a
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: ens33: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 00:0c:29:c6:79:90 brd ff:ff:ff:ff:ff:ff
    inet 192.168.0.4/24 brd 192.168.186.255 scope global noprefixroute ens33
       valid_lft forever preferred_lft forever
    inet 192.168.0.200/24 scope global secondary ens33
       valid_lft forever preferred_lft forever
    inet6 fe80::9d58:5651:daa8:880a/64 scope link noprefixroute 
       valid_lft forever preferred_lft forever

到目前為止 k8s的前端HA和SLB做準備已經實現，下面開始部署另一個k8s-master，部署完在測試。

如果想配置 master 機器高可用，其實配置的就是apiserver 應用的高可用，但是需要配置好高可用ip地址之後，再去配置master02。

Kubernets Master02 部署

準備環境

接下來準備安裝另一個Kubernets master(192.168.0.12)。我們要安裝兩個master前端做slb。其實就是新增一個master節點，無非就是把證書，啟動文件，拷過去，然後修改對應參數即可。

拷貝master01 配置文件

scp -P 12525 -r /data/soft/kubernetes [email protected]:/data/soft/

scp -P 12525 -r /usr/lib/systemd/system/{kube-apiserver,kube-controller-manager,kube-scheduler}.service [email protected]:/usr/lib/systemd/system/

scp -P 12525 -r /usr/bin/kubectl [email protected]:/usr/bin/

scp -P 12525 -r /data/soft/etcd/ssl/ [email protected]:/data/soft/etcd/

注意修改配置文件，把kube-apiserver中的bind-address和dvertise-address ip地址修改為為本地ip地址

啟動apiserver,scheduler,controller-manager組件

systemctl start kube-apiserver.service 
systemctl start kube-scheduler.service 
systemctl start kube-controller-manager.service

檢查 master02 對應的進程

[root@k8s-master02 cfg]# ps axf|grep scheduler
  8644 pts/1    S+     0:00          \_ grep --color=auto scheduler
  8576 ?        Ssl    0:01 /data/soft/kubernetes/bin/kube-scheduler --logtostderr=true --v=4 --master=127.0.0.1:8080 --leader-elect

 
[root@k8s-master02 cfg]# ps axf|grep controller-manager
  8646 pts/1    S+     0:00          \_ grep --color=auto controller-manager
  8628 ?        Ssl    0:00 /data/soft/kubernetes/bin/kube-controller-manager --logtostderr=true --v=4 --master=127.0.0.1:8080 --leader-elect=true --address=127.0.0.1 --service-cluster-ip-range=10.0.0.0/24 --cluster-name=kubernetes --cluster-signing-cert-file=/data/soft/kubernetes/ssl/ca.pem --cluster-signing-key-file=/data/soft/kubernetes/ssl/ca-key.pem --root-ca-file=/data/soft/kubernetes/ssl/ca.pem --service-account-private-key-file=/data/soft/kubernetes/ssl/ca-key.pem --experimental-cluster-signing-duration=87600h0m0s

[root@k8s-master02 etcd]# ps axf|grep apiserver
  9528 pts/1    S+     0:00          \_ grep --color=auto apiserver
  9479 ?        Ssl    0:28 /data/soft/kubernetes/bin/kube-apiserver --logtostderr=true --v=4 --etcd-servers=//192.168.0.10:2379,//192.168.0.12:2379,//192.168.0.4:2379 --bind-address=192.168.0.12 --secure-port=6443 --advertise-address=192.168.0.12 --allow-privileged=true --service-cluster-ip-range=10.0.0.0/24 --enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,ResourceQuota,NodeRestriction --authorization-mode=RBAC,Node --kubelet-https=true --enable-bootstrap-token-auth --token-auth-file=/data/soft/kubernetes/cfg/token.csv --service-node-port-range=30000-50000 --tls-cert-file=/data/soft/kubernetes/ssl/server.pem --tls-private-key-file=/data/soft/kubernetes/ssl/server-key.pem --client-ca-file=/data/soft/kubernetes/ssl/ca.pem --service-account-key-file=/data/soft/kubernetes/ssl/ca-key.pem --etcd-cafile=/data/soft/etcd/ssl/ca.pem --etcd-certfile=/data/soft/etcd/ssl/server.pem --etcd-keyfile=/data/soft/etcd/ssl/server-key.pem[root@k8s-master02 etcd]# ps axf|grep scheduler
  9530 pts/1    S+     0:00          \_ grep --color=auto scheduler
  8576 ?        Ssl    0:21 /data/soft/kubernetes/bin/kube-scheduler --logtostderr=true --v=4 --master=127.0.0.1:8080 --leader-elect
[root@k8s-master02 etcd]# ps axf|grep controller-manager
  9532 pts/1    S+     0:00          \_ grep --color=auto controller-manager
  8628 ?        Ssl    0:01 /data/soft/kubernetes/bin/kube-controller-manager --logtostderr=true --v=4 --master=127.0.0.1:8080 --leader-elect=true --address=127.0.0.1 --service-cluster-ip-range=10.0.0.0/24 --cluster-name=kubernetes --cluster-signing-cert-file=/data/soft/kubernetes/ssl/ca.pem --cluster-signing-key-file=/data/soft/kubernetes/ssl/ca-key.pem --root-ca-file=/data/soft/kubernetes/ssl/ca.pem --service-account-private-key-file=/data/soft/kubernetes/ssl/ca-key.pem --experimental-cluster-signing-duration=87600h0m0s

**master02的所有配置文件如下: **

[root@k8s-master02 kubernetes]# tree .
.
├── bin
│   ├── kube-apiserver
│   ├── kube-controller-manager
│   └── kube-scheduler
├── cfg
│   ├── kube-apiserver
│   ├── kube-controller-manager
│   ├── kube-scheduler
│   └── token.csv
├── logs
└── ssl
    ├── ca-key.pem
    ├── ca.pem
    ├── server-key.pem
    └── server.pem
 
4 directories, 11 files

查看master02 上kube-apiserver配置文件

[root@k8s-master02 cfg]# cat kube-apiserver
KUBE_APISERVER_OPTS="--logtostderr=true \
--v=4 \
--etcd-servers=//192.168.0.10:2379,//192.168.0.12:2379,//192.168.0.4:2379 \
--bind-address=192.168.0.12 \
--secure-port=6443 \
--advertise-address=192.168.0.12 \
--allow-privileged=true \
--service-cluster-ip-range=10.0.0.0/24 \
--enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,ResourceQuota,NodeRestriction \
--authorization-mode=RBAC,Node \
--kubelet-https=true \
--enable-bootstrap-token-auth \
--token-auth-file=/data/soft/kubernetes/cfg/token.csv \
--service-node-port-range=30000-50000 \
--tls-cert-file=/data/soft/kubernetes/ssl/server.pem  \
--tls-private-key-file=/data/soft/kubernetes/ssl/server-key.pem \
--client-ca-file=/data/soft/kubernetes/ssl/ca.pem \
--service-account-key-file=/data/soft/kubernetes/ssl/ca-key.pem \
--etcd-cafile=/data/soft/etcd/ssl/ca.pem \
--etcd-certfile=/data/soft/etcd/ssl/server.pem \
--etcd-keyfile=/data/soft/etcd/ssl/server-key.pem"

查看master02 上 kube-controller-manager 配置文件

[root@k8s-master02 cfg]# cat kube-controller-manager
KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=true \
--v=4 \
--master=127.0.0.1:8080 \
--leader-elect=true \
--address=127.0.0.1 \
--service-cluster-ip-range=10.0.0.0/24 \
--cluster-name=kubernetes \
--cluster-signing-cert-file=/data/soft/kubernetes/ssl/ca.pem \
--cluster-signing-key-file=/data/soft/kubernetes/ssl/ca-key.pem  \
--root-ca-file=/data/soft/kubernetes/ssl/ca.pem \
--service-account-private-key-file=/data/soft/kubernetes/ssl/ca-key.pem \
--experimental-cluster-signing-duration=87600h0m0s"

查看master02 上kube-scheduler 配置文件

[root@k8s-master02 cfg]# cat kube-scheduler
KUBE_SCHEDULER_OPTS="--logtostderr=true \
--v=4 \
--master=127.0.0.1:8080 \
--leader-elect"

token.csv 配置文件

[root@k8s-master02 cfg]# cat token.csv
2366a641f656a0a025abb4aabda4511b,kubelet-bootstrap,10001,"system:kubelet-bootstrap"

測試Master02配置

[root@k8s-master02 ~]# kubectl get pods
NAME                   READY   STATUS    RESTARTS   AGE
nginx-5c7588df-c58ql   1/1     Running   0          3d15h
nginx-5c7588df-gh6l9   1/1     Running   0          3d15h
nginx-5c7588df-nlj5l   1/1     Running   0          3d15h
nginx-5c7588df-p8ls9   1/1     Running   0          2d17h
nginx-5c7588df-sv64n   1/1     Running   0          2d17h

[root@k8s-master02 ~]# kubectl get nodes -o wide
NAME              STATUS   ROLES    AGE     VERSION   INTERNAL-IP       EXTERNAL-IP   OS-IMAGE                KERNEL-VERSION               CONTAINER-RUNTIME
192.168.0.7   Ready    <none>   3d16h   v1.13.4   192.168.0.7   <none>        CentOS Linux 7 (Core)   3.10.0-957.el7.x86_64        docker://18.9.5
192.168.0.8   Ready    <none>   3d15h   v1.13.4   192.168.0.8   <none>        CentOS Linux 7 (Core)   3.10.0-957.10.1.el7.x86_64   docker://18.9.5

[root@k8s-master02 kubernetes]# kubectl get cs
NAME                 STATUS    MESSAGE             ERROR
scheduler            Healthy   ok                  
controller-manager   Healthy   ok                  
etcd-0               Healthy   {"health":"true"}   
etcd-1               Healthy   {"health":"true"}   
etcd-2               Healthy   {"health":"true"}

到目前為相當完全複製master[除了修改配置文件]過來，啟動一個新的master。以後不管新增幾台master都是這樣操作。
注意：

服務器時間
證書
配置文件
啟動命令

Node節點配置Apiserver負載地址

配置node節點

我們此時將node節點指向到slb上，不在是指向master上了。此時就是將node節點的指向ip由原來的指向master ip改為slb的vip即可。

node1修改配置

[root@k8s-node01 ~]# cd /data/soft/kubernetes/cfg/
[root@k8s-node01 cfg]# ls
bootstrap.kubeconfig  flanneld  kubelet  kubelet.config  kubelet.kubeconfig  kube-proxy  kube-proxy.kubeconfig
[root@k8s-node01 cfg]# grep -irn 0.10 *
bootstrap.kubeconfig:5:    server: //192.168.0.10:6443
flanneld:2:FLANNEL_OPTIONS="--etcd-endpoints=//192.168.0.10:2379,//192.168.0.12:2379,//192.168.0.4:2379 -etcd-cafile=/data/soft/etcd/ssl/ca.pem -etcd-certfile=/data/soft/etcd/ssl/server.pem -etcd-keyfile=/data/soft/etcd/ssl/server-key.pem"kubelet.kubeconfig:5:    server: //192.168.0.10:6443
kube-proxy.kubeconfig:5:    server: //192.168.0.10:6443

其中要修改的 bootstrap.kubeconfig 第五行，kubelet.kubeconfig第五行，kube-proxy.kubeconfig第五行。修改後如下：
[root@k8s-node01 cfg]# grep -irn 200 *
bootstrap.kubeconfig:5:    server: //192.168.0.200:6443
kubelet.kubeconfig:5:    server: //192.168.0.200:6443
kube-proxy.kubeconfig:5:    server: //192.168.0.200:6443

# 重啟服務

[root@k8s-node01 cfg]# systemctl restart kubelet
[root@k8s-node01 cfg]# systemctl restart kube-proxy

node2修改配置

[root@k8s-node02 ~]# cd /data/soft/kubernetes/cfg/
[root@k8s-node02 cfg]# ll
total 32
-rw------- 1 root root 2169 Apr 18 17:49 bootstrap.kubeconfig
-rw-r--r-- 1 root root  241 Apr 18 17:49 flanneld
-rw-r--r-- 1 root root  413 Apr 18 17:55 kubelet
-rw-r--r-- 1 root root  269 Apr 18 17:56 kubelet.config
-rw------- 1 root root 2298 Apr 18 18:07 kubelet.kubeconfig
-rw-r--r-- 1 root root  191 Apr 18 18:01 kube-proxy
-rw------- 1 root root 6271 Apr 18 17:49 kube-proxy.kubeconfig

[root@k8s-node02 cfg]# grep -irn 223 *
bootstrap.kubeconfig:5:    server: //192.168.0.10:6443
flanneld:2:FLANNEL_OPTIONS="--etcd-endpoints=//192.168.0.10:2379,//192.168.0.12:2379,//192.168.0.12:2379 -etcd-cafile=/data/soft/etcd/ssl/ca.pem -etcd-certfile=/data/soft/etcd/ssl/server.pem -etcd-keyfile=/data/soft/etcd/ssl/server-key.pem"kubelet.kubeconfig:5:    server: //192.168.0.10:6443
kube-proxy.kubeconfig:5:    server: //192.168.0.10:6443
[root@k8s-node02 cfg]# vim bootstrap.kubeconfig +5
[root@k8s-node02 cfg]# vim kubelet.kubeconfig +5
[root@k8s-node02 cfg]# vim kube-proxy.kubeconfig +5

[root@k8s-node02 cfg]# grep -irn 200 *
bootstrap.kubeconfig:5:    server: //192.168.0.200:6443
kubelet.kubeconfig:5:    server: //192.168.0.200:6443
kube-proxy.kubeconfig:5:    server: //192.168.0.200:6443

重啟node2節點服務

[root@k8s-node02 cfg]# systemctl restart kubelet
[root@k8s-node02 cfg]# systemctl restart kube-proxy

到此kubernetes 基礎架構配置完成————————-

擴展配置

NODE節點執行kubectl命令

這一章節操作是為了生產kubeconfig文件，此文件主要用於在node節點上面執行kubectl 命令，同時也可以生成此文件給開發或者其他普通用戶執行kubectl命令。具體步驟如下：

# 在master01上操作

cd k8s-cert

vim kubectl.sh 
kubectl config set-cluster kubernetes \
--server=//192.168.0.200:6443 \
--embed-certs=true \
--certificate-authority=ca.pem \
--kubeconfig=config

kubectl config set-credentials cluster-admin \
--certificate-authority=ca.pem \
--embed-certs=true \
--client-key=admin-key.pem \
--client-certificate=admin.pem \
--kubeconfig=config

kubectl config set-context default --cluster=kubernetes --user=cluster-admin --kubeconfig=config
kubectl config use-context default --kubeconfig=config

[root@k8s-master01 k8s-cert]# pwd
/data/www/k8s-cert
[root@k8s-master01 k8s-cert]# bash kubectl.sh 
Cluster "kubernetes" set.
User "cluster-admin" set.
Context "default" created.
Switched to context "default".

[root@k8s-master01 k8s-cert]# ls config 
config

[root@k8s-master01 k8s-cert]# ls
admin.csr       bootstrap.kubeconfig  ca-key.pem   kubeconfig.sh        kube-proxy-key.pem     server-csr.json
admin-csr.json  ca-config.json        ca.pem       kubectl.sh           kube-proxy.kubeconfig  server-key.pem
admin-key.pem   ca.csr                config       kube-proxy.csr       kube-proxy.pem         server.pem
admin.pem       ca-csr.json           k8s-cert.sh  kube-proxy-csr.json  server.csr

分發新生成的證書到node節點

192.168.0.7[root@k8s-master01 k8s-cert]# scp  /usr/bin/kubectl [email protected]:/usr/bin/
[email protected]'s password: 
kubectl                                                                                         100%   37MB  68.2MB/s   00:00    
[root@k8s-master01 k8s-cert]# scp  config [email protected]:/root
[email protected]'s password: 
config                                                                                          100% 6273     3.7MB/s   00:00

在node1上操作

[root@k8s-node01 ~]# pwd
/root
[root@k8s-node01 ~]# ls
anaconda-ks.cfg  config  flannel.sh  flannel-v0.10.0-linux-amd64.tar.gz  kubelet.sh  node.zip  proxy.sh  README.md
[root@k8s-node01 ~]# kubectl --kubeconfig=./config  get nodes
NAME              STATUS   ROLES    AGE     VERSION
192.168.0.7   Ready    <none>   3d18h   v1.16.4
192.168.0.8   Ready    <none>   3d17h   v1.16.4

[root@k8s-node01 ~]# kubectl --kubeconfig=./config  get nodes -o wide
NAME              STATUS   ROLES    AGE     VERSION   INTERNAL-IP       EXTERNAL-IP   OS-IMAGE                KERNEL-VERSION               CONTAINER-RUNTIME
192.168.0.7   Ready    <none>   3d18h   v1.16.4   192.168.0.7   <none>        CentOS Linux 7 (Core)   3.10.0-957.el7.x86_64        docker://18.9.5
192.168.0.8   Ready    <none>   3d17h   v1.16.4   192.168.0.8   <none>        CentOS Linux 7 (Core)   3.10.0-957.10.1.el7.x86_64   docker://18.9.5

常見問題

api啟動不了報錯（配置文件錯誤）

#發現api-server沒啟動排錯

[root@k8s-master02 cfg]# source /data/soft/kubernetes/cfg/kube-apiserver
[root@k8s-master02 cfg]# /data/soft/kubernetes/bin/kube-apiserver $KUBE_APISERVER_OPTS
error: failed to create listener: failed to listen on 192.168.0.10:6443: listen tcp 192.168.0.10:6443: bind: cannot assign requested address

[root@k8s-master02 cfg]# grep 10 *
kube-apiserver:--etcd-servers=//192.168.0.10:2379,//192.168.0.12:2379,//192.168.0.4:2379 \
kube-apiserver:--bind-address=192.168.0.10 \

**--bind-address=192.168.0.12 要修改成本機的。我模擬了該錯誤，怎麼排查**

[root@k8s-master02 cfg]# systemctl start kube-apiserver.service

鏈接api-server報錯（證書問題）

這個時候如果出現連接api-server 報錯時，多數情況是因為api-server 證書連接沒有被允許。
可以看出，我們從其他非master的機器通過證書和命令鏈接到機器中[其實就是通過加載證書，鏈接apiserver，我沒有其他閑置機器。我使用了node1節點，你找其他機器都可以，但是保證你的apiserver的證書中允許該ip]

如果需要再後面配置多個地址鏈接apiserver，需要提前在k8s-cert.sh中指定了api server允許鏈接的ip，就是下面這個配置中

cat > api-server-csr.json <<EOF
{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
      "127.0.0.1",
      "192.168.0.10",
      "192.168.0.12",
      "192.168.0.7",
      "192.168.0.8",
      "192.168.0.4",
      "192.168.0.9",
      "192.168.0.200",
      "kubernetes",
      "kubernetes.default",
      "kubernetes.default.svc",
      "kubernetes.default.svc.cluster",
      "kubernetes.default.svc.cluster.local"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Shenzhen",
            "ST": "Shenzhen",
            "O": "k8s",
            "OU": "System"
        }
    ]
}
EOF

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes server-csr.json | cfssljson -bare server

# 具體參考安裝master時候，給apiserver 製作的證書

我在做master+nginx slb的時候把證書和啟動文件拷貝到node1上 啟動的時候加載了證書，顯示顯示如下: 
[root@k8s-node01 ~]# kubectl --kubeconfig=./config get node   # 其實就是去鏈接apiserver[apiserver中ip限制].
Unable to connect to the server: x509: certificate is valid for 10.0.0.1, 127.0.0.1, 192.168.0.10, 192.168.0.12, 192.168.0.7,192.168.0.8,192.168.0.4, 192.168.0.9, 192.168.0.200, not 192.168.186.100

後面發現我的vip 192.168.0.200不在apiserver 信任裏面。解決辦法:

1. 修改我製作apiserver的時候預留的ip
2. 重新製作spiserver證書，分發到其他機器上。

我們選擇了第一種

普通用戶操作systemd服務啟動和重啟

普通用戶操作systemd服務
解決方案：
根據上面提示得知權限由polkit進行管理，對應的是org.freedesktop.systemd1.policy這個配置文件下的manae-units動作

進入/usr/share/polkit-1/actions/org.freedesktop.systemd1.policy，
配置如下：
				<action id="org.freedesktop.systemd1.manage-units">
				省略...
                        <defaults>
                        <allow_any>yes</allow_any>
                        <allow_inactive>yes</allow_inactive>
                        <allow_active>yes</allow_active>
                </defaults>
        </action>
end---

將對應manae-units的defaults中的授權全部改為yes，然後執行systemctl restart polkit重啟polkit

查看pod日誌報錯

kubectl logs nginx-6db489d4b7-2xnhg
error: You must be logged in to the server (the server has asked for the client to provide credentials ( pods/log nginx-6db489d4b7-2xnhg))

查看日誌出現這個錯誤，需要先授權。

[root@k8s-master01 bin]# kubectl create clusterrolebinding cluster-system-anonymous --clusterrole=cluster-admin --user=system:anonymous
clusterrolebinding.rbac.authorization.k8s.io/cluster-system-anonymous created
[root@k8s-master01 bin]# kubectl logs nginx-5c7588df-c58ql
172.17.66.0 - - [18/Apr/2019:10:17:42 +0000] "GET / HTTP/1.1" 200 612 "-" "curl/7.29.0" "-"
172.17.66.0 - - [18/Apr/2019:10:18:50 +0000] "GET / HTTP/1.1" 200 612 "-" "curl/7.2

Tags: Kubernetes