二進制部署k8s集群

一、生產環境環境搭建

1、服務器說明
我們這里使用的是三台centos 7.6實體機，具體信息如下表：

10.10.14.95  gyl-test-master1

10.10.14.96  gyl-test-master2

10.10.14.97  gyl-test-node

master2后面也作為node節點

2、系統設置（所有節點）
2.1主機名
主機名必須每個節點都不一樣，並且保證所有點之間可以通過hostname互相訪問。
# 查看主機名
$ hostname

# 修改主機名
$ hostnamectl set-hostname <your_hostname>

# 配置host，使主節點之間可以通過hostname互相訪問
$ vi /etc/hosts
# <node-ip> <node-hostname>
2.2安裝依賴包
# 更新yum
$ yum update

# 安裝依賴包
$ yum install -y conntrack ipvsadm ipset jq sysstat curl iptables libseccomp

2.3 關閉防火牆、swap，重置iptables
# 關閉防火牆
$ systemctl stop firewalld && systemctl disable firewalld

# 重置iptables
$ iptables -F && iptables -X && iptables -F -t nat && iptables -X -t nat && iptables -P FORWARD ACCEPT

# 關閉swap
$ swapoff -a
$ sed -i '/swap/s/^\(.*\)$/#\1/g' /etc/fstab

# 關閉selinux
$ setenforce 0

# 關閉dnsmasq(否則可能導致docker容器無法解析域名) #若沒安裝dnsmasq就不用
$ service dnsmasq stop && systemctl disable dnsmasq
2.4 系統參數設置
# 制作配置文件
$ cat > /etc/sysctl.d/kubernetes.conf <<EOF
net.bridge.bridge-nf-call-iptables=1
net.bridge.bridge-nf-call-ip6tables=1
net.ipv4.ip_forward=1
vm.swappiness=0
vm.overcommit_memory=1
vm.panic_on_oom=0
fs.inotify.max_user_watches=89100
EOF

# 開啟模塊
$ modprobe br_netfilter
#檢查橋接網卡
$ls /proc/sys/net/bridge
#生效文件
$ sysctl -p /etc/sysctl.d/kubernetes.conf

 

二、安裝docker（三台機都要安裝docker）

1、常用方法（這里我選擇的是常用的方法）

# 配置yum源 $ yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo # 清理原有版本 $ yum remove docker \ docker-client \ docker-client-latest \ docker-common \ docker-latest \ docker-latest-logrotate \ docker-logrotate \ docker-engine \ container-selinux # 查看版本列表 $ yum list docker-ce --showduplicates | sort -r # 根據kubernetes對docker版本的兼容測試情況，我們選擇18.09版本 $ yum install docker-ce-18.09.9 docker-ce-cli-18.09.9 containerd.io

# 開機啟動 $ systemctl enable docker

# 1.查看磁盤掛載 $ df -h Filesystem Size Used Avail Use% Mounted on /dev/sda2 98G 2.8G 95G 3% / devtmpfs 63G 0 63G 0% /dev /dev/sda5 1015G 8.8G 1006G 1% /data /dev/sda1 197M 161M 37M 82% /boot # 2.選擇比較大的分區（我這里是/data） $ mkdir -p /data/docker-data $ cat <<EOF > /etc/docker/daemon.json { "graph": "/data/docker-data" } EOF # 啟動docker服務 $ service docker restart

三. 准備二進制文件（所有節點）

3.1配置免密登錄

為了方便文件的copy我們選擇一個中轉節點，配置好跟其他所有節點的免密登錄

 

# 創建一個新的秘鑰文件（輸入命令后直接一路回車，在其中一台master操作就可以了，然后把文件拷貝授權給其他機器即可）
$ ssh-keygen -t rsa

$ cat ~/.ssh/id_rsa.pub

# 把id_rsa.pub文件內容copy到其他機器的授權文件中（先yes、然后輸入密碼、再回車確認下即可）

$ ssh-copy-id remote_username@server_ip_address

4.2 下載二進制文件
官方下載地址（在CHANGELOG鏈接里面）： https://github.com/kubernetes/kubernetes/releases

網盤下載地址--推薦（我從官網下載整理好的文件）：

鏈接: https://pan.baidu.com/s/1_w9vyQaDGLKDOf_TU2Xu8Q
提取碼: vca8

 

4.3 分發文件並設置好PATH
# 把文件copy到每個節點上（注意替換自己的文件目錄）

$ ssh <user>@<node-ip> "mkdir -p /opt/kubernetes/bin"

 

$ scp master/* <user>@<master-ip>:/opt/kubernetes/bin/
$ scp worker/* <user>@<worker-ip>:/opt/kubernetes/bin/

 

 

# 給每個節點設置PATH
$ ssh <user>@<node-ip> "echo 'PATH=/opt/kubernetes/bin:$PATH' >>~/.bashrc"

# 給中控機設置path，后面會用到kubectl命令
$ vi ~/.bash_profile

增加環境變量 export PATH=$PATH:/opt/kubernetes/bin

source ~/.bash_profile

 

5. 准備配置文件（中轉節點）
上一步我們下載了kubernetes各個組件的二進制文件，這些可執行文件的運行也是需要添加很多參數的，包括有的還會依賴一些配置文件。現在我們就把運行它們需要的參數和配置文件都准備好。

5.1 下載配置文件
我這准備了一個項目，專門為大家按照自己的環境生成配置的。它只是幫助大家盡量的減少了機械化的重復工作。它並不會幫你設置系統環境，不會給你安裝軟件。總之就是會減少你的部署工作量，但不會耽誤你對整個系統的認識和把控。

下載地址 

鏈接：https://pan.baidu.com/s/18qmC-H_0VVmOqROILTuGuw
提取碼：c5p3

# 下載后上傳到中控機，查看git內容
$ ls -l kubernetes-ha-binary
addons/
configs/
pki/
services/
init.sh
global-configs.properties

 

 

5.2 文件說明
addons: kubernetes的插件目錄，包括calico、coredns、dashboard等。

configs: 這個目錄比較 - 凌亂，包含了部署集群過程中用到的雜七雜八的配置文件、腳本文件等。

pki: 各個件的認證授權相關證書配置。

services: 所有的kubernetes服務(service)配置文件。

global-configs.properties: 全局配置，包含各種易變的配置內容。

init.sh : 初始化腳本，配置好global-config之后，會自動生成所有配置文件。

5.3 生成配置
這里會根據大家各自的環境生成kubernetes部署過程需要的配置文件。 在每個節點上都生成一遍，把所有配置都生成好，后面會根據節點類型去使用相關的配置。

# cd到之前下載的git代碼目錄
$ cd kubernetes-ha-binary

# 編輯屬性配置（根據文件注釋中的說明填寫好每個key-value）
$ vi global-config.properties(留意網卡接口名，我這里是ens192)

# 生成配置文件，確保執行過程沒有異常信息
$ ./init.sh

# 查看生成的配置文件，確保腳本執行成功
$ find target/ -type f

 

二、高可用集群部署

1. CA證書（任意節點，這些我選擇master1）
1.1 安裝cfssl
cfssl是非常好用的CA工具，我們用它來生成證書和秘鑰文件 安裝過程比較簡單，如下：

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

# 修改為可執行權限
$ chmod +x ~/bin/cfssl ~/bin/cfssljson

# 設置PATH
$ vi ~/.bash_profile

export PATH=$PATH:/opt/kubernetes/bin:~/bin

$ source ~/.bash_profile

# 驗證
$ cfssl version
1.2 生成根證書
根證書是集群所有節點共享的，只需要創建一個 CA 證書，后續創建的所有證書都由它簽名。

# 生成證書和私鑰
$ cd target/pki
$ cfssl gencert -initca ca-csr.json | cfssljson -bare ca

# 生成完成后會有以下文件（我們最終想要的就是ca-key.pem和ca.pem，一個秘鑰，一個證書）
$ ls
ca-config.json ca.csr ca-csr.json ca-key.pem ca.pem

# 創建目錄
$ ssh <user>@<node-ip> "mkdir -p /etc/kubernetes/pki/"

# 分發到每個主節點
$ scp ca*.pem <user>@<node-ip>:/etc/kubernetes/pki/

 

 

2. 部署etcd集群（master節點）
2.1 下載etcd
如果你是從網盤下載的二進制可以跳過這一步（網盤中已經包含了etcd，不需要另外下載）。 沒有從網盤下載bin文件的話需要自己下載etcd

$ wget https://github.com/coreos/etcd/releases/download/v3.2.18/etcd-v3.2.18-linux-amd64.tar.gz
2.2 生成證書和私鑰
# 生成證書、私鑰
$ cd target/pki/etcd
$ cfssl gencert -ca=../ca.pem \
-ca-key=../ca-key.pem \
-config=../ca-config.json \
-profile=kubernetes etcd-csr.json | cfssljson -bare etcd

# 分發到每個etcd節點（就是三個master節點）
$ scp etcd*.pem <user>@<node-ip>:/etc/kubernetes/pki/

2.3 創建service文件
# scp配置文件到每個master節點
$ scp target/<node-ip>/services/etcd.service <username>@<node-ip>:/etc/systemd/system/

# 創建數據和工作目錄
$ ssh <user>@<node-ip> "mkdir -p /var/lib/etcd"
2.4 啟動服務
etcd 進程首次啟動時會等待其它節點的 etcd 加入集群，命令 systemctl start etcd 會卡住一段時間，為正常現象。

#啟動服務
$ systemctl daemon-reload && systemctl enable etcd && systemctl restart etcd

#查看狀態
$ service etcd status

#查看啟動日志
$ journalctl -f -u etcd

 

 

啟動報錯，腳本有問題，然后我手工刪掉后面那段，然后重新 systemctl daemon-reload 加載配置，然后啟動，就正常了

 

 

 

3. 部署api-server（master節點）
3.1 生成證書和私鑰
# 生成證書、私鑰
$ cd target/pki/apiserver
$ cfssl gencert -ca=../ca.pem \
-ca-key=../ca-key.pem \
-config=../ca-config.json \
-profile=kubernetes kubernetes-csr.json | cfssljson -bare kubernetes

# 分發到每個master節點
$ scp kubernetes*.pem <user>@<node-ip>:/etc/kubernetes/pki/
3.2 創建service文件
# scp配置文件到每個master節點
$ scp target/<node-ip>/services/kube-apiserver.service <user>@<node-ip>:/etc/systemd/system/

# 創建日志目錄
$ ssh <user>@<node-ip> "mkdir -p /var/log/kubernetes"
3.3 啟動服務
#啟動服務
$ systemctl daemon-reload && systemctl enable kube-apiserver && systemctl restart kube-apiserver

#查看運行狀態
$ service kube-apiserver status

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

#檢查監聽端口
$ netstat -ntlp
4. 部署keepalived - apiserver高可用（master節點）
4.1 安裝keepalived
# 在兩個主節點上安裝keepalived（一主一備）
$ yum install -y keepalived
4.2 創建keepalived配置文件
# 創建目錄
$ ssh <user>@<master-ip> "mkdir -p /etc/keepalived"
$ ssh <user>@<backup-ip> "mkdir -p /etc/keepalived"

# 分發配置文件
$ scp target/configs/keepalived-master.conf <user>@<master-ip>:/etc/keepalived/keepalived.conf
$ scp target/configs/keepalived-backup.conf <user>@<backup-ip>:/etc/keepalived/keepalived.conf

# 分發監測腳本
$ scp target/configs/check-apiserver.sh <user>@<master-ip>:/etc/keepalived/
$ scp target/configs/check-apiserver.sh <user>@<backup-ip>:/etc/keepalived/
4.3 啟動keepalived
# 分別在master和backup上啟動服務
$ systemctl enable keepalived && service keepalived start

# 檢查狀態
$ service keepalived status

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

# 訪問測試
$ curl --insecure https://<master-vip>:6443/
5. 部署kubectl（任意節點）
kubectl 是 kubernetes 集群的命令行管理工具，它默認從 ~/.kube/config 文件讀取 kube-apiserver 地址、證書、用戶名等信息。

5.1 創建 admin 證書和私鑰
kubectl 與 apiserver https 安全端口通信，apiserver 對提供的證書進行認證和授權。 kubectl 作為集群的管理工具，需要被授予最高權限。這里創建具有最高權限的 admin 證書。

# 創建證書、私鑰
$ cd target/pki/admin
$ cfssl gencert -ca=../ca.pem \
-ca-key=../ca-key.pem \
-config=../ca-config.json \
-profile=kubernetes admin-csr.json | cfssljson -bare admin
5.2 創建kubeconfig配置文件
kubeconfig 為 kubectl 的配置文件，包含訪問 apiserver 的所有信息，如 apiserver 地址、CA 證書和自身使用的證書

# 設置集群參數（就是keeperlive的ip）
$ kubectl config set-cluster kubernetes \
--certificate-authority=../ca.pem \
--embed-certs=true \
--server=https://<MASTER_VIP>:6443 \
--kubeconfig=kube.config

# 設置客戶端認證參數
$ kubectl config set-credentials admin \
--client-certificate=admin.pem \
--client-key=admin-key.pem \
--embed-certs=true \
--kubeconfig=kube.config

# 設置上下文參數
$ kubectl config set-context kubernetes \
--cluster=kubernetes \
--user=admin \
--kubeconfig=kube.config

# 設置默認上下文
$ kubectl config use-context kubernetes --kubeconfig=kube.config

# 分發到目標節點
$ scp kube.config <user>@<node-ip>:~/.kube/config
5.3 授予 kubernetes 證書訪問 kubelet API 的權限
在執行 kubectl exec、run、logs 等命令時，apiserver 會轉發到 kubelet。這里定義 RBAC 規則，授權 apiserver 調用 kubelet API。

$ kubectl create clusterrolebinding kube-apiserver:kubelet-apis --clusterrole=system:kubelet-api-admin --user kubernetes
5.4 小測試
# 查看集群信息
$ kubectl cluster-info

$ kubectl get all --all-namespaces

$ kubectl get componentstatuses

6. 部署controller-manager（master節點）
controller-manager啟動后將通過競爭選舉機制產生一個 leader 節點，其它節點為阻塞狀態。當 leader 節點不可用后，剩余節點將再次進行選舉產生新的 leader 節點，從而保證服務的可用性。

6.1 創建證書和私鑰
# 生成證書、私鑰
$ cd target/pki/controller-manager
$ cfssl gencert -ca=../ca.pem \
-ca-key=../ca-key.pem \
-config=../ca-config.json \
-profile=kubernetes controller-manager-csr.json | cfssljson -bare controller-manager
# 分發到每個master節點
$ scp controller-manager*.pem <user>@<node-ip>:/etc/kubernetes/pki/

6.2 創建controller-manager的kubeconfig
# 創建kubeconfig
$ kubectl config set-cluster kubernetes \
--certificate-authority=../ca.pem \
--embed-certs=true \
--server=https://<MASTER_VIP>:6443 \
--kubeconfig=controller-manager.kubeconfig

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

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

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

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

6.3 創建service文件
# scp配置文件到每個master節點
$ scp target/services/kube-controller-manager.service <user>@<node-ip>:/etc/systemd/system/
6.4 啟動服務
# 啟動服務
$ systemctl daemon-reload && systemctl enable kube-controller-manager && systemctl restart kube-controller-manager

# 檢查狀態
$ service kube-controller-manager status

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

# 查看leader
$ kubectl get endpoints kube-controller-manager --namespace=kube-system -o yaml
7. 部署scheduler（master節點）
scheduler啟動后將通過競爭選舉機制產生一個 leader 節點，其它節點為阻塞狀態。當 leader 節點不可用后，剩余節點將再次進行選舉產生新的 leader 節點，從而保證服務的可用性。

7.1 創建證書和私鑰
# 生成證書、私鑰
$ cd target/pki/scheduler
$ cfssl gencert -ca=../ca.pem \
-ca-key=../ca-key.pem \
-config=../ca-config.json \
-profile=kubernetes scheduler-csr.json | cfssljson -bare kube-scheduler
7.2 創建scheduler的kubeconfig
# 創建kubeconfig
$ kubectl config set-cluster kubernetes \
--certificate-authority=../ca.pem \
--embed-certs=true \
--server=https://<MASTER_VIP>:6443 \
--kubeconfig=kube-scheduler.kubeconfig

$ kubectl config set-credentials system:kube-scheduler \
--client-certificate=kube-scheduler.pem \
--client-key=kube-scheduler-key.pem \
--embed-certs=true \
--kubeconfig=kube-scheduler.kubeconfig

$ kubectl config set-context system:kube-scheduler \
--cluster=kubernetes \
--user=system:kube-scheduler \
--kubeconfig=kube-scheduler.kubeconfig

$ kubectl config use-context system:kube-scheduler --kubeconfig=kube-scheduler.kubeconfig

# 分發kubeconfig
$ scp kube-scheduler.kubeconfig <user>@<node-ip>:/etc/kubernetes/
7.3 創建service文件
# scp配置文件到每個master節點
$ scp target/services/kube-scheduler.service <user>@<node-ip>:/etc/systemd/system/
7.4 啟動服務
# 啟動服務
$ systemctl daemon-reload && systemctl enable kube-scheduler && systemctl restart kube-scheduler

# 檢查狀態
$ service kube-scheduler status

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

# 查看leader
$  
8. 部署kubelet（worker節點）
8.1 預先下載需要的鏡像
# 預先下載鏡像到所有節點（由於鏡像下載的速度過慢，我給大家提供了阿里雲倉庫的鏡像）
$ scp target/configs/download-images.sh <user>@<node-ip>:~

# 在目標節點上執行腳本下載鏡像
$ sh ~/download-images.sh
8.2 創建bootstrap配置文件
# 創建 token
$ cd target/pki/admin　　
$ export BOOTSTRAP_TOKEN=$(kubeadm token create \
--description kubelet-bootstrap-token \
--groups system:bootstrappers:worker \
--kubeconfig kube.config)

# 設置集群參數
$ kubectl config set-cluster kubernetes \
--certificate-authority=../ca.pem \
--embed-certs=true \
--server=https://<MASTER_VIP>:6443 \
--kubeconfig=kubelet-bootstrap.kubeconfig

# 設置客戶端認證參數
$ kubectl config set-credentials kubelet-bootstrap \
--token=${BOOTSTRAP_TOKEN} \
--kubeconfig=kubelet-bootstrap.kubeconfig

# 設置上下文參數
$ kubectl config set-context default \
--cluster=kubernetes \
--user=kubelet-bootstrap \
--kubeconfig=kubelet-bootstrap.kubeconfig

# 設置默認上下文
$ kubectl config use-context default --kubeconfig=kubelet-bootstrap.kubeconfig

# 把生成的配置copy到每個worker節點上
$ scp kubelet-bootstrap.kubeconfig <user>@<node-ip>:/etc/kubernetes/kubelet-bootstrap.kubeconfig

# 先在worker節點上創建目錄
$ mkdir -p /etc/kubernetes/pki

# 把ca分發到每個worker節點
$ scp target/pki/ca.pem <user>@<node-ip>:/etc/kubernetes/pki/
8.3 kubelet配置文件
把kubelet配置文件分發到每個worker節點上

$ scp target/worker-<node-ip>/kubelet.config.json <user>@<node-ip>:/etc/kubernetes/
8.4 kubelet服務文件
把kubelet服務文件分發到每個worker節點上

$ scp target/worker-<node-ip>/kubelet.service <user>@<node-ip>:/etc/systemd/system/
8.5 啟動服務
kublet 啟動時查找配置的 --kubeletconfig 文件是否存在，如果不存在則使用 --bootstrap-kubeconfig 向 kube-apiserver 發送證書簽名請求 (CSR)。 kube-apiserver 收到 CSR 請求后，對其中的 Token 進行認證（事先使用 kubeadm 創建的 token），認證通過后將請求的 user 設置為 system:bootstrap:，group 設置為 system:bootstrappers，這就是Bootstrap Token Auth。

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

# 啟動服務
$ mkdir -p /var/lib/kubelet
$ systemctl daemon-reload && systemctl enable kubelet && systemctl restart kubelet

# 在master上Approve bootstrap請求
$ kubectl get csr
$ kubectl certificate approve <name>

# 查看服務狀態
$ service kubelet status

# 查看日志
$ journalctl -f -u kubelet
9. 部署kube-proxy（worker節點）
9.1 創建證書和私鑰
$ cd target/pki/proxy
$ cfssl gencert -ca=../ca.pem \
-ca-key=../ca-key.pem \
-config=../ca-config.json \
-profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy
9.2 創建和分發 kubeconfig 文件
# 創建kube-proxy.kubeconfig
$ kubectl config set-cluster kubernetes \
--certificate-authority=../ca.pem \
--embed-certs=true \
--server=https://<master-vip>:6443 \
--kubeconfig=kube-proxy.kubeconfig
$ kubectl config set-credentials kube-proxy \
--client-certificate=kube-proxy.pem \
--client-key=kube-proxy-key.pem \
--embed-certs=true \
--kubeconfig=kube-proxy.kubeconfig
$ kubectl config set-context default \
--cluster=kubernetes \
--user=kube-proxy \
--kubeconfig=kube-proxy.kubeconfig
$ kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig

# 分發kube-proxy.kubeconfig
$ scp kube-proxy.kubeconfig <user>@<node-ip>:/etc/kubernetes/
9.3 分發kube-proxy.config
$ scp target/worker-<node-ip>/kube-proxy.config.yaml <user>@<node-ip>:/etc/kubernetes/
9.4 分發kube-proxy服務文件
$ scp target/services/kube-proxy.service <user>@<node-ip>:/etc/systemd/system/
9.5 啟動服務
# 創建依賴目錄
$ mkdir -p /var/lib/kube-proxy && mkdir -p /var/log/kubernetes

# 啟動服務
$ systemctl daemon-reload && systemctl enable kube-proxy && systemctl restart kube-proxy

# 查看狀態
$ service kube-proxy status

# 查看日志
$ journalctl -f -u kube-proxy
10. 部署CNI插件 - calico
我們使用calico官方的安裝方式來部署。

# 創建目錄（在配置了kubectl的節點上執行）
$ mkdir -p /etc/kubernetes/addons

# 上傳calico配置到配置好kubectl的節點（一個節點即可）
$ scp target/addons/calico* <user>@<node-ip>:/etc/kubernetes/addons/

# 部署calico
$ kubectl create -f /etc/kubernetes/addons/calico-rbac-kdd.yaml
$ kubectl create -f /etc/kubernetes/addons/calico.yaml

# 查看狀態
$ kubectl get pods -n kube-system
11. 部署DNS插件 - coredns
# 上傳配置文件
$ scp target/addons/coredns.yaml <user>@<node-ip>:/etc/kubernetes/addons/

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

 

三、集群可用性測試
1. 創建nginx ds
# 寫入配置

cat > nginx-ds.yml <<EOF
apiVersion: v1
kind: Service
metadata:
  name: nginx-ds
  labels:
    app: nginx-ds
spec:
  type: NodePort selector: app: nginx-ds ports: - name: http port: 80 targetPort: 80 --- apiVersion: extensions/v1beta1 kind: DaemonSet metadata: name: nginx-ds labels: addonmanager.kubernetes.io/mode: Reconcile spec: template: metadata: labels: app: nginx-ds spec: containers: - name: my-nginx image: nginx:1.7.9 ports: - containerPort: 80 EOF

# 創建ds
$ kubectl create -f nginx-ds.yml

 

 

2. 檢查各種ip連通性
# 檢查各 Node 上的 Pod IP 連通性（主節點沒有calico所以不能訪問podip）
$ kubectl get pods -o wide

 

 

# 在每個worker節點上ping pod ip
$ ping <pod-ip>

# 檢查service可達性
$ kubectl get svc

# 在每個worker節點上訪問服務（主節點沒有proxy所以不能訪問service-ip）
$ curl <service-ip>:<port>

# 在每個節點檢查node-port可用性
$ curl <node-ip>:<port>
3. 檢查dns可用性
# 創建一個nginx pod

$ cat > pod-nginx.yaml <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  containers:
  - name: nginx
    image: nginx:1.7.9
    ports:
    - containerPort: 80
EOF

# 創建pod

$ kubectl create -f pod-nginx.yaml

# 進入pod，查看dns
$ kubectl exec nginx -i -t -- /bin/bash

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

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

root@nginx:/# ping kubernetes