# 第四模块 Kubernetes落地实践(上)

# 认识K8S

本章学习kubernetes的架构及工作流程,重点介绍如何使用Workload管理业务应用的生命周期,实现服务不中断的滚动更新,通过服务发现和集群内负载均衡来实现集群内部的服务间访问,并通过ingress实现外部使用域名访问集群内部的服务。

学习过程中会逐步对Django项目做k8s改造,从零开始编写所需的资源文件。通过本章的学习,学员会掌握高可用k8s集群的搭建,同时Django demo项目已经可以利用k8s的控制器、服务发现、负载均衡、配置管理等特性来实现生命周期的管理。

# 纯容器模式的问题

  1. 业务容器数量庞大,哪些容器部署在哪些节点,使用了哪些端口,如何记录、管理,需要登录到每台机器去管理?
  2. 跨主机通信,多个机器中的容器之间相互调用如何做,iptables规则手动维护?
  3. 跨主机容器间互相调用,配置如何写?写死固定IP+端口?
  4. 如何实现业务高可用?多个容器对外提供服务如何实现负载均衡?
  5. 容器的业务中断了,如何可以感知到,感知到以后,如何自动启动新的容器?
  6. 如何实现滚动升级保证业务的连续性?
  7. ......

# 容器调度管理平台

Docker Swarm Mesos Google Kubernetes

2017年开始Kubernetes凭借强大的容器集群管理功能, 逐步占据市场,目前在容器编排领域一枝独秀

https://kubernetes.io/ (opens new window)

# 架构图

如何设计一个容器管理平台?

  • 集群架构,管理节点分发容器到数据节点
  • 如何部署业务容器到各数据节点
  • N个数据节点,业务容器如何选择部署在最合理的节点
  • 容器如何实现多副本,如何满足每个机器部署一个容器的模型
  • 多副本如何实现集群内负载均衡

分布式系统,两类角色:管理节点和工作节点

# 核心组件

  • ETCD:分布式高性能键值数据库,存储整个集群的所有元数据

  • ApiServer: API服务器,集群资源访问控制入口,提供restAPI及安全访问控制

  • Scheduler:调度器,负责把业务容器调度到最合适的Node节点

  • Controller Manager:控制器管理,确保集群资源按照期望的方式运行

    • Replication Controller
    • Node controller
    • ResourceQuota Controller
    • Namespace Controller
    • ServiceAccount Controller
    • Token Controller
    • Service Controller
    • Endpoints Controller
  • kubelet:运行在每个节点上的主要的“节点代理”,脏活累活

    • pod 管理:kubelet 定期从所监听的数据源获取节点上 pod/container 的期望状态(运行什么容器、运行的副本数量、网络或者存储如何配置等等),并调用对应的容器平台接口达到这个状态。
    • 容器健康检查:kubelet 创建了容器之后还要查看容器是否正常运行,如果容器运行出错,就要根据 pod 设置的重启策略进行处理.
    • 容器监控:kubelet 会监控所在节点的资源使用情况,并定时向 master 报告,资源使用数据都是通过 cAdvisor 获取的。知道整个集群所有节点的资源情况,对于 pod 的调度和正常运行至关重要
  • kube-proxy:维护节点中的iptables或者ipvs规则

  • kubectl: 命令行接口,用于对 Kubernetes 集群运行命令 https://kubernetes.io/zh/docs/reference/kubectl/

静态Pod的方式:

## etcd、apiserver、controller-manager、kube-scheduler
$ kubectl -n kube-system get po

systemd服务方式:

$ systemctl status kubelet

kubectl:二进制命令行工具

# 理解集群资源

组件是为了支撑k8s平台的运行,安装好的软件。

资源是如何去使用k8s的能力的定义。比如,k8s可以使用Pod来管理业务应用,那么Pod就是k8s集群中的一类资源,集群中的所有资源可以提供如下方式查看:

$ kubectl api-resources

如何理解namespace:

命名空间,集群内一个虚拟的概念,类似于资源池的概念,一个池子里可以有各种资源类型,绝大多数的资源都必须属于某一个namespace。集群初始化安装好之后,会默认有如下几个namespace:

$ kubectl get namespaces
NAME                   STATUS   AGE
default                Active   84m
kube-node-lease        Active   84m
kube-public            Active   84m
kube-system            Active   84m
kubernetes-dashboard   Active   71m
  • 所有NAMESPACED的资源,在创建的时候都需要指定namespace,若不指定,默认会在default命名空间下
  • 相同namespace下的同类资源不可以重名,不同类型的资源可以重名
  • 不同namespace下的同类资源可以重名
  • 通常在项目使用的时候,我们会创建带有业务含义的namespace来做逻辑上的整合

# kubectl的使用

类似于docker,kubectl是命令行工具,用于与APIServer交互,内置了丰富的子命令,功能极其强大。 https://kubernetes.io/docs/reference/kubectl/overview/

$ kubectl -h
$ kubectl get -h
$ kubectl create -h
$ kubectl create namespace -h

# 工作流程

  1. 用户准备一个资源文件(记录了业务应用的名称、镜像地址等信息),通过调用APIServer执行创建Pod
  2. APIServer收到用户的Pod创建请求,将Pod信息写入到etcd中
  3. 调度器通过list-watch的方式,发现有新的pod数据,但是这个pod还没有绑定到某一个节点中
  4. 调度器通过调度算法,计算出最适合该pod运行的节点,并调用APIServer,把信息更新到etcd中
  5. kubelet同样通过list-watch方式,发现有新的pod调度到本机的节点了,因此调用容器运行时,去根据pod的描述信息,拉取镜像,启动容器,同时生成事件信息
  6. 同时,把容器的信息、事件及状态也通过APIServer写入到etcd中

# 架构设计的几点思考

  1. 系统各个组件分工明确(APIServer是所有请求入口,CM是控制中枢,Scheduler主管调度,而Kubelet负责运行),配合流畅,整个运行机制一气呵成。
  2. 除了配置管理和持久化组件ETCD,其他组件并不保存数据。意味除ETCD外其他组件都是无状态的。因此从架构设计上对kubernetes系统高可用部署提供了支撑。
  3. 同时因为组件无状态,组件的升级,重启,故障等并不影响集群最终状态,只要组件恢复后就可以从中断处继续运行。
  4. 各个组件和kube-apiserver之间的数据推送都是通过list-watch机制来实现。

# Pod定义

# 最小调度单元 Pod

docker调度的是容器,在k8s集群中,最小的调度单元是Pod(豆荚)

# 为什么引入Pod

  • 与容器引擎解耦

    Docker、Rkt。平台设计与引擎的具体的实现解耦

  • 多容器共享网络|存储|进程 空间, 支持的业务场景更加灵活

# 使用yaml格式定义Pod

  • 新增编排文件 mydig/one-pod/pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: mydig
  namespace: ni-ning
  labels:
    component: mydig
spec:
  containers:
  - name: mydig
    image: 192.168.75.129:5000/mydig:v1
    env:
    - name: MYSQL_HOST      #  指定root用户的用户名
      value: "127.0.0.1"
    - name: MYSQL_PASSWD
      value: "123456"
    ports:
    - containerPort: 80
  - name: mysql
    image: arm64v8/mysql   # 不同架构选定不同版本即可 mysql:5.7
    args:
    - --character-set-server=utf8mb4
    - --collation-server=utf8mb4_unicode_ci
    ports:
    - containerPort: 3306
    env:
    - name: MYSQL_ROOT_PASSWORD
      value: "123456"
    - name: MYSQL_DATABASE
      value: "dig"
apiVersion 含义
alpha 进入K8s功能的早期候选版本,可能包含Bug,最终不一定进入K8s
beta 已经过测试的版本,最终会进入K8s,但功能、对象定义可能会发生变更。
stable 可安全使用的稳定版本
v1 stable 版本之后的首个版本,包含了更多的核心对象
apps/v1 使用最广泛的版本,像Deployment、ReplicaSets都已进入该版本

资源类型与apiVersion对照表

Kind apiVersion
ClusterRoleBinding rbac.authorization.k8s.io/v1
ClusterRole rbac.authorization.k8s.io/v1
ConfigMap v1
CronJob batch/v1beta1
DaemonSet extensions/v1beta1
Node v1
Namespace v1
Secret v1
PersistentVolume v1
PersistentVolumeClaim v1
Pod v1
Deployment v1、apps/v1、apps/v1beta1、apps/v1beta2
Service v1
Ingress extensions/v1beta1
ReplicaSet apps/v1、apps/v1beta2
Job batch/v1
StatefulSet apps/v1、apps/v1beta1、apps/v1beta2

快速获得资源和版本

$ kubectl explain pod
$ kubectl explain Pod.apiVersion

# 创建和访问Pod

## 创建namespace, namespace是逻辑上的资源池
$ kubectl create namespace ni-ning

## 使用指定文件创建Pod
$ kubectl create -f pod.yaml

## 查看pod,可以简写po
## 所有的操作都需要指定namespace,如果是在default命名空间下,则可以省略
$ kubectl -n nining get pods -o wide
NAME     READY   STATUS    RESTARTS   AGE    IP             NODE
mydig   2/2     Running   0          3m     10.244.1.146   k8s-slave1

## 回顾流程

## 使用Pod Ip访问服务,3306和80
$ curl 10.244.1.146:3306
$ curl 10.244.1.146:80

## 进入容器,执行初始化, 不必到对应的主机执行docker exec
$ kubectl -n ni-ning exec -it mydig -c mydig bash
/ # env
/ # python3 manage.py migrate
$ kubectl -n ni-ning exec -it mydig -c mysql bash
/ # mysql -p123456

## 再次访问服务,3306和8002
$ curl 10.244.1.146

# Infra容器

登录k8s-slave1节点

$ docker ps -a |grep mydig  ## 发现有三个容器
## 其中包含mysql和mydig程序以及Infra容器
## 为了实现Pod内部的容器可以通过localhost通信,每个Pod都会启动Infra容器,然后Pod内部的其他容器的网络空间会共享该Infra容器的网络空间(Docker网络的container模式),Infra容器只需要hang住网络空间,不需要额外的功能,因此资源消耗极低。

## 登录master节点,查看pod内部的容器ip均相同,为pod ip
$ kubectl -n ni-ning exec -it mydig -c mydig bash
/ # ifconfig
$ kubectl -n ni-ning exec -it mydig -c mysql bash
/ # ifconfig

pod容器命名: k8s_<container_name>_<pod_name>_<namespace>_<random_string>

# 查看pod详细信息

## 查看pod调度节点及pod_ip
$ kubectl -n ni-ning get pods -o wide
## 查看完整的yaml
$ kubectl -n ni-ning get po mydig -o yaml
## 查看pod的明细信息及事件
$ kubectl -n ni-ning describe pod mydig

# Troubleshooting and Debugging

#进入Pod内的容器
$ kubectl -n <namespace> exec <pod_name> -c <container_name> -ti /bin/sh

#查看Pod内容器日志,显示标准或者错误输出日志
$ kubectl -n <namespace> logs -f <pod_name> -c <container_name>

# 更新服务版本

$ kubectl apply -f demo-pod.yaml

# 删除Pod服务

#根据文件删除
$ kubectl delete -f demo-pod.yaml

#根据pod_name删除
$ kubectl -n <namespace> delete pod <pod_name>

# Pod常用设置

# Pod数据持久化

若删除了Pod,由于mysql的数据都在容器内部,会造成数据丢失,因此需要数据进行持久化。

  • 定点使用hostpath挂载,nodeSelector定点

    mydig/one-pod/pod-with-volume.yaml

    apiVersion: v1
    kind: Pod
    metadata:
      name: mydig
      namespace: ni-ning
      labels:
        component: mydig
    spec:
      volumes: 
      - name: mysql-data
        hostPath: 
          path: /opt/mysql/data
      nodeSelector:   # 使用节点选择器将Pod调度到指定label的节点
        component: mysql
      containers:
      - name: mydig
        image: 192.168.75.129:5000/mydig:v1
        env:
        - name: MYSQL_HOST   #  指定root用户的用户名
          value: "127.0.0.1"
        - name: MYSQL_PASSWD
          value: "123456"
        ports:
        - containerPort: 80
      - name: mysql
        image: mysql:5.7
        args:
        - --character-set-server=utf8mb4
        - --collation-server=utf8mb4_unicode_ci
        ports:
        - containerPort: 3306
        env:
        - name: MYSQL_ROOT_PASSWORD
          value: "123456"
        - name: MYSQL_DATABASE
          value: "mydig"
        volumeMounts:
        - name: mysql-data
          mountPath: /var/lib/mysql
    

    保存文件为pod-with-volume.yaml,执行创建

    ## 若存在旧的同名服务,先删除掉,后创建
    $ kubectl -n ni-ninig delete pod mydig
    ## 创建
    $ kubectl create -f pod-with-volume.yaml
    
    ## 此时pod状态Pending
    $ kubectl -n ni-ning get po
    NAME     READY   STATUS    RESTARTS   AGE
    mydig   0/2     Pending   0          32s
    
    ## 查看原因,提示调度失败,因为节点不满足node selector
    $ kubectl -n ni-ning describe po mydig
    Events:
      Type     Reason            Age                From               Message
      ----     ------            ----               ----               -------
      Warning  FailedScheduling  12s (x2 over 12s)  default-scheduler  0/3 nodes are available: 3 node(s) didn't match node selector.
      
    ## 为节点打标签
    $ kubectl label node k8s-slave1 component=mysql
    
    ## 再次查看,已经运行成功
    $ kubectl -n ni-ning get po
    NAME     READY   STATUS    RESTARTS   AGE     IP             NODE
    mydig   2/2     Running   0          3m54s   10.244.1.150   k8s-slave1
    
    ## 到k8s-slave1节点,查看/opt/mysql/data
    $ ll /opt/mysql/data/
    total 188484
    -rw-r----- 1 polkitd input       56 Mar 29 09:20 auto.cnf
    -rw------- 1 polkitd input     1676 Mar 29 09:20 ca-key.pem
    -rw-r--r-- 1 polkitd input     1112 Mar 29 09:20 ca.pem
    drwxr-x--- 2 polkitd input     8192 Mar 29 09:20 sys
    ...
    
    ## 执行migrate,创建数据库表,然后删掉pod,再次创建后验证数据是否存在
    $ kubectl -n ni-ning exec -it mydig python3 manage.py migrate
    
    ## 访问服务,正常
    $ curl 10.244.1.150
    
    ## 删除pod
    $ kubectl delete -f pod-with-volume.yaml
    
    ## 再次创建Pod
    $ kubectl create -f pod-with-volume.yaml
    
    ## 查看pod ip并访问服务
    $ kubectl -n ni-ning get po -o wide
    NAME     READY   STATUS    RESTARTS   AGE   IP             NODE  
    mydig   2/2     Running   0          7s    10.244.1.151   k8s-slave1
    
    ## 未重新做migrate,服务正常
    $ curl 10.244.1.151
    
    
  • 使用PV+PVC连接分布式存储解决方案

    • ceph
    • glusterfs
    • nfs

# 服务健康检查

检测容器服务是否健康的手段,若不健康,会根据设置的重启策略(restartPolicy)进行操作,两种检测机制可以分别单独设置,若不设置,默认认为Pod是健康的。

两种机制:

  • LivenessProbe探针 存活性探测:用于判断容器是否存活,即Pod是否为running状态,如果LivenessProbe探针探测到容器不健康,则kubelet将kill掉容器,并根据容器的重启策略是否重启,如果一个容器不包含LivenessProbe探针,则Kubelet认为容器的LivenessProbe探针的返回值永远成功。
  ...
    containers:
    - name: mydig
      image: 192.168.75.129:5000/mydig:v1
      livenessProbe:
        httpGet:
          path: /
          port: 80
          scheme: HTTP
        initialDelaySeconds: 10  # 容器启动后第一次执行探测是需要等待多少秒
        periodSeconds: 10 	# 执行探测的频率
        timeoutSeconds: 2		# 探测超时时间
  ...

  • ReadinessProbe探针 可用性探测:用于判断容器是否正常提供服务,即容器的Ready是否为True,是否可以接收请求,如果ReadinessProbe探测失败,则容器的Ready将为False, Endpoint Controller 控制器将此Pod的Endpoint从对应的service的Endpoint列表中移除,不再将任何请求调度此Pod上,直到下次探测成功。(剔除此pod不参与接收请求不会将流量转发给此Pod)。

    ...
      containers:
      - name: mydig
        image: 192.168.75.129:5000/mydig:v1
        readinessProbe: 
          httpGet: 
            path: 
            port: 80
            scheme: HTTP
          initialDelaySeconds: 10 
          timeoutSeconds: 2
          periodSeconds: 10
    ...
    
    

三种类型:

  • exec:通过执行命令来检查服务是否正常,返回值为0则表示容器健康

    ...
        livenessProbe:
          exec:
            command:
            - cat
            - /tmp/healthy
          initialDelaySeconds: 5
          periodSeconds: 5
    ...
    
  • httpGet方式:通过发送http请求检查服务是否正常,返回200-399状态码则表明容器健康

  • tcpSocket:通过容器的IP和Port执行TCP检查,如果能够建立TCP连接,则表明容器健康

      ...
          livenessProbe:
            tcpSocket:
              port: 8002
            initialDelaySeconds: 10  # 容器启动后第一次执行探测是需要等待多少秒
            periodSeconds: 10     # 执行探测的频率
            timeoutSeconds: 2        # 探测超时时间
      ...
    

示例:

完整文件路径 mydig/one-pod/pod-with-healthcheck.yaml

  containers:
  - name: mydig
    image: 192.168.75.129:5000/mydig:v1
    env:
    - name: MYSQL_HOST   #  指定root用户的用户名
      value: "127.0.0.1"
    - name: MYSQL_PASSWD
      value: "123456"
    ports:
    - containerPort: 8002
    livenessProbe:
      httpGet:
        path: /
        port: 80
        scheme: HTTP
      initialDelaySeconds: 10  # 容器启动后第一次执行探测是需要等待多少秒
      periodSeconds: 10 	# 执行探测的频率
      timeoutSeconds: 2		# 探测超时时间
    readinessProbe: 
      httpGet: 
        path: /
        port: 80
        scheme: HTTP
      initialDelaySeconds: 10 
      timeoutSeconds: 2
      periodSeconds: 10
  • initialDelaySeconds:容器启动后第一次执行探测是需要等待多少秒。
  • periodSeconds:执行探测的频率。默认是10秒,最小1秒。
  • timeoutSeconds:探测超时时间。默认1秒,最小1秒。
  • successThreshold:探测失败后,最少连续探测成功多少次才被认定为成功。默认是1。
  • failureThreshold:探测成功后,最少连续探测失败多少次 才被认定为失败。默认是3,最小值是1。

K8S将在Pod开始启动10s(initialDelaySeconds)后利用HTTP访问8002端口的/blog/index/,如果超过2s或者返回码不在200~399内,则健康检查失败

# 重启策略

Pod的重启策略(RestartPolicy)应用于Pod内的所有容器,并且仅在Pod所处的Node上由kubelet进行判断和重启操作。当某个容器异常退出或者健康检查失败时,kubelet将根据RestartPolicy的设置来进行相应的操作。 Pod的重启策略包括Always、OnFailure和Never,默认值为Always。

  • Always:当容器进程退出后,由kubelet自动重启该容器;
  • OnFailure:当容器终止运行且退出码不为0时,由kubelet自动重启该容器;
  • Never:不论容器运行状态如何,kubelet都不会重启该容器。

演示重启策略:

apiVersion: v1
kind: Pod
metadata:
  name: test-restart-policy
spec:
  restartPolicy: Always
  containers:
  - name: busybox
    image: busybox
    args:
    - /bin/sh
    - -c
    - sleep 10
  1. 使用默认的重启策略,即 restartPolicy: Always ,无论容器是否是正常退出,都会自动重启容器
  2. 使用OnFailure的策略时
    • 如果把exit 1,去掉,即让容器的进程正常退出的话,则不会重启
    • 只有非正常退出状态才会重启
  3. 使用Never时,退出了就不再重启

可以看出,若容器正常退出,Pod的状态会是Completed,非正常退出,状态为CrashLoopBackOff

# 镜像拉取策略

spec:
  containers:
  - name: mydig
    image: 192.168.75.129:5000/mydig:v1
    imagePullPolicy: IfNotPresent

设置镜像的拉取策略,默认为IfNotPresent

  • Always,总是拉取镜像,即使本地有镜像也从仓库拉取
  • IfNotPresent ,本地有则使用本地镜像,本地没有则去仓库拉取
  • Never,只使用本地镜像,本地没有则报错

# Pod资源限制

为了保证充分利用集群资源,且确保重要容器在运行周期内能够分配到足够的资源稳定运行,因此平台需要具备

Pod的资源限制的能力。 对于一个pod来说,资源最基础的2个的指标就是:CPU和内存。

Kubernetes提供了个采用requests和limits 两种类型参数对资源进行预分配和使用限制。

完整文件路径:mydig/one-pod/pod-with-resourcelimits.yaml

...
  containers:
  - name: mydig
    image: 192.168.75.129:5000/mydig:v1
    env:
    - name: MYSQL_HOST   #  指定root用户的用户名
      value: "127.0.0.1"
    - name: MYSQL_PASSWD
      value: "123456"
    ports:
    - containerPort: 8002
    resources:
      requests:
        memory: 100Mi
        cpu: 50m
      limits:
        memory: 500Mi
        cpu: 100m
...


requests:

  • 容器使用的最小资源需求,作用于schedule阶段,作为容器调度时资源分配的判断依赖
  • 只有当前节点上可分配的资源量 >= request 时才允许将容器调度到该节点
  • request参数不限制容器的最大可使用资源
  • requests.cpu被转成docker的--cpu-shares参数,与cgroup cpu.shares功能相同 (无论宿主机有多少个cpu或者内核,--cpu-shares选项都会按照比例分配cpu资源)
  • requests.memory没有对应的docker参数,仅作为k8s调度依据

limits:

  • 容器能使用资源的最大值
  • 设置为0表示对使用的资源不做限制, 可无限的使用
  • 当pod 内存超过limit时,会被oom
  • 当cpu超过limit时,不会被kill,但是会限制不超过limit值
  • limits.cpu会被转换成docker的–cpu-quota参数。与cgroup cpu.cfs_quota_us功能相同
  • limits.memory会被转换成docker的–memory参数。用来限制容器使用的最大内存

对于 CPU,我们知道计算机里 CPU 的资源是按“时间片”的方式来进行分配的,系统里的每一个操作都需要 CPU 的处理,所以,哪个任务要是申请的 CPU 时间片越多,那么它得到的 CPU 资源就越多。

然后还需要了解下 CGroup 里面对于 CPU 资源的单位换算:

1 CPU =  1000 millicpu(1 Core = 1000m)

这里的 m 就是毫、毫核的意思,Kubernetes 集群中的每一个节点可以通过操作系统的命令来确认本节点的 CPU 内核数量,然后将这个数量乘以1000,得到的就是节点总 CPU 总毫数。比如一个节点有四核,那么该节点的 CPU 总毫量为 4000m。

docker run命令和 CPU 限制相关的所有选项如下:

选项 描述
--cpuset-cpus="" 允许使用的 CPU 集,值可以为 0-3,0,1
-c,--cpu-shares=0 CPU 共享权值(相对权重)
cpu-period=0 限制 CPU CFS 的周期,范围从 100ms~1s,即[1000, 1000000]
--cpu-quota=0 限制 CPU CFS 配额,必须不小于1ms,即 >= 1000,绝对限制
docker run -it --cpu-period=50000 --cpu-quota=25000 ubuntu:16.04 /bin/bash

将 CFS 调度的周期设为 50000,将容器在每个周期内的 CPU 配额设置为 25000,表示该容器每 50ms 可以得到 50% 的 CPU 运行时间。

注意:若内存使用超出限制,会引发系统的OOM机制,因CPU是可压缩资源,不会引发Pod退出或重建

# mydig改造及优化

# yaml优化

目前完善后的yaml,mydig/one-pod/pod-completed.yaml

apiVersion: v1
kind: Pod
metadata:
  name: mydig
  namespace: ni-ning
  labels:
    component: mydig
spec:
  volumes: 
  - name: mysql-data
    hostPath: 
      path: /opt/mysql/data
  nodeSelector:   # 使用节点选择器将Pod调度到指定label的节点
    component: mysql
  containers:
  - name: mydig
    image: 192.168.75.129:5000/mydig:v1
    env:
    - name: MYSQL_HOST   #  指定root用户的用户名
      value: "127.0.0.1"
    - name: MYSQL_PASSWD
      value: "123456"
    ports:
    - containerPort: 8002
    resources:
      requests:
        memory: 100Mi
        cpu: 50m
      limits:
        memory: 500Mi
        cpu: 100m
    livenessProbe:
      httpGet:
        path: /
        port: 80
        scheme: HTTP
      initialDelaySeconds: 10  # 容器启动后第一次执行探测是需要等待多少秒
      periodSeconds: 15 	# 执行探测的频率
      timeoutSeconds: 2		# 探测超时时间
    readinessProbe: 
      httpGet: 
        path: /
        port: 80
        scheme: HTTP
      initialDelaySeconds: 10 
      timeoutSeconds: 2
      periodSeconds: 15
  - name: mysql
    image: mysql:5.7
    args:
    - --character-set-server=utf8mb4
    - --collation-server=utf8mb4_unicode_ci
    ports:
    - containerPort: 3306
    env:
    - name: MYSQL_ROOT_PASSWORD
      value: "123456"
    - name: MYSQL_DATABASE
      value: "mydig"
    resources:
      requests:
        memory: 100Mi
        cpu: 50m
      limits:
        memory: 500Mi
        cpu: 100m
    readinessProbe:
      tcpSocket:
        port: 3306
      initialDelaySeconds: 5
      periodSeconds: 10
    livenessProbe:
      tcpSocket:
        port: 3306
      initialDelaySeconds: 15
      periodSeconds: 20
    volumeMounts:
    - name: mysql-data
      mountPath: /var/lib/mysql

为什么要优化

  • 考虑真实的使用场景,像数据库这类中间件,是作为公共资源,为多个项目提供服务,不适合和业务容器绑定在同一个Pod中,因为业务容器是经常变更的,而数据库不需要频繁迭代
  • yaml的环境变量中存在敏感信息(账号、密码),存在安全隐患

解决问题一,需要拆分yaml

mydig/two-pod/mysql.yaml

apiVersion: v1
kind: Pod
metadata:
  name: mysql
  namespace: ni-ning
  labels:
    component: mysql
spec:
  hostNetwork: true	# 声明pod的网络模式为host模式,效果同docker run --net=host
  volumes: 
  - name: mysql-data
    hostPath: 
      path: /opt/mysql/data
  nodeSelector:   # 使用节点选择器将Pod调度到指定label的节点
    component: mysql
  containers:
  - name: mysql
    image: mysql:5.7
    args:
    - --character-set-server=utf8mb4
    - --collation-server=utf8mb4_unicode_ci
    ports:
    - containerPort: 3306
    env:
    - name: MYSQL_ROOT_PASSWORD
      value: "123456"
    - name: MYSQL_DATABASE
      value: "mydig"
    resources:
      requests:
        memory: 100Mi
        cpu: 50m
      limits:
        memory: 500Mi
        cpu: 100m
    readinessProbe:
      tcpSocket:
        port: 3306
      initialDelaySeconds: 5
      periodSeconds: 10
    livenessProbe:
      tcpSocket:
        port: 3306
      initialDelaySeconds: 15
      periodSeconds: 20
    volumeMounts:
    - name: mysql-data
      mountPath: /var/lib/mysql


mydig.yaml

apiVersion: v1
kind: Pod
metadata:
  name: mydig
  namespace: ni-ning
  labels:
    component: mydig
spec:
  containers:
  - name: mydig
    image: 192.168.75.129:5000/mydig:v1
    imagePullPolicy: IfNotPresent
    env:
    - name: MYSQL_HOST   #  指定root用户的用户名
      value: "172.21.51.55"
    - name: MYSQL_PASSWD
      value: "123456"
    ports:
    - containerPort: 80
    resources:
      requests:
        memory: 100Mi
        cpu: 50m
      limits:
        memory: 500Mi
        cpu: 100m
    livenessProbe:
      httpGet:
        path: /
        port: 80
        scheme: HTTP
      initialDelaySeconds: 10  # 容器启动后第一次执行探测是需要等待多少秒
      periodSeconds: 15 	# 执行探测的频率
      timeoutSeconds: 2		# 探测超时时间
    readinessProbe: 
      httpGet: 
        path: /
        port: 80
        scheme: HTTP
      initialDelaySeconds: 10 
      timeoutSeconds: 2
      periodSeconds: 15

创建测试

## 先删除旧pod
$ kubectl -n ni-ning delete po mydig

## 分别创建mysql和mydig
$ kubectl create -f mysql.yaml
$ kubectl create -f mydig.yaml

## 查看pod,注意mysqlIP为宿主机IP,因为网络模式为host
$ kubectl -n ni-ning get po -o wide 
NAME     READY   STATUS    RESTARTS   AGE   IP                NODE
mydig   1/1     Running   0          41s   10.244.1.152      k8s-slave1
mysql    1/1     Running   0          52s   172.21.51.67   k8s-slave1

## 访问mydig服务正常
$ curl 10.244.1.152

解决问题二,环境变量中敏感信息带来的安全隐患

为什么要统一管理环境变量

  • 环境变量中有很多敏感的信息,比如账号密码,直接暴漏在yaml文件中存在安全性问题
  • 团队内部一般存在多个项目,这些项目直接存在配置相同环境变量的情况,因此可以统一维护管理
  • 对于开发、测试、生产环境,由于配置均不同,每套环境部署的时候都要修改yaml,带来额外的开销

k8s提供两类资源,configMap和Secret,可以用来实现业务配置的统一管理, 允许将配置文件与镜像文件分离,以使容器化的应用程序具有可移植性 。

  • configMap,通常用来管理应用的配置文件或者环境变量,mydig/two-pod/configmap.yaml

    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: mydig
      namespace: ni-ning
    data:
      MYSQL_HOST: "192.168.75.129"
      MYSQL_PORT: "3306"
    

    创建并查看configMap:

    $ kubectl create -f configmap.yaml
    $ kubectl -n ni-ning get cm mydig -oyaml
    

    或者可以使用命令的方式,从文件中创建,比如:

    configmap.txt

    $ cat configmap.txt
    MYSQL_HOST=172.21.51.55
    MYSQL_PORT=3306
    $ kubectl create configmap mydig --from-env-file=configmap.txt
    
  • Secret,管理敏感类的信息,默认会base64编码存储,有三种类型

    • Service Account :用来访问Kubernetes API,由Kubernetes自动创建,并且会自动挂载到Pod的/run/secrets/kubernetes.io/serviceaccount目录中;创建ServiceAccount后,Pod中指定serviceAccount后,自动创建该ServiceAccount对应的secret;
    • Opaque : base64编码格式的Secret,用来存储密码、密钥等;
    • kubernetes.io/dockerconfigjson :用来存储私有docker registry的认证信息。

    mydig/two-pod/secret.yaml

    apiVersion: v1
    kind: Secret
    metadata:
      name: mydig
      namespace: ni-ning
    type: Opaque
    data:
      MYSQL_USER: cm9vdA==		#注意加-n参数, echo -n root|base64
      MYSQL_PASSWD: MTIzNDU2
    

    创建并查看:

    $ kubectl create -f secret.yaml
    $ kubectl -n ni-ning get secret
    

    如果不习惯这种方式,可以通过如下方式:

    $ cat secret.txt
    MYSQL_USER=root
    MYSQL_PASSWD=123456
    $ kubectl -n ni-ning create secret generic mydig --from-env-file=secret.txt 
    

修改后的mysql的yaml,资源路径:mydig/two-pod/mysql-with-config.yaml

...
spec:
  containers:
  - name: mysql
    args:
    - --character-set-server=utf8mb4
    - --collation-server=utf8mb4_unicode_ci
    env:
    - name: MYSQL_USER
      valueFrom:
        secretKeyRef:
          name: mydig
          key: MYSQL_USER
    - name: MYSQL_ROOT_PASSWORD
      valueFrom:
        secretKeyRef:
          name: mydig
          key: MYSQL_PASSWD
    - name: MYSQL_DATABASE
      value: "mydig"
...


整体修改后的mydig的yaml,资源路径:mydig/two-pod/mydig-with-config.yaml

apiVersion: v1
kind: Pod
metadata:
  name: mydig
  namespace: ni-ning
  labels:
    component: mydig
spec:
  containers:
  - name: mydig
    image: 192.168.75.129:5000/mydig:v1
    imagePullPolicy: IfNotPresent
    env:
    - name: MYSQL_HOST
      valueFrom:
        configMapKeyRef:
          name: mydig
          key: MYSQL_HOST
    - name: MYSQL_PORT
      valueFrom:
        configMapKeyRef:
          name: mydig
          key: MYSQL_PORT
    - name: MYSQL_USER
      valueFrom:
        secretKeyRef:
          name: mydig
          key: MYSQL_USER
    - name: MYSQL_PASSWD
      valueFrom:
        secretKeyRef:
          name: mydig
          key: MYSQL_PASSWD
    ports:
    - containerPort: 8002
    resources:
      requests:
        memory: 100Mi
        cpu: 50m
      limits:
        memory: 500Mi
        cpu: 100m
    livenessProbe:
      httpGet:
        path: /
        port: 80
        scheme: HTTP
      initialDelaySeconds: 10  # 容器启动后第一次执行探测是需要等待多少秒
      periodSeconds: 15 	# 执行探测的频率
      timeoutSeconds: 2		# 探测超时时间
    readinessProbe: 
      httpGet: 
        path: /
        port: 80
        scheme: HTTP
      initialDelaySeconds: 10 
      timeoutSeconds: 2
      periodSeconds: 15

在部署不同的环境时,pod的yaml无须再变化,只需要在每套环境中维护一套ConfigMap和Secret即可。但是注意configmap和secret不能跨namespace使用,且更新后,pod内的env不会自动更新,重建后方可更新。

# Pod生命周期

# 如何编写资源yaml

  1. 拿来主义,从机器中已有的资源中拿

    $ kubectl -n kube-system get po,deployment,ds
    
    
    
  2. 学会在官网查找, https://kubernetes.io/docs/home/

  3. 从kubernetes-api文档中查找, https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.16/#pod-v1-core

  4. kubectl explain 查看具体字段含义

# pod状态与生命周期

Pod的状态如下表所示:

状态值 描述
Pending API Server已经创建该Pod,等待调度器调度
ContainerCreating 拉取镜像启动容器中
Running Pod内容器均已创建,且至少有一个容器处于运行状态、正在启动状态或正在重启状态
Succeeded|Completed Pod内所有容器均已成功执行退出,且不再重启
Failed|Error Pod内所有容器均已退出,但至少有一个容器退出为失败状态
CrashLoopBackOff Pod内有容器启动失败,比如配置文件丢失导致主进程启动失败
Unknown 由于某种原因无法获取该Pod的状态,可能由于网络通信不畅导致

生命周期示意图:

启动和关闭示意:

初始化容器:

  • 验证业务应用依赖的组件是否均已启动
  • 修改目录的权限
  • 调整系统参数
...
      initContainers:
      - command:
        - /sbin/sysctl
        - -w
        - vm.max_map_count=262144
        image: alpine:3.6
        imagePullPolicy: IfNotPresent
        name: elasticsearch-logging-init
        resources: {}
        securityContext:
          privileged: true
      - name: fix-permissions
        image: alpine:3.6
        command: ["sh", "-c", "chown -R 1000:1000 /usr/share/elasticsearch/data"]
        securityContext:
          privileged: true
        volumeMounts:
        - name: elasticsearch-logging
          mountPath: /usr/share/elasticsearch/data
...

验证Pod生命周期:

apiVersion: v1
kind: Pod
metadata:
  name: pod-lifecycle
  namespace: ni-ning
  labels:
    component: pod-lifecycless
spec:
  initContainers:
  - name: init
    image: busybox
    command: ['sh', '-c', 'echo $(date +%s): INIT >> /loap/timing']
    volumeMounts:
    - mountPath: /loap
      name: timing
  containers:
  - name: main
    image: busybox
    command: ['sh', '-c', 'echo $(date +%s): START >> /loap/timing;
sleep 10; echo $(date +%s): END >> /loap/timing;']
    volumeMounts:
    - mountPath: /loap 
      name: timing
    livenessProbe:
      exec:
        command: ['sh', '-c', 'echo $(date +%s): LIVENESS >> /loap/timing']
    readinessProbe:
      exec:
        command: ['sh', '-c', 'echo $(date +%s): READINESS >> /loap/timing']
    lifecycle:
      postStart:
        exec:
          command: ['sh', '-c', 'echo $(date +%s): POST-START >> /loap/timing']
      preStop:
        exec:
          command: ['sh', '-c', 'echo $(date +%s): PRE-STOP >> /loap/timing']
  volumes:
  - name: timing
    hostPath:
      path: /tmp/loap

创建pod测试:

$ kubectl create -f pod-lifecycle.yaml

## 查看demo状态
$ kubectl -n ni-ning get po -o wide -w

## 查看调度节点的/tmp/loap/timing
$ cat /tmp/loap/timing
1585424708: INIT
1585424746: START
1585424746: POST-START
1585424754: READINESS
1585424756: LIVENESS
1585424756: END

须主动杀掉 Pod 才会触发 pre-stop hook,如果是 Pod 自己 Down 掉,则不会执行 pre-stop hook ,且杀掉Pod进程前,进程必须是正常运行状态,否则不会执行pre-stop钩子

# Pod操作小结

  1. 实现k8s平台与特定的容器运行时解耦,提供更加灵活的业务部署方式,引入了Pod概念
  2. k8s使用yaml格式定义资源文件,yaml中Map与List的语法,与json做类比
  3. 通过kubectl apply| get | exec | logs | delete 等操作k8s资源,必须指定namespace
  4. 每启动一个Pod,为了实现网络空间共享,会先创建Infra容器,并把其他容器网络加入该容器
  5. 通过livenessProbe和readinessProbe实现Pod的存活性和就绪健康检查
  6. 通过requests和limit分别限定容器初始资源申请与最高上限资源申请
  7. Pod通过initContainer和lifecycle分别来执行初始化、pod启动和删除时候的操作,使得功能更加全面和灵活
  8. 编写yaml讲究方法,学习k8s,养成从官方网站查询知识的习惯

做了哪些工作:

  1. 定义Pod.yaml,将mydig和mysql打包在同一个Pod中,使用mydig使用localhost访问mysql
  2. mysql数据持久化,为mydig业务应用添加了健康检查和资源限制
  3. 将mydig与mysql拆分,使用独立的Pod管理
  4. yaml文件中的环境变量存在账号密码明文等敏感信息,使用configMap和Secret来统一配置,优化部署

只使用Pod, 面临的问题:

  1. 业务应用启动多个副本
  2. Pod重建后IP会变化,外部如何访问Pod服务
  3. 运行业务Pod的某个节点挂了,可以自动帮我把Pod转移到集群中的可用节点启动起来
  4. 我的业务应用功能是收集节点监控数据,需要把Pod运行在k8集群的各个节点上
上次更新: 9/8/2022, 8:10:54 PM