部分內容參考專欄學習筆記：
https://www.qikqiak.com/
第0章 參考網站
0.k8s介紹
https://kubernetes.io/zh/docs/concepts/overview/what-is-kubernetes/
1.docker官方文檔
https://docs.docker.com/
2.k8s官方文檔
https://kubernetes.io/zh/
3.kubeadm官方文檔
https://kubernetes.io/zh/docs/setup/production-environment/tools/
4.prometheus官方文檔
https://prometheus.io/docs/introduction/overview/
5.ansible安裝k8s項目
https://github.com/easzlab/kubeasz
6.阿里雲ACK
https://www.aliyun.com/product/kubernetes
第1章 k8s介紹
https://kubernetes.io/zh/docs/concepts/overview/what-is-kubernetes/
第2章 k8s系統架構和組件介紹
1.k8s架構
從系統架構來看，k8s分為2個節點
Master 控制節點 指揮官
Node 工作節點 干活的
2.Master節點組件
kube-API Server
kube-API Server：提供k8s API接口
主要處理Rest操作以及更新Etcd中的對象
是所有資源增刪改查的唯一入口。
Scheduler
Scheduler：資源調度器
根據etcd里的節點資源狀態決定將Pod綁定到哪個Node上
Controller Manager
Controller Manager
負責保障pod的健康存在
資源對象的自動化控制中心，Kubernetes集群有很多控制器。
Etcd
這個是Kubernetes集群的數據庫
所有持久化的狀態信息存儲在Etcd中
kubectl
kubectl是管理k8s集群的客戶端工具，管理員通過kubectl命令對API Server進行操作
API Server 響應並返回對應的命令結果，從而達到對 Kubernetes 集群的管理
3.Node節點的組成
容器運行時（Container Runtime)
容器運行時是負責容器運行的軟件。
默認情況下，Kubernetes 使用 容器運行時接口（Container Runtime Interface，CRI） 來與你所選擇的容器運行時交互。
如果同時檢測到 Docker 和 containerd，則優先選擇 Docker。 這是必然的，因為 Docker 18.09 附帶了 containerd 並且兩者都是可以檢測到的， 即使你僅安裝了 Docker。 如果檢測到其他兩個或多個運行時，kubeadm 輸出錯誤信息並退出。
kubelet 通過內置的 dockershim CRI 實現與 Docker 集成。
Docker Engine
負責節點容器的管理工作，最終創建出來的是一個Docker容器。
kubelet
安裝在Node上的代理服務，用來管理Pods以及容器/鏡像/Volume等，實現對集群對節點的管理。
kube-proxy
安裝在Node上的網絡代理服務，提供網絡代理以及負載均衡，實現與Service通訊。
第3章 k8s核心資源
1.POD
POD是k8s的最小單位
POD的IP地址是隨機的，刪除POD會改變IP
POD都有一個根容器
一個POD內可以由一個或多個容器組成
一個POD內的容器共享根容器的網絡命名空間和文件系統卷
一個POD的內的網絡地址由根容器提供
創建Pod流程圖:
文字說明：
創建Pod的清單 --> API Server
API Server --> etcd
etcd --> API Server
kube-scheduler --> API Server --> etcd
etcd --> API server --> kubelet --> Docker
kubelet --> API Server --> etcd
管理員清單提交給了 APIServer
API Server 接收到請求后把資源清單信息存入到 etcd 數據庫中
etcd 存好后更新狀態給 API Server
API Server通過相應的接口更新事件
kube-scheduler 組件發現這個時候有一個 Pod 還沒有綁定到節點上，就會對這個 Pod 進行一系列的調度，把它調度到一個最合適的節點上
然后把這個節點和 Pod 綁定到一起的信息告訴 API Server
API Server將調度消息更新到etcd里，etcd更新好后返回狀態給API Server
節點上的 kubelet 組件這個時候 watch 到有一個 Pod 被分配過來了，就去把這個 Pod 的信息拉取下來，然后根據描述通過容器運行時把容器創建出來，最后當然同樣把 Pod 狀態匯報給API Server 再寫回到 etcd 中去，這樣就完成了一整個的創建流程。
容器運行狀態：
Waiting（等待）
如果容器並不處在Running或Terminated狀態之一，它就處在Waiting狀態。 處於Waiting狀態的容器仍在運行它完成啟動所需要的操作：例如，從某個容器鏡像 倉庫拉取容器鏡像，或者向容器應用數據等等。 當你使用 kubectl 來查詢包含 Waiting狀態的容器的 Pod 時，你也會看到一個 Reason 字段，其中給出了容器處於等待狀態的原因。
Running（運行中）
Running狀態表明容器正在執行狀態並且沒有問題發生。
如果你使用 kubectl 來查詢包含 Running 狀態的容器的 Pod 時，你也會看到 關於容器進入Running狀態的信息。
Terminated（已終止）
處於Terminated狀態的容器已經開始執行並且或者正常結束或者因為某些原因失敗。 如果你使用kubectl來查詢包含Terminated狀態的容器的 Pod 時，你會看到 容器進入此狀態的原因、退出代碼以及容器執行期間的起止時間。
2.Label
label標簽是kubernetes中非常重要的一個屬性，label標簽就像身份證一樣，可以用來識別k8s的對象。
我們在傳統架構里不同組件之間查找都是通過IP地址，但是在k8s里，很多的匹配關系都是通過標簽來查找的。
3.Namespace
Namespace(命令空間)是k8s里另一個非常重要的概念，Namespace通過將集群內部的資源對象划分為不同的。Namespace里，形成邏輯上的不同項目組或用戶組。
常見的pod,service,Deployment等資源如果沒有指定命令空間，則默認創建在名為default的默認命名空間。
4.Controller
用來管理POD,控制器的種類有很多
- RC Replication Controller 控制POD有多個副本
- RS ReplicaSet RC控制的升級版
- Deployment 推薦使用，功能更強大，包含了RS控制器
- DaemonSet 保證所有的Node上有且只有一個Pod在運行
- StatefulSet 有狀態的應用，為Pod提供唯一的標識，它可以保證部署和scale的順序
5.Service
Service服務也是k8s的核心資源之一，Service定義了服務的入口地址，用來將后端的Pod服務暴露給外部用戶訪問。
我們知道Pod會隨時被銷毀和創建，而新創的Pod的IP地址並不是固定的，那么Service資源是如何找到后面不確定IP的Pod呢？
為了解決這個問題，k8s在PodIP之上又設計了一層IP，名為ClusterIP,這個ClusterIP在創建后就不會再變化，除非被刪除重新創建。
通過這樣的設計，我們只需要創建Cluster類型的Service資源，再通過標簽和后端的Pod綁定在一起，這樣只要訪問ClusterIP就可以將請求轉發到了后端的Pod，而且如果后端有多個Pod，ClusterIP還會將流量自動負載均衡到后面的Pod
通過ClusterIP我們可以訪問對應的Pod，但是這個ClusterIP是一個虛擬IP，只能在k8s集群內部使用。外部用戶是訪問不到的，那么我們如何讓外面的用戶也可以訪問到我們的服務呢？
我們的k8s運行在物理服務器上，那么必然會有物理網卡和真實的IP地址，也就是說所有k8s集群之外的節點想訪問k8s集群內的某個節點，都必須通過物理網卡和IP。
所以我們可以通過將物理網卡的IP地址的端口和Cluster做端口映射來實現外部流量對內部Pod的訪問。
這種IP在k8s里稱為NodeIP，暴露的端口稱為NodePort。
總結一下：
NodeIP 對外提供用戶訪問
CluterIP 集群內部IP，可以動態感知后面的POD IP
POD IP POD的IP
Service三種網絡圖：
Service和Pod和RS的關系：
第4章 k8s實驗環境准備
1.配置信息
主機名 IP地址 推薦配置
master 10.0.0.10 1C2G40G
node1 10.0.0.11 1C2G40G
node2 10.0.0.12 1C2G40G
2.系統環境准備
配置主機名
主機名 IP地址
master 10.0.0.10
node1 10.0.0.11
node2 10.0.0.12
配置host解析
cat >> /etc/hosts << EOF
10.0.0.10 master
10.0.0.11 node1
10.0.0.12 node2
EOF
關閉防火牆
systemctl stop firewalld NetworkManager
systemctl disable firewalld NetworkManager
關閉SELinux
setenforce 0
sed -i 's#SELINUX=disabled#SELINUX=disabled#g' /etc/selinux/config
getenforce
更新好阿里源
curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
curl -o /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
sed -i '/aliyuncs/d' /etc/yum.repos.d/*.repo
確保網絡通暢
ping -c 1 www.baidu.com
ping -c 1 master
ping -c 1 node1
ping -c 1 node2
配置時間同步
yum install chrony -y
systemctl start chronyd
systemctl enable chronyd
date
關閉SWAP分區
swapoff -a
sed -i '/swap/d' /etc/fstab
free -h
第5章 安裝部署kubeadm
1.k8s安裝部署方式
k8s的安裝方式有很多種，常見的安裝方式主要有以下幾種：
1.二進制安裝 生產推薦
2.kubeadm安裝 學習和實驗
3.網友寫的ansible二進制安裝 非常牛叉
4.第三方安裝工具比如rancher
5.雲服務的k8s 比如阿里雲的ACK
這里我們應該把學習使用k8s作為首要任務，所以先選擇安裝最簡單的kubeadm來部署一套k8s集群。
2.kubeadm介紹
kubeadm是google推出的一種部署k8s集群的套件，他將k8s的組件打包封裝成了容器，然后通過kubeadm進行集群的初始化。
kubeadm的好處是安裝部署方便，缺點是不容易看到每個組件的配置，出了問題不好排查。但是我們現在的重點是學習k8s的使用，所以這些優先選擇簡單的安裝方式，最后會介紹二進制安裝部署。
3.kubeadm部署前規划
節點規划
master master節點 API Server,controlle,scheduler,kube-proxy,kubelet,etcd
node1 node節點 Dokcer kubelet kube-proxy
node2 node節點 Dokcer kubelet kube-proxy
IP規划
POD IP 10.2.0.0
Cluster IP 10.1.0.0
Node IP 10.0.0.0
注意！！！以下步驟如果沒有特別指出在某個節點運行則默認在所有節點都執行。
4.kubeadm部署前系統環境准備
設置k8s禁止使用swap
cat > /etc/sysconfig/kubelet<<EOF
KUBELET_CGROUP_ARGS="--cgroup-driver=systemd"
KUBELET_EXTRA_ARGS="--fail-swap-on=false"
EOF
設置內核參數
cat > /etc/sysctl.d/k8s.conf <<EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF
sysctl --system
加載IPVS模塊
cat >/etc/sysconfig/modules/ipvs.modules<<EOF
#!/bin/bash
modprobe -- ip_vs
modprobe -- ip_vs_rr
modprobe -- ip_vs_wrr
modprobe -- ip_vs_sh
modprobe -- nf_conntrack_ipv4
EOF
chmod +x /etc/sysconfig/modules/ipvs.modules
source /etc/sysconfig/modules/ipvs.modules
lsmod | grep -e ip_vs -e nf_conntrack_ipv
5.安裝配置Docker
配置阿里源
cd /etc/yum.repos.d/
wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
yum makecache fast
安裝指定版本的Docker
yum list docker-ce --showduplicates
yum -y install docker-ce-19.03.15 docker-ce-cli-19.03.15
配置docker鏡像加速和cgroup驅動:
mkdir /etc/docker -p
cat > /etc/docker/daemon.json <<EOF
{
"registry-mirrors": ["https://ig2l319y.mirror.aliyuncs.com"],
"exec-opts": ["native.cgroupdriver=systemd"]
}
EOF
啟動Docker並設置開機自啟動
systemctl enable docker && systemctl start docker
檢查版本
docker -v
6.設置kubeadm的國內yum倉庫
cat >/etc/yum.repos.d/kubernetes.repo<<EOF
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF
7.安裝kubeadm
yum list kubeadm --showduplicates
yum install -y kubelet-1.19.3 kubeadm-1.19.3 kubectl-1.19.3 ipvsadm
8.設置kubelet開機啟動
systemctl enable kubelet
9.初始化集群命令-只在master節點運行
初始化命令：
kubeadm init \
--apiserver-advertise-address=10.0.0.10 \
--image-repository registry.aliyuncs.com/google_containers \
--kubernetes-version v1.19.3 \
--service-cidr=10.1.0.0/16 \
--pod-network-cidr=10.2.0.0/16 \
--service-dns-domain=cluster.local \
--ignore-preflight-errors=Swap \
--ignore-preflight-errors=NumCPU
參數解釋：
--apiserver-advertise-address=10.0.0.11 #API Server的地址
--image-repository registry.aliyuncs.com/google_containers #鏡像倉庫地址，這里使用的是阿里雲
--kubernetes-version v1.19.3 #安裝的k8s版本
--service-cidr=10.1.0.0/16 #Cluster IP
--pod-network-cidr=10.2.0.0/16 #Pod IP
--service-dns-domain=cluster.local #全域名的后綴，默認是cluster.local
--ignore-preflight-errors=Swap #忽略SWAP檢查不通過的警告
--ignore-preflight-errors=NumCPU #忽略CPU檢查不通過的警告
這個步驟需要幾分鍾時間，執行完成后會有輸出，這是node節點加入k8s集群的命令,需要自己保存到文本里
kubeadm join 10.0.0.11:6443 --token fsteby.4pz9czptzvxhzrg2 \
--discovery-token-ca-cert-hash sha256:8466da60f808479cf39c78fbbfc7c80b397ac95ed23164253abe05a9c8c619b4
10.為kubectl准備kubeconfig
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
11.獲取node節點信息
[root@node1 ~]# kubectl get nodes
NAME STATUS ROLES AGE VERSION
master NotReady master 15m v1.19.3
12.設置kube-proxy使用ipvs模式
k8s默認使用的是iptables防火牆，可以修改為性能更高的ipvs模式
執行編輯命令，然后將mode: ""修改為mode: "ipvs"然后保存退出，這里涉及到configmap資源類型，后面詳細講解。
kubectl edit cm kube-proxy -n kube-system
重啟kube-proxy
kubectl -n kube-system get pod|grep kube-proxy|awk '{print "kubectl -n kube-system delete pod "$1}'|bash
查看pod信息
kubectl get -n kube-system pod|grep "kube-proxy"
檢查日志，如果出現IPVS rr就表示成功
[root@node1 ~]# kubectl -n kube-system logs -f kube-proxy-7cdbn
I0225 08:03:57.736191 1 node.go:135] Successfully retrieved node IP: 10.0.0.11
I0225 08:03:57.736249 1 server_others.go:176] Using ipvs Proxier.
W0225 08:03:57.736841 1 proxier.go:420] IPVS scheduler not specified, use rr by default
檢查IPVS規則
[root@node1 ~]# ipvsadm -Ln
IP Virtual Server version 1.2.1 (size=4096)
Prot LocalAddress:Port Scheduler Flags
-> RemoteAddress:Port Forward Weight ActiveConn InActConn
TCP 10.1.0.1:443 rr
-> 10.0.0.11:6443 Masq 1 0 0
TCP 10.1.0.10:53 rr
TCP 10.1.0.10:9153 rr
UDP 10.1.0.10:53 rr
13.警告解決
告警內容：
[init] Using Kubernetes version: v1.20.4
[preflight] Running pre-flight checks
[WARNING NumCPU]: the number of available CPUs 1 is less than the required 2
[WARNING IsDockerSystemdCheck]: detected "cgroupfs" as the Docker cgroup driver. The recommended driver is "systemd". Please follow the guide at https://kubernetes.io/docs/setup/cri/
[WARNING SystemVerification]: this Docker version is not on the list of validated versions: 20.10.7. Latest validated version: 19.03
上面的告警信息主要有幾點
1.kubeadm和docker的版本不對，提示docker的版本太高
2.Docker的cgroup driver驅動模式不對，建議使用systemd
14.部署Flannel網絡插件-只在master節點上安裝部署
克隆代碼
git clone --depth 1 https://github.com/coreos/flannel.git
下載下來后還需要修改資源配置清單
#修改配置文件，將128行替換為PodIP，在189行新增加一行指定網卡名
cd flannel/Documentation/
vim kube-flannel.yml
128: "Network": "10.2.0.0/16",
189: - --iface=eth0
應用資源配置清單
kubectl create -f kube-flannel.yml
檢查pod運行狀態，等一會應該全是running
[root@node1 ~]# kubectl -n kube-system get pod
NAME READY STATUS RESTARTS AGE
coredns-6d56c8448f-2w8gz 1/1 Running 0 12m
coredns-6d56c8448f-6k7wf 1/1 Running 0 12m
etcd-node1 1/1 Running 0 12m
kube-apiserver-node1 1/1 Running 0 12m
kube-controller-manager-node1 1/1 Running 0 12m
kube-flannel-ds-2nmgt 1/1 Running 0 99s
kube-proxy-nmk2b 1/1 Running 0 12m
kube-scheduler-node1 1/1 Running 0 12m
15.node節點執行加入集群命令-所有的Node節點執行
剛才在master集群初始化的時候會生成一串命令，這個命令就是給node節點加入集群的指令。
kubeadm join 10.0.0.11:6443 --token uqf018.mia8v3i1zcai19sj --discovery-token-ca-cert-hash sha256:e7d36e1fb53e59b12f0193f4733edb465d924321bcfc055f801cf1ea59d90aae
如果當時沒有保存，可以執行以下命令重新查看:
kubeadm token create --print-join-command
16.查看集群狀態
在master節點上查看節點狀態
kubectl get nodes
17.給節點打標簽
在master節點上設置節點標簽
kubectl label nodes node1 node-role.kubernetes.io/node=
kubectl label nodes node2 node-role.kubernetes.io/node=
18.再次查看節點狀態
全部都是Ready就是正常狀態
[root@node1 Documentation]# kubectl get nodes
NAME STATUS ROLES AGE VERSION
node1 Ready master 7m18s v1.19.3
node2 Ready node 6m40s v1.19.3
node3 Ready node 6m50s v1.19.3
19.支持命令補全
yum install bash-completion -y
source /usr/share/bash-completion/bash_completion
source <(kubectl completion bash)
kubectl completion bash >/etc/bash_completion.d/kubectl
第6章 常用資源類型
1.工作負載類型
RC ReplicaController
RS ReplicaSet
DP Deployment
DS DaemonSet
2.服務發現及負載均衡
Service
Ingress
3.配置與存儲資源
ConfigMap 存儲配置文件
Secret 存儲用戶字典
4.集群級別資源
Namespace
Node
Role
ClusterRole
RoleBinding
ClusterRoleBinding
第7章 資源配置清單體驗
1.創建資源的方法
在Docker時代，我們可以使用docker run或者docker-compose來管理容器。但是在k8s里，我們使用json格式或者YAML格式的資源清單來描述應用。
但是相對來說，yaml格式更容器理解和閱讀，所以我們都是使用yaml格式來聲明。
2.資源清單介紹
查看資源清單所需字段
kubectl explain pod
kubectl explain pod
kubectl explain pod.spec
kubectl explain pod.spec.volumes
資源清單字段介紹
apiVersion: v1 #屬於k8s哪一個API版本或組
kind: Pod #資源類型
metadata: #元數據，嵌套字段
spec: #定義容器的規范，創建的容器應該有哪些特性
status: #只讀的，由系統控制，顯示當前容器的狀態
3.使用資源配置清單創建POD
3.1首先使用命令行創建一個pod
kubectl create deployment nginx --image=nginx:alpine
kubectl get pod -o wide
3.2 將剛才創建的pod配置到處成yaml格式
kubectl get pod -o yaml > nginx-pod.yaml
3.3 精簡資源清單，刪掉不需要的配置
apiVersion: v1
kind: Pod
metadata:
name: nginx
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:alpine
imagePullPolicy: IfNotPresent
ports:
- name: http
containerPort: 80
json格式寫法：
{
apiVersion: "v1",
kind: "Pod",
metadata:
{
name: "nginx",
labels:
{
app: "nginx"
}
}
spec:
{
containers:
{
name: "nginx",
image: "nginx:alpine",
imagePullPolicy: "IfNotPresent"
}
}
}
3.5 刪除命令行創建的資源
kubectl delete deployments.apps nginx
3.6 應用資源配置清單
kubectl create -f nginx-pod.yaml
3.7 查看pod信息
kubectl get pod -o wide
3.8 查看pod詳細信息
kubectl describe pod nginx
4.POD資源清單總結
聲明式管理 我想運行一個Nginx k8s幫你干活
apiVersion: v1 #api版本號
kind: Pod #資源類型
metadata: #原數據
name: nginx #pod顯示名稱
labels: #標簽
app: nginx #具體的標簽
spec: #定義pod參數
containers: #定義容器
- image: nginx:alpine #鏡像名稱
imagePullPolicy: IfNotPresent #拉取鏡像策略，如果本地已經存在鏡像，就不重新拉取
name: nginx #容器名稱
第8章 標簽的使用設置
1.Node標簽的設置使用
1.1 查看node的標簽
kubectl get node --show-labels
1.2 給node打標簽
kubectl label nodes node1 CPU=Xeon
kubectl label nodes node2 disktype=ssd
1.3 編輯POD資源配置清單，使用node標簽選擇器
apiVersion: v1
kind: Pod
metadata:
name: nginx
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:1.14.0
imagePullPolicy: IfNotPresent
ports:
- name: http
containerPort: 80
nodeSelector:
#CPU: Xeon
disktype: SSD
1.4 刪除容器重新創建
kubectl delete pod nginx
kubectl create -f nginx-pod.yaml
1.5 查看結果
kubectl get pod -o wide
1.6 刪除節點標簽
kubectl label nodes node2 CPU-
kubectl label nodes node3 disktype-
2.Pod標簽設置
2.1 標簽說明
一個標簽可以給多個POD使用
一個POD也可以擁有多個標簽
2.2 查看POD標簽
kubectl get pod --show-labels
2.3 添加標簽方法
方法1:直接編輯資源配置清單：
apiVersion: v1
kind: Pod
metadata:
name: nginx
labels:
app: nginx
release: beta
方法2:命令行打標簽
kubectl label pods nginx release=beta
kubectl label pods nginx job=linux
kubectl get pod --show-labels
2.4 刪除標簽
kubectl label pod nginx job-
kubectl get pod --show-labels
2.5 POD標簽實驗
生成2個不同標簽的POD
kubectl create deployment nginx --image=nginx:1.14.0
kubectl get pod --show-labels
kubectl label pods nginx-xxxxxxxx release=stable
kubectl get pod --show-labels
根據標簽查看
kubectl get pods -l release=beta --show-labels
kubectl get pods -l release=stable --show-labels
根據標簽刪除
kubectl delete pod -l app=nginx
第9章 重新認識POD
1.Pod的原理
1.1 共享網絡空間
POD內的容器使用container模式共享根容器的網絡
容器看到的網絡設備信息和根容器完全相同
POD內的多個容器可以直接使用localhost通信
POD內的多個容器不能綁定相同的端口
POD的生命周期和根容器一樣，如果根容器推出，POD就退出了
可以在node節點使用docker inspect查看容器的詳細信息，會發現有網絡模式為container
[root@node2 ~]# docker inspect 6d636151f567|grep "NetworkMode"
"NetworkMode": "container:1613f2dee9e410805679c6073ee7c1a9160c3fd24b7135f7e5ed17ffc6502ee2",
1.2 共享文件系統
默認情況下一個POD內的容器文件系統是互相隔離的
如果想讓一個POD的容器共享文件，那么只需要定義一個Volume，然后兩個容器分別掛在這個Volume就可以共享了
舉個例子：
cat > nginx_vo.yaml << 'EOF'
apiVersion: v1
kind: Pod
metadata:
name: nginx
spec:
nodeName: node2
volumes:
- name: nginxlog
hostPath:
path: /var/log?/nginx/
containers:
- name: nginx-1
image: nginx
volumeMounts:
- name: nginxlog
mountPath: /var/log/nginx/
- name: tail-log
image: busybox
args: [/bin/sh, -c, 'tail -f /var/log/nginx/access.log']
volumeMounts:
- name: nginxlog
mountPath: /var/log/nginx/
EOF
2.Pod的生命周期
init container：
初始化容器是指在主容器啟動之前，先啟動一個容器來做一些准備工作，比如兩個容器做了共享volum，然后可以先啟動一個容器來對目錄進行更改用戶授權。
比如主容器需要連接數據庫，可以先使用初始化容器測試可否正常連接數據庫，如果可以正常連接再啟動主容器。
hook：
PostStart：在容器啟動創建后立刻執行，但是時間不能太長，否則容器將不會是running狀態
PreStop：在容器停止被刪除前執行，主要用於優雅的關閉應用程序。
liveness probe:
存活性探針，用於確定容器內的應用是否還活着
readiness probe:
就緒性探針，用於確定容器是否已經准備就緒可以干活了，比如擴容一個Pod，只有等這個Pod里面的應用完全啟動了，才會將流量進入。
3.POD運行狀態
Pending（掛起）:
Pod 已被Kubernetes 系統接受，但有一個或者多個容器尚未創建亦未運行。此階段包括等待 Pod 被調度的時間和通過網絡下載鏡像的時間
Running（運行中）:
Pod 已經綁定到了某個節點，Pod 中所有的容器都已被創建。至少有一個容器仍在運行，或者正處於啟動或重啟狀態。
Succeeded(成功）:
Pod 中的所有容器都已成功終止，並且不會再重啟。
Failed（失敗）:
Pod 中的所有容器都已終止，並且至少有一個容器是因為失敗終止。也就是說，容器以非 0 狀態退出或者被系統終止。
Unknown（未知）:
因為某些原因無法取得 Pod 的狀態。這種情況通常是因為與 Pod 所在主機通信失敗。
4.Pod對容器的封裝和應用
那么在工作中我們究竟如何決策一個POD是跑一個容器還是多個容器呢？
在實際工作中我們除了完成任務以外還需要考慮以后擴容的問題，就拿wordpress舉例，有以下兩種方案：
第一種：全部放一個pod里
第二種：Wordpress和MySQL分開
那么如何擴容呢？如果第一種方案大家會發現沒有辦法很好的擴容，因為數據庫和wordpress已經綁定成一個整體了，擴容wordpress就得擴容mysql。而第二種方案就要靈活的多。
總結：
多個容器之間是否非常緊密的關系，比如nginx和php就非常緊密，但是php和mysql不緊密
這些容器是否必須是一個整體
這些容器放在一起是否影響擴容
5.初始化容器
apiVersion: v1
kind: Pod
metadata:
name: nginx-init
spec:
nodeName: node2
volumes:
- name: nginx-index
emptyDir: {}
initContainers:
- name: init
image: busybox
args: [/bin/sh, -c, 'echo k8s >> /usr/share/nginx/html/index.html']
volumeMounts:
- name: nginx-index
mountPath: "/usr/share/nginx/html"
containers:
- name: nginx
image: nginx:alpine
ports:
- containerPort: 80
volumeMounts:
- name: nginx-index
mountPath: "/usr/share/nginx/html"
5.Pod hook
PostStart：
apiVersion: v1
kind: Pod
metadata:
name: nginx-hook
spec:
nodeName: node2
containers:
- name: nginx
image: nginx:alpine
lifecycle:
postStart:
exec:
command: [/bin/sh, -c, 'echo k8s > /usr/share/nginx/html/index.html']
ports:
- containerPort: 80
PostStop:
apiVersion: v1
kind: Pod
metadata:
name: nginx-hook
spec:
nodeName: node2
volumes:
- name: nginxlog
hostPath:
path: /var/log/nginx/
containers:
- name: nginx
image: nginx:alpine
lifecycle:
postStart:
exec:
command: [/bin/sh, -c, 'echo k8s > /usr/share/nginx/html/index.html']
preStop:
exec:
command: [/bin/sh, -c, 'echo bye > /var/log/nginx/stop.log']
ports:
- containerPort: 80
volumeMounts:
- name: nginxlog
mountPath: /var/log/nginx/
6.Pod 健康檢查
6.1 存活探針
存活探針簡單來說就是用來檢測容器的應用程序是否還正常工作，如果應用程序不正常，即使容器還活着也沒有意義了，所以這時候就可以使用存活探針來探測，如果應用程序不正常，就重啟POD。
存活探針語法：
apiVersion: v1
kind: Pod
metadata:
name: liveness-pod
spec:
nodeName: node2
volumes:
- name: nginx-html
hostPath:
path: /usr/share/nginx/html/
containers:
- name: liveness
image: nginx
imagePullPolicy: IfNotPresent
lifecycle:
postStart:
exec:
command: [/bin/sh, -c, 'echo k8s > /usr/share/nginx/html/index.html']
livenessProbe:
exec:
command:
- cat
- /usr/share/nginx/html/index.html
initialDelaySeconds: 3
periodSeconds: 1
volumeMounts:
- name: nginx-html
mountPath: /usr/share/nginx/html/
配置解釋：
livenessProbe: #存活探針
exec: #執行命令
command: #具體的命令結果0的狀態被視為存活，非零是不健康的。
- cat
- /tmp/healthy
initialDelaySeconds: 3 #第一次執行探針的時候等待5秒
periodSeconds: 1 #每隔5秒執行一次存活探針，默認為10秒，最小值為1秒
通過命令可以查看Pod的詳細狀態
kubectl describe pod liveness-pod
kubectl get pod -w
除了我們自己寫的命令以外，也支持基於http請求:
apiVersion: v1
kind: Pod
metadata:
name: liveness-pod
spec:
nodeName: node2
volumes:
- name: nginx-html
hostPath:
path: /usr/share/nginx/html/
containers:
- name: liveness
image: nginx
imagePullPolicy: IfNotPresent
lifecycle:
postStart:
exec:
command: [/bin/sh, -c, 'echo k8s > /usr/share/nginx/html/index.html']
livenessProbe:
#exec:
# command:
# - cat
# - /usr/share/nginx/html/index.html
httpGet:
path: /index.html
port: 80
initialDelaySeconds: 3
periodSeconds: 1
volumeMounts:
- name: nginx-html
mountPath: /usr/share/nginx/html/
參數解釋：
livenessProbe:
httpGet: #基於http請求探測
path: /health.html #請求地址，如果這個地址返回的狀態碼在200-400之間正常
port: 80 #請求的端口
initialDelaySeconds: 3 #第一次啟動探測在容器啟動后3秒開始
periodSeconds: 3 #容器啟動后每隔3秒檢查一次
6.3 就緒探針
有時候我們Pod本身已經起來了，但是pod的容器還沒有完全准備好對外提供服務，那么這時候流量進來就會造成請求失敗的情況出現，針對這種情況k8s有一種探針叫就緒探針，他的作用就是讓k8s知道你的Pod內應用是否准備好為請求提供服務。只有就緒探針ok了才會把流量轉發到pod上。
配置語法：就緒探針的配置語法和存活探針基本一樣
apiVersion: v1
kind: Pod
metadata:
name: liveness-pod
spec:
containers:
- name: liveness-pod
image: nginx
lifecycle:
postStart:
exec:
command: ["/bin/sh", "-c", "echo ok > /usr/share/nginx/html/health.html"]
readinessProbe:
httpGet:
path: /actuator/health
port: 8080
initialDelaySeconds: 5
timeoutSeconds: 3
periodSeconds: 3
successThreshold: 3
failureThreshold: 3
livenessProbe:
httpGet:
path: /health.html
port: 80
initialDelaySeconds: 3
periodSeconds: 3
參數解釋：
initialDelaySeconds: 第一次執行探針需要在容器啟動后等待的時候時間
periodSeconds: 容器啟動后每隔多少秒執行一次存活探針
timeoutSeconds: 探針超時時間，默認1秒，最小1秒
successThreshold: 探針失敗后最少連續探測成功多少次才被認定成功，默認1次，如果是liveness必須為1
failureThreshold: 探針成功后被視為失敗的探測的最小連續失敗次數。默認3次。最小值為1
7.Pod資源限制
在學習Docker的時候我們知道容器可以使用Linux系統的CGroup技術限制內存和CPU的使用率，那么POD里應該如何限制容器的CPU和內存資源呢？
資源配置清單：
apiVersion: v1
kind: Pod
metadata:
name: resource-demo
spec:
containers:
- name: resource-demo
image: nginx
ports:
- containerPort: 80
resources:
requests:
memory: 50Mi
cpu: 1500m
limits:
memory: 100Mi
cpu: 200m
參數解釋：
requests :節點所需的最小計算資源量，k8s調度的時候的依據值
limits :限制允許的最大計算資源量,真正的資源限制參數
數值的轉換：
1 CPU = 1000m
0.5 CPU = 500m
1 Mib = 1024 Kib
1 MB = 1000 KB
查看驗證：
docker inspect 容器ID|grep CgroupParent
cd /sys/fs/cgroup/cpu/kubepods.slice/kubepods-burstable.slice/kubepods-burstable-podxxxx.slice
cat cpu.cfs_quota_us
第10章 Pod控制器
1.控制器作用
1.pod類型的資源，刪除pod后，不會重建
2.替用戶監視並保證相應的節點上始終有用戶所期望的副本數量的pod在運行
3.如果所運行的pod副本數超過了用戶期望的，那么控制器就會刪掉，直到和用戶期望的一致
4.如果所運行的pod副本數低於用戶期望的，那么控制器就會創建，直到和用戶期望的一致
2.常用控制器類型
ReplicationSet RS:
按用戶期望的副本創建pod,並始終保持相應數量副本
Deployment:
Deployment通過控制RS來保證POD始終保持相應的數量副本
支持滾動更新，回滾,回滾默認保留10個版本
提供聲明式配置，支持動態修改
管理無狀態應用最理想的控制器
node節點可能會運行0個或多個POD
DeamonSet:
一個節點只運行一個，必須是始終運行的狀態
StatefulSet:
有狀態應用
4.ReplicationSet控制器
4.1編寫RS控制器資源配置清單
cat >nginx-rs.yaml <<EOF
apiVersion: apps/v1
kind: ReplicaSet
metadata:
name: nginx-rs
namespace: default
spec:
replicas: 2 #期望的Pod副本數量
selector: #匹配標簽，這里寫的是Pod模版里的標簽，Rs控制器就是通過POD標簽來監控POD數量的
matchLabels:
app: nginx
template: #RS控制器按照以下模版來創建Pod
metadata:
name: nginx-pod
labels:
app: nginx
spec:
containers:
- name: nginx-containers
image: nginx:1.14.0
imagePullPolicy: IfNotPresent
ports:
- name: http
containerPort: 80
EOF
4.2.應用RS資源配置清單
kubectl create -f nginx-rs.yaml
4.3.查看RS資源
kubectl get rs
kubectl get pod -o wide
4.4.修改yaml文件應用修改
vim nginx-rs.yaml
kubectl apply -f nginx-rs.yaml
4.5.動態修改配置 擴容 收縮 升級
kubectl edit rs nginx
kubectl scale rs nginx --replicas=5
5.Deployment控制器
5.1 Deployment和RS控制器的關系
雖然我們創建的是Deployment類型資源，但實際上控制副本還是由RS來控制的，Deployment只是替我們去創建RS控制器，然后再由RS去控制POD副本.
Deployment控制器還有一個比較重要的功能就是滾動更新和版本回滾，而這個功能就是以來RS控制器。
5.2 資源配置清單
cat >nginx-dp.yaml<<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx-deployment
namespace: default
spec:
replicas: 2
selector:
matchLabels:
app: nginx
template:
metadata:
name: nginx-pod
labels:
app: nginx
spec:
containers:
- name: nginx-containers
image: nginx:1.14.0
imagePullPolicy: IfNotPresent
ports:
- name: http
containerPort: 80
EOF
5.2.應用資源配置清單
kubectl create -f nginx-dp.yaml
5.3.查看
kubectl get pod -o wide
kubectl get deployments.apps
kubectl describe deployments.apps nginx-deployment
5.4.更新版本
方法1: 命令行根據資源配置清單修改鏡像
kubectl set image -f nginx-dp.yaml nginx-containers=nginx:1.16.0
查看有沒有更新
kubectl get pod
kubectl describe deployments.apps nginx-deployment
kubectl describe pod nginx-deployment-7c596b4d95-6ztld
方法2: 命令行根據資源類型修改鏡像
打開2個窗口：
第一個窗口監控pod狀態
kubectl get pod -w
第二個窗口更新操作
kubectl set image deployment nginx-deployment nginx-containers=nginx:1.14.0
查看更新后的deployment信息
kubectl describe deployments.apps nginx-deployment
----------------------------------------------------
Normal ScalingReplicaSet 14m deployment-controller Scaled up replica set nginx-deployment-7c596b4d95 to 1
Normal ScalingReplicaSet 14m deployment-controller Scaled down replica set nginx-deployment-9c74bb6c7 to 1
Normal ScalingReplicaSet 14m deployment-controller Scaled up replica set nginx-deployment-7c596b4d95 to 2
Normal ScalingReplicaSet 13m deployment-controller Scaled down replica set nginx-deployment-9c74bb6c7 to 0
Normal ScalingReplicaSet 8m30s deployment-controller Scaled up replica set nginx-deployment-9c74bb6c7 to 1
Normal ScalingReplicaSet 8m29s (x2 over 32m) deployment-controller Scaled up replica set nginx-deployment-9c74bb6c7 to 2
Normal ScalingReplicaSet 8m29s deployment-controller Scaled down replica set nginx-deployment-7c596b4d95 to 1
Normal ScalingReplicaSet 8m28s deployment-controller Scaled down replica set nginx-deployment-7c596b4d95 to 0
更新過程：
nginx-deployment-7c596b4d95-8z7kf #老的版本
nginx-deployment-7c596b4d95-6ztld #老的版本
nginx-deployment-9c74bb6c7-pgfxz 0/1 Pending
nginx-deployment-9c74bb6c7-pgfxz 0/1 Pending
nginx-deployment-9c74bb6c7-pgfxz 0/1 ContainerCreating #拉取新版本鏡像
nginx-deployment-9c74bb6c7-pgfxz 1/1 Running #運行新POD
nginx-deployment-7c596b4d95-8z7kf 1/1 Terminating #停止一個舊的POD
nginx-deployment-9c74bb6c7-h7mk2 0/1 Pending
nginx-deployment-9c74bb6c7-h7mk2 0/1 Pending
nginx-deployment-9c74bb6c7-h7mk2 0/1 ContainerCreating #拉取新版本鏡像
nginx-deployment-9c74bb6c7-h7mk2 1/1 Running #運行新POD
nginx-deployment-7c596b4d95-6ztld 1/1 Terminating #停止一個舊的POD
nginx-deployment-7c596b4d95-8z7kf 0/1 Terminating #等待舊的POD結束
nginx-deployment-7c596b4d95-6ztld 0/1 Terminating #等待舊的POD結束
查看滾動更新狀態：
kubectl rollout status deployment nginx-deployment
滾動更新示意圖：
5.5.回滾上一個版本
kubectl describe deployments.apps nginx-deployment
kubectl rollout undo deployment nginx-deployment
kubectl describe deployments.apps nginx-deployment
5.6.回滾到指定版本
v1 1.14.0
v2 1.15.0
v3 3.333.3
回滾到v1版本
創建第一版 1.14.0
kubectl create -f nginx-dp.yaml --record
更新第二版 1.15.0
kubectl set image deployment nginx-deployment nginx-containers=nginx:1.15.0
更新第三版 1.99.0
kubectl set image deployment nginx-deployment nginx-containers=nginx:1.16.0
查看所有歷史版本
kubectl rollout history deployment nginx-deployment
查看指定歷史版本信息
kubectl rollout history deployment nginx-deployment --revision=1
回滾到指定版本
kubectl rollout undo deployment nginx-deployment --to-revision=1
5.7.擴縮容
kubectl scale deployment nginx-deployment --replicas=5
kubectl scale deployment nginx-deployment --replicas=2
6.DaemonSet控制器
6.1 DaemonSet類型介紹
簡單來說就是每個節點部署一個POD副本
常見的應用場景：
監控容器
日志收集容器
6.2 DaemonSet舉例
apiVersion: apps/v1
kind: DaemonSet
metadata:
name: nginx-ds
namespace: default
spec:
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
containers:
- image: nginx
name: nginx
ports:
- name: http
containerPort: 80
7.HPA
7.1 HPA介紹
官網地址：
https://kubernetes.io/zh/docs/tasks/run-application/horizontal-pod-autoscale-walkthrough/
HPA工作原理：
HAP通過收集來的監控指標分析所有Pod的負載情況，並且根據我們設定好的標准來自動擴容收縮ReplicationController、 Deployment、ReplicaSet 或 StatefulSet 中的 Pod 數量
7.2 Metrics Server介紹
在HAP早期版本使用的是一個叫Heapster組件來提供CPU和內存指標的，在后期的版本k8s轉向了使用Metrcis Server組件來提供Pod的CPU和內存指標，Metrcis Server通過Metrics API將數據暴露出來，然后我們就可以使用k8s的API來獲取相應的數據。
7.3 Metrics Server安裝
下載項目yaml文件
wget https://github.com/kubernetes-sigs/metrics-server/releases/download/v0.4.0/components.yaml
由於默認的鏡像是從google雲下載的，所以需要一些手段先下載下來，然后再導入本地的節點中。
修改配置文件：
spec:
hostNetwork: true #使用host網絡模式
containers:
- args:
- --cert-dir=/tmp
- --secure-port=4443
- --kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname
- --kubelet-use-node-status-port
- --kubelet-insecure-tls #跳過證書檢查
image: metrics-server:v0.4.0 #修改為本地的鏡像
創建資源：
kubectl apply -f components.yaml
查看結果：
[root@master ~]# kubectl top node
NAME CPU(cores) CPU% MEMORY(bytes) MEMORY%
master 79m 7% 1794Mi 46%
node1 26m 2% 795Mi 20%
node2 23m 2% 785Mi 20%
7.4 生成測試鏡像
創建測試首頁
cat > index.php << 'EOF'
<?php
$x = 0.0001;
for ($i = 0; $i <= 1000000; $i++) {
$x += sqrt($x);
}
echo "OK!";
?>
EOF
創建dockerfile
cat > dockerfile << 'EOF'
FROM php:5-apache
ADD index.php /var/www/html/index.php
RUN chmod a+rx index.php
EOF
生成鏡像
docker build -t php:v1 .
將鏡像導出發送到其他節點：
docker save php:v1 > php.tar
scp php.tar 10.0.0.12:/opt/
scp php.tar 10.0.0.13:/opt/
導入鏡像：
docker load < /opt/php.tar
7.5 創建Deployment資源
cat >php-dp.yaml<< 'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
name: php-apache
spec:
replicas: 1
selector:
matchLabels:
run: php-apache
template:
metadata:
labels:
run: php-apache
spec:
containers:
- image: php:v1
imagePullPolicy: IfNotPresent
name: php-apache
ports:
- containerPort: 80
protocol: TCP
resources:
requests:
cpu: 200m
EOF
7.6 創建HPA資源
cat > php-hpa.yaml <<EOF
apiVersion: autoscaling/v1
kind: HorizontalPodAutoscaler
metadata:
name: php-apache
namespace: default
spec:
maxReplicas: 10
minReplicas: 1
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: php-apache
targetCPUUtilizationPercentage: 50
EOF
7.7 查看HPA擴所容情況
kubectl get hpa -w
kubectl get pod -w
7.8 壓測
while true; do wget -q -O- http://10.2.1.18; done
7.9 簡單創建命令
創建dp
kubectl run php-apache --image=php:v1 --requests=cpu=200m --expose --port=80
創建hpa
kubectl autoscale deployment php-apache --cpu-percent=50 --min=1 --max=10
11章 Service服務
1.Service服務介紹
Sercice控制器和POD控制器沒關系
Sercice控制器可以選擇由POD控制器創建的POD資源
2.三種IP
NodeIP :節點對外提供訪問的IP
ClusterIP :用來動態發現和負載均衡POD的IP
PodIP :提供POD使用的IP
3.創建ClusterIP
apiVersion: v1
kind: Service
metadata:
name: nginx-service
namespace: default
spec:
selector:
app: nginx
ports:
- name: http
port: 80 #clusterIP的端口號
protocol: TCP #協議類型
targetPort: 80 #POD暴露的端口
type: ClusterIP
4.查看ClusterIP
kubectl get svc
5.創建NodeIP資源配置清單
apiVersion: v1
kind: Service
metadata:
name: nginx-service
namespace: default
spec:
selector:
app: nginx
ports:
- name: http
port: 8080 #clusterIP的端口號
protocol: TCP
targetPort: 80 #POD暴露的端口
nodePort: 30000 #NodeIP的端口號，也就是對外用戶訪問的端口號
type: NodePort
6.查看創建的資源
kubectl get svc
7.示意圖
第14章 Ingress服務
1.NodePort缺點
1.沒有ingress之前，pod對外提供服務只能通過NodeIP:NodePort的形式，但是這種形式有缺點，一個節點上的PORT不能重復利用。比如某個服務占用了80，那么其他服務就不能在用這個端口了。
2.NodePort是4層代理，不能解析7層的http，不能通過域名區分流量
3.為了解決這個問題，我們需要用到資源控制器叫Ingress，作用就是提供一個統一的訪問入口。工作在7層
4.雖然我們可以使用nginx/haproxy來實現類似的效果，但是傳統部署不能動態的發現我們新創建的資源，必須手動修改配置文件並重啟。
5.適用於k8s的ingress控制器主流的有ingress-nginx和traefik
2.安裝部署traefik
2.1 traefik_dp.yaml
kind: Deployment
apiVersion: apps/v1
metadata:
name: traefik-ingress-controller
namespace: kube-system
labels:
k8s-app: traefik-ingress-lb
spec:
replicas: 1
selector:
matchLabels:
k8s-app: traefik-ingress-lb
template:
metadata:
labels:
k8s-app: traefik-ingress-lb
name: traefik-ingress-lb
spec:
serviceAccountName: traefik-ingress-controller
terminationGracePeriodSeconds: 60
tolerations:
- operator: "Exists"
nodeSelector:
kubernetes.io/hostname: node1
containers:
- image: traefik:v1.7.17
name: traefik-ingress-lb
ports:
- name: http
containerPort: 80
hostPort: 80
- name: admin
containerPort: 8080
args:
- --api
- --kubernetes
- --logLevel=INFO
2.2 traefik_rbac.yaml
---
apiVersion: v1
kind: ServiceAccount
metadata:
name: traefik-ingress-controller
namespace: kube-system
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
name: traefik-ingress-controller
rules:
- apiGroups:
- ""
resources:
- services
- endpoints
- secrets
verbs:
- get
- list
- watch
- apiGroups:
- extensions
resources:
- ingresses
verbs:
- get
- list
- watch
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
name: traefik-ingress-controller
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: traefik-ingress-controller
subjects:
- kind: ServiceAccount
name: traefik-ingress-controller
namespace: kube-system
2.3 traefik_svc.yaml
kind: Service
apiVersion: v1
metadata:
name: traefik-ingress-service
namespace: kube-system
spec:
selector:
k8s-app: traefik-ingress-lb
ports:
- protocol: TCP
port: 80
name: web
- protocol: TCP
port: 8080
name: admin
type: NodePort
3.應用資源配置
kubectl create -f ./
4.查看並訪問
kubectl -n kube-system get svc
5.創建traefik的web-ui的ingress規則
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
name: traefik-ui
namespace: kube-system
spec:
rules:
- host: traefik.ui.com
http:
paths:
- path: /
backend:
serviceName: traefik-ingress-service
servicePort: 8080
6.訪問測試
traefik.ui.com
7.ingress實驗
7.1.實驗目標
未使用ingress之前只能通過IP+端口訪問：
tomcat 8080
nginx 8090
使用ingress之后直接可以使用域名訪問：
traefik.nginx.com:80 --> nginx 8090
traefik.tomcat.com:80 --> tomcat 8080
7.2.創建2個pod和svc
mysql-dp.yaml
mysql-svc.yaml
tomcat-dp.yaml
tomcat-svc.yaml
nginx-dp.yaml
nginx-svc-clusterip.yaml
7.3.創建ingress控制器資源配置清單並應用
cat >nginx-ingress.yaml <<EOF
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
name: traefik-nginx
namespace: default
spec:
rules:
- host: traefik.nginx.com
http:
paths:
- path: /
backend:
serviceName: nginx-service
servicePort: 80
EOF
cat >tomcat-ingress.yaml<<EOF
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
name: traefik-tomcat
namespace: default
spec:
rules:
- host: traefik.tomcat.com
http:
paths:
- path: /
backend:
serviceName: myweb
servicePort: 8080
EOF
kubectl apply -f nginx-ingress.yaml
kubectl apply -f tomcat-ingress.yaml
7.4.查看創建的資源
kubectl get svc
kubectl get ingresses
kubectl describe ingresses traefik-nginx
kubectl describe ingresses traefik-tomcat
7.5.訪問測試
traefik.nginx.com
traefik.tomcat.com
第15章 數據持久化
1.Volume介紹
Volume是Pad中能夠被多個容器訪問的共享目錄
Kubernetes中的Volume不Pad生命周期相同，但不容器的生命周期丌相關
Kubernetes支持多種類型的Volume，並且一個Pod可以同時使用任意多個Volume
Volume類型包括:
EmptyDir：Pod分配時創建， K8S自動分配，當Pod被移除數據被清空。用於臨時空間等。
hostPath：為Pod上掛載宿主機目錄。用於持久化數據。
nfs：掛載相應磁盤資源。
2.EmptyDir實驗
cat >emptyDir.yaml <<EOF
apiVersion: v1
kind: Pod
metadata:
name: busybox-empty
spec:
containers:
- name: busybox-pod
image: busybox
volumeMounts:
- mountPath: /data/busybox/
name: cache-volume
command: ["/bin/sh","-c","while true;do echo $(date) >> /data/busybox/index.html;sleep 3;done"]
volumes:
- name: cache-volume
emptyDir: {}
EOF
3.hostPath實驗
3.1 type類型說明
https://kubernetes.io/docs/concepts/storage/volumes/#hostpath
DirectoryOrCreate 目錄不存在就自動創建
Directory 目錄必須存在
FileOrCreate 文件不存在則創建
File 文件必須存在
3.2 創建hostPath類型volume資源配置清單
apiVersion: v1
kind: Pod
metadata:
name: busybox-nodename
spec:
nodeName: node2
containers:
- name: busybox-pod
image: busybox
volumeMounts:
- mountPath: /data/pod/
name: hostpath-volume
command: ["/bin/sh","-c","while true;do echo $(date) >> /data/pod/index.html;sleep 3;done"]
volumes:
- name: hostpath-volume
hostPath:
path: /data/node/
type: DirectoryOrCreate
4.根據Node標簽選擇POD創建在指定的Node上
4.1 方法1: 直接選擇Node節點名稱
apiVersion: v1
kind: Pod
metadata:
name: busybox-nodename
spec:
nodeName: node2
containers:
- name: busybox-pod
image: busybox
volumeMounts:
- mountPath: /data/pod/
name: hostpath-volume
command: ["/bin/sh","-c","while true;do echo $(date) >> /data/pod/index.html;sleep 3;done"]
volumes:
- name: hostpath-volume
hostPath:
path: /data/node/
type: DirectoryOrCreate
4.2 方法2: 根據Node標簽選擇Node節點
節點添加標簽
kubectl label nodes node3 disktype=SSD
資源配置清單
apiVersion: v1
kind: Pod
metadata:
name: busybox-nodename
spec:
nodeSelector:
disktype: SSD
containers:
- name: busybox-pod
image: busybox
volumeMounts:
- mountPath: /data/pod/
name: hostpath-volume
command: ["/bin/sh","-c","while true;do echo $(date) >> /data/pod/index.html;sleep 3;done"]
volumes:
- name: hostpath-volume
hostPath:
path: /data/node/
type: DirectoryOrCreate
5.編寫mysql的持久化deployment
apiVersion: apps/v1
kind: Deployment
metadata:
name: mysql-dp
namespace: default
spec:
selector:
matchLabels:
app: mysql
replicas: 1
template:
metadata:
name: mysql-pod
namespace: default
labels:
app: mysql
spec:
containers:
- name: mysql-pod
image: mysql:5.7
ports:
- name: mysql-port
containerPort: 3306
env:
- name: MYSQL_ROOT_PASSWORD
value: "123456"
volumeMounts:
- mountPath: /var/lib/mysql
name: mysql-volume
volumes:
- name: mysql-volume
hostPath:
path: /data/mysql
type: DirectoryOrCreate
nodeSelector:
disktype: SSD
第19章 PV和PVC
1.PV和PVC介紹
PV是對底層網絡共享存儲的抽象，將共享存儲定義為一種“資源”。
PV由管理員創建和配置
PV只能是共享存儲
PVC則是用戶對存儲資源的一個“申請”。
就像Pod消費Node的資源一樣，PVC能夠“消費”PV資源
PVC可以申請特定的存儲空間和訪問模式
2.PV和PVC生命周期
3.實驗-創建nfs和mysql的pv及pvc
3.1 master節點安裝nfs
yum install nfs-utils -y
mkdir /data/nfs-volume/mysql -p
vim /etc/exports
/data/nfs-volume 10.0.0.0/24(rw,async,no_root_squash,no_all_squash)
systemctl start rpcbind
systemctl start nfs
showmount -e 127.0.0.1
3.2 所有node節點安裝nfs
yum install nfs-utils.x86_64 -y
showmount -e 10.0.0.11
3.3 編寫並創建nfs-pv資源
cat >nfs-pv.yaml <<EOF
apiVersion: v1
kind: PersistentVolume
metadata:
name: pv01
spec:
capacity:
storage: 5Gi
accessModes:
- ReadWriteOnce
persistentVolumeReclaimPolicy: Recycle
storageClassName: nfs
nfs:
path: /data/nfs-volume/mysql
server: 10.0.0.11
EOF
kubectl create -f nfs-pv.yaml
kubectl get persistentvolume
3.4 創建mysql-pvc資源
cat >mysql-pvc.yaml <<EOF
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: mysql-pvc
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 1Gi
storageClassName: nfs
EOF
kubectl create -f mysql-pvc.yaml
kubectl get pvc
3.5 創建mysql-deployment資源
cat >mysql-dp.yaml <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
name: mysql
spec:
replicas: 1
selector:
matchLabels:
app: mysql
template:
metadata:
labels:
app: mysql
spec:
containers:
- name: mysql
image: mysql:5.7
ports:
- containerPort: 3306
env:
- name: MYSQL_ROOT_PASSWORD
value: "123456"
volumeMounts:
- name: mysql-pvc
mountPath: /var/lib/mysql
- name: mysql-log
mountPath: /var/log/mysql
volumes:
- name: mysql-pvc
persistentVolumeClaim:
claimName: mysql-pvc
- name: mysql-log
hostPath:
path: /var/log/mysql
nodeSelector:
disktype: SSD
EOF
kubectl create -f mysql-dp.yaml
kubectl get pod -o wide
3.6 測試方法
1.創建nfs-pv
2.創建mysql-pvc
3.創建mysql-deployment並掛載mysq-pvc
4.登陸到mysql的pod里創建一個數據庫
5.將這個pod刪掉，因為deployment設置了副本數，所以會自動再創建一個新的pod
6.登錄這個新的pod，查看剛才創建的數據庫是否依然能看到
7.如果仍然能看到，則說明數據是持久化保存的
3.7 accessModes字段說明
ReadWriteOnce 單路讀寫
ReadOnlyMany 多路只讀
ReadWriteMany 多路讀寫
resources 資源的限制，比如至少5G
3.8 volumeName精確匹配
capacity 限制存儲空間大小
reclaim policy pv的回收策略
retain pv被解綁后上面的數據仍保留
recycle pv上的數據被釋放
delete pvc和pv解綁后pv就被刪除
備注：用戶在創建pod所需要的存儲空間時，前提是必須要有pv存在
才可以，這樣就不符合自動滿足用戶的需求，而且之前在k8s 9.0
版本還可刪除pv，這樣造成數據不安全性
``
第20章 configMap資源
1.為什么要用configMap？
將配置文件和POD解耦
2.congiMap里的配置文件是如何存儲的？
鍵值對
key:value
文件名:配置文件的內容
3.configMap支持的配置類型
直接定義的鍵值對
基於文件創建的鍵值對
4.configMap創建方式
命令行
資源配置清單
5.configMap的配置文件如何傳遞到POD里
變量傳遞
數據卷掛載
6.命令行創建configMap
kubectl create configmap --help
kubectl create configmap nginx-config --from-literal=nginx_port=80 --from-literal=server_name=nginx.cookzhang.com
kubectl get cm
kubectl describe cm nginx-config
7.POD環境變量形式引用configMap
kubectl explain pod.spec.containers.env.valueFrom.configMapKeyRef
cat >nginx-cm.yaml <<EOF
apiVersion: v1
kind: Pod
metadata:
name: nginx-cm
spec:
containers:
- name: nginx-pod
image: nginx:1.14.0
ports:
- name: http
containerPort: 80
env:
- name: NGINX_PORT
valueFrom:
configMapKeyRef:
name: nginx-config
key: nginx_port
- name: SERVER_NAME
valueFrom:
configMapKeyRef:
name: nginx-config
key: server_name
EOF
kubectl create -f nginx-cm.yaml
8.查看pod是否引入了變量
[root@node1 ~/confimap]# kubectl exec -it nginx-cm /bin/bash
root@nginx-cm:~# echo ${NGINX_PORT}
80
root@nginx-cm:~# echo ${SERVER_NAME}
nginx.cookzhang.com
root@nginx-cm:~# printenv |egrep "NGINX_PORT|SERVER_NAME"
NGINX_PORT=80
SERVER_NAME=nginx.cookzhang.com
注意：
變量傳遞的形式，修改confMap的配置，POD內並不會生效
因為變量只有在創建POD的時候才會引用生效，POD一旦創建好，環境變量就不變了
9.文件形式創建configMap
創建配置文件：
cat >www.conf <<EOF
server {
listen 80;
server_name www.cookzy.com;
location / {
root /usr/share/nginx/html/www;
index index.html index.htm;
}
}
EOF
創建configMap資源：
kubectl create configmap nginx-www --from-file=www.conf=./www.conf
查看cm資源
kubectl get cm
kubectl describe cm nginx-www
編寫pod並以存儲卷掛載模式引用configMap的配置
cat >nginx-cm-volume.yaml <<EOF
apiVersion: v1
kind: Pod
metadata:
name: nginx-cm
spec:
containers:
- name: nginx-pod
image: nginx:1.14.0
ports:
- name: http
containerPort: 80
volumeMounts:
- name: nginx-www
mountPath: /etc/nginx/conf.d/
volumes:
- name: nginx-www
configMap:
name: nginx-www
items:
- key: www.conf
path: www.conf
EOF
測試：
1.進到容器內查看文件
kubectl exec -it nginx-cm /bin/bash
cat /etc/nginx/conf.d/www.conf
2.動態修改
configMap
kubectl edit cm nginx-www
3.再次進入容器內觀察配置會不會自動更新
cat /etc/nginx/conf.d/www.conf
nginx -T
10.配置文件內容直接以數據格式直接存儲在configMap里
創建config配置清單：
cat >nginx-configMap.yaml <<EOF
apiVersion: v1
kind: ConfigMap
metadata:
name: nginx-config
namespace: default
data:
www.conf: |
server {
listen 80;
server_name www.cookzy.com;
location / {
root /usr/share/nginx/html/www;
index index.html index.htm;
}
}
blog.conf: |
server {
listen 80;
server_name blog.cookzy.com;
location / {
root /usr/share/nginx/html/blog;
index index.html index.htm;
}
}
應用並查看清單:
kubectl create -f nginx-configMap.yaml
kubectl get cm
kubectl describe cm nginx-config
創建POD資源清單並引用configMap
cat >nginx-cm-volume-all.yaml <<EOF
apiVersion: v1
kind: Pod
metadata:
name: nginx-cm
spec:
containers:
- name: nginx-pod
image: nginx:1.14.0
ports:
- name: http
containerPort: 80
volumeMounts:
- name: nginx-config
mountPath: /etc/nginx/conf.d/
volumes:
- name: nginx-config
configMap:
name: nginx-config
items:
- key: www.conf
path: www.conf
- key: blog.conf
path: blog.conf
EOF
應用並查看:
kubectl create -f nginx-cm-volume-all.yaml
kubectl get pod
kubectl describe pod nginx-cm
進入容器內並查看：
kubectl exec -it nginx-cm /bin/bash
ls /etc/nginx/conf.d/
cat /etc/nginx/conf.d/www.conf
測試動態修改configMap會不會生效
kubectl edit cm nginx-config
kubectl exec -it nginx-cm /bin/bash
ls /etc/nginx/conf.d/
cat /etc/nginx/conf.d/www.conf
第21章 安全認證和RBAC
API Server是訪問控制的唯一入口
在k8s平台上的操作對象都要經歷三種安全相關的操作
1.認證操作
http協議 token 認證令牌
ssl認證 kubectl需要證書雙向認證
2.授權檢查
RBAC 基於角色的訪問控制
3.准入控制
進一步補充授權機制，一般在創建，刪除，代理操作時作補充
k8s的api賬戶分為2類
1.實實在在的用戶 人類用戶 userAccount
2.POD客戶端 serviceAccount 默認每個POD都有認真信息
RBAC就是基於角色的訪問控制
你這個賬號可以擁有什么權限
以traefik舉例：
1.創建了賬號 ServiceAccount:traefik-ingress-controller
2.創建角色 ClusterRole: traefik-ingress-controller
Role POD相關的權限
ClusterRole namespace級別操作
3.將賬戶和權限角色進行綁定 traefik-ingress-controller
RoleBinding
ClusterRoleBinding
4.創建POD時引用ServiceAccount
serviceAccountName: traefik-ingress-controller
注意！！！
kubeadm安裝的k8s集群，證書默認只有1年
第22章 k8s dashboard
1.官方項目地址
https://github.com/kubernetes/dashboard
2.下載配置文件
wget https://raw.githubusercontent.com/kubernetes/dashboard/v2.0.4/aio/deploy/recommended.yaml
3.修改配置文件
39 spec:
40 ports:
41 - port: 443
42 targetPort: 8443
43 nodePort: 30000
44 selector:
45 k8s-app: kubernetes-dashboard
46 type: NodePort
4.應用資源配置
kubectl create -f recommended.yaml
5.查看創建的pod
[root@node1 k8s]# kubectl -n kubernetes-dashboard get pods
NAME READY STATUS RESTARTS AGE
dashboard-metrics-scraper-7b59f7d4df-62m6s 1/1 Running 0 62s
kubernetes-dashboard-665f4c5ff-4twq7 1/1 Running 0 62s
6.創建管理員賬戶並應用
https://github.com/kubernetes/dashboard/blob/master/docs/user/access-control/creating-sample-user.md
cat > dashboard-admin.yaml<<EOF
apiVersion: v1
kind: ServiceAccount
metadata:
name: admin-user
namespace: kubernetes-dashboard
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: admin-user
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: cluster-admin
subjects:
- kind: ServiceAccount
name: admin-user
namespace: kubernetes-dashboard
EOF
kubectl create -f dashboard-admin.yaml
7.查看資源並獲取token
kubectl get pod -n kubernetes-dashboard -o wide
kubectl get svc -n kubernetes-dashboard
kubectl get secret -n kubernetes-dashboard
kubectl -n kubernetes-dashboard describe secret $(kubectl -n kubernetes-dashboard get secret | grep admin-user | awk '{print $1}')
8.瀏覽器訪問
https://10.0.0.11:30000
google瀏覽器打不開就換火狐瀏覽器
黑科技
9.報錯總結
{"level":"error","msg":"Error scraping node metrics: the server could not find the requested resource (get nodes.metrics.k8s.io)","time":"2020-03-03T09:57:00Z"}
Skipping metric because of error: Metric label not set
原因：
沒喲安裝metrics監控組建
第23章 prometheus
1.官網地址
https://github.com/prometheus/prometheus
2.監控k8s需要的組件
使用metric-server收集數據給k8s集群內使用，如kubectl,hpa,scheduler等
使用prometheus-operator部署prometheus，存儲監控數據
使用kube-state-metrics收集k8s集群內資源對象數據
使用node_exporter收集集群中各節點的數據
使用prometheus收集apiserver，scheduler，controller-manager，kubelet組件數據
使用alertmanager實現監控報警
使用grafana實現數據可視化
metrics-server 主要關注的是資源度量 API 的實現，比如 CPU、文件描述符、內存、請求延時等指標。
kube-state-metrics 主要關注的是業務相關的一些元數據，比如 Deployment、Pod、副本狀態等
3.安裝部署prometheus
導入鏡像
docker load < prom-prometheusv2_2_1.tar
創建命名空間
kubectl create namespace prom
創建資源
cd prometheus
kubectl create -f ./
檢查資源
kubectl -n prom get all -o wide
web瀏覽器查看
http://10.0.0.11:30090/targets
4.安裝部署metrics-server
導入鏡像
docker load < k8s-gcr-io-addon-resizer1_8_6.tar
docker load < k8s-gcr-io-metrics-server-amd64v0-3-6.tar
創建資源
kubectl create -f ./
檢查
kubectl top node
kubectl top pod
5.安裝node-exporterv
導入鏡像
docker load < prom-node-exporterv0_15_2.tar
創建資源
kubectl create -f ./
查看資源
kubectl -n prom get pod -o wide
kubectl -n prom get svc
瀏覽器查看
http://10.0.0.12:9100/metrics
http://10.0.0.13:9100/metrics
6.安裝kube-state-metrics
導入鏡像
docker load < gcr-io-google_containers-kube-state-metrics-amd64v1-3-1.tar
創建資源
kubectl create -f ./
查看
kubectl -n prom get pod
kubectl -n prom get svc
curl 10.1.232.109:8080/metrics
7.安裝grafna和k8s-prometheus-adapter
導入鏡像
docker load < directxman12-k8s-prometheus-adapter-amd64-latest.tar
docker load < k8s-gcr-io-heapster-grafana-amd64v5_0_4.tar
修改grafana資源配置清單
1 apiVersion: apps/v1
2 kind: Deployment
3 metadata:
4 name: monitoring-grafana
5 namespace: prom
6 spec:
7 selector:
8 matchLabels:
9 k8s-app: grafana
10 replicas: 1
11 template:
創建資源
cd k8s-prometheus-adapter
kubectl create -f ./
檢查創建的資源
kubectl -n prom get pod -o wide
kubectl -n prom get svc
瀏覽器查看
http://10.0.0.11:32725
導入dashboard
https://grafana.com/grafana/dashboards/10000
prometheus查詢語句
sum by (name) (rate (container_cpu_usage_seconds_total{image!=""}[1m]))
container_cpu_usage_seconds_total{name =~ "^k8s_POD.*",namespace="default"}
正則表達式：
=～ 模糊匹配
== 完全匹配
!= 不匹配
!~ 不匹配正則表達式
查詢語句：
sum (container_memory_working_set_bytes{image!="",name=~"^k8s_.*",kubernetes_io_hostname=~".*",namespace="default"}) by (pod)
翻譯：
sum (監控指標{字段1!="字段1配置的值",字段2!="字段2配置的值"}) by (分組字段名)
添加namespace標簽后grafana修改圖標
sum (container_memory_working_set_bytes{image!="",name=~"^k8s_.*",kubernetes_io_hostname=~"^$Node$",namespace=~"^$Namespace$"}) by (pod)
第25章 wordpress-demo
apiVersion: apps/v1
kind: Deployment
metadata:
name: mysql
namespace: blog
labels:
app: mysql
spec:
selector:
matchLabels:
app: mysql
template:
metadata:
labels:
app: mysql
spec:
containers:
- name: mysql
image: mysql:5.7
args:
- --default_authentication_plugin=mysql_native_password
- --character-set-server=utf8mb4
- --collation-server=utf8mb4_unicode_ci
ports:
- containerPort: 3306
name: dbport
env:
- name: MYSQL_ROOT_PASSWORD
value: rootPassW0rd
- name: MYSQL_DATABASE
value: wordpress
- name: MYSQL_USER
value: wordpress
- name: MYSQL_PASSWORD
value: wordpress
volumeMounts:
- name: db
mountPath: /var/lib/mysql
volumes:
- name: db
hostPath:
path: /data/mysql
nodeSelector:
disktype: SSD
---
apiVersion: v1
kind: Service
metadata:
name: mysql
namespace: blog
spec:
selector:
app: mysql
ports:
- name: mysqlport
protocol: TCP
port: 3306
targetPort: dbport
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: wordpress
namespace: blog
labels:
app: wordpress
spec:
replicas: 2
selector:
matchLabels:
app: wordpress
minReadySeconds: 5
strategy:
type: RollingUpdate
rollingUpdate:
maxSurge: 1
maxUnavailable: 1
template:
metadata:
labels:
app: wordpress
spec:
volumes:
- name: data
nfs:
server: 10.0.0.11
path: /data/nfs-volume/blog
#initContainers:
#- name: init-db
# image: busybox
# command: ['sh', '-c', 'until nslookup mysql; do echo waiting for mysql service; sleep 2; done;']
containers:
- name: wordpress
image: wordpress
imagePullPolicy: IfNotPresent
ports:
- containerPort: 80
name: wdport
env:
- name: WORDPRESS_DB_HOST
value: mysql:3306
- name: WORDPRESS_DB_USER
value: wordpress
- name: WORDPRESS_DB_PASSWORD
value: wordpress
readinessProbe:
tcpSocket:
port: 80
#initialDelaySeconds: 5
#periodSeconds: 10
resources:
limits:
cpu: 200m
memory: 256Mi
requests:
cpu: 100m
memory: 100Mi
volumeMounts:
- name: data
mountPath: /var/www/html/wp-content
---
apiVersion: v1
kind: Service
metadata:
name: wordpress
namespace: blog
spec:
selector:
app: wordpress
ports:
- port: 80
name: wordpressport
protocol: TCP
targetPort: wdport
---
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
name: blog-web-app
namespace: blog
annotations:
kubernetes.io/ingress.class: "traefik"
spec:
rules:
- host: traefik.wordpress.com
http:
paths:
- path: /
backend:
serviceName: wordpress
servicePort: 80
dashboard-ingress
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: kubernetes-dashboard-ingress
namespace: kubernetes-dashboard
annotations:
kubernetes.io/ingress.class: "nginx"
ingress.kubernetes.io/ssl-passthrough: "true"
nginx.ingress.kubernetes.io/backend-protocol: "HTTPS"
nginx.ingress.kubernetes.io/rewrite-target: /
spec:
rules:
- host: "dashboard.k8s.com"
http:
paths:
- path: /
pathType: ImplementationSpecific
backend:
service:
name: kubernetes-dashboard
port:
number: 443