使用二進制的方式部署 K8S-1.16 高可用集羣(二十)

一、項目介紹

項目致力於讓有意向使用原生kubernetes集羣的企業或個人,可以方便的、系統的使用二進制的方式手工搭建kubernetes高可用集羣。並且讓相關的人員可以更好的理解kubernetes集羣的運作機制。

軟件版本

  • os centos7.7(ubuntu也適用,需要替換部分命令)
  • kubernetes 1.16.2
  • etcd 3.4.3
  • docker 18.06
  • calico 3.10.1-2
  • coredns 1.6.2

二、實踐環境準備

1. 服務器說明

我們這裏使用的是五臺centos 7.7虛擬機,具體信息如下表:

系統類型 IP地址 節點角色 CPU Memory Hostname
centos-7.7 172.18.0.100 master \>=2 \>=2G k8s-m01
centos-7.7 172.18.0.101 master \>=2 \>=2G k8s-m02
centos-7.7 172.18.0.102 master \>=2 \>=2G k8s-m03
centos-7.7 172.18.0.103 worker \>=2 \>=2G k8s-n01
centos-7.7 172.18.0.104 worker \>=2 \>=2G k8s-n02

使用二進制的方式部署 K8S-1.16 高可用集羣(二十)

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 wget

## 時間同步
$ ntpdate time1.aliyun.com

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容器無法解析域名)
$ 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

# 生效文件
$ sysctl -p /etc/sysctl.d/kubernetes.conf

3. 安裝docker(worker節點)

根據kubernetes對docker版本的兼容測試情況,我們選擇18.06版本,我們配置阿里雲的源,速度比較快。

# 添加 yum 源
wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo -P /etc/yum.repos.d/

# 清理原有版本
yum remove -y docker* container-selinux

# 安裝docker
yum list docker-ce.x86_64  --showduplicates |sort -r
yum install docker-ce-18.06.1.ce -y

# 開機啓動
systemctl enable docker

# 配置加速器
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://hdi5v8p1.mirror.aliyuncs.com"]
}
EOF

# 啓動docker服務
service docker restart

4. 準備二進制文件(所有節點)

4.1 配置免密登錄

爲了方便文件的copy我們選擇一箇中轉節點(隨便一個節點,可以是集羣中的也可以是非集羣中的),配置好跟其他所有節點的免密登錄,我們這裏使用 k8s-m01。

# 看看是否已經存在rsa公鑰
$ cat ~/.ssh/id_rsa.pub

# 如果不存在就創建一個新的
$ ssh-keygen -t rsa

# 免密鑰認證
$ ssh-copy-id root@<your-server-ip>

4.2 下載二進制文件

官方下載地址(在CHANGELOG鏈接裏面):
https://github.com/kubernetes/kubernetes/releases

我們選擇的版本是 1.16.2。

網盤下載地址--推薦(我從官網下載整理好的文件):

鏈接: https://pan.baidu.com/s/1Ut9VERgm55B4lmz0wjjzFQ
提取碼: mjem

4.3 分發文件

# 把文件copy到每個節點上(注意替換自己的文件目錄)
$ scp master/* <user>@<master-ip>:/usr/local/bin/
$ scp worker/* <user>@<worker-ip>:/usr/local/bin/

# 給文件添加可執行權限
$ chmod +x /usr/local/bin/*

5. 準備配置文件(k8s-m01 節點)

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

5.1 下載配置文件

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

$ cd ~
$ git clone https://github.com/wangzan18/kubernetes-ha-binary.git

# 看看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

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

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

三、高可用集羣部署

1. CA證書(任意節點)

1.1 安裝cfssl

cfssl是非常好用的CA工具,我們用它來生成證書和祕鑰文件
安裝過程比較簡單,如下:

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

# 修改爲可執行權限
$ chmod +x /usr/local/bin/cfssl /usr/local/bin/cfssljson

# 驗證
$ 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/"

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

2. 部署etcd集羣(master節點)

2.1 下載etcd,並傳到各master節點

$ wget https://github.com/etcd-io/etcd/releases/download/v3.4.3/etcd-v3.4.3-linux-amd64.tar.gz
$ tar xf etcd-v3.4.3-linux-amd64.tar.gz
$ scp etcd-v3.4.3-linux-amd64/etcd* <user>@<master-ip>:/usr/local/bin/

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>@<master-ip>:/etc/kubernetes/pki/

2.3 創建service文件

# scp配置文件到每個master節點
$ scp target/<node-ip>/services/etcd.service <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

#查看服務監聽端口
$ netstat -tlnp |grep etcd

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>@<master-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|grep kube-apiserver

4. 部署keepalived - apiserver高可用(master節點)

4.1 安裝keepalived

# 在兩個主節點上安裝keepalived(一主一備),我這裏選擇 k8s-m01, k8s-m02
$ 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(任意節點),我選擇 k8s-m01

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 證書和自身使用的證書

# 設置集羣參數
$ 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
$ kubectl get endpoints kube-scheduler --namespace=kube-system -o yaml

8. 部署kubelet(worker節點)

8.1 創建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

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

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

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

8.2 kubelet配置文件

把kubelet配置文件分發到每個worker節點上

$ scp target/worker-<node-ip>/kubelet.config.json <user>@<node-ip>:/etc/kubernetes/

8.3 kubelet服務文件

把kubelet服務文件分發到每個worker節點上

$ scp target/worker-<node-ip>/kubelet.service <user>@<node-ip>:/etc/systemd/system/

8.4 啓動服務

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
$ mkdir -p /var/log/kubernetes
$ 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 到 node 節點
$ 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

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

# 查看狀態
$ service kube-proxy status

# 查看日誌
$ journalctl -f -u kube-proxy

目前是 iptables 模式,使用 ipvs 模式可以修改文件 kube-proxy.config.yaml

10. 部署CNI插件 - calico

我們使用calico官方的安裝方式來部署。

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

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

# 部署calico
$ kubectl apply -f /etc/kubernetes/addons/calico.yaml

# 查看狀態
$ kubectl get pods -n kube-system

https://docs.projectcalico.org/v3.10/getting-started/kubernetes/

11. 部署DNS插件 - coredns

# 上傳配置文件
$ scp target/addons/coredns.yaml <user>@<node-ip>:/etc/kubernetes/addons/

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

https://github.com/kubernetes/kubernetes/blob/master/cluster/addons/dns/coredns/coredns.yaml.base

四、集羣可用性測試

1. 創建nginx ds

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

# 創建ds
$ kubectl apply -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 apply -f pod-nginx.yaml

# 進入pod,查看dns
$ kubectl exec nginx -it -- /bin/bash

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

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

五. 部署dashboard

1. 部署dashboard

# 上傳dashboard配置
$ scp target/addons/dashboard-all.yaml <user>@<node-ip>:/etc/kubernetes/addons/

# 創建服務
$ kubectl apply -f /etc/kubernetes/addons/dashboard-all.yaml

# 查看服務運行情況
$ kubectl get deployment kubernetes-dashboard -n kube-system
$ kubectl --namespace kube-system get pods -o wide
$ kubectl get services kubernetes-dashboard -n kube-system
$ netstat -ntlp|grep 8401

2. 訪問dashboard

爲了集羣安全,從 1.7 開始,dashboard 只允許通過 https訪問,我們使用nodeport的方式暴露服務,可以使用 https://NodeIP:NodePort 地址訪問。

關於自定義證書

默認dashboard的證書是自動生成的,肯定是非安全的證書,如果大家有域名和對應的安全證書可以自己替換掉。使用安全的域名方式訪問dashboard。
在dashboard-all.yaml中增加dashboard啓動參數,可以指定證書文件,其中證書文件是通過secret注進來的。

- –tls-cert-file - dashboard.cer - –tls-key-file - dashboard.key

3. 登錄dashboard

Dashboard 默認只支持 token 認證,所以如果使用 KubeConfig 文件,需要在該文件中指定 token,我們這裏使用token的方式登錄

# 創建service account
$ kubectl create sa dashboard-admin -n kube-system

# 創建角色綁定關係
$ kubectl create clusterrolebinding dashboard-admin --clusterrole=cluster-admin --serviceaccount=kube-system:dashboard-admin

# 查看dashboard-admin的secret名字
$ ADMIN_SECRET=$(kubectl get secrets -n kube-system | grep dashboard-admin | awk '{print $1}')

# 打印secret的token
$ kubectl describe secret -n kube-system ${ADMIN_SECRET} | grep -E '^token' | awk '{print $2}'
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章