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

PassZhang發表於2020-07-12

操作環境

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

注意

  1. flannel可以只安裝node上，flannel只是跨機器宿主機和容器通訊使用

  2. docker可以只安裝node上，master上可以不安裝

  3. etcd 鍵值對的資料庫，是獨立三臺機器。不要複用。

  4. 192.168.0.200是keepalived上的vip

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

自籤SSL證書

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

k8s安裝包下載

https://github.com/kubernetes

部署網路說明

Kubernetes 網路架構圖

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

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

Flannel：是Overlay網路的一種，也是將源資料包封裝在另一種網路包裡面進行路由轉發和通訊，目前已經支援UDP、VXLAN、AWS VPC和GCE路由等資料轉發方式。

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

Flannel網路架構圖

  1. 資料從源容器中發出後，經由所在主機的docker0虛擬網路卡轉發到flannel0虛擬網路卡，這是個P2P的虛擬網路卡，flanneld服務監聽在網路卡的另外一端。

  2. Flannel通過Etcd服務維護了一張節點間的路由表，在稍後的配置部分我們會介紹其中的內容。

  3. 源主機的flanneld服務將原本的資料內容UDP封裝後根據自己的路由表投遞給目的節點的flanneld服務，資料到達以後被解包，然後直接進入目的節點的flannel0虛擬網路卡，

  4. 然後被轉發到目的主機的docker0虛擬網路卡，最後就像本機容器通訊一下的有docker0路由到達目標容器。

Kubernetes基本工作流程

客戶端建立pod 流程：

  1. 首先管理員建立 Pod 的請求預設是通過kubectl 客戶端管理命令 api server 元件進行互動的，預設會將請求傳送給 API Server 叢集統一入口。

  2. API Server 會根據請求的型別選擇用何種 REST API 對請求作出處理（比如：建立 Pod 時 Storage 型別是 Pods 時，其對應的就是 REST Storage API）。

  3. REST Storage API 會對請求作相應的處理並將處理的結果存入高可用鍵值儲存系統 Etcd 中。

  4. 同時Scheduler會檢測到etcd叢集的變化，Scheduler 會根據ETCD叢集中執行 Pod情況 及 Node 資訊進行判斷，將需要建立的 Pod 分發到可用的 Node 節點上。然後根據一組相關規則將pod分配到可以執行它們的節點上，並更新etcd資料庫，記錄pod分配情況。

  5. Node節點上Kubelet監控etcd資料庫變化，管理建立pod，kubelet在Node節點上面開始建立新的pod，就會進行docker元件的啟動，docker元件會啟動對應的容器（pod），會在該節點上執行這個新pod。

  6. 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 http://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 https://get.daocloud.io/daotools/set_mirror.sh | sh -s http://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 https://pkg.cfssl.org/R1.2/cfssl_linux-amd64
wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64
wget https://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="https://192.168.0.10:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.0.10:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.0.10:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.0.10:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.0.10:2380,etcd02=https://192.168.0.12:2380,etcd03=https://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},http://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 www@192.168.0.12:/data/soft/etcd/ssl/
scp -P 12525 etcd-ca.pem etcd-server.pem  etcd-server-key.pem www@192.168.0.4:/data/soft/etcd/ssl/

將啟動檔案、配置檔案拷貝到 節點1、節點2

cd /data/soft/ 

scp -P 12525 -r etcd www@192.168.0.12:/data/soft
scp -P 12525 -r etcd www@192.168.0.4:/data/soft

scp -P 12525 -r /usr/lib/systemd/system/etcd.service  www@192.168.0.12:/usr/lib/systemd/system/etcd.service
scp -P 12525 -r /usr/lib/systemd/system/etcd.service  www@192.168.0.4:/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="https://192.168.0.12:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.0.12:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.0.12:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.0.12:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.0.10:2380,etcd02=https://192.168.0.12:2380,etcd03=https://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="https://192.168.0.4:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.0.4:2379"
 

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.0.4:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.0.4:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.0.10:2380,etcd02=https://192.168.0.12:2380,etcd03=https://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="https://192.168.0.10:2379,\
https://192.168.0.12:2379,\
https://192.168.0.4:2379" cluster-health
member b8fffb7f5b2f26e is healthy: got healthy result from https://192.168.0.12:2379
member 5ac283d796e472ba is healthy: got healthy result from https://192.168.0.4:2379
member a569e0ee3b34eefa is healthy: got healthy result from https://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機器，我就搞錯了，第一次錯誤，證書問題搞了好久]

部署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節點都操作。

  1. 安裝好docker
yum install -y yum-utils device-mapper-persistent-data lvm2 && yum-config-manager --add-repo https://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
  1. 配置docker加速器
cat > /etc/docker/daemon.json<<EOF
{
"registry-mirrors":["https://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="https://192.168.0.10:2379,https://192.168.0.12:2379,https://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"}}

注意：

  1. Falnnel要用etcd儲存自身一個子網資訊，所以要保證能成功連線Etcd，寫入預定義子網段：
  2. flanneld 當前版本 (v0.10.0) 不支援 etcd v3，故使用 etcd v2 API 寫入配置 key 和網段資料；
  3. 寫入的 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=https://192.168.0.10:2379,https://192.168.0.12:2379,https://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=https://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 www@192.168.0.7:/data/soft/
scp -P 12525 -r kubernetes www@192.168.0.8:/data/soft/
scp -P 12525 /data/soft/kubernetes/cfg/flanneld www@192.168.0.7:/data/soft/kubernetes/cfg/flanneld
scp -P 12525 /data/soft/kubernetes/cfg/flanneld www@192.168.0.8:/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=https://192.168.0.10:2379,https://192.168.0.12:2379,https://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 相關引數，參考：

注意：

  1. --requestheader-client-ca-file 指定的 CA 證書，必須具有 client auth and server auth；

  2. 如果--requestheader-allowed-names不為空,且--proxy-client-cert-file證書的 CN 名稱不在 allowed-names 中，則後續檢視 node 或 pods 的 metrics 失敗，會提示：

    $ kubectl top nodes
Error from server (Forbidden): nodes.metrics.k8s.io is forbidden: User "aggregator" cannot list

建立 kube-apiserver 的kube-apiserver.service檔案

vim /usr/lib/systemd/system/kube-apiserver.service 
[Unit]
Description=Kubernetes API Server
Documentation=https://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=https://192.168.0.10:2379,https://192.168.0.12:2379,https://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=https://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=https://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動態簽署。

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

image-20200712150856136

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
  1. node節點安裝好docker
yum-config-manager --add-repo http://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
  1. 配置docker加速器
curl -sSL https://get.daocloud.io/daotools/set_mirror.sh | sh -s http://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 www@192.168.0.7:/data/soft/kubernetes/bin/
scp -P 12525 -r kubelet kube-proxy www@192.168.0.8:/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="https://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 www@192.168.0.7:/data/soft/kubernetes/cfg/
scp -P 12525 -r bootstrap.kubeconfig kube-proxy.kubeconfig www@192.168.0.8:/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 www@192.168.0.7:/data/soft/kubernetes/cfg/
scp -P 12525 -r kubelet.config   kubelet www@192.168.0.8:/data/soft/kubernetes/cfg/
scp -P 12525 -r /usr/lib/systemd/system/kubelet.service www@192.168.0.7:/usr/lib/systemd/system/kubelet.service
scp -P 12525 -r /usr/lib/systemd/system/kubelet.service www@192.168.0.8:/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 www@192.168.0.7:/data/soft/kubernetes/cfg/
scp -P 12525 -r kube-proxy www@192.168.0.8:/data/soft/kubernetes/cfg/
scp -P 12525 -r /usr/lib/systemd/system/kube-proxy.service www@192.168.0.7:/usr/lib/systemd/system/kube-proxy.service
scp -P 12525 -r /usr/lib/systemd/system/kube-proxy.service www@192.168.0.8:/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，開啟瀏覽器輸入：http://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=http://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 { 
     acassen@firewall.loc 
     failover@firewall.loc 
     sysadmin@firewall.loc 
   } 
   notification_email_from Alexandre.Cassen@firewall.loc  
   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 { 
     acassen@firewall.loc 
     failover@firewall.loc 
     sysadmin@firewall.loc 
   } 
   notification_email_from Alexandre.Cassen@firewall.loc  
   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 www@192.168.0.12:/data/soft/

scp -P 12525 -r /usr/lib/systemd/system/{kube-apiserver,kube-controller-manager,kube-scheduler}.service www@192.168.0.12:/usr/lib/systemd/system/

scp -P 12525 -r /usr/bin/kubectl root@192.168.0.12:/usr/bin/

scp -P 12525 -r /data/soft/etcd/ssl/ www@192.168.0.12:/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=https://192.168.0.10:2379,https://192.168.0.12:2379,https://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=https://192.168.0.10:2379,https://192.168.0.12:2379,https://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都是這樣操作。
注意：

  1. 伺服器時間
  2. 證書
  3. 配置檔案
  4. 啟動命令

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: https://192.168.0.10:6443
flanneld:2:FLANNEL_OPTIONS="--etcd-endpoints=https://192.168.0.10:2379,https://192.168.0.12:2379,https://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: https://192.168.0.10:6443
kube-proxy.kubeconfig:5:    server: https://192.168.0.10:6443

其中要修改的 bootstrap.kubeconfig 第五行，kubelet.kubeconfig第五行，kube-proxy.kubeconfig第五行。修改後如下：
[root@k8s-node01 cfg]# grep -irn 200 *
bootstrap.kubeconfig:5:    server: https://192.168.0.200:6443
kubelet.kubeconfig:5:    server: https://192.168.0.200:6443
kube-proxy.kubeconfig:5:    server: https://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: https://192.168.0.10:6443
flanneld:2:FLANNEL_OPTIONS="--etcd-endpoints=https://192.168.0.10:2379,https://192.168.0.12:2379,https://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: https://192.168.0.10:6443
kube-proxy.kubeconfig:5:    server: https://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: https://192.168.0.200:6443
kubelet.kubeconfig:5:    server: https://192.168.0.200:6443
kube-proxy.kubeconfig:5:    server: https://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=https://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 root@192.168.0.7:/usr/bin/
root@192.168.0.7's password: 
kubectl                                                                                         100%   37MB  68.2MB/s   00:00    
[root@k8s-master01 k8s-cert]# scp  config root@192.168.0.7:/root
root@192.168.0.7'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=https://192.168.0.10:2379,https://192.168.0.12:2379,https://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

相關文章