Kubernetes 1.11.2概述和搭建(多節點)

本文轉載自查看原文 2018-11-13 17:01 1390 python 運維開發/ Kubernetes

一、Kubernetes整體概述和架構

Kubernetes是什么

Kubernetes是一個輕便的和可擴展的開源平台，用於管理容器化應用和服務。通過Kubernetes能夠進行應用的自動化部署和擴縮容。在Kubernetes中，會將組成應用的容器組合成一個邏輯單元以更易管理和發現。Kubernetes積累了作為Google生產環境運行工作負載15年的經驗，並吸收了來自於社區的最佳想法和實踐。Kubernetes經過這幾年的快速發展，形成了一個大的生態環境，Google在2014年將Kubernetes作為開源項目。Kubernetes的關鍵特性包括：

自動化裝箱：在不犧牲可用性的條件下，基於容器對資源的要求和約束自動部署容器。同時，為了提高利用率和節省更多資源，將關鍵和最佳工作量結合在一起。
自愈能力：當容器失敗時，會對容器進行重啟；當所部署的Node節點有問題時，會對容器進行重新部署和重新調度；當容器未通過監控檢查時，會關閉此容器；直到容器正常運行時，才會對外提供服務。
水平擴容：通過簡單的命令、用戶界面或基於CPU的使用情況，能夠對應用進行擴容和縮容。
服務發現和負載均衡：開發者不需要使用額外的服務發現機制，就能夠基於Kubernetes進行服務發現和負載均衡。
自動發布和回滾：Kubernetes能夠程序化的發布應用和相關的配置。如果發布有問題，Kubernetes將能夠回歸發生的變更。
保密和配置管理：在不需要重新構建鏡像的情況下，可以部署和更新保密和應用配置。
存儲編排：自動掛接存儲系統，這些存儲系統可以來自於本地、公共雲提供商（例如：GCP和AWS）、網絡存儲(例如：NFS、iSCSI、Gluster、Ceph、Cinder和Floker等)。

Kubernetes的整體架構

Kubernetes屬於主從分布式架構，主要由Master Node和Worker Node組成，以及包括客戶端命令行工具kubectl和其它附加項。

Master Node：作為控制節點，對集群進行調度管理；Master Node由API Server、Scheduler、Cluster State Store和Controller-Manger Server所組成；
Worker Node：作為真正的工作節點，運行業務應用的容器；Worker Node包含kubelet、kube proxy和Container Runtime；
kubectl：用於通過命令行與API Server進行交互，而對Kubernetes進行操作，實現在集群中進行各種資源的增刪改查等操作；
Add-on：是對Kubernetes核心功能的擴展，例如增加網絡和網絡策略等能力。

Master Node（主節點）

API Server（API服務器）

API Server主要用來處理REST的操作，確保它們生效，並執行相關業務邏輯，以及更新etcd（或者其他存儲）中的相關對象。API Server是所有REST命令的入口，它的相關結果狀態將被保存在etcd（或其他存儲）中。API Server的基本功能包括：

REST語義，監控，持久化和一致性保證，API 版本控制，放棄和生效
內置准入控制語義，同步准入控制鈎子，以及異步資源初始化
API注冊和發現

另外，API Server也作為集群的網關。默認情況，客戶端通過API Server對集群進行訪問，客戶端需要通過認證，並使用API Server作為訪問Node和Pod（以及service）的堡壘和代理/通道。

Cluster state store（集群狀態存儲）

Kubernetes默認使用etcd作為集群整體存儲，當然也可以使用其它的技術。etcd是一個簡單的、分布式的、一致的key-value存儲，主要被用來共享配置和服務發現。etcd提供了一個CRUD操作的REST API，以及提供了作為注冊的接口，以監控指定的Node。集群的所有狀態都存儲在etcd實例中，並具有監控的能力，因此當etcd中的信息發生變化時，就能夠快速的通知集群中相關的組件。

View Code

Controller-Manager Server（控制管理服務器）

Controller-Manager Serve用於執行大部分的集群層次的功能，它既執行生命周期功能(例如：命名空間創建和生命周期、事件垃圾收集、已終止垃圾收集、級聯刪除垃圾收集、node垃圾收集)，也執行API業務邏輯（例如：pod的彈性擴容）。控制管理提供自愈能力、擴容、應用生命周期管理、服務發現、路由、服務綁定和提供。Kubernetes默認提供Replication Controller、Node Controller、Namespace Controller、Service Controller、Endpoints Controller、Persistent Controller、DaemonSet Controller等控制器。

View Code

Scheduler（調度器）

scheduler組件為容器自動選擇運行的主機。依據請求資源的可用性，服務請求的質量等約束條件，scheduler監控未綁定的pod，並將其綁定至特定的node節點。Kubernetes也支持用戶自己提供的調度器，Scheduler負責根據調度策略自動將Pod部署到合適Node中，調度策略分為預選策略和優選策略，Pod的整個調度過程分為兩步：

1）預選Node：遍歷集群中所有的Node，按照具體的預選策略篩選出符合要求的Node列表。如沒有Node符合預選策略規則，該Pod就會被掛起，直到集群中出現符合要求的Node。

2）優選Node：預選Node列表的基礎上，按照優選策略為待選的Node進行打分和排序，從中獲取最優Node。

View Code

Worker Node（從節點）

Kubelet

Kubelet是Kubernetes中最主要的控制器，它是Pod和Node API的主要實現者，Kubelet負責驅動容器執行層。在Kubernetes中，應用容器彼此是隔離的，並且與運行其的主機也是隔離的，這是對應用進行獨立解耦管理的關鍵點。

在Kubernets中，Pod作為基本的執行單元，它可以擁有多個容器和存儲數據卷，能夠方便在每個容器中打包一個單一的應用，從而解耦了應用構建時和部署時的所關心的事項，已經能夠方便在物理機/虛擬機之間進行遷移。API准入控制可以拒絕或者Pod，或者為Pod添加額外的調度約束，但是Kubelet才是Pod是否能夠運行在特定Node上的最終裁決者，而不是scheduler或者DaemonSet。kubelet默認情況使用cAdvisor進行資源監控。負責管理Pod、容器、鏡像、數據卷等，實現集群對節點的管理，並將容器的運行狀態匯報給Kubernetes API Server。

View Code

Container Runtime（容器運行時）

每一個Node都會運行一個Container Runtime，其負責下載鏡像和運行容器。Kubernetes本身並不停容器運行時環境，但提供了接口，可以插入所選擇的容器運行時環境。kubelet使用Unix socket之上的gRPC框架與容器運行時進行通信，kubelet作為客戶端，而CRI shim作為服務器。

View Code

protocol buffers API提供兩個gRPC服務，ImageService和RuntimeService。ImageService提供拉取、查看、和移除鏡像的RPC。RuntimeSerivce則提供管理Pods和容器生命周期管理的RPC，以及與容器進行交互(exec/attach/port-forward)。容器運行時能夠同時管理鏡像和容器（例如：Docker和Rkt），並且可以通過同一個套接字提供這兩種服務。在Kubelet中，這個套接字通過–container-runtime-endpoint和–image-service-endpoint字段進行設置。Kubernetes CRI支持的容器運行時包括docker、rkt、cri-o、frankti、kata-containers和clear-containers等。

View Code

kube proxy

基於一種公共訪問策略（例如：負載均衡），服務提供了一種訪問一群pod的途徑。此方式通過創建一個虛擬的IP來實現，客戶端能夠訪問此IP，並能夠將服務透明的代理至Pod。每一個Node都會運行一個kube-proxy，kube proxy通過iptables規則引導訪問至服務IP，並將重定向至正確的后端應用，通過這種方式kube-proxy提供了一個高可用的負載均衡解決方案。服務發現主要通過DNS實現。

在Kubernetes中，kube proxy負責為Pod創建代理服務；引到訪問至服務；並實現服務到Pod的路由和轉發，以及通過應用的負載均衡。

View Code

kubectl

kubectl是Kubernetes集群的命令行接口。運行kubectl命令的語法如下所示：

$ kubectl [command] [TYPE] [NAME] [flags]

這里的command，TYPE、NAME和flags為：

comand：指定要對資源執行的操作，例如create、get、describe和delete
TYPE：指定資源類型，資源類型是大小學敏感的，開發者能夠以單數、復數和縮略的形式。例如：

NAME：指定資源的名稱，名稱也大小寫敏感的。如果省略名稱，則會顯示所有的資源，例如:

 $kubectl get pods

flags：指定可選的參數。例如，可以使用-s或者–server參數指定Kubernetes API server的地址和端口。

另外，可以通過運行kubectl help命令獲取更多的信息。

附加項和其他依賴

在Kunbernetes中可以以附加項的方式擴展Kubernetes的功能，目前主要有網絡、服務發現和可視化這三大類的附加項，下面是可用的一些附加項：

網絡和網絡策略

ACI 通過與Cisco ACI集成的容器網絡和網絡安全。
Calico 是一個安全的3層網絡和網絡策略提供者。
Canal 聯合Fannel和Calico，通過網絡和網絡側。
Cilium 是一個3層網絡和網絡側插件，它能夠透明的加強HTTP/API/L7 策略。其即支持路由，也支持overlay/encapsultion模式。
Flannel 是一個overlay的網絡提供者。

服務發現

CoreDNS 是一個靈活的，可擴展的DNS服務器，它能夠作為Pod集群內的DNS進行安裝。
Ingress 提供基於Http協議的路由轉發機制。

可視化&控制

Dashboard 是Kubernetes的web用戶界面。

二、k8s搭建

kubeadm是Kubernetes官方提供的用於快速安裝Kubernetes集群的工具，伴隨Kubernetes每個版本的發布都會同步更新，kubeadm會對集群配置方面的一些實踐做調整，通過實驗kubeadm可以學習到Kubernetes官方在集群配置上一些新的最佳實踐。

在Kubernetes的文檔Creating a single master cluster with kubeadm中已經給出了目前kubeadm的主要特性已經處於beta狀態了，在2018年將進入GA狀態，說明kubeadm離可以在生產環境中使用的距離越來越近了。

當然我們線上穩定運行的Kubernetes集群是使用ansible以二進制形式的部署的高可用集群，這里體驗Kubernetes 1.11中的kubeadm是為了跟隨官方對集群初始化和配置方面的最佳實踐，進一步完善我們的ansible部署腳本。

環境准備

環境說明

操作系統	主機名	IP地址	功能
ubuntu-16.04.5-server-amd64	k8s-master001	192.168.91.128	主節點
ubuntu-16.04.5-server-amd64	k8s-node001	192.168.91.129	從節點,etcd
ubuntu-16.04.5-server-amd64	k8s-node002	192.168.91.131	從節點,docker registry,Ubuntu私有源

3台服務器的配置均為：1核2G，硬盤20G

請確保主節點能ssh免密登錄2個從節點。3台服務器，主要使用root用戶操作

etcd這里只用1個，如果要做高可用，請保證節點數量是奇數。比如3,5,7。偶數節點，會無法選舉Leader

由於k8s需要的docker鏡像和deb包被牆了。所以需要構建私有的docker倉庫

相關軟件包已經上傳到百度雲，下載方式為：

鏈接：https://pan.baidu.com/s/1Z31IcS2f15ufoqDw19-i3Q 提取碼：tlex

其中deb包，是ubuntu的軟件包，其他壓縮包，全部都是docker鏡像！

docker鏡像都是從google下載的，如果不放心，可自行下載！

如果你使用的是Centos 7系統，可以不用這么麻煩，使用開源Breeze工具部署Kubernetes。

Breeze項目是深圳睿雲智合所開源的Kubernetes圖形化部署工具，大大簡化了Kubernetes部署的步驟，其最大亮點在於支持全離線環境的部署，且不需要翻牆獲取Google的相應資源包，尤其適合某些不便訪問互聯網的服務器場景。

具體操作，請參考鏈接：

https://www.kubernetes.org.cn/4623.html

主機名

登錄3台服務器，查看主機名

cat /etc/hostname

如果輸出不是上面表格中的主機名，請務必修改！

修改完成之后，必須要重啟服務器才行！

由於這里並沒有使用私有的DNS，所以直接用hosts文件來強制解析。

務必保證3台服務器的hosts文件有如下3條記錄

192.168.91.128 k8s-master001
192.168.91.129 k8s-node001
192.168.91.131 k8s-node002

時間設置

務必保證3台服務器的時區是一樣的，強制更改時區為上海，執行以下命令

ln -snf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
bash -c "echo 'Asia/Shanghai' > /etc/timezone"

安裝ntpdate

apt-get install -y ntpdate

如果出現以下錯誤

E: Could not get lock /var/lib/dpkg/lock - open (11: Resource temporarily unavailable)
E: Unable to lock the administration directory (/var/lib/dpkg/), is another process using it?

執行2個命令解決

sudo rm /var/cache/apt/archives/lock
sudo rm /var/lib/dpkg/lock

使用阿里雲的時間服務器更新

ntpdate ntp1.aliyun.com

3台服務器都執行一下，確保時間一致！

請確保防火牆都關閉了！

ssh免密登錄

3台服務器生成秘鑰，並寫入到authorized_keys

ssh-keygen -t rsa -P "" -f ~/.ssh/id_rsa
cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys

登錄到主節點服務器，copy秘鑰，執行以下命令

ssh-copy-id k8s-master001
ssh-copy-id k8s-node001
ssh-copy-id k8s-node002

測試ssh免密登錄

登錄到主節點服務器，測試ssh免密登錄

ssh k8s-master001
exit

ssh k8s-node001
exit

ssh k8s-node002
exit

請確保以上3個命令，不需要輸入密碼

更新ubuntu數據庫

使用阿里雲的更新源，默認的太慢了

vi /etc/apt/sources.list

清空文件內容，添加如下內容：

deb http://mirrors.aliyun.com/ubuntu/ xenial main restricted
deb http://mirrors.aliyun.com/ubuntu/ xenial-updates main restricted
deb http://mirrors.aliyun.com/ubuntu/ xenial universe
deb http://mirrors.aliyun.com/ubuntu/ xenial-updates universe
deb http://mirrors.aliyun.com/ubuntu/ xenial multiverse
deb http://mirrors.aliyun.com/ubuntu/ xenial-updates multiverse
deb http://mirrors.aliyun.com/ubuntu/ xenial-backports main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu xenial-security main restricted
deb http://mirrors.aliyun.com/ubuntu xenial-security universe
deb http://mirrors.aliyun.com/ubuntu xenial-security multiverse

使用apt-get update來更新一下

apt-get update

確保3台都是使用阿里雲的更新源

3台服務器，都需要安裝docker

apt-get install -y docker.io

修改daemon.json

vim /etc/docker/daemon.json

內容如下：

{
   "registry-mirrors": [ "https://kv3qfp85.mirror.aliyuncs.com" ], "insecure-registries": [ "192.168.91.131:5000" ] }

重啟docker服務

systemctl restart docker

確保3台服務器，都修改了daemon.json

etcd部署

登錄到k8s-node001服務器，直接運行etcd_v3.3.10.sh即可。請注意前置條件！

etcd_v3.3.10.sh

說明：本腳本，只能在本地服務器安裝。請確保etcd-v3.3.10-linux-amd64.tar.gz文件和shell腳本在同一目錄下。

腳本附帶了使用systemctl命令啟動etcd服務

#/bin/bash
# 單擊版etcd安裝腳本
# 本腳本,只能在本地服務器安裝。
# 請確保etcd-v3.3.10-linux-amd64.tar.gz文件和當前腳本在同一目錄下。
# 務必使用root用戶執行此腳本!
# 確保可以直接執行python3,因為倒數第4行,有一個json格式化輸出。如果不需要可以忽略
#set -e

# 輸入本機ip
while true
do
    echo '請輸入本機ip'
    echo 'Example: 192.168.0.1'
    echo -e "etcd server ip=\c"
    read ETCD_Server
    if [ "$ETCD_Server" == "" ];then
        echo 'No input etcd server IP'
    else
            #echo 'No input etcd server IP'
            break
    fi
done

# etcd啟動服務
cat > /lib/systemd/system/etcd.service <<EOF
[Unit]
Description=etcd - highly-available key value store
Documentation=https://github.com/coreos/etcd
Documentation=man:etcd
After=network.target
Wants=network-online.target

[Service]
Environment=DAEMON_ARGS=
Environment=ETCD_NAME=%H
Environment=ETCD_DATA_DIR=/var/lib/etcd/default
EnvironmentFile=-/etc/default/%p
Type=notify
User=etcd
PermissionsStartOnly=true
#ExecStart=/bin/sh -c "GOMAXPROCS=\$(nproc) /usr/bin/etcd \$DAEMON_ARGS"
ExecStart=/usr/bin/etcd \$DAEMON_ARGS
Restart=on-abnormal
#RestartSec=10s
#LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
Alias=etcd3.service
EOF


# 主機名
name=`hostname`
# etcd的http連接地址
initial_cluster="http://$ETCD_Server:2380"


# 判斷進程是否啟動
A=`ps -ef|grep /usr/bin/etcd|grep -v grep|wc -l`
if [ $A -ne 0 ];then
    # 殺掉進程
    killall etcd
fi 

# 刪除etcd相關文件
rm -rf /var/lib/etcd/*
rm -rf /etc/default/etcd

# 設置時區
ln -snf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime

# 判斷壓縮文件
if [ ! -f "etcd-v3.3.10-linux-amd64.tar.gz" ];then
    echo "當前目錄etcd-v3.3.10-linux-amd64.tar.gz文件不存在"
    exit
fi

# 安裝etcd
tar zxf etcd-v3.3.10-linux-amd64.tar.gz -C /tmp/
cp -f /tmp/etcd-v3.3.10-linux-amd64/etcd /usr/bin/
cp -f /tmp/etcd-v3.3.10-linux-amd64/etcdctl /usr/bin/


# etcd配置文件
cat > /etc/default/etcd <<EOF
ETCD_NAME=$name
ETCD_DATA_DIR="/var/lib/etcd/"
ETCD_LISTEN_PEER_URLS="http://$ETCD_Server:2380"
ETCD_LISTEN_CLIENT_URLS="http://$ETCD_Server:2379,http://127.0.0.1:4001"
ETCD_INITIAL_ADVERTISE_PEER_URLS="http://$ETCD_Server:2380"
ETCD_INITIAL_CLUSTER="$ETCD_Servernitial_cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster-sdn"
ETCD_ADVERTISE_CLIENT_URLS="http://$ETCD_Server:2379"
EOF


# 臨時腳本,添加用戶和組
cat  > /tmp/foruser <<EOF
#!/bin/bash
if [ \`cat /etc/group|grep etcd|wc -l\` -eq 0 ];then groupadd -g 217 etcd;fi
if [ \`cat /etc/passwd|grep etcd|wc -l\` -eq 0 ];then mkdir -p /var/lib/etcd && useradd -g 217 -u 111 etcd -d /var/lib/etcd/ -s /bin/false;fi
if [ \`cat /etc/profile|grep ETCDCTL_API|wc -l\` -eq 0 ];then bash -c "echo 'export ETCDCTL_API=3' >> /etc/profile" && bash -c "source /etc/profile";fi
EOF

# 執行腳本
bash /tmp/foruser

# 啟動服務
systemctl daemon-reload
systemctl enable etcd.service
chown -R etcd:etcd /var/lib/etcd
systemctl restart etcd.service
#netstat -anpt | grep 2379
# 查看版本
etcdctl -v
# 訪問API, -s 去掉curl的統計信息. python3 -m json.tool 表示json格式化
curl $initial_cluster/version -s | python3 -m json.tool

# 刪除臨時文件
rm -rf /tmp/foruser /tmp/etcd-v3.3.10-linux-amd64

View Code

執行腳本

bash etcd_v3.3.10.sh

輸出：

請輸入本機ip
Example: 192.168.0.1 etcd server ip=192.168.91.129 Created symlink from /etc/systemd/system/etcd3.service to /lib/systemd/system/etcd.service. Created symlink from /etc/systemd/system/multi-user.target.wants/etcd.service to /lib/systemd/system/etcd.service. etcdctl version: 3.3.10 API version: 2 { "etcdserver": "3.3.10", "etcdcluster": "3.3.0" }

搭建 docker 私有倉庫

登錄到k8s-node002服務器，安裝docker

apt-get install -y docker.io

拉取registry鏡像

docker pull registry

創建registry docker進程

docker run -d --name docker-registry --restart=always -p 5000:5000 registry

上面已經修改過了 /etc/docker/daemon.json，所以這里不需要修改了！

創建目錄/reop，將百度雲的k8s-1.11下載下來，上傳到/repo目錄。

mkdir /repo

repo的目錄結構如下：

/repo/
└── k8s-1.11
    ├── calico_cni_v1.11.4.tar.gz
    ├── calico_kube-controllers_v1.0.3.tar.gz
    ├── calico_node_v2.6.8.tar.gz
    ├── calico.yaml
    ├── coredns-1.1.3.tar.gz
    ├── cri-tools_1.11.0-00_amd64_768e5551f9badfde12b10c42c88afb45c412c1bf307a5985a4b29f4499d341bd.deb
    ├── kubeadm_1.11.2-00_amd64_7602f5c4362b9c17aba83e8424830a98ca66074e36dead31d239f2beda91f1ff.deb
    ├── kube-apiserver.tar.gz
    ├── kube-controller-manager.tar.gz
    ├── kubectl_1.11.2-00_amd64_49e2a857e4852da0c27e3e92bc92fef4d33db7c93c2a4628cb9374e3a486bc92.deb
    ├── kubelet_1.11.2-00_amd64_7537d39713573280e1cc245915fc7565ac49d041fbd0e0515daa1ea2ac659dbb.deb
    ├── kube-proxy.tar.gz
    ├── kubernetes-cni_0.6.0-00_amd64_43460dd3c97073851f84b32f5e8eebdc84fadedb5d5a00d1fc6872f30a4dd42c.deb
    ├── kube-scheduler.tar.gz
    └── pause3.1.tar.gz

View Code

測試etcd的狀態，運行是否正常

測試docker私有倉庫，運行是否正常

kubernetes Master 配置

以下都是主節點操作，從節點不需要做任何操作！

安裝kubernetes 服務器

復制軟件包

scp -r 192.168.91.131:/repo/k8s-1.11 ./

安裝相關組件

apt-get install -y docker.io ipvsadm ebtables socat --allow-unauthenticated

安裝k8s的deb包

dpkg -i k8s-1.11/*.deb

開啟cadvisor

sed -i 's?config.yaml?config.yaml --cadvisor-port=4194?g' /etc/systemd/system/kubelet.service.d/10-kubeadm.conf

這條命令的意思就是將 config.yaml替換為config.yaml --cadvisor-port=4194

添加cgroup驅動程序

sed -i 8i'Environment="KUBELET_CGROUP_ARGS=--cgroup-driver=cgroupfs"' /etc/systemd/system/kubelet.service.d/10-kubeadm.conf

8i表示在第8行之前插入文本，文本的內容就是Environment="KUBELET_CGROUP_ARGS=--cgroup-driver=cgroupfs

重新應用配置

systemctl daemon-reload

導入k8s鏡像

for i in k8s-1.11/*.gz; do sudo docker load < $i; done

查看當前鏡像

root@k8s-master001:~# docker images
REPOSITORY                                 TAG                 IMAGE ID            CREATED             SIZE
k8s.gcr.io/kube-apiserver-amd64            v1.11.2             214c48e87f58        4 months ago        187 MB
k8s.gcr.io/kube-controller-manager-amd64   v1.11.2             55b70b420785        4 months ago        155 MB
k8s.gcr.io/kube-proxy-amd64                v1.11.2             1d3d7afd77d1        4 months ago        97.8 MB
k8s.gcr.io/kube-scheduler-amd64            v1.11.2             0e4a34a3b0e6        4 months ago        56.8 MB
k8s.gcr.io/coredns                         1.1.3               b3b94275d97c        5 months ago        45.6 MB
quay.io/calico/node                        v2.6.8              e96a297310fd        8 months ago        282 MB
quay.io/calico/cni                         v1.11.4             4c4cb67d7a88        9 months ago        70.8 MB
quay.io/calico/kube-controllers            v1.0.3              34aebe64326d        10 months ago       52.3 MB
k8s.gcr.io/pause                           3.1                 da86e6ba6ca1        10 months ago       742 kB

將包含quay.io鏡像推送到私有倉庫

docker tag quay.io/calico/cni:v1.11.4 192.168.91.131:5000/calico/cni:v1.11.4
docker push 192.168.91.131:5000/calico/cni:v1.11.4

docker tag quay.io/calico/kube-controllers:v1.0.3 192.168.91.131:5000/calico/kube-controllers:v1.0.3
docker push 192.168.91.131:5000/calico/kube-controllers:v1.0.3

docker tag quay.io/calico/node:v2.6.8 192.168.91.131:5000/calico/node:v2.6.8
docker push 192.168.91.131:5000/calico/node:v2.6.8

View Code

這一步操作，可能有點麻煩，可以使用shell腳本完成

push_mirror.sh

#!/bin/bash

# 私有倉庫地址
dockerREG="192.168.91.131:5000"

# 查詢包含calico的鏡像
CalicoPro=$(sudo docker images|grep quay.io|awk -F 'quay.io/' '{print $2}'|awk '{print $1}'|sort|uniq)
for i in $CalicoPro;do
        # 查詢鏡像的tag版本
        Proversion=$(docker images|grep quay.io|grep $i|awk '{print $2}')
        for j in $Proversion;do
                # 打tag並推送鏡像到私有倉庫
                sudo docker tag quay.io/$i:$j $dockerREG/$i:$j
                sudo docker push $dockerREG/$i:$j
        done
done

執行腳本

bash push_mirror.sh

暫時關閉kubelet

# 重新設置kubelet服務開機啟動
systemctl enable kubelet.service
# 停止kubelet服務
systemctl stop kubelet.service

關閉swap

Kubernetes 1.8開始要求關閉系統的Swap，如果不關閉，默認配置下kubelet將無法啟動。

關閉系統的Swap方法如下

swapoff -a

修改 /etc/fstab 文件，注釋掉 SWAP 的自動掛載，使用free -m確認swap已經關閉

fswap=`cat /etc/fstab |grep swap|awk '{print $1}'`
for i in $fswap;do
    sed -i "s?$i?#$i?g" /etc/fstab
done

上面這段代碼表示，包含swap的行前面添加#

刪除默認的k8s文件

rm -rf /etc/kubernetes/*
rm -rf /var/lib/kubelet/*

重置k8s集群

kubeadm reset -f

編輯臨時配置文件

vim /tmp/kubeadm-conf.yaml

內容如下：

apiVersion: kubeadm.k8s.io/v1alpha1
kind: MasterConfiguration
networking:
  podSubnet: 192.138.0.0/16
#apiServerCertSANs:
#- master01
#- master02
#- master03
#- 172.16.2.1
#- 172.16.2.2
#- 172.16.2.3
#- 172.16.2.100
etcd:
  endpoints:
  - http://192.168.91.129:2379
#token: 67e411.zc3617bb21ad7ee3
kubernetesVersion: v1.11.2
api:
 advertiseAddress: 192.168.91.128

注意修改主節點的IP和etcd的IP地址

定義podSubnet為192.138.0.0/16

初始化集群

使用kubeadm init初始化集群

kubeadm init --config=/tmp/kubeadm-conf.yaml| sudo tee /etc/kube-server-key

執行輸出：

[init] using Kubernetes version: v1.11.2
[preflight] running pre-flight checks
I1113 11:56:57.910361   20411 kernel_validator.go:81] Validating kernel version
I1113 11:56:57.910897   20411 kernel_validator.go:96] Validating kernel config
[preflight/images] Pulling images required for setting up a Kubernetes cluster
[preflight/images] This might take a minute or two, depending on the speed of your internet connection
[preflight/images] You can also perform this action in beforehand using 'kubeadm config images pull'
[kubelet] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
[kubelet] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
[preflight] Activating the kubelet service
[certificates] Generated ca certificate and key.
[certificates] Generated apiserver certificate and key.
[certificates] apiserver serving cert is signed for DNS names [k8s-master001 kubernetes kubernetes.default kubernetes.default.svc kubernetes.default.svc.cluster.local] and IPs [10.96.0.1 192.168.91.128]
[certificates] Generated apiserver-kubelet-client certificate and key.
[certificates] Generated sa key and public key.
[certificates] Generated front-proxy-ca certificate and key.
[certificates] Generated front-proxy-client certificate and key.
[certificates] valid certificates and keys now exist in "/etc/kubernetes/pki"
[kubeconfig] Wrote KubeConfig file to disk: "/etc/kubernetes/admin.conf"
[kubeconfig] Wrote KubeConfig file to disk: "/etc/kubernetes/kubelet.conf"
[kubeconfig] Wrote KubeConfig file to disk: "/etc/kubernetes/controller-manager.conf"
[kubeconfig] Wrote KubeConfig file to disk: "/etc/kubernetes/scheduler.conf"
[controlplane] wrote Static Pod manifest for component kube-apiserver to "/etc/kubernetes/manifests/kube-apiserver.yaml"
[controlplane] wrote Static Pod manifest for component kube-controller-manager to "/etc/kubernetes/manifests/kube-controller-manager.yaml"
[controlplane] wrote Static Pod manifest for component kube-scheduler to "/etc/kubernetes/manifests/kube-scheduler.yaml"
[init] waiting for the kubelet to boot up the control plane as Static Pods from directory "/etc/kubernetes/manifests" 
[init] this might take a minute or longer if the control plane images have to be pulled
[apiclient] All control plane components are healthy after 44.009208 seconds
[uploadconfig] storing the configuration used in ConfigMap "kubeadm-config" in the "kube-system" Namespace
[kubelet] Creating a ConfigMap "kubelet-config-1.11" in namespace kube-system with the configuration for the kubelets in the cluster
[markmaster] Marking the node k8s-master001 as master by adding the label "node-role.kubernetes.io/master=''"
[markmaster] Marking the node k8s-master001 as master by adding the taints [node-role.kubernetes.io/master:NoSchedule]
[patchnode] Uploading the CRI Socket information "/var/run/dockershim.sock" to the Node API object "k8s-master001" as an annotation
[bootstraptoken] using token: 8kjvh8.jc3kjgjepz06ptxl
[bootstraptoken] configured RBAC rules to allow Node Bootstrap tokens to post CSRs in order for nodes to get long term certificate credentials
[bootstraptoken] configured RBAC rules to allow the csrapprover controller automatically approve CSRs from a Node Bootstrap Token
[bootstraptoken] configured RBAC rules to allow certificate rotation for all node client certificates in the cluster
[bootstraptoken] creating the "cluster-info" ConfigMap in the "kube-public" namespace
[addons] Applied essential addon: CoreDNS
[addons] Applied essential addon: kube-proxy

Your Kubernetes master has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

You can now join any number of machines by running the following on each node
as root:

  kubeadm join 192.168.91.128:6443 --token 8kjvh8.jc3kjgjepz06ptxl --discovery-token-ca-cert-hash sha256:98ad46e571ba9ce4f759fb8e00a93bf992f43862af0efb2fc544bc881eb8e192

View Code

出現Your Kubernetes master has initialized successfully! 就表示成功了

查看/etc/kube-server-key文件，就是剛剛輸出的內容

添加Nodrport端口范圍

添加端口范圍1000-62000

line_conf=`cat /etc/kubernetes/manifests/kube-apiserver.yaml|grep -n "allow-privileged=true"|cut -f 1 -d ":"`
sed -i -e "$line_conf"i'\    - --service-node-port-range=1000-62000' /etc/kubernetes/manifests/kube-apiserver.yaml

line_conf的執行結果是18，下面sed的意思就是，在18行之前添加指定內容

apiserver綁定主機的非安全端口，這里綁定的是主節點IP

line_conf=`grep -n "insecure-port" /etc/kubernetes/manifests/kube-apiserver.yaml|awk -F ":" '{print $1}'`
sed -i -e "$line_conf"i"\    - --insecure-bind-address=192.168.91.128" /etc/kubernetes/manifests/kube-apiserver.yaml

line_conf的執行結果是25，下面sed的意思就是，在18行之前添加指定內容

apiserver綁定主機的非安全端口號，默認為8080

sed -i -e 's?insecure-port=0?insecure-port=8080?g' /etc/kubernetes/manifests/kube-apiserver.yaml

sed的意思就是，將insecure-port=0替換為insecure-port=8080

設置kubectl權限

mkdir -p $HOME/.kube
sudo cp -f /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

這里的$HOME指的就是當前登錄用戶的宿主目錄，也就是/root

部署CalICO網絡插件

修改etcd端點的IP

line=`grep "etcd_endpoints:" -n k8s-1.11/calico.yaml | cut -f 1 -d ":"`
sed -i "$line c \ \ etcd_endpoints: \"http://192.168.91.129:2379\"" k8s-1.11/calico.yaml

line的執行結果是17，$line后面的c表示用新文本替換當前行中的文本

修改CIDR

Kubernetes集群中service的虛擬IP地址范圍，以CIDR表示，該IP范圍不能與物理機的真實IP段有重合。

將192.168.0.0替換為192.138.0.0

sed -i -e 's/192.168.0.0/192.138.0.0/g' k8s-1.11/calico.yaml

將quay.io修改為私有庫地址

sed -i -e "s?quay.io?192.168.91.131:5000?g" k8s-1.11/calico.yaml

除了Kube DNS，它需要一個網絡插件

kubectl --kubeconfig=/etc/kubernetes/admin.conf apply -f k8s-1.11/calico.yaml

Kubernetes node配置

還是在主節點操作，編寫腳本

client.sh

#!/bin/bash

# 安裝組件
sudo apt-get update
sudo apt-get install -y docker.io ipvsadm --allow-unauthenticated
sudo apt-get install -y ebtables socat --allow-unauthenticated

# 關閉swap
sudo swapoff -a
fswap=`cat /etc/fstab |grep swap|awk '{print $1}'`
for i in $fswap;do
    sudo sed -i "s?$i?#$i?g" /etc/fstab
done

# 手動加載IPVS的基本模塊
sudo modprobe ip_vs
sudo modprobe ip_vs_rr
sudo modprobe ip_vs_sh
sudo modprobe ip_vs_wrr

# 安裝deb軟件包
sudo dpkg -i k8s-1.11/cri-tools*.deb
sudo dpkg -i k8s-1.11/kubernetes-cni*.deb
sudo dpkg -i k8s-1.11/kubelet*.deb
sudo dpkg -i k8s-1.11/kubectl*.deb
sudo dpkg -i k8s-1.11/kubeadm*.deb

# 開啟cadvisor
sudo sed -i 's?config.yaml?config.yaml --cadvisor-port=4194?g' /etc/systemd/system/kubelet.service.d/10-kubeadm.conf

# 添加cgroup驅動程序
sudo sed -i 8i'Environment="KUBELET_CGROUP_ARGS=--cgroup-driver=cgroupfs"' /etc/systemd/system/kubelet.service.d/10-kubeadm.conf

# 重新應用配置
sudo systemctl daemon-reload

# 導入k8s鏡像
for i in k8s-1.11/*.tar.gz; do sudo docker load < $i; done
# 停止kubelet
sudo systemctl enable kubelet.service
sudo systemctl stop kubelet.service
# 重置k8s集群
sudo kubeadm reset -f

# 新增集群集工作節點的命令

View Code

將新增集群集工作節點的命令，寫入到client.sh

echo "`tail -n2 /etc/kube-server-key`" >> client.sh

執行echo之后，那么client.sh的完整內容為：

#!/bin/bash

# 安裝組件
sudo apt-get update
sudo apt-get install -y docker.io ipvsadm --allow-unauthenticated
sudo apt-get install -y ebtables socat --allow-unauthenticated

# 關閉swap
sudo swapoff -a
fswap=`cat /etc/fstab |grep swap|awk '{print $1}'`
for i in $fswap;do
    sudo sed -i "s?$i?#$i?g" /etc/fstab
done

# 手動加載IPVS的基本模塊
sudo modprobe ip_vs
sudo modprobe ip_vs_rr
sudo modprobe ip_vs_sh
sudo modprobe ip_vs_wrr

# 安裝deb軟件包
sudo dpkg -i k8s-1.11/cri-tools*.deb
sudo dpkg -i k8s-1.11/kubernetes-cni*.deb
sudo dpkg -i k8s-1.11/kubelet*.deb
sudo dpkg -i k8s-1.11/kubectl*.deb
sudo dpkg -i k8s-1.11/kubeadm*.deb

# 開啟cadvisor
sudo sed -i 's?config.yaml?config.yaml --cadvisor-port=4194?g' /etc/systemd/system/kubelet.service.d/10-kubeadm.conf

# 添加cgroup驅動程序
sudo sed -i 8i'Environment="KUBELET_CGROUP_ARGS=--cgroup-driver=cgroupfs"' /etc/systemd/system/kubelet.service.d/10-kubeadm.conf

# 重新應用配置
sudo systemctl daemon-reload

# 導入k8s鏡像
for i in k8s-1.11/*.tar.gz; do sudo docker load < $i; done
# 停止kubelet
sudo systemctl enable kubelet.service
sudo systemctl stop kubelet.service
# 重置k8s集群
sudo kubeadm reset -f

# 新增集群集工作節點的命令
sudo   kubeadm join 192.168.91.128:6443 --token bei68w.iovq9kr5w0kwcet3 --discovery-token-ca-cert-hash sha256:9ecbd6024fd9c66beee434cf277a69cfa2b325f4bcbf96d11e91a2a1f896fd62

View Code

遠程執行客戶端腳本

編寫install_client.sh腳本

#!/bin/bash

# node節點的IP地址
minions="192.168.91.129 192.168.91.131"

for i in $minions; do
        # 復制軟件包
        scp -r k8s-1.11/ $i:/$HOME/
        # 復制daemon.json
        ssh $i sudo mkdir -p /etc/docker
        scp /etc/docker/daemon.json $i:/$HOME/daemon.json
        ssh $i sudo cp /$HOME/daemon.json /etc/docker/daemon.json
        ssh $i sudo rm -f /$HOME/daemon.json
        # 復制cilent.sh
        scp client.sh $i:/$HOME/
        # node節點執行client.sh
        ssh $i sudo bash /$HOME/client.sh
done
echo 'please check kubenetes DNS server is runing or not ......'
echo 'command: kubectl get po -n kube-system|grep dns'

執行腳本

bash install_client.sh

查看k8s的DNS服務狀態

root@k8s-master001:~# kubectl get po -n kube-system|grep dns
coredns-78fcdf6894-9cmnz                   0/1       ContainerCreating   0          3h
coredns-78fcdf6894-zs6zb                   0/1       ContainerCreating   0          3h

等待5秒，查看集群中的節點

root@k8s-master001:~# kubectl get nodes
NAME            STATUS    ROLES     AGE       VERSION
k8s-master001   Ready     master    3h        v1.11.2
k8s-node001     Ready     <none>    27m       v1.11.2
k8s-node002     Ready     <none>    27m       v1.11.2

如果狀態都是Ready，表示正常！

三、一鍵部署腳本

請確保已經滿足了上面說的環境准備條件

k8s-v1.11.sh

#!/bin/bash
set -e

# 運行前置條件
# 請確保主節點能ssh免密登錄從節點。所有服務器，主要使用root用戶操作
# 確保etcd已經部署好,節點數量為奇數,運行正常
# 確保docker私有倉庫運行正常
# 確保所有服務器的時間一致
# 確保所有服務器已經安裝好docker服務,並且已經修改了/etc/docker/daemon.json,能夠正常推送到私有倉庫
# 本腳本只能在主節點操作
# 具體操作,請參考鏈接：https://www.cnblogs.com/xiao987334176/articles/9947548.html

##########################################################################
#                         INPUT
##########################################################################

#setting kubernets master
while true
do 
    if [ "$masterIP" == "" ]; then
        echo '請輸入k8s主節點ip'
        echo -e "K8S_MASTER_IP=\c"
        read masterIP
    else
        break
    fi
done
#setting docker registry
echo '請輸入docker私有倉庫ip,默認端口是5000'
echo '如果端口不是5000,請輸入ip:端口,比如: 192.168.0.50:8888'
echo -e "dockerREG=\c"
read dockerREG
echo '請輸入etcd服務器ip'
echo '如果有多個,用空格隔開。比如:"192.168.0.100 192.168.0.101 192.168.0.102"'
echo -e "ETCD_Severs=\c"
read ETCD_Server

#setting minions
while true
do 
    if [ "$k8minions" == "" ]; then
        echo '請輸入k8s從節點ip'
        echo '如果有多個,用空格隔開。比如:"192.168.0.100 192.168.0.101 192.168.0.102"'
        echo -e "minions=\c"
        read k8minions
    else
        break
    fi
done
######################################################################################
#                                 Settings
######################################################################################
# 判斷etcd的ip變量
if [ "$ETCD_Server" == "" ];then
        EXTERNAL_ETCD_ENDPOINTS=""
else
    EXTERNAL_ETCD_ENDPOINTS=""
    for i in $ETCD_Server;do
            EXTERNAL_ETCD_ENDPOINTS="http://$i:2379,$EXTERNAL_ETCD_ENDPOINTS"
    done
    EXTERNAL_ETCD_ENDPOINTS=${EXTERNAL_ETCD_ENDPOINTS%?}
fi

# 判斷docker倉庫ip
if [ "$dockerREG" == "" ];then
        dockerREG="$masterIP:5000"
else
    if [ `echo $dockerREG|grep ":"|wc -l` -eq 0 ];then
      dockerREG="$dockerREG:5000"
    fi
fi

MASTERIP="$masterIP"
REPO=`echo $dockerREG | cut -d ":" -f 1`
K8S_MASTER_IP="$MASTERIP"
minions="$k8minions"

echo "REPO=$REPO"
echo "K8S_MASTER_IP=$MASTERIP"
echo "DOCKERREG=$dockerREG"
echo "minions=$k8minions"
echo "etcds=$EXTERNAL_ETCD_ENDPOINTS"
######################################################################################
#                                 正式安裝
######################################################################################
# 復制軟件包
scp -r $REPO:/repo/k8s-1.11 ./

# 安裝相關組件
apt-get install -y docker.io ipvsadm ebtables socat --allow-unauthenticated

# 安裝k8s的deb包
dpkg -i k8s-1.11/*.deb

# 開啟cadvisor
sed -i 's?config.yaml?config.yaml --cadvisor-port=4194?g' /etc/systemd/system/kubelet.service.d/10-kubeadm.conf


# 添加cgroup驅動程序
sed -i 8i'Environment="KUBELET_CGROUP_ARGS=--cgroup-driver=cgroupfs"' /etc/systemd/system/kubelet.service.d/10-kubeadm.conf

# 重新應用配置
systemctl daemon-reload

# 導入k8s鏡像
for i in k8s-1.11/*.gz; do sudo docker load < $i; done
 
# 將包含quay.io鏡像推送到私有倉庫
# 查詢包含calico的鏡像
CalicoPro=$(sudo docker images|grep quay.io|awk -F 'quay.io/' '{print $2}'|awk '{print $1}'|sort|uniq)
for i in $CalicoPro;do
        # 查詢鏡像的tag版本
        Proversion=$(docker images|grep quay.io|grep $i|awk '{print $2}')
        for j in $Proversion;do
                # 打tag並推送鏡像到私有倉庫
                sudo docker tag quay.io/$i:$j $dockerREG/$i:$j
                sudo docker push $dockerREG/$i:$j
        done
done


# 暫時關閉kubelet
# 重新設置kubelet服務開機啟動
systemctl enable kubelet.service
# 停止kubelet服務
systemctl stop kubelet.service

# 關閉swap
swapoff -a
fswap=`cat /etc/fstab |grep swap|awk '{print $1}'`
for i in $fswap;do
    sed -i "s?$i?#$i?g" /etc/fstab
done

# 刪除默認的k8s文件
rm -rf /etc/kubernetes/*
rm -rf /var/lib/kubelet/*

# 重置k8s集群
kubeadm reset -f

# k8s臨時配置文件
cat > /tmp/kubeadm-conf.yaml <<EOF
apiVersion: kubeadm.k8s.io/v1alpha1
kind: MasterConfiguration
networking:
  podSubnet: 192.138.0.0/16
#apiServerCertSANs:
#- master01
#- master02
#- master03
#- 172.16.2.1
#- 172.16.2.2
#- 172.16.2.3
#- 172.16.2.100
etcd:
  endpoints:
#token: 67e411.zc3617bb21ad7ee3
kubernetesVersion: v1.11.2
api:
  advertiseAddress: $masterIP

EOF

# 將etcd添加到/tmp/kubeadm-conf.yaml
for i in `echo $EXTERNAL_ETCD_ENDPOINTS|sed 's?,? ?g'`;do
    sudo sed -i "15i\  - $i" /tmp/kubeadm-conf.yaml    
done

# 初始化集群
# 使用kubeadm init初始化集群
kubeadm init --config=/tmp/kubeadm-conf.yaml| sudo tee /etc/kube-server-key

# 添加Nodrport端口范圍
# 添加端口范圍1000-62000
line_conf=`cat /etc/kubernetes/manifests/kube-apiserver.yaml|grep -n "allow-privileged=true"|cut -f 1 -d ":"`
sed -i -e "$line_conf"i'\    - --service-node-port-range=1000-62000' /etc/kubernetes/manifests/kube-apiserver.yaml

# apiserver綁定主機的非安全端口，這里綁定的是主節點IP
line_conf=`grep -n "insecure-port" /etc/kubernetes/manifests/kube-apiserver.yaml|awk -F ":" '{print $1}'`
sed -i -e "$line_conf"i"\    - --insecure-bind-address=$masterIP" /etc/kubernetes/manifests/kube-apiserver.yaml

# apiserver綁定主機的非安全端口號，默認為8080
sed -i -e 's?insecure-port=0?insecure-port=8080?g' /etc/kubernetes/manifests/kube-apiserver.yaml

# 設置kubectl權限,$HOME是內置變量，表示宿主目錄
mkdir -p $HOME/.kube
sudo cp -f /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

# 部署CalICO網絡插件
# 修改etcd端點的IP
line=`grep "etcd_endpoints:" -n k8s-1.11/calico.yaml | cut -f 1 -d ":"`
sed -i "$line c \ \ etcd_endpoints: \"$EXTERNAL_ETCD_ENDPOINTS\"" k8s-1.11/calico.yaml

# 修改CIDR
# 將192.168.0.0替換為192.138.0.0
sed -i -e 's/192.168.0.0/192.138.0.0/g' k8s-1.11/calico.yaml
#將quay.io修改為私有庫地址
sed -i -e "s?quay.io?$dockerREG?g" k8s-1.11/calico.yaml

# 等待15秒
sleep 15
# 除了Kube DNS，它需要一個網絡插件
kubectl --kubeconfig=/etc/kubernetes/admin.conf apply -f k8s-1.11/calico.yaml

# Kubernetes node配置
cat >client.sh <<EOF
# 安裝組件
sudo apt-get update
sudo apt-get install -y docker.io ipvsadm --allow-unauthenticated
sudo apt-get install -y ebtables socat --allow-unauthenticated

# 關閉swap
sudo swapoff -a
fswap=\`cat /etc/fstab |grep swap|awk '{print \$1}'\`
for i in \$fswap;do
    sudo sed -i "s?\$i?#\$i?g" /etc/fstab
done

# 手動加載IPVS的基本模塊
Dline=\`sudo grep -n LimitNOFILE /lib/systemd/system/docker.service|cut -f 1 -d ":" \`
sudo sed -i "\$Dline c\LimitNOFILE=1048576" /lib/systemd/system/docker.service 
sudo systemctl restart docker
if [ \`dpkg -l|grep kube|wc -l\` -ne 0 ];then
    sudo apt purge -y \`dpkg -l|grep kube|awk '{print \$2}'\`
fi

# 安裝deb軟件包
sudo modprobe ip_vs
sudo modprobe ip_vs_rr
sudo modprobe ip_vs_sh
sudo modprobe ip_vs_wrr
sudo dpkg -i k8s-1.11/cri-tools*.deb
sudo dpkg -i k8s-1.11/kubernetes-cni*.deb
sudo dpkg -i k8s-1.11/kubelet*.deb
sudo dpkg -i k8s-1.11/kubectl*.deb
sudo dpkg -i k8s-1.11/kubeadm*.deb

# 開啟cadvisor
sudo sed -i 's?config.yaml?config.yaml --cadvisor-port=4194?g' /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
if [ \`cat /etc/systemd/system/kubelet.service.d/10-kubeadm.conf|grep cgroup-driver|wc -l\` -eq 0 ];then
    # 添加cgroup驅動程序
    sudo sed -i 8i'Environment="KUBELET_CGROUP_ARGS=--cgroup-driver=cgroupfs"' /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
    sudo sed -i "s?\`tail -n1 /etc/systemd/system/kubelet.service.d/10-kubeadm.conf\`?& \$KUBELET_CGROUP_ARGS?g" /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
fi
# 重新應用配置
sudo systemctl daemon-reload

# 導入k8s鏡像
for i in k8s-1.11/*.tar.gz; do sudo docker load < \$i; done
# 停止kubelet
sudo systemctl enable kubelet.service
sudo systemctl stop kubelet.service
# 重置k8s集群
sudo kubeadm reset -f
# 新增集群集工作節點的命令
EOF

# 新增集群集工作節點的命令,追加到最后一行
sudo echo "sudo `tail -n2 /etc/kube-server-key`" >> client.sh

# 安裝客戶端
for i in $minions; do
        # 復制軟件包
        scp -r k8s-1.11/ $i:/$HOME/
        # 復制daemon.json
        ssh $i sudo mkdir -p /etc/docker
        scp /etc/docker/daemon.json $i:/$HOME/daemon.json
        ssh $i sudo cp /$HOME/daemon.json /etc/docker/daemon.json
        ssh $i sudo rm -f /$HOME/daemon.json
        # 復制cilent.sh
        scp client.sh $i:/$HOME/
        # node節點執行client.sh
        ssh $i sudo bash /$HOME/client.sh
done
echo 'please check kubenetes DNS server is runing or not ......'
echo 'command: kubectl get po -n kube-system|grep dns'

# 查看k8s的DNS服務狀態
kubectl get po -n kube-system|grep dns
# 睡眠25秒
sleep 25
# 查看集群中的節點
kubectl get nodes

View Code

運行之前，查看etcd的狀態

root@k8s-master001:~# curl http://192.168.91.129:2379/version -s | python3 -m json.tool
{
    "etcdserver": "3.3.10",
    "etcdcluster": "3.3.0"
}

查看docker私有倉庫的狀態

root@k8s-master001:~# curl http://192.168.91.131:5000/v2/_catalog -s | python3 -m json.tool
{
    "repositories": [
        "calico/cni",
        "calico/kube-controllers",
        "calico/node"
    ]
}

登錄到docker私有倉庫服務器，查看/repo目錄

root@k8s-node002:~# ll /repo/
total 12
drwxr-xr-x  3 root root 4096 Nov 13 16:50 ./
drwxr-xr-x 24 root root 4096 Nov 13 16:50 ../
drwxr-xr-x  2 root root 4096 Nov 13 16:50 k8s-1.11/

正式運行腳本

bash k8s-v1.11.sh

輸入如下：

請輸入k8s主節點ip
K8S_MASTER_IP=192.168.91.128
請輸入docker私有倉庫ip,默認端口是5000
如果端口不是5000,請輸入ip:端口,比如: 192.168.0.50:8888
dockerREG=192.168.91.131
請輸入etcd服務器ip
如果有多個,用空格隔開。比如:"192.168.0.100 192.168.0.101 192.168.0.102"
ETCD_Severs=192.168.91.129
請輸入k8s從節點ip
如果有多個,用空格隔開。比如:"192.168.0.100 192.168.0.101 192.168.0.102"
minions=192.168.91.129 192.168.91.131

中間輸出略....

NAME            STATUS    ROLES     AGE       VERSION
k8s-master001   Ready     master    4m        v1.11.2
k8s-node001     Ready     <none>    2m        v1.11.2
k8s-node002     Ready     <none>    1m        v1.11.2

上面的紅色部分，請根據環境需求填寫。

末尾的k8s節點狀態都是Ready，表示安裝成功了！

查看所有命名空間

root@k8s-master001:~# kubectl get ds --all-namespaces 
NAMESPACE     NAME          DESIRED   CURRENT   READY     UP-TO-DATE   AVAILABLE   NODE SELECTOR                   AGE
kube-system   calico-node   3         3         3         3            3           <none>                          8m
kube-system   kube-proxy    3         3         3         3            3           beta.kubernetes.io/arch=amd64   8m

查看calico網絡狀態

kubectl get pods -o wide -n kube-system | grep calico-node

確保都是Running 狀態

至此k8s，安裝就完成了！

本文參考鏈接：

https://www.kubernetes.org.cn/4047.html

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 kubernetes多節點部署解析 IPFS系列多節點搭建二 kubesphere集群搭建(多節點) 從0開始搭建多節點kafka集群 consul 多節點/單節點集群搭建多節點OpenMPI集群的搭建和使用基於docker快速搭建多節點Hadoop集群 Kubernetes : 多節點 k8s 集群實踐在 Linux 部署多節點 Kubernetes 集群與 KubeSphere 容器平台三、Kubernetes系列之kubeadm部署多節點master集群