部分内容参考专栏学习笔记：
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