k8s（pod）详解

罪恶克星  金牌会员 | 2024-5-22 20:13:16 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 655|帖子 655|积分 1965

一：Pod介绍

pod资源的各种配置和原理
关于很多yaml文件的编写，都是基于配置引出来的
1：pod的结构和界说


 每个Pod中都可以包含一个大概多个容器，这些容器可以分为2大类：
　　1：用户所在的容器，数量可多可少（用户容器）
　　2：pause容器，这是每个pod都会有的一个跟容器，作用有2个
　　　　1、可以以它为根据，评估整个pod的康健状态
　　　　2、可以在根容器上面设置ip地址，其他容器都以此ip，实现Pod内部的网络通信
　　　　　　这里的Pod内部通讯是，pod之间采用二层网络技术来实现
　　　　　　；其他容器都共享这个根容器的ip地址，外界访问这个根容器ip地址+端口即可
2：pod界说

pod的资源清单：
属性，依次类推的进行查找
  1. [root@master /]# kubectl  explain pod
  2. #查看二级属性
  3. [root@master /]# kubectl  explain pod.metadata
复制代码
 
介绍
  1. apiVersion 版本
  2. #查看所有的版本
  3. [root@master /]# kubectl  api-versions
  4. admissionregistration.k8s.io/v1
  5. apiextensions.k8s.io/v1
  6. apiregistration.k8s.io/v1
  7. apps/v1
  8. authentication.k8s.io/v1
  9. authorization.k8s.io/v1
  10. autoscaling/v1
  11. autoscaling/v2
  12. batch/v1
  13. certificates.k8s.io/v1
  14. coordination.k8s.io/v1
  15. discovery.k8s.io/v1
  16. events.k8s.io/v1
  17. flowcontrol.apiserver.k8s.io/v1beta2
  18. flowcontrol.apiserver.k8s.io/v1beta3
  19. networking.k8s.io/v1
  20. node.k8s.io/v1
  21. policy/v1
  22. rbac.authorization.k8s.io/v1
  23. scheduling.k8s.io/v1
  24. storage.k8s.io/v1
  25. v1
  27. kind 类型
  28. #查看资源的类型
  29. [root@master /]# kubectl  api-resources
  31. metadata  元数据，资源的名字，标签等等
  32. [root@master /]# kubectl  explain  pod.metadata
  34. status   状态信息，自动的进行生成，不需要自己定义
  35. [root@master /]# kubectl  get pods -o yaml
  37. spec  定义资源的详细信息，
  38. 下面的子属性
  39. containers：object  容器列表，用于定义容器的详细信息
  40. nodename：string   根据nodename的值将pod的调度到指定的node节点，pod部署在哪个Pod上面
  41. nodeselector：pod标签选择器，可以将pod调度到包含这些label的Node上
  42. hostnetwork：默认是false，k8s自动的分配一个ip地址，如果设置为true，就使用宿主机的ip
  43. volumes：存储卷，用于定义pod上面挂载的存储信息
  44. restartpolicy：重启策略，表示pod在遇到故障的时候处理的策略
复制代码
3：pod配置

重要关于pod.spec.containers属性
里面有的是数组，就是可以选择多个值，在里面的话，有的只是一个值，看环境进行区分
  1. [root@master /]# kubectl  explain pod.spec.containers
  2. KIND:       Pod
  3. VERSION:    v1
  5. name：容器名称
  6. image：容器需要的镜像地址
  7. imagePullPolicy：镜像拉取策略  本地的还是远程的
  8. command：容器的启动命令列表，如不指定，使用打包时使用的启动命令  string
  9. args：容器的启动命令需要的参数列表，也就是上面的列表的命令   string
  10. env：容器环境变量的配置   object
  11. ports：容器需要暴露的端口列表   object
  12. resources：资源限制和资源请求的设置   object
复制代码
1、基本配置
  1. [root@master ~]# cat pod-base.yaml
  2. apiVersion: v1
  3. kind: Pod
  4. metadata:
  5.   name: pod-base
  6.   namespace: dev
  7.   labels:
  8.     user: qqqq
  9. spec:
  10.    containers:
  11.      - name: nginx
  12.        image: nginx:1.17.1
  13.      - name: busybox
  14.        image: busybox:1.30
  16. 简单的Pod的配置，里面有2个容器
  17. nginx轻量级的web软件
  18. busybox：就是一个小巧的Linux命令集合
  20. [root@master ~]# kubectl create  -f pod-base.yaml
  21. pod/pod-base created
  23. #查看Pod状态，
  24. ready：只有里面有2个容器，但是只有一个是准备就绪的，还有一个没有启动
  25. restarts：重启的次数，因为有一个容器故障了，Pod一直重启试图恢复它
  26. [root@master ~]# kubectl get pods -n dev
  27. NAME       READY   STATUS             RESTARTS      AGE
  28. pod-base   1/2     CrashLoopBackOff   4 (29s ago)   2m36s
  30. #可以查看pod详情
  31. [root@master ~]# kubectl describe  pods pod-base -n dev
  32. Events:
  33.   Type     Reason     Age                   From               Message
  34.   ----     ------     ----                  ----               -------
  35.   Normal   Scheduled  4m51s                 default-scheduler  Successfully assigned dev/pod-base to node2
  36.   Normal   Pulling    4m51s                 kubelet            Pulling image "nginx:1.17.1"
  37.   Normal   Pulled     4m17s                 kubelet            Successfully pulled image "nginx:1.17.1" in 33.75s (33.75s including waiting)
  38.   Normal   Created    4m17s                 kubelet            Created container nginx
  39.   Normal   Started    4m17s                 kubelet            Started container nginx
  40.   Normal   Pulling    4m17s                 kubelet            Pulling image "busybox:1.30"
  41.   Normal   Pulled     4m9s                  kubelet            Successfully pulled image "busybox:1.30" in 8.356s (8.356s including waiting)
  42.   Normal   Created    3m27s (x4 over 4m9s)  kubelet            Created container busybox
  43.   Normal   Started    3m27s (x4 over 4m9s)  kubelet            Started container busybox
  44.   Warning  BackOff    2m59s (x7 over 4m7s)  kubelet            Back-off restarting failed container busybox in pod pod-base_dev(2e9aeb3f-2bec-4af5-853e-2d8473e115a7)
  45.   Normal   Pulled     2m44s (x4 over 4m8s)  kubelet            Container image "busybox:1.30" already present on machine　　
复制代码
之后再来进行办理
2、镜像拉取

imagePullPolicy
就是pod里面有个容器，一个有本地镜像，一个没有，可以使用这个参数来进行控制是本地照旧远程的
imagePullPolicy的值，
　　Always：总是从远程仓库进行拉取镜像（一直用远程下载）
　　ifNotPresent：本地有则使用本地的镜像，本地没有则使用从远程仓库拉取镜像
　　Never：一直使用本地的，不使用远程下载
假如镜像的tag为具体的版本号：默认值是ifNotPresent，
 假如是latest：默认策略是always
  1. [root@master ~]# cat pod-policy.yaml
  2. apiVersion: v1
  3. kind: Pod
  4. metadata:
  5.   name: pod-imagepullpolicy
  6.   namespace: dev
  7.   labels:
  8.     user: qqqq
  9. spec:
  10.    containers:
  11.      - name: nginx
  12.        image: nginx:1.17.2
  13.        imagePullPolicy: Never
  14.      - name: busybox
  15.        image: busybox:1.30
  17. [root@master ~]# kubectl create -f pod-policy.yaml
  18. pod/pod-imagepullpolicy created
  20. #查看pods状态
  21. [root@master ~]# kubectl get pods -n dev
  22. NAME                  READY   STATUS             RESTARTS        AGE
  23. pod-base              1/2     CrashLoopBackOff   9 (3m59s ago)   25m
  24. pod-imagepullpolicy   0/2     CrashLoopBackOff   1 (9s ago)      19s
  26. #查看详细的信息
  27. [root@master ~]# kubectl describe  pods pod-imagepullpolicy -n dev
  28. Events:
  29.   Type     Reason             Age                From               Message
  30.   ----     ------             ----               ----               -------
  31.   Normal   Scheduled          64s                default-scheduler  Successfully assigned dev/pod-imagepullpolicy to node1
  32.   Normal   Pulling            64s                kubelet            Pulling image "busybox:1.30"
  33.   Normal   Pulled             56s                kubelet            Successfully pulled image "busybox:1.30" in 8.097s (8.097s including waiting)
  34.   Normal   Created            39s (x3 over 56s)  kubelet            Created container busybox
  35.   Normal   Started            39s (x3 over 56s)  kubelet            Started container busybox
  36.   Normal   Pulled             39s (x2 over 55s)  kubelet            Container image "busybox:1.30" already present on machine
  37.   Warning  ErrImageNeverPull  38s (x6 over 64s)  kubelet            Container image "nginx:1.17.2" is not present with pull policy of Never
  38.   Warning  Failed             38s (x6 over 64s)  kubelet            Error: ErrImageNeverPull
  39.   Warning  BackOff            38s (x3 over 54s)  kubelet            Back-off restarting failed container busybox in pod pod-imagepullpolicy_dev(38d5d2ff-6155-4ff3-ad7c-8b7f4a370107)
  41. #直接报了一个错误，就是镜像拉取失败了
  43. #解决的措施，修改里面的策略为ifnotpresent即可
  44. [root@master ~]# kubectl  delete  -f pod-policy.yaml
  45. [root@master ~]# kubectl  apply  -f pod-policy.yaml
  46. [root@master ~]# kubectl  get pods -n dev
  47. [root@master ~]# kubectl  get pods -n dev
  48. NAME                  READY   STATUS             RESTARTS         AGE
  49. pod-base              1/2     CrashLoopBackOff   11 (2m34s ago)   34m
  50. pod-imagepullpolicy   1/2     CrashLoopBackOff   4 (63s ago)      2m55s
  51. 这样就拉取成功了
复制代码
3、启动下令

command：容器启动的下令列表，假如不指定的话，使用打包时使用的启动下令
args：容器的启动下令需要的参数列表
为什么没有busybox运行了，busybox并不是一个程序，而是类似于一个工具类的集合，他会自动的进行关闭，办理的方法就是让其一直的运行，这就要使用command下令了
  1. [root@master ~]# cat command.yaml
  2. apiVersion: v1
  3. kind: Pod
  4. metadata:
  5.   name: pod-command
  6.   namespace: dev
  7. spec:
  8.    containers:
  9.      - name: nginx
  10.        image: nginx:1.17.1
  11.      - name: busybox
  12.        image: busybox:1.30
  13.        command: ["/bin/sh","-c","touch /tmp/hello.txt;while true;do /bin/echo $(date +%T) >> /tmp/hell0.txt;sleep 3;done;"]
  16. #/bin/sh  命令行脚本
  17. -c  之后的字符串作为一个命令来执行
  18. 向这个文件里面执行时间，然后执行结束后，休息3秒钟，这个就是一个进程一直在运行
  20. [root@master ~]# kubectl  create -f command.yaml
  21. pod/pod-command created
  23. #这样就好了，都启动了
  24. [root@master ~]# kubectl get pods -n dev
  25. NAME          READY   STATUS    RESTARTS   AGE
  26. pod-command   2/2     Running   0          6s
  28. #进入这个容器
  29. [root@master ~]# kubectl  exec pod-command -n dev -it -c busybox /bin/sh
  30. kubectl exec [POD] [COMMAND] is DEPRECATED and will be removed in a future version. Use kubectl exec [POD] -- [COMMAND] instead.
  31. / #
  33. 这样就成功的进入里面去了
  34. / # cat /tmp/hell0.txt ，因为有这个进程的存在，就不是关闭掉
复制代码
　　
分析：发现command已经完成启动下令后和传递参数后的功能，为什么还需要提供一个args的选项了，用于传递参数呢，这其实跟docker有点关系，整个个就是覆盖dockerfile中的entrypoint的功能
k8s拉取镜像的时候，里面有一个dockerfile来构建镜像，然后k8s的command和args会替换
环境：
　　1，假如command和args没有写，那么用dockerfile的配置
　　2、假如command写了，但是args没有写，那么用dockerfile默认配置会被忽略，实行输入的command下令
　　3、假如command没写，但是args写了，那么dockerfile中的配置的entrypoint下令会被实行，使用当前的args的参数
　　4、假如都写了，那么dockerfile的配置被忽略，实行command并追上args参数
 4、环境变量（了解即可）

env向容器里面传入环境变量，object范例的数组
键值对，就是一个键加上一个值即可
  1. [root@master ~]# cat pod-env.yaml
  2. apiVersion: v1
  3. kind: Pod
  4. metadata:
  5.   name: pod-command
  6.   namespace: dev
  7. spec:
  8.    containers:
  9.      - name: nginx
  10.        image: nginx:1.17.1
  11.      - name: busybox
  12.        image: busybox:1.30
  13.        command: ["/bin/sh","-c","touch /tmp/hello.txt;while true;do /bin/echo $(date +%T) >> /tmp/hell0.txt;sleep 3;done;"]
  14.        env:
  15.        - name: "username"
  16.           vaule : "admin"
  17.        - name: "password"
  18.          vaule: "123456"
  21. #创建Pod
  22. [root@master ~]# kubectl create -f pod-env.yaml
  23. pod/pod-command created
  24. [root@master ~]# kubectl get pods -n dev
  25. NAME          READY   STATUS    RESTARTS   AGE
  26. pod-command   2/2     Running   0          47s
  29. #进入容器里面
  30. -c选项，只有一个容器的话，可以省略掉即可
  31. [root@master ~]# kubectl  exec -ti pod-command -n dev -c busybox /bin/sh
  32. kubectl exec [POD] [COMMAND] is DEPRECATED and will be removed in a future version. Use kubectl exec [POD] -- [COMMAND] instead.
  33. / # ls
  34. bin   dev   etc   home  proc  root  sys   tmp   usr   var
  35. / # echo $username
  36. admin
  37. / # echo password
  38. password
复制代码
5、端口设置（ports）

查察端口一些选项　　
  1. [root@master ~]# kubectl  explain  pod.spec.containers.ports
  2. ports
  3.    name：端口的名称，必须是在Pod中是唯一的
  4.    containerport 容器要监听的端口
  5.    hostport 容器要在主机上公开的端口，如果设置，主机上只能运行容器的一个副本，会有冲突，多个Pod会占用一个端口
  6.    hostip  要将外部端口绑定到主机的Ip（一般省略了）
  7.    protocol  端口协议，默认是TCP，UTP,SCTP
  8.    
复制代码

 
案例：
  1. [root@master ~]# cat pod-port.yaml
  2. apiVersion: v1
  3. kind: Pod
  4. metadata:
  5.   name: pod-ports
  6.   namespace: dev
  7. spec:
  8.    containers:
  9.    - name: nginx
  10.      image: nginx:1.17.1
  11.      ports:
  12.      - name: nginx-port
  13.        containerPort: 80
  14.        protocol: TCP
  16. kubectl create -f pod-port.yaml
  17. [root@master ~]# kubectl get pod -n dev -o wide
  18. NAME          READY   STATUS    RESTARTS   AGE     IP           NODE    NOMINATED NODE   READINESS GATES
  19. pod-command   2/2     Running   0          27m     10.244.1.2   node2   <none>           <none>
  20. pod-ports     1/1     Running   0          2m58s   10.244.2.2   node1   <none>           <none>
  22. #访问容器里面的程序的话，需要使用Pod的ip加上容器的端口即可，进行访问
  23. [root@master ~]# curl 10.244.2.2:80
  24. <!DOCTYPE html>
  25. <html>
  26. <head>
  27. <title>Welcome to nginx!</title>
  29. </head>
  30. <body>
  31. <h1>Welcome to nginx!</h1>
  32. <p>If you see this page, the nginx web server is successfully installed and
  33. working. Further configuration is required.</p>
  35. <p>For online documentation and support please refer to
  36. <a target="_blank" href="http://nginx.org/">nginx.org</a>.<br/>
  37. Commercial support is available at
  38. <a target="_blank" href="http://nginx.com/">nginx.com</a>.</p>
  40. <p><em>Thank you for using nginx.</em></p>
  41. </body>
  42. </html>
复制代码
6、资源限定（resources）

因为容器的运行需要占用一些资源，就是对某些容器进行资源的限定，假如某个资源突然大量的值内存的话，其他的容器就不能正常的工作了，就会出现问题
就是规定A容器只需要600M内存，假如大于的话，就出现了问题，进行重启容器的操作
有2个字选项：
limits：用于限定运行时容器的最大占用资源，当容器占用的资源凌驾了limits会被终止，并就进行重启（上限）
requests：用于设置容器需要的最小资源，假如环境资源不够的话，容器无法进行启动（下限）　　
　　作用：
　　　　1、只针对cpu，内存
案例：
  1. [root@master ~]# cat pod-r.yaml
  2. apiVersion: v1
  3. kind: Pod
  4. metadata:
  5.   name: pod-resources
  6.   namespace: dev
  7. spec:
  8.    containers:
  9.    - name: nginx
  10.      image: nginx:1.17.1
  11.      resources:
  12.         limits:
  13.            cpu: "2"
  14.            memory: "10Gi"
  15.         requests:
  16.             cpu: "1"
  17.             memory: "10Mi"
  19. kubectl create -f pod-r.yaml
  20. [root@master ~]# kubectl get pods -n dev
  21. NAME            READY   STATUS    RESTARTS   AGE
  22. pod-command     2/2     Running   0          41m
  23. pod-ports       1/1     Running   0          16m
  24. pod-resources   1/1     Running   0          113s
  27. #规定最少需要10G才能启动容器，但是不会进行启动
  28. [root@master ~]# cat pod-r.yaml
  29. apiVersion: v1
  30. kind: Pod
  31. metadata:
  32.   name: pod-resources
  33.   namespace: dev
  34. spec:
  35.    containers:
  36.    - name: nginx
  37.      image: nginx:1.17.1
  38.      resources:
  39.         limits:
  40.            cpu: "2"
  41.            memory: "10Gi"
  42.         requests:
  43.             cpu: "1"
  44.             memory: "10G"
  45. [root@master ~]# kubectl create -f pod-r.yaml
  46. pod/pod-resources created
  48. #查找状态
  49. [root@master ~]# kubectl get pods -n dev
  50. NAME            READY   STATUS    RESTARTS   AGE
  51. pod-command     2/2     Running   0          44m
  52. pod-ports       1/1     Running   0          19m
  53. pod-resources   0/1     Pending   0          89s
  55. #查看详细的信息
  56. [root@master ~]# kubectl  describe  pods pod-resources -n dev
  58. cpu和内存的单位
  59. cpu为整数
  60. 内存为Gi Mi  G M等形式
复制代码
二：pod生命周期　　　　

 1：概念

一般是指Pod对象从创建至终的时间范围称为pod的生命周期，重要包含一下过程
　　1、pod创建过程
　　2、运行初始化容器过程，它是容器的一种，可多可少，一定在主容器运行之前实行
　　3、运行主容器过程
　　　　容器启动后钩子，容器终止前钩子，就是启动之后的一些下令，2个特殊的点
　　　　容器的存活性探测，就绪性探测
　　4、pod终止过程

在整个生命周期中，pod会出现5中状态
挂起（pending）：apiserver，已经创建了pod资源对象，但它尚未被调度，大概仍然处于下载镜像的过程中；创建一个pod，里面有容器，需要拉取
运行中（running）：pod已经被调度至某一个节点，并且全部的容器都已经被kubelet创建完成
成功（succeeded）：Pod中的全部容器都已经被成功终止，并且不会被重启；就是运行一个容器，30秒后，打印，然退却出
失败（failed）：全部容器都已经被终止，但至少有一个容器终止失败，即容器返回非0的退出状态
未知（unknown）：apiserver无法正常的获取到pod对象的状态信息，通常由网络通信失败所导致的
2：pod创建和终止

pod的创建过程：

都监听到apiserver上面了 
开始创建就已经返回一个信息了，给etcd了，
scheduler：开始为pod分配主机，将结果告诉apiserver
node节点上面发现有pod调度过来，调用docker启动容器，并将结果告诉apiserver
apiserver将吸取的信息pod状态信息存入etcd中
pod的终止过程：

service就是Pod的代理，访问pod通过service即可
 向apiserver发送一个请求，apiserver更新pod的状态，将pod标志为terminating状态，kubelet监听到为terminating，就启动关闭pod过程
3：初始化容器

重要做的就是主容器的前置工作（环境的准备），2个特点
　　1、初始化容器必须运行在完成直至结束，若某初始化容器运行失败了，那么k8s需要重启它知道成功完成
　　2、初始化容器必须按照界说的顺序实行，当且仅当前一个成功了，后面的一个才能运行，否则不运行
初始化容器应用场景：
　　提供主容器进行不具备工具程序或自界说代码
　　初始化容器需要先于应用容器串行启动并运行成功，因此，可应用容器的启动直至依靠的条件得到满足
      nginx，mysql，redis，  先连mysql，不成功，则会一直处于连接， 一直连成功了，就会去连接redis，这2个条件都满足了，nginx这个主容器就会启动了
测试：
规定mysql 192.168.109.201  redis 192.168.109.202
 
  1. [root@master ~]# cat pod-init.yaml
  2. apiVersion: v1
  3. kind: Pod
  4. metadata:
  5.    name: pod-init
  6.    namespace: dev
  7. spec:
  8.    containers:
  9.    - name: main-container
  10.      image: nginx:1.17.1
  11.      ports:
  12.      - name: nginx-port
  13.        containerPort: 80
  14.    initContainers:
  15.    - name: test-mysql
  16.      image: busybox:1.30
  17.      command: ['sh','-c','util ping 192.168.109.201 -c 1;do echo waiting for mysql;sleep 2;done;']
  18.    - name: test-redis
  19.      image: busybox:1.30
  20.      command: ['sh','-c','util ping 192.168.109.202 -c 1;di echo waiting for redis;sleep 2;done']
  21. #由于没有地址，所以的话，初始化失败
  22. [root@master ~]# kubectl get pods -n dev
  23. NAME       READY   STATUS                  RESTARTS      AGE
  24. pod-init   0/1     Init:CrashLoopBackOff   3 (27s ago)   83s
  26. #添加地址，第一个初始化容器就能运行了
  27. [root@master ~]# ifconfig  ens33:1 192.168.109.201 netmask 255.255.255.0 up
  29. #再次添加地址，第二个初始化容器也能运行了
  30. [root@master ~]# ifconfig  ens33:2 192.168.109.202 netmask 255.255.255.0 up
  31. [root@master ~]# kubectl get pods -n dev -w
  32. NAME       READY   STATUS     RESTARTS   AGE
  33. pod-init   0/1     Init:0/2   0          6s
  34. pod-init   0/1     Init:1/2   0          13s
  35. pod-init   0/1     Init:1/2   0          14s
  36. pod-init   0/1     PodInitializing   0          27s
  37. pod-init   1/1     Running           0          28s
  39. 主容器就运行成功了
复制代码
4：主容器钩子函数

就是主容器上面的一些点，能够答应用户使用一些代码
2个点　　

post start：容器启动后钩子，容器启动之后会立即的实行，成功了，则启动，否则，会重启
prestop：容器终止前钩子，容器在删除之前实行，就是terming状态，会壅闭容器删除，实行成功了，就会删除
1、钩子处置惩罚器（三种方式界说动作）

exec下令：在容器内实行一次下令
用的最多的exec方式
  1. lifecycle：
  2.    podstart：
  3.      exec：
  4.        command:
  5.         - cat
  6.         - /tmp/healthy　
复制代码
tcpsocket：在当前容器内尝试访问指定socket，在容器内部访问8080端口
  1. lifecycle：
  2.    podstart:
  3.       tcpsocket：
  4.          port：8080   #会尝试连接8080端口　　
复制代码
httpget：在当前容器中向某url发起http请求
  1. lifecycle：
  2.    poststart:
  3.     httpGet:
  4.      path： url地址
  5.      port：   80
  6.      host: 主机地址
  7.      schme： HTTP 支持的协议　　
复制代码
案例：
  1. apiVersion: v1
  2. kind: Pod
  3. metadata:
  4.    name: pod-exec
  5.    namespace: dev
  6. spec:
  7.    containers:
  8.    - name: main-container
  9.      image: nginx:1.17.1
  10.      ports:
  11.      - name: nginx-port
  12.        containerPort: 80  #容器内部的端口，一般是service将公开pod端口，将pod端口映射到主机上面
  13.      lifecycle:
  14.        postStart:
  15.          exec:   ###在启动的时候，执行一个命令，修改默认网页内容
  16.             command: ["/bin/sh","-c","echo poststart > /usr/share/nginx/html/index.html"]
  17.        preStop:
  18.           exec:    ###停止容器的时候，-s传入一个参数，优雅的停止nginx服务
  19.              command: ["/usr/sbin/nginx","-s","quit"]
  21. [root@master ~]# kubectl create -f pod-exec.yaml
  22. pod/pod-exec created
  23. [root@master ~]# kubectl get pods -n dev -o wide
  24. NAME       READY   STATUS    RESTARTS   AGE   IP           NODE    NOMINATED NODE   READINESS GATES
  25. pod-exec   1/1     Running   0          53s   10.244.1.7   node1   <none>           <none>
  26. pod-init   1/1     Running   0          27m   10.244.1.6   node1   <none>           <none>
  28. 访问一下pod里面容器的服务即可
  29. 格式为pod的ip+容器的端口
  30. [root@master ~]# curl 10.244.1.7:80
  31. poststart
复制代码
5：容器探测　　

主容器探测：用于检测容器中的应用实例是否正常的工作，是保障业务可用性的一种传统机制，假如经过了探测，实例的状态不符合预期，那么k8s就会把问题的实例摘除，不承担业务的流量，k8s提供了2种探针来实现容器探测，
分别是：
　　liveness probes：存活性探针，用于检测应用实例，是否处于正常的运行状态，假如不是，k8s会重启容器；用于决定是否重启容器
　　readiness probes：就绪性探针，用于检测应用实例是否可以担当请求，假如不能，k8s不会转发流量；nginx需要读取很多的web文件，在读取的过程中，service认为nginx已经成功了，假如有个请求的话，那么就无法提供了服务；所以就不会将请求转发到这里了
就是一个service来代理许多的pod，请求来到了pod，假如有一个pod出现了问题，假如没有了探针的话，就会出现了问题
作用：
　　1、找出这些出了问题的pod
　　2、服务是否已经准备成功了
三种探测方式：

exec：退出码为0，则正常
  1. livenessProbe
  2.    exec:
  3.      command:
  4.        - cat
  5.        - /tmp/healthy
复制代码
tcpsocket：
  1. livenessProbe:
  2.     tcpSocket:
  3.        port: 8080
复制代码
httpget：
返回的状态码在200个399之间，则认为程序正常，否则不正常
  1. livenessProbe:
  2.     httpGet:
  3.       path: /  url地址
  4.        port：80  主机端口
  5.        host：主机地址
  6.        scheme：http
  7.       
复制代码
案例：
exec案例：
  1. [root@master ~]# cat pod-live-exec.yaml
  2. apiVersion: v1
  3. kind: Pod
  4. metadata:
  5.    name: pod-liveness-exec
  6.    namespace: dev
  7. spec:
  8.    containers:
  9.    - name: main-container
  10.      image: nginx:1.17.1
  11.      ports:
  12.      - name: nginx-port
  13.        containerPort: 80
  14.      livenessProbe:
  15.         exec:
  16.           command: ["/bin/cat","/tmp/hello.txt"]   #由于没有这个文件，所以就会一直进行重启
  18. #出现了问题，就会处于一直重启的状态
  19. [root@master ~]# kubectl get pods -n dev
  20. NAME                READY   STATUS    RESTARTS      AGE
  21. pod-exec            1/1     Running   0             38m
  22. pod-init            1/1     Running   0             65m
  23. pod-liveness-exec   1/1     Running   2 (27s ago)   97s
  25. #查看pod的详细信息
  26. [root@master ~]# kubectl describe  pod -n dev pod-liveness-exec
  27. Events:
  28.   Type     Reason     Age                 From               Message
  29.   ----     ------     ----                ----               -------
  30.   Normal   Scheduled  2m13s               default-scheduler  Successfully assigned dev/pod-liveness-exec to node2
  31.   Normal   Pulling    2m12s               kubelet            Pulling image "nginx:1.17.1"
  32.   Normal   Pulled     2m                  kubelet            Successfully pulled image "nginx:1.17.1" in 12.606s (12.606s including waiting)
  33.   Normal   Created    33s (x4 over 2m)    kubelet            Created container main-container
  34.   Normal   Started    33s (x4 over 2m)    kubelet            Started container main-container
  35.   Warning  Unhealthy  33s (x9 over 113s)  kubelet            Liveness probe failed: /bin/cat: /tmp/hello.txt: No such file or directory
  36.   Normal   Killing    33s (x3 over 93s)   kubelet            Container main-container failed liveness probe, will be restarted
  37.   Normal   Pulled     33s (x3 over 93s)   kubelet            Container image "nginx:1.17.1" already present on machine
  39. #一直在重启
  40. [root@master ~]# kubectl get pods -n dev
  41. NAME                READY   STATUS             RESTARTS      AGE
  42. pod-exec            1/1     Running            0             39m
  43. pod-init            1/1     Running            0             66m
  44. pod-liveness-exec   0/1     CrashLoopBackOff   4 (17s ago)   2m57s
  47. #一个正常的案例
  48. [root@master ~]# cat pod-live-exec.yaml
  49. apiVersion: v1
  50. kind: Pod
  51. metadata:
  52.    name: pod-liveness-exec
  53.    namespace: dev
  54. spec:
  55.    containers:
  56.    - name: main-container
  57.      image: nginx:1.17.1
  58.      ports:
  59.      - name: nginx-port
  60.        containerPort: 80
  61.      livenessProbe:
  62.         exec:
  63.           command: ["/bin/ls","/tmp/"]
  64. [root@master ~]# kubectl create -f pod-live-exec.yaml
  65. pod/pod-liveness-exec created
  67. #就不会一直重启了
  68. [root@master ~]# kubectl get pods -n dev
  69. NAME                READY   STATUS    RESTARTS   AGE
  70. pod-exec            1/1     Running   0          42m
  71. pod-init            1/1     Running   0          69m
  72. pod-liveness-exec   1/1     Running   0          56s
  74. #查看详细的信息，发现没有错误
复制代码
　　
tcpsocket：　　
  1. [root@master ~]# cat tcp.yaml
  2. apiVersion: v1
  3. kind: Pod
  4. metadata:
  5.    name: pod-liveness-tcp
  6.    namespace: dev
  7. spec:
  8.    containers:
  9.    - name: main-container
  10.      image: nginx:1.17.1
  11.      ports:
  12.      - name: nginx-port
  13.        containerPort: 80
  14.      livenessProbe:
  15.         tcpSocket:
  16.            port: 8080    访问容器的8080端口
  19. kubectl create -f tcp.yaml
  20. #发现一直在进行重启，没有访问到8080端口
  21. [root@master ~]# kubectl get pods -n dev
  22. NAME               READY   STATUS    RESTARTS      AGE
  23. pod-liveness-tcp   1/1     Running   5 (72s ago)   3m43s
  25. #查看详细的信息
  26. [root@master ~]# kubectl describe  pod -n dev pod-liveness-tcp  
  27. Events:
  28.   Type     Reason     Age                    From               Message
  29.   ----     ------     ----                   ----               -------
  30.   Normal   Scheduled  3m22s                  default-scheduler  Successfully assigned dev/pod-liveness-tcp to node2
  31.   Normal   Pulled     112s (x4 over 3m22s)   kubelet            Container image "nginx:1.17.1" already present on machine
  32.   Normal   Created    112s (x4 over 3m22s)   kubelet            Created container main-container
  33.   Normal   Started    112s (x4 over 3m22s)   kubelet            Started container main-container
  34.   Normal   Killing    112s (x3 over 2m52s)   kubelet            Container main-container failed liveness probe, will be restarted
  35.   Warning  Unhealthy  102s (x10 over 3m12s)  kubelet            Liveness probe failed: dial tcp 1
复制代码
正常的案例：
  1. [root@master ~]# cat tcp.yaml
  2. apiVersion: v1
  3. kind: Pod
  4. metadata:
  5.    name: pod-liveness-tcp
  6.    namespace: dev
  7. spec:
  8.    containers:
  9.    - name: main-container
  10.      image: nginx:1.17.1
  11.      ports:
  12.      - name: nginx-port
  13.        containerPort: 80
  14.      livenessProbe:
  15.         tcpSocket:
  16.            port: 80
  18. #查看效果，没有任何的问题
  19. [root@master ~]# kubectl describe  pods -n dev  pod-liveness-tcp
  20. Events:
  21.   Type    Reason     Age   From               Message
  22.   ----    ------     ----  ----               -------
  23.   Normal  Scheduled  27s   default-scheduler  Successfully assigned dev/pod-liveness-tcp to node2
  24.   Normal  Pulled     28s   kubelet            Container image "nginx:1.17.1" already present on machine
  25.   Normal  Created    28s   kubelet            Created container main-container
  26.   Normal  Started    28s   kubelet            Started container main-container
复制代码
httpget
  1. [root@master ~]# cat tcp.yaml
  2. apiVersion: v1
  3. kind: Pod
  4. metadata:
  5.    name: pod-liveness-http
  6.    namespace: dev
  7. spec:
  8.    containers:
  9.    - name: main-container
  10.      image: nginx:1.17.1
  11.      ports:
  12.      - name: nginx-port
  13.        containerPort: 80
  14.      livenessProbe:
  15.         httpGet:
  16.            scheme: HTTP
  17.            port: 80
  18.            path: /hello   # http://127.0.0.1:80/hello
  21. #发现一直在进行重启的操作
  22. [root@master ~]# kubectl describe pod  -n dev  pod-liveness-http
  23. [root@master ~]# kubectl get pods -n dev
  24. NAME                READY   STATUS    RESTARTS      AGE
  25. pod-liveness-http   1/1     Running   1 (17s ago)   48s
  26. pod-liveness-tcp    1/1     Running   0             4m21s
  28. #正常的情况
  29. [root@master ~]# cat tcp.yaml
  30. apiVersion: v1
  31. kind: Pod
  32. metadata:
  33.    name: pod-liveness-http
  34.    namespace: dev
  35. spec:
  36.    containers:
  37.    - name: main-container
  38.      image: nginx:1.17.1
  39.      ports:
  40.      - name: nginx-port
  41.        containerPort: 80
  42.      livenessProbe:
  43.         httpGet:
  44.            scheme: HTTP
  45.            port: 80
  46.            path: /
  47. [root@master ~]# kubectl describe  pods -n dev pod-liveness-http
  48. Events:
  49.   Type    Reason     Age   From               Message
  50.   ----    ------     ----  ----               -------
  51.   Normal  Scheduled  21s   default-scheduler  Successfully assigned dev/pod-liveness-http to node1
  52.   Normal  Pulled     22s   kubelet            Container image "nginx:1.17.1" already present on machine
  53.   Normal  Created    22s   kubelet            Created container main-container
  54.   Normal  Started    22s   kubelet            Started container main-container
复制代码
容器探测补充
  1. [root@master ~]# kubectl explain pod.spec.containers.livenessProbe
  2. initialDelaySeconds        <integer>  容器启动后等待多少秒执行第一次探测
  3. timeoutSeconds        <integer>   探测超时时间，默认是1秒，最小1秒
  4. periodSeconds        <integer>   执行探测的频率，默认是10秒，最小是1秒
  5. failureThreshold        <integer>    连续探测失败多少次后才被认为失败，默认是3，最小值是1
  6. successThreshold        <integer>  连续探测成功多少次后才被认定为成功，默认是1
复制代码
案例：
6：重启策略

就是容器探测出现了问题，k8s就会对容器所在的Pod进行重启，这个由pod的重启策略决定的，pod的重启策略有三种
　　always：容器失效时，自动重启该容器，默认值
　　onfailure：容器终止运行且退出码不为0时重启，异常终止
　　never：不论状态为何，都不重启该容器
重启策略适用于Pod对象中的全部容器，初次需要重启的容器，将在需要时立即重启，随后再次需要重启的操作由kubelet延迟一段时间进行，且反复的重启操作的延迟时长为10S，20S，300s为最大的延迟时长
案例：
  1. apiVersion: v1
  2. kind: Pod
  3. metadata:
  4.    name: restart-pod
  5.    namespace: dev
  6. spec:
  7.    containers:
  8.    - name: main-container
  9.      image: nginx:1.17.1
  10.      ports:
  11.      - name: nginx-port
  12.        containerPort: 80
  13.      livenessProbe:
  14.         httpGet:
  15.            scheme: HTTP
  16.            port: 80
  17.            path: /hello   # http://127.0.0.1:80/hello
  18.    restartPolicy: Always
  20. #会一直进行重启
  22. #改为Never
  23. 容器监听失败了，就不会进行重启，直接停止了
  24. 状态是完成的状态，
  25. [root@master ~]# kubectl get pods -n dev
  26. NAME                READY   STATUS      RESTARTS      AGE
  27. pod-liveness-http   1/1     Running     1 (16h ago)   16h
  28. pod-liveness-tcp    1/1     Running     1 (22m ago)   16h
  29. restart-pod         0/1     Completed   0             41s
  31. [root@master ~]# kubectl describe  pod -n dev  restart-pod
  33. Events:
  34.   Type     Reason     Age                From               Message
  35.   ----     ------     ----               ----               -------
  36.   Normal   Scheduled  84s                default-scheduler  Successfully assigned dev/restart-pod to node1
  37.   Normal   Pulled     84s                kubelet            Container image "nginx:1.17.1" already present on machine
  38.   Normal   Created    84s                kubelet            Created container main-container
  39.   Normal   Started    84s                kubelet            Started container main-container
  40.   Warning  Unhealthy  55s (x3 over 75s)  kubelet            Liveness probe failed: HTTP probe failed with statuscode: 404
  41.   Normal   Killing    55s                kubelet            Stopping container main-container
复制代码
三：pod调度

默认的环境下，一个Pod在哪个节点上面运行，是有scheduler组件采用相应的算法盘算出来，这个过程是不受人工控制的，但是在实际中，这不满足需求，需要控制pod在哪个节点上面运行，这个就需要调度的规则了，四大类调度的方式
自动调度：经过算法自动的调度
定向调度：通过nodename属性（node的名字），nodeselector（标签）
亲和性调度：nodeAffinity（node的亲和性），podAffinity（pod的亲和性），podANtiAffinity（这个就是跟Pod的亲和性差，所以就去相反的一侧）
污点（容忍调度）：站在node节点上面完成的，有一个污点，别人就不能在；容忍站在pod上面来说的，可以在node上面的污点进行就是容忍调度
1：定向调度

指定的是pod声明nodename，大概nodeselector，依次将pod调度到指定的node节点上面，这个是逼迫性的，即使node不存在，也会被调度，只不过是pod运行失败而已
1、nodename

逼迫的调度，直接跳过了scheduler的调度逻辑，直接将pod调度到指定的节点上面
  1. [root@master ~]# cat pod-nodename.yaml
  2. apiVersion: v1
  3. kind: Pod
  4. metadata:
  5.    name: pod-nodename
  6.    namespace: dev
  7. spec:
  8.    containers:
  9.    - name: main-container
  10.      image: nginx:1.17.1
  11.      ports:
  12.    nodeName: node1
  14. [root@master ~]# kubectl create  -f pod-nodename.yaml
  15. pod/pod-nodename created
  16. #运行在node1上面运行
  17. [root@master ~]# kubectl get pods -n dev -o wide
  18. NAME                READY   STATUS    RESTARTS      AGE   IP            NODE    NOMINATED NODE   READINESS GATES
  19. pod-liveness-http   1/1     Running   1 (16h ago)   17h   10.244.2.8    node1   <none>           <none>
  20. pod-liveness-tcp    1/1     Running   1 (42m ago)   17h   10.244.1.7    node2   <none>           <none>
  21. pod-nodename        1/1     Running   0             41s   10.244.2.10   node1   <none>           <none>
  23. #将节点改为不存在的，pod会失败而已
  24. [root@master ~]# kubectl get pods -n dev -o wide
  25. NAME                READY   STATUS    RESTARTS      AGE   IP           NODE    NOMINATED NODE   READINESS GATES
  26. pod-liveness-http   1/1     Running   1 (16h ago)   17h   10.244.2.8   node1   <none>           <none>
  27. pod-liveness-tcp    1/1     Running   1 (43m ago)   17h   10.244.1.7   node2   <none>           <none>
  28. pod-nodename        0/1     Pending   0             9s    <none>       node3   <none>           <none>　　
复制代码
2、nodeselector

看的就是节点上面的标签，标签选择器，逼迫性的
  1. [root@master ~]# kubectl label  nodes node1 nodeenv=pro
  2. node/node1 labeled
  3. [root@master ~]# kubectl label  nodes node2 nodeenv=test
  4. node/node2 labeled
  5. [root@master ~]# cat pod-selector.yaml
  6. apiVersion: v1
  7. kind: Pod
  8. metadata:
  9.    name: pod-select
  10.    namespace: dev
  11. spec:
  12.    containers:
  13.    - name: main-container
  14.      image: nginx:1.17.1
  15.    nodeSelector:
  16.        nodeenv: pro
  18. [root@master ~]# kubectl get pods -n dev -o wide
  19. NAME                READY   STATUS    RESTARTS      AGE     IP            NODE    NOMINATED NODE   READINESS GATES
  20. pod-liveness-http   1/1     Running   1 (17h ago)   17h     10.244.2.8    node1   <none>           <none>
  21. pod-liveness-tcp    1/1     Running   1 (51m ago)   17h     10.244.1.7    node2   <none>           <none>
  22. pod-select          1/1     Running   0             2m16s   10.244.2.11   node1   <none>           <none>
  24. #不存在的标签
  25. 改为pr1，调度失败
  26. [root@master ~]# kubectl get pods -n dev
  27. NAME                READY   STATUS    RESTARTS      AGE
  28. pod-liveness-http   1/1     Running   1 (17h ago)   17h
  29. pod-liveness-tcp    1/1     Running   1 (51m ago)   17h
  30. pod-select          0/1     Pending   0             5s
复制代码
2：亲和性调度

上面的问题，就是逼迫性的调度，就是假如没有节点的话，Pod就会调度失败
就是声明一个调度的节点，假如找到了，就调度，否则，找其他的；这个就是亲和性
　　nodeAffinity：node的亲和性，以node为目标，重要就是标签（）
　　podAffinity：pod的亲和性，以pod为目标，就是以正在运行的pod为目标，就是一个web的pod需要和一个mysql的pod在一起，向其中一个打个标签，另外一个就会来找他
　　podAntAffinity：pod的反亲和性，以pod为目标，讨厌和谁在一起，就选择其他的
 
场景的分析：
假如2个应用时频繁交互，那么就有须要利用亲和性让2个应用尽大概的靠近，这样就能淘汰因为网络通信带来的性能消耗了，调度到了pod1上面就都在一个节点上面，通信的性能就消耗淘汰了
 
反亲和性的应用：
当应用的采用多副本摆设时，有须要采用反亲和性让各个应用实列打散分布在各个node上面，这样就能提高服务的高可用性
应用的功能是雷同的，使用反亲和性，都分布在不同的节点上面，高可用性，就是坏了一个节点，其他的节点也能正常的提供工作
参数：
  1. [root@master ~]# kubectl explain pod.spec.affinity.nodeAffinity
  3. requiredDuringSchedulingIgnoredDuringExecution  node节点必须满足的指定的所有规划才可以，相当于硬限制
  4.    nodeSelectorTerms：节点选择列表
  5.        matchFields：按节点字段列出的节点选择器要求列表
  6.        matchExpressions  按节点标签列出的节点选择器要求列表（标签）
  7.          key：
  8.          vaules：
  9.          operator：关系符，支持in, not exists
  11. 如果有符合的条件，就调度，没有符合的条件就调度失败
  13. preferredDuringSchedulingIgnoredDuringExecution         <NodeSelector>  软限制，优先找这些满足的节点
  14.     preference    一个节点选择器，以相应的权重相关联
  15.             matchFields：按节点字段列出的节点选择器要求列表
  16.             matchExpressions  按节点标签列出的节点选择器要求列表  
  17.                  key：键
  18.                  vaules：
  19.                  operator：
  20.     weight：倾向权重，1~100  ##就是倾向调度   
  23. 如果找不到的话，就从其他的节点调度上去
  25. 关系符
  26. - key：nodedev   匹配存在标签的key为noddev的节点
  27.     operator: exists  
  28. - key:  nodedev   匹配标签的key为nodedev，且vaule是xxx或者yyy的节点
  29.    operator：in
  30.    vaules：['xxx','yyy']   
复制代码
　　
1、nodeAffinity

node的亲和性，2大类，硬限定，软限定，节点上面的标签作为选择
  1. [root@master ~]# cat pod-aff-re.yaml
  2. apiVersion: v1
  3. kind: Pod
  4. metadata:
  5.    name: pod-aff
  6.    namespace: dev
  7. spec:
  8.    containers:
  9.    - name: main-container
  10.      image: nginx:1.17.1
  11.    affinity:
  12.        nodeAffinity:   ##亲和性设置
  13.           requiredDuringSchedulingIgnoredDuringExecution:  #设置node亲和性，硬限制
  14.              nodeSelectorTerms:     
  15.                   matchExpressions:     匹配nodeenv的值在[xxx,yyy]中的标签
  16.                     - key: nodeenv
  17.                       operator: In
  18.                       vaules: ["xxx","yyy"]
  19. [root@master ~]# kubectl create -f pod-aff-re.yaml
  20. pod/pod-aff created
  21. [root@master ~]# kubectl get pod -n dev
  22. NAME                READY   STATUS    RESTARTS      AGE
  23. pod-aff             0/1     Pending   0             23s
  24. pod-liveness-http   1/1     Running   1 (17h ago)   18h
  25. pod-liveness-tcp    1/1     Running   1 (94m ago)   18h
  26. pod-select          0/1     Pending   0             43m
  28. #调度失败
  30. #值改为pro，就能在node1上面调度了
  31. [root@master ~]# kubectl create -f pod-aff-re.yaml
  32. pod/pod-aff created
  33. [root@master ~]# kubectl get pods -n dev
  34. NAME                READY   STATUS    RESTARTS      AGE
  35. pod-aff             1/1     Running   0             5s
  36. pod-liveness-http   1/1     Running   1 (17h ago)   18h
  37. pod-liveness-tcp    1/1     Running   1 (96m ago)   18h
  38. pod-select          0/1     Pending   0             45m
复制代码
　　
软限定
  1. #软限制
  2. [root@master ~]# cat pod-aff-re.yaml
  3. apiVersion: v1
  4. kind: Pod
  5. metadata:
  6.    name: pod-aff
  7.    namespace: dev
  8. spec:
  9.    containers:
  10.    - name: main-container
  11.      image: nginx:1.17.1
  12.    affinity:
  13.      nodeAffinity:
  14.        preferredDuringSchedulingIgnoredDuringExecution:   #软限制
  15.        - weight: 1   
  16.          preference:
  17.             matchExpressions:
  18.             - key: nodeenv
  19.               operator: In
  20.               values: ["xxx","yyy"]
  22. #直接调度在node2上面了
  23. [root@master ~]# kubectl get pods -n dev -o wide
  24. NAME                READY   STATUS    RESTARTS       AGE   IP           NODE     NOMINATED NODE   READINESS GATES
  25. pod-aff             1/1     Running   0              41s   10.244.1.9   node2    <none>           <none>
  26. pod-liveness-http   1/1     Running   1 (17h ago)    18h   10.244.2.8   node1    <none>           <none>
  27. pod-liveness-tcp    1/1     Running   1 (102m ago)   18h   10.244.1.7   node2    <none>           <none>
  28. pod-select          0/1     Pending   0              50m   <none>       <none>   <none>           <none>
复制代码
 
注意：
  1. 如果同时定义了nodeSelector和nodeAffinity，那么必须满足这2个条件，pod才能在指定的node上面运行
  2. 如果nodeaffinity指定了多个nodeSelectorTerms，那么只要有一个能够匹配成功即可
  3. 如果一个nodeSelectorTerms中有多个matchExpressions，则一个节点必须满足所有的才能匹配成功
  4. 如果一个Pod所在node在pod运行期间标签发生了改变，不符合该pod的节点亲和性需求，则系统将忽略此变化
复制代码
 这个调度就是只在调度的时候见效，所以的话，就是假如调度成功后，标签发生了变化，不会对这个pod进行什么样的变化
2、podAffinitly

就是以正在运行的pod为参照，硬限定和软限定
  1. kubectl explain pod.spec.affinity.podAffinity
  3. requiredDuringSchedulingIgnoredDuringExecution   硬限制
  4.     namespace：指定参照pod的名称空间，如果不指定的话，默认的参照物pod就跟pod一眼的
  5.     topologkey：调度的作用域，靠近到节点上，还是网段上面，操作系统了
  6.                         ###hostname的话，就是以node节点为区分的范围，调度到node1的节点上面
  7.                                 os的话，就是以操作系统为区分的，调度到跟pod1操作系统上一样的
  8.      labeSelector：标签选择器
  9.           matchExpressions： 按节点列出的节点选择器要求列表
  10.                key:
  11.                vaules:
  12.                operator:
  13.           matchLbales:   指多个matchExpressions映射的内容
  14. preferredDuringSchedulingIgnoredDuringExecution  软限制
  15.     namespace：指定参照pod的名称空间，如果不指定的话，默认的参照物pod就跟pod一眼的
  16.     topologkey：调度的作用域，靠近到节点上，还是网段上面，操作系统了
  17.                         ###hostname的话，就是以node节点为区分的范围，调度到node1的节点上面
  18.                                 os的话，就是以操作系统为区分的，调度到跟pod1操作系统上一样的
  19.      labeSelector：标签选择器
  20.           matchExpressions： 按节点列出的节点选择器要求列表
  21.                key:
  22.                vaules:
  23.                operator:
  24.           matchLbales:   指多个matchExpressions映射的内容
  25.     weight：倾向权重1~100
复制代码
 
案例：
软亲和性：
  1. apiVersion: v1
  2. kind: Pod
  3. metadata:   #元数据的信息
  4.    name: pods-1   #pod的名字
  5.    namespace: dev   #名称空间
  6. spec:   
  7.   containers:   #容器
  8.     - name: my-tomcat   #镜像的名字
  9.       image: tomcat    #拉取的镜像
  10.       imagePullPolicy: IfNotPresent   #策略为远程和本地都有
  11.   affinity:
  12.      podAffinity:   #pod的亲和性
  13.        preferredDuringSchedulingIgnoredDuringExecution:   #软限制
  14.        - weight: 1    #权重为1
  15.          podAffinityTerm:    #定义了具体的pod亲和性的条件
  16.           labelSelector:    #标签选择器
  17.              matchExpressions:   #一个或者多个标签匹配式
  18.                  - key: user   #标签的键
  19.                    operator: In   
  20.                    values:    #标签的值
  21.                       - "qqqq"
  22.           topologyKey: kubernetes.io/hostname   #按照主机进行区分
  25. 就是这个pod会被调度到节点上面有pod，并且标签为user=qqqq这个节点上面去
复制代码
 
硬亲和性：
  1. apiVersion: v1
  2. kind: Pod
  3. metadata:
  4.    name: pod-5
  5.    namespace: dev
  6. spec:
  7.   containers:
  8.     - name: my-tomcat
  9.       image: tomcat
  10.       imagePullPolicy: IfNotPresent
  11.   affinity:
  12.      podAffinity:
  13.        requiredDuringSchedulingIgnoredDuringExecution:  #软限制
  14.          - labelSelector:   #标签选择器
  15.              matchExpressions:    #匹配列表
  16.                  - key: user   
  17.                    operator: In
  18.                    values: ["qqqq"]   
  19.            topologyKey: kubernetes.io/hostname    #按照主机来进行划分
复制代码
　　
　　
3、反亲和性

就是不在这个pod上面进行调度，在另外的一个pod上面进行调度即可
案例：
  1. [root@master mnt]# cat podaff.yaml
  2. apiVersion: v1
  3. kind: Pod
  4. metadata:
  5.    name: podaff
  6.    namespace: dev
  7. spec:
  8.    containers:
  9.    - name: main-container
  10.      image: nginx:1.17.1
  11.    affinity:
  12.      podAntiAffinity:
  13.        requiredDuringSchedulingIgnoredDuringExecution:
  14.        - labelSelector:
  15.            matchExpressions:
  16.            - key: podenv
  17.              operator: In
  18.              values: ["pro"]
  19.          topologyKey: kubernets.io/hostname
  21. 发现在node2节点上面创建了
  22. [root@master mnt]# kubectl get pods -n dev -o wide
  23. NAME         READY   STATUS    RESTARTS   AGE     IP            NODE    NOMINATED NODE   READINESS GATES
  24. pod-podaff   1/1     Running   0          61m     10.244.2.14   node1   <none>           <none>
  25. podaff       1/1     Running   0          2m57s   10.244.1.12   node2   <none>           <none>
复制代码
 3：污点（taints）

 前面都是站在pod的角度上面来进行配置的属性，那么就是可以站在node的节点上面，是否答应这些pod调度过来，这些在node上面的信息就是被称为了污点
就是一个拒绝的策略
污点作用：
　　可以将拒绝Pod调度过来
　　乃至还可以将已经存在的pod赶出去
污点的格式：
key=value：effect
key和value：是污点的标签，effect描述污点的作用
effect三种的选项为：
　　PreferNoSchedule：k8s尽量避免把Pod调度到具有该污点的node上面，除非没有其他的节点可以调度了
　　NoSchedule：k8s不会把pod调度到该具有污点node上面，但不会影响当前node上已经存在的pod
　　NoExecue：k8s将不会把Pod调度该具有污点的node上面，同时也会将node已经存在的Pod驱离，一个pod也没有了

 设置污点：
  1. #设置污点
  2. [root@master mnt]# kubectl taint  nodes node1 key=vaule:effect
  4. #去除污点
  5. [root@master mnt]# kubectl taint  nodes node1 key：effect-
  7. #去除所有的污点
  8. [root@master mnt]# kubectl taint  nodes node1 key-
复制代码
　　
案例：
  1. 准备节点node1，先暂时停止node2节点
  2. 为node1节点一个污点，tag=heima:PreferNoSchedule;  然后创建pod1
  3. 修改node1节点设置一个污点；tag=heima:NoSchedule： 然后创建pod2，不在接收新的pod，原来的也不会离开
  4. 修改node1节点设置一个污点；tag=heima:NoExecute;然后创建pod3，pod3也不会被创建，都没有了pod了
  6. #关掉node2节点即可
  8. #设置node1污点
  9. [root@master mnt]# kubectl taint  nodes node1 tag=heima:PreferNoSchedule
  10. node/node1 tainted
  11. #查看污点
  12. [root@master mnt]# kubectl describe  nodes -n dev node1| grep heima
  13. Taints:             tag=heima:PreferNoSchedule
  15. #第一个pod可以进行运行
  16. [root@master mnt]# kubectl run taint1 --image=nginx:1.17.1 -n dev
  17. pod/taint1 created
  18. [root@master mnt]# kubectl  get pods -n dev
  19. NAME         READY   STATUS        RESTARTS   AGE
  20. pod-podaff   1/1     Running       0          90m
  21. podaff       1/1     Terminating   0          31m
  22. taint1       1/1     Running       0          6s
  24. #修改node1的污点
  25. [root@master mnt]# kubectl taint  nodes node1 tag=heima:PreferNoSchedule-
  26. node/node1 untainted
  28. [root@master mnt]# kubectl taint  nodes node1 tag=heima:NoSchedule
  29. node/node1 tainted
  31. #第一个正常的运行，第二个运行不了
  32. [root@master mnt]# kubectl run taint2 --image=nginx:1.17.1 -n dev
  33. pod/taint2 created
  34. [root@master mnt]# kubectl get pods -n dev
  35. NAME         READY   STATUS        RESTARTS   AGE
  36. pod-podaff   1/1     Running       0          94m
  37. podaff       1/1     Terminating   0          35m
  38. taint1       1/1     Running       0          3m35s
  39. taint2       0/1     Pending       0          3s
  41. #第三种污点的级别
  42. [root@master mnt]# kubectl taint  nodes node1 tag=heima:NoSchedule-
  43. node/node1 untainted
  44. 设置级别
  45. [root@master mnt]# kubectl taint  nodes node1 tag=heima:NoExecute
  46. node/node1 tainted
  47. #新的pod也会不能创建了
  48. [root@master mnt]# kubectl run taint3 --image=nginx:1.17.1 -n dev
  49. pod/taint3 created
  50. [root@master mnt]# kubectl get pods -n dev
  51. NAME     READY   STATUS        RESTARTS   AGE
  52. podaff   1/1     Terminating   0          39m
  53. taint3   0/1     Pending       0          4s
复制代码
　　
为什么创建pod的时候，不能往master节点上面进行调度了，因为有污点的作用
4、容忍

 容忍就是忽略，node上面有污点,但是pod上面有容忍，进行忽略，可以进行调度

 案例：
  1. apiVersion: v1
  2. kind: Pod
  3. metadata:
  4.    name: pod-aff
  5.    namespace: dev
  6. spec:
  7.    containers:   
  8.    - name: main-container
  9.      image: nginx:1.17.1
  10.    tolerations:     #添加容忍
  11.    - key: "tag"    #要容忍的key
  12.      operator: "Equal"     #操作符
  13.      values: "heima"            #容忍的污点
  14.      effect: "NoExecute"    #添加容忍的规划，这里必须和标记的污点规则相同
  16. #首先创建一个没有容忍的pod，看能不能进行创建
  17. #无法进行创建
  18. [root@master mnt]# kubectl get pods -n dev
  19. NAME      READY   STATUS        RESTARTS   AGE
  20. pod-aff   0/1     Pending       0          6s
  21. podaff    1/1     Terminating   0          55m
  23. #有容忍的创建
  24. [root@master mnt]# kubectl create -f to.yaml
  25. pod/pod-aff created
  26. [root@master mnt]# kubectl get pods -n dev
  27. NAME      READY   STATUS        RESTARTS   AGE
  28. pod-aff   1/1     Running       0          3s
  29. podaff    1/1     Terminating   0          57m
复制代码
　　
容忍的具体信息
  1. Key:对应的容忍的污点的值，空意味着匹配的所有的键
  2. value：对应着容忍的污点的值
  3. operator：key-value的运算符，支持Equal和Exists（默认），对于所有的键进行操作，跟值就没有关系了
  4. effect：对应的污点的effect，空意味着匹配所有的影响
  5. tolerationSeconds    容忍的时间，当effect为NoExecute时生效，表示pod在node上停留的时间
复制代码
　　
 四：pod控制器

1、pod的控制器的介绍

1：pod的分类：

　　自主式pod,k8s直接创建出来的pod，这种pod删除后就没有了。也不会重建
　　控制器创建的pod，通过控制器创建的Pod，这种pod删除后，还会自动重建
作用：
 pod控制器管理pod的中间层，使用了pod控制器后，我们需要告诉pod控制器，想要多少个pod即可，他会创建满足条件的pod并确保pod处于用户期望的状态，假如pod运行中出现了故障，控制器会基于策略重启大概重建pod
 
2：控制器范例


replicaSet：保证指定命量的pod运行支持数量变更
deployment：通过控制replicaSet来控制pod，支持滚动升级，版本回退的功能
horizontal pod autoscaler：可以根据集群负载均衡自动调整pod的数量
 
 2：控制器的具体介绍

replicaSet（rs）

：创建的数量的Pod能够正常的运行，会持续监听pod的运行状态
支持对pod数量的扩容缩容，

案例：副本数量
  1. apiVersion: apps/v1
  2. kind: ReplicaSet
  3. metadata:
  4.   name: pc-replicaset   #pod控制器的名字
  5.   namespace: dev  
  6. spec:
  7.    replicas: 3   #创建的pod的数量，
  8.    selector:   #pod标签选择器规则，选择app=nginx-pod的pod的标签用来进行管理，用来管理pod上面有相同的标签
  9.      matchLabels:    #标签选择器规则
  10.       app: nginx-pod  
  11.    template:   副本，也就是创建pod的模版
  12.      metadata:    #pod元数据的信息
  13.        labels:    #pod上面的标签
  14.          app: nginx-pod   
  15.      spec:   
  16.        containers:   #容器里面的名字
  17.          - name: nginx   
  18.            image: nginx:1.17.1  
  21. #查看控制器
  22. [root@master ~]# kubectl get rs -n dev
  23. NAME            DESIRED   CURRENT   READY   AGE
  24. pc-replicaset   3         3         3       70s
  25. RESIRED 期望的pod数量
  26. CURRENT：当前有几个
  27. READY:准备好提供服务的有多少
  29. #查看pod
  30. [root@master ~]# kubectl get rs,pods -n dev
  31. NAME                            DESIRED   CURRENT   READY   AGE
  32. replicaset.apps/pc-replicaset   3         3         3       2m31s
  34. NAME                      READY   STATUS    RESTARTS      AGE
  35. pod/pc-replicaset-448tq   1/1     Running   0             2m31s
  36. pod/pc-replicaset-9tdhd   1/1     Running   0             2m31s
  37. pod/pc-replicaset-9z64w   1/1     Running   0             2m31s
  38. pod/pod-pod-affinity      1/1     Running   1 (47m ago)   12h　　
复制代码
案例2：实现扩缩容的pod
  1. #编辑yaml文件 edit
  2. [root@master ~]# kubectl edit rs -n dev pc-replicaset
  3. replicaset.apps/pc-replicaset edited
  4. [root@master ~]# kubectl get pods -n dev
  5. NAME                  READY   STATUS    RESTARTS      AGE
  6. pc-replicaset-448tq   1/1     Running   0             10m
  7. pc-replicaset-9tdhd   1/1     Running   0             10m
  8. pc-replicaset-9z64w   1/1     Running   0             10m
  9. pc-replicaset-q6ps9   1/1     Running   0             94s
  10. pc-replicaset-w5krn   1/1     Running   0             94s
  11. pc-replicaset-zx8gw   1/1     Running   0             94s
  12. pod-pod-affinity      1/1     Running   1 (55m ago)   12h
  13. [root@master ~]# kubectl get rs -n dev
  14. NAME            DESIRED   CURRENT   READY   AGE
  15. pc-replicaset   6         6         6       10m
  18. #第二种方式
  19. [root@master ~]# kubectl scale  rs -n dev pc-replicaset --replicas=2 -n dev
  20. replicaset.apps/pc-replicaset scaled
  21. [root@master ~]# kubectl get rs,pod -n dev
  22. NAME                            DESIRED   CURRENT   READY   AGE
  23. replicaset.apps/pc-replicaset   2         2         2       12m
  25. NAME                      READY   STATUS    RESTARTS      AGE
  26. pod/pc-replicaset-448tq   1/1     Running   0             12m
  27. pod/pc-replicaset-9tdhd   1/1     Running   0             12m
  28. pod/pod-pod-affinity      1/1     Running   1 (57m ago)   12h
复制代码
 
案例3、镜像的版本的升级
  1. #编辑镜像的版本
  2. [root@master ~]# kubectl edit rs -n dev pc-replicaset
  3. replicaset.apps/pc-replicaset edited
  4. [root@master ~]# kubectl get rs -n dev pc-replicaset -o wide
  5. NAME            DESIRED   CURRENT   READY   AGE   CONTAINERS   IMAGES         SELECTOR
  6. pc-replicaset   2         2         2       15m   nginx        nginx:1.17.2   app=nginx-pod
  8. #命令来进行编辑，但是一般使用edit来进行编辑即可
  9. [root@master ~]# kubectl get rs -n dev -o wide
  10. NAME            DESIRED   CURRENT   READY   AGE   CONTAINERS   IMAGES         SELECTOR
  11. pc-replicaset   2         2         2       17m   nginx        nginx:1.17.1   app=nginx-pod
复制代码
　　
案例4、删除replicaSet
就是先删除pod再来删除控制器
  1. #文件来进行删除
  2. root@master ~]# kubectl delete -f replicas.yaml
  3. replicaset.apps "pc-replicaset" deleted
  4. [root@master ~]# kubectl get rs -n dev
  5. No resources found in dev namespace.
  7. #命令来进行删除
  8. [root@master ~]# kubectl delete rs -n dev pc-replicaset
  9. replicaset.apps "pc-replicaset" deleted
  10. [root@master ~]# kubectl get rs -n dev
  11. No resources found in dev namespace.　　
复制代码
deployment（deploy）　　


支持全部的RS的功能
 
 
保留汗青的版本，就是可以进行回退版本
滚动更新的策略
 更新策略：
案例：创建deployment
  1. [root@master ~]# cat deploy.yaml
  2. apiVersion: apps/v1
  3. kind: Deployment
  4. metadata:
  5.    name: pc-deployment
  6.    namespace: dev
  7. spec:
  8.    replicas: 3
  9.    selector:
  10.       matchLabels:
  11.        app: nginx-pod
  12.    template:
  13.       metadata:
  14.          labels:
  15.            app: nginx-pod
  16.       spec:
  17.         containers:
  18.         - name: nginx
  19.           image: nginx:1.17.1
  20. [root@master ~]# kubectl get deploy -n dev
  21. NAME            READY   UP-TO-DATE   AVAILABLE   AGE
  22. pc-deployment   3/3     3            3           53s
  24. update：最新版本的pod数量
  25. available：当前可用的pod的数量
  27. #所以也会创建一个rs出来
  28. [root@master ~]# kubectl get rs -n dev
  29. NAME                       DESIRED   CURRENT   READY   AGE
  30. pc-deployment-6cb555c765   3         3         3       2m9s　　
复制代码
扩缩容：

基本上和之前的一样的操作
  1. #命令来进行编辑
  2. [root@master ~]# kubectl scale deployment -n dev pc-deployment --replicas=5
  3. deployment.apps/pc-deployment scaled
  4. [root@master ~]# kubectl get pods -n dev
  5. NAME                             READY   STATUS    RESTARTS      AGE
  6. pc-deployment-6cb555c765-8qc9g   1/1     Running   0             4m52s
  7. pc-deployment-6cb555c765-8xss6   1/1     Running   0             4m52s
  8. pc-deployment-6cb555c765-m7wdf   1/1     Running   0             4s
  9. pc-deployment-6cb555c765-plkbf   1/1     Running   0             4m52s
  10. pc-deployment-6cb555c765-qh6gk   1/1     Running   0             4s
  11. pod-pod-affinity                 1/1     Running   1 (81m ago)   13h
  13. #编辑文件
  14. [root@master ~]# kubectl edit deployments.apps -n dev pc-deployment
  15. deployment.apps/pc-deployment edited
  16. [root@master ~]# kubectl get pods -n dev
  17. NAME                             READY   STATUS    RESTARTS      AGE
  18. pc-deployment-6cb555c765-8qc9g   1/1     Running   0             5m41s
  19. pc-deployment-6cb555c765-8xss6   1/1     Running   0             5m41s
  20. pc-deployment-6cb555c765-plkbf   1/1     Running   0             5m41s
  21. pod-pod-affinity                 1/1     Running   1 (82m ago)   13h
复制代码
　
镜像更新

分为重建更新，滚动更新
重建更新：
一次性删除全部的来老版本的pod，然后再来创建新版本的pod
滚动更新：（默认）
先删除一部分的内容，进行更新，老的版本越来越少，新的版本越来越多

 
  1. #重建策略
  2. #先创建pod，实时观看
  3. [root@master ~]# cat deploy.yaml
  4. apiVersion: apps/v1
  5. kind: Deployment
  6. metadata:
  7.    name: pc-deployment
  8.    namespace: dev
  9. spec:
  10.    strategy:
  11.      type: Recreate
  12.    replicas: 3
  13.    selector:
  14.       matchLabels:
  15.        app: nginx-pod
  16.    template:
  17.       metadata:
  18.          labels:
  19.            app: nginx-pod
  20.       spec:
  21.         containers:
  22.         - name: nginx
  23.           image: nginx:1.17.1
  25. [root@master ~]# kubectl get pods -n dev -w
  27. #然后更新镜像的版本
  28. [root@master ~]# kubectl set image deploy pc-deployment nginx=nginx:1.17.2 -n dev
  30. #查看
  31. pc-deployment-6cb555c765-m92t8   0/1     Terminating   0             60s
  32. pc-deployment-6cb555c765-m92t8   0/1     Terminating   0             60s
  33. pc-deployment-6cb555c765-m92t8   0/1     Terminating   0             60s
  34. pc-deployment-5967bb44bb-bbkzz   0/1     Pending       0             0s
  35. pc-deployment-5967bb44bb-bbkzz   0/1     Pending       0             0s
  36. pc-deployment-5967bb44bb-kxrn5   0/1     Pending       0             0s
  37. pc-deployment-5967bb44bb-zxfwl   0/1     Pending       0             0s
  38. pc-deployment-5967bb44bb-kxrn5   0/1     Pending       0             0s
  39. pc-deployment-5967bb44bb-zxfwl   0/1     Pending       0             0s
  40. pc-deployment-5967bb44bb-bbkzz   0/1     ContainerCreating   0             0s
  41. pc-deployment-5967bb44bb-kxrn5   0/1     ContainerCreating   0             0s
  42. pc-deployment-5967bb44bb-zxfwl   0/1     ContainerCreating   0             0s
  43. pc-deployment-5967bb44bb-kxrn5   1/1     Running             0             1s
复制代码
　　
滚动更新：
  1. [root@master ~]# cat deploy.yaml
  2. apiVersion: apps/v1
  3. kind: Deployment
  4. metadata:
  5.    name: pc-deployment
  6.    namespace: dev
  7. spec:
  8.    strategy:
  9.      type: RollingUpdate
  10.      rollingUpdate:
  11.         maxUnavailable: 25%
  12.         maxSurge: 25%
  13.    replicas: 3
  14.    selector:
  15.       matchLabels:
  16.        app: nginx-pod
  17.    template:
  18.       metadata:
  19.          labels:
  20.            app: nginx-pod
  21.       spec:
  22.         containers:
  23.         - name: nginx
  24.           image: nginx:1.17.1
  26. #更新
  27. [root@master ~]# kubectl set image deploy pc-deployment nginx=nginx:1.17.3 -n dev
  28. deployment.apps/pc-deployment image updated
  30. #就会更新
  31. [root@master ~]# kubectl set image deploy pc-deployment nginx=nginx:1.17.3 -n dev
  32. deployment.apps/pc-deployment image updated
复制代码
 

 
总结：
镜像版本更新的话，会先创建一个新的RS，老RS也会存在，pod会在新的RS里面，老RS就会删除一个，到末了老的rs里面没有了pod，新的rs里面就会有pod了
留这个老的rs的作用的话，就是版本回退作用
 
版本回退：


 
undo回滚到上一个版本
  1. #记录整个更新的deployment过程
  2. [root@master ~]# kubectl create -f deploy.yaml --record
  3. Flag --record has been deprecated, --record will be removed in the future
  4. deployment.apps/pc-deployment created
  5. #更新版本就会有历史记录
  6. [root@master ~]# kubectl edit deployments.apps  -n dev pc-deployment
  7. deployment.apps/pc-deployment edited
  9. [root@master ~]# kubectl rollout history deployment -n dev pc-deployment
  10. deployment.apps/pc-deployment
  11. REVISION  CHANGE-CAUSE
  12. 1         kubectl create --filename=deploy.yaml --record=true
  13. 2         kubectl create --filename=deploy.yaml --record=true
  14. 3         kubectl create --filename=deploy.yaml --record=true
  16. #直接回退到到指定的版本，如果不指定的话，默认是上一个版本
  18. [root@master ~]# kubectl rollout undo deployment  -n dev  pc-deployment --to-revision=1
  19. deployment.apps/pc-deployment rolled back   
  20. #rs也发生了变化，pod回到了老的rs里面了
  21. [root@master ~]# kubectl get rs -n dev
  22. NAME                       DESIRED   CURRENT   READY   AGE
  23. pc-deployment-5967bb44bb   0         0         0       4m11s
  24. pc-deployment-6478867647   0         0         0       3m38s
  25. pc-deployment-6cb555c765   3         3         3       5m28s
  26. [root@master ~]# kubectl rollout  history deployment -n dev
  27. deployment.apps/pc-deployment
  28. REVISION  CHANGE-CAUSE
  29. 2         kubectl create --filename=deploy.yaml --record=true
  30. 3         kubectl create --filename=deploy.yaml --record=true
  31. 4         kubectl create --filename=deploy.yaml --record=true   #这个就相当于是1了
复制代码
　　　
金丝雀发布：
deployment支持更新过程中的控制，停息，继续更新操作
就是在更新的过程中，仅存在一部分的更新的应用，主机部分是一些旧的版本，将这些请求发送到新的应用上面，不能吸取请求就赶紧回退，能担当请求，就继续更新，这个就被称为金丝雀发布
  1. #更新，并且立刻暂停
  2. [root@master ~]# kubectl set image deploy pc-deployment nginx=nginx:1.17.2 -n dev && kubectl rollout pause deployment  -n dev pc-deployment
  3. deployment.apps/pc-deployment image updated
  4. deployment.apps/pc-deployment paused
  6. #rs的变化
  7. [root@master ~]# kubectl get rs -n dev
  8. NAME                       DESIRED   CURRENT   READY   AGE
  9. pc-deployment-5967bb44bb   1         1         1       21m
  10. pc-deployment-6478867647   0         0         0       20m
  11. pc-deployment-6cb555c765   3         3         3       22m
  13. #有一个已经更新完毕了
  14. [root@master ~]# kubectl rollout  status  deployment  -n dev
  15. Waiting for deployment "pc-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
  17. #发送一个请求
  19. #继续更新
  20. [root@master ~]# kubectl rollout  resume deployment  -n dev pc-deployment
  21. deployment.apps/pc-deployment resumed
  23. #查看状态
  24. [root@master ~]# kubectl rollout  status  deployment  -n dev
  25. Waiting for deployment "pc-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
  26. Waiting for deployment spec update to be observed...
  27. Waiting for deployment spec update to be observed...
  28. Waiting for deployment "pc-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
  29. Waiting for deployment "pc-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
  30. Waiting for deployment "pc-deployment" rollout to finish: 2 out of 3 new replicas have been updated...
  31. Waiting for deployment "pc-deployment" rollout to finish: 2 out of 3 new replicas have been updated...
  32. Waiting for deployment "pc-deployment" rollout to finish: 1 old replicas are pending termination...
  33. Waiting for deployment "pc-deployment" rollout to finish: 1 old replicas are pending termination...
  34. deployment "pc-deployment" successfully rolled out
  36. #查看rs
  37. [root@master ~]# kubectl get rs -n dev
  38. NAME                       DESIRED   CURRENT   READY   AGE
  39. pc-deployment-5967bb44bb   3         3         3       24m
  40. pc-deployment-6478867647   0         0         0       24m
  41. pc-deployment-6cb555c765   0         0         0       26m　　
复制代码
 hpa控制器


 

 
总的来说就是，就是获取每个pod的利用率，与pod上面的hpa界说的指标进行比力，假如大于的话，就直接自动的增长pod，当访问量淘汰了话，会删除增长的pod
通过监控pod负载均衡的环境，实现pod数量的扩缩容
安装一个软件，拿到pod的负载
metries-server可以用来网络集群中的资源使用环境。pod。node都可以以进行监控
  1. # 下载最新版配置软件包
  2. wget https://github.com/kubernetes-sigs/metrics-server/releases/download/v0.6.3/components.yaml
  4. #到每台服务器上系在阿里云版本的相关版本
  5. ctr image pull registry.cn-hangzhou.aliyuncs.com/google_containers/metrics-server:v0.6.3
  7. #修改配置文件
  8. containers:
  9. - args:
  10.   - --cert-dir=/tmp
  11.   - --secure-port=4443
  12.   - --kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname
  13.   - --kubelet-use-node-status-port
  14.   - --metric-resolution=15s
  15.   - --kubelet-insecure-tls  #增加证书忽略
  16.   image: registry.cn-hangzhou.aliyuncs.com/google_containers/metrics-server:v0.6.3 #修改image为阿里云下载的这个
  18. #应用下配置文件
  19. kubectl apply -f   components.yaml
  21. #查看执行结果
  22. [root@master ~]# kubectl get pod -n kube-system
  23. NAME                              READY   STATUS    RESTARTS       AGE
  24. coredns-66f779496c-88c5b          1/1     Running   33 (55m ago)   10d
  25. coredns-66f779496c-hcpp5          1/1     Running   33 (55m ago)   10d
  26. etcd-master                       1/1     Running   14 (55m ago)   10d
  27. kube-apiserver-master             1/1     Running   14 (55m ago)   10d
  28. kube-controller-manager-master    1/1     Running   14 (55m ago)   10d
  29. kube-proxy-95x52                  1/1     Running   14 (55m ago)   10d
  30. kube-proxy-h2qrf                  1/1     Running   14 (55m ago)   10d
  31. kube-proxy-lh446                  1/1     Running   15 (55m ago)   10d
  32. kube-scheduler-master             1/1     Running   14 (55m ago)   10d
  33. metrics-server-6779c94dff-dflh2   1/1     Running   0              2m6s
复制代码
 
查察资源的使用环境
  1. #查看node的使用情况信息
  2. [root@master ~]# kubectl top nodes
  3. NAME     CPU(cores)   CPU%   MEMORY(bytes)   MEMORY%   
  4. master   104m         5%     1099Mi          58%      
  5. node1    21m          1%     335Mi           17%      
  6. node2    22m          1%     305Mi           16%      
  7. #查看pod的使用情况
  8. [root@master ~]# kubectl top pods -n dev
  9. NAME        CPU(cores)   MEMORY(bytes)   
  10. pod-aff     3m           83Mi            
  11. pod-label   0m           1Mi   　　
复制代码
 
实现这个hpa的操作，就是pod上面要有资源的限定才可以，
然后使用下令即可

 
测试：
 
  1. [root@master ~]# cat deploy.yaml
  2. apiVersion: apps/v1
  3. kind: Deployment
  4. metadata:
  5.    name: nginx
  6.    namespace: dev
  7. spec:
  8.    replicas: 1   #一个副本数量
  9.    selector:
  10.       matchLabels:
  11.        app: nginx-pod    #标签选择器
  12.    template:
  13.       metadata:
  14.          labels:
  15.            app: nginx-pod
  16.       spec:
  17.         containers:
  18.         - name: nginx
  19.           image: nginx:1.17.1
  20.           resources:
  21.              requests:
  22.                cpu: 100m   #最少需要100毫核才能启动
  25. #创建deployment
  26. kubectl create  -f deploy.yaml
  27. #创建service
  28. kubectl expose deployment  nginx --type=NodePort --port=80 -n dev
  30. #创建一个hpa
  31. [root@master ~]# cat hpa.yaml
  32. apiVersion: autoscaling/v1
  33. kind: HorizontalPodAutoscaler
  34. metadata:
  35.    name: pc-hpa
  36.    namespace: dev
  37. spec:
  38.    minReplicas: 1
  39.    maxReplicas: 10
  40.    targetCPUUtilizationPercentage: 3   #cpu的指标为%3，方便测试用的
  41.    scaleTargetRef:  #选择的控制器
  42.       apiVersion: apps/v1
  43.       kind: Deployment   #deploy控制器
  44.       name: nginx
  47. #查看hpa控制器
  48. [root@master ~]# kubectl get hpa -n dev
  49. NAME     REFERENCE          TARGETS        MINPODS   MAXPODS   REPLICAS   AGE
  50. pc-hpa   Deployment/nginx   <unknown>/3%   1         10        0          5s
  51. [root@master ~]# kubectl get hpa -n dev
  52. NAME     REFERENCE          TARGETS   MINPODS   MAXPODS   REPLICAS   AGE
  53. pc-hpa   Deployment/nginx   0%/3%     1         10        1          114s
  56. #进行压力测试，就是超过%3
  57. [root@master ~]# cat f.sh
  58. while `true`:
  59. do
  60.         curl 192.168.109.100:30843 &> /dev/null
  61. done
  63. [root@master ~]# kubectl get hpa -n dev -w
  64. pc-hpa   Deployment/nginx   1%/3%     1         10        1          22m
  65. pc-hpa   Deployment/nginx   0%/3%     1         10        1          22m
  66. pc-hpa   Deployment/nginx   42%/3%    1         10        1          25m
  67. pc-hpa   Deployment/nginx   92%/3%    1         10        4          25m
  68. pc-hpa   Deployment/nginx   23%/3%    1         10        8          25m
  69. pc-hpa   Deployment/nginx   0%/3%     1         10        10         26m
  71. [root@master ~]# kubectl get deployment -n dev -w
  72. NAME    READY   UP-TO-DATE   AVAILABLE   AGE
  73. nginx   1/1     1            1           39m
  74. nginx   1/4     1            1           60m
  75. nginx   1/4     1            1           60m
  76. nginx   1/4     1            1           60m
  77. nginx   1/4     4            1           60m
  78. nginx   2/4     4            2           60m
  79. nginx   3/4     4            3           60m
  80. nginx   4/4     4            4           60m
  81. nginx   4/8     4            4           60m
  82. nginx   4/8     4            4           60m
  83. nginx   4/8     4            4           60m
  84. nginx   4/8     8            4           60m
  85. nginx   5/8     8            5           60m
  86. nginx   6/8     8            6           60m
  87. nginx   7/8     8            7           60m
  88. nginx   8/8     8            8           60m
  89. nginx   8/10    8            8           61m
  90. nginx   8/10    8            8           61m
  91. nginx   8/10    8            8           61m
  92. nginx   8/10    10           8           61m
  93. nginx   9/10    10           9           61m
  94. nginx   10/10   10           10          61m
  96. [root@master ~]# kubectl get pod-n dev -w
  97. nginx-7f89875f58-gt67w   0/1     Pending             0          0s
  98. nginx-7f89875f58-gt67w   0/1     Pending             0          0s
  99. nginx-7f89875f58-545rj   0/1     Pending             0          0s
  100. nginx-7f89875f58-gt67w   0/1     ContainerCreating   0          0s
  101. nginx-7f89875f58-545rj   0/1     Pending             0          0s
  102. nginx-7f89875f58-545rj   0/1     ContainerCreating   0          0s
  103. nginx-7f89875f58-545rj   1/1     Running             0          1s
  104. nginx-7f89875f58-gt67w   1/1     Running             0          1s
  106. #当访问量减少的时候，这个pod里面自动的减少，只不过需要一点时间　　
复制代码
daemonset（DS）控制器


 在每个节点上面创建一个副本（并且只能有一个），就是节点级别的，一般用于日志网络，节点监控等
当节点移除的话，自然Pod也就没有了

 
案例：
  1. [root@master ~]# cat daemonset.yaml
  2. apiVersion: apps/v1
  3. kind: DaemonSet
  4. metadata:
  5.    name: daemon
  6.    namespace: dev
  7. spec:
  8.    selector:
  9.       matchLabels:
  10.         app: nginx-pod
  11.    template:
  12.         metadata:
  13.           labels:
  14.              app: nginx-pod
  15.         spec:
  16.           containers:
  17.           - name: nginx
  18.             image: nginx:1.17.1
  20. [root@master ~]# kubectl get pod -n dev -o wide
  21. NAME                     READY   STATUS    RESTARTS   AGE     IP             NODE    NOMINATED NODE   READINESS GATES
  22. daemon-g8b4v             1/1     Running   0          2m30s   10.244.1.102   node2   <none>           <none>
  23. daemon-t5tmd             1/1     Running   0          2m30s   10.244.2.89    node1   <none>           <none>
  24. nginx-7f89875f58-prf9c   1/1     Running   0          79m     10.244.2.84    node1   <none>           <none>
  26. #每个副本上面都有一个pod
复制代码
　　
job控制器


 批量处置惩罚（依次处置惩罚指定命量的任务），一次性任务（每个任务仅运行一次就结束）
由job创建的pod实行成功时，job会记载成功结束的Pod数量
当成功结束的pod达到指定的数量时，job将完成实行
里面的job都是存放的一次性文件

重启策略：在这里不能设置为always,因为这个是一次性任务，结束了，都要进行重启
只能设置为onfailure和never才行
onfailure：pod出现故障时，重启容器，不是创建pod,failed次数不变
never：出现故障，并且故障的pod不会消散也不会重启，failed次数=1
 
案例：
  1. [root@master ~]# cat jod.yaml
  2. apiVersion: batch/v1
  3. kind: Job
  4. metadata:
  5.    name: pc-job
  6.    namespace: dev
  7. spec:
  8.    manualSelector: true
  9.    completions: 6  #一次性创建6个pod
  10.    parallelism: 3   #允许三个一起执行，2轮就结束了
  11.    selector:
  12.       matchLabels:
  13.         app: counter-pod
  14.    template:
  15.         metadata:
  16.           labels:
  17.              app: counter-pod
  18.         spec:
  19.           restartPolicy: Never
  20.           containers:
  21.           - name: busybox
  22.             image: busybox:1.30
  23.             command: ["/bin/sh","-c","for i in 1 2 3 4 5 6 7 8 9;do echo $i;sleep 3;done"]
  25. [root@master ~]# kubectl get job -n dev -w
  26. NAME     COMPLETIONS   DURATION   AGE
  27. pc-job   0/6                      0s
  28. pc-job   0/6           0s         0s
  29. pc-job   0/6           2s         2s
  30. pc-job   0/6           29s        29s
  31. pc-job   0/6           30s        30s
  32. pc-job   3/6           30s        30s
  33. pc-job   3/6           31s        31s
  34. pc-job   3/6           32s        32s
  35. pc-job   3/6           59s        59s
  36. pc-job   3/6           60s        60s
  37. pc-job   6/6           60s        60s
  38. [root@master ~]# kubectl get pod -n dev -w
  39. NAME                     READY   STATUS    RESTARTS   AGE
  40. daemon-g8b4v             1/1     Running   0          20m
  41. daemon-t5tmd             1/1     Running   0          20m
  42. nginx-7f89875f58-prf9c   1/1     Running   0          97m
  43. pc-job-z2gmb             0/1     Pending   0          0s
  44. pc-job-z2gmb             0/1     Pending   0          0s
  45. pc-job-z2gmb             0/1     ContainerCreating   0          0s
  46. pc-job-z2gmb             1/1     Running             0          1s
  47. pc-job-z2gmb             0/1     Completed           0          28s
  48. pc-job-z2gmb             0/1     Completed           0          29s
  49. pc-job-z2gmb             0/1     Completed           0          30s
  50. pc-job-z2gmb             0/1     Completed           0          30s
复制代码
cronjob控制器（cj）


 就是指定时间的周期实行job任务

 
案例：
  1. [root@master ~]# cat cronjob.yaml
  2. apiVersion: batch/v1
  3. kind: CronJob
  4. metadata:
  5.    name: pc-cronjob
  6.    namespace: dev
  7.    labels:
  8.        controller: cronjob
  9. spec:
  10.     schedule: "*/1 * * * *"
  11.     jobTemplate:
  12.         metadata:
  13.           name: pc-cronjob
  14.           labels:
  15.              controller: cronjob
  16.         spec:
  17.           template:
  18.               spec:
  19.                 restartPolicy: Never
  20.                 containers:
  21.                 - name: counter
  22.                   image: busybox:1.30
  23.                   command: ["/bin/sh","-c","for i in 1 2 3 4 5 6 7 8 9;do echo$i;sleep 3;done"]
  25. [root@master ~]# kubectl get job -n dev -w
  26. NAME                  COMPLETIONS   DURATION   AGE
  27. pc-cronjob-28604363   0/1           21s        21s
  28. pc-job                6/6           60s        33m
  29. pc-cronjob-28604363   0/1           28s        28s
  30. pc-cronjob-28604363   0/1           29s        29s
  31. pc-cronjob-28604363   1/1           29s        29s
  32. pc-cronjob-28604364   0/1                      0s
  33. pc-cronjob-28604364   0/1           0s         0s
  34. pc-cronjob-28604364   0/1           1s         1s
  35. pc-cronjob-28604364   0/1           29s        29s
  36. pc-cronjob-28604364   0/1           30s        30s
  37. pc-cronjob-28604364   1/1           30s        30s
  38. ^C[root@master ~]#
  40. [root@master ~]# kubectl get pod -n dev -w
  41. NAME                     READY   STATUS      RESTARTS   AGE
  42. daemon-g8b4v             1/1     Running     0          57m
  43. daemon-t5tmd             1/1     Running     0          57m
  44. nginx-7f89875f58-prf9c   1/1     Running     0          134m
  45. pc-job-2p6p6             0/1     Completed   0          32m
  46. pc-job-62z2d             0/1     Completed   0          32m
  47. pc-job-6sm97             0/1     Completed   0          32m
  48. pc-job-97j4j             0/1     Completed   0          31m
  49. pc-job-lsjz5             0/1     Completed   0          31m
  50. pc-job-pt28s             0/1     Completed   0          31m
  53. [root@master ~]# kubectl get pod -n dev -w
  54. pc-cronjob-28604363-fcnvr   0/1     Pending     0          0s
  55. pc-cronjob-28604363-fcnvr   0/1     Pending     0          0s
  56. pc-cronjob-28604363-fcnvr   0/1     ContainerCreating   0          0s
  57. pc-cronjob-28604363-fcnvr   1/1     Running             0          0s
  58. pc-cronjob-28604363-fcnvr   0/1     Completed           0          27s
  59. pc-cronjob-28604363-fcnvr   0/1     Completed           0          29s
  60. pc-cronjob-28604363-fcnvr   0/1     Completed           0          29s
  62. #就是这个job执行结束后，每隔1分钟再去执行　
复制代码
四：service详解

 流量负载组件service和ingress
serverice用于四层的负载ingress用于七层负载
1、service介绍

 pod有一个ip地址，但是不是固定的，所以的话，service就是一部分的pod的代理，有一个ip地址，可以通过这个地址来进行访问pod
service就是一个标签选择器的机制

 kube-proxy代理

 核心就是kube-proxy机制发生的作用，当创建service时，api-server向etcd存储service相关的信息，kube-proxy监听到发生了变化，就会将service相关的信息转换为访问规则
查察规则

 
kube-proxy支持的三种模式
userspace模式：用户空间模式

 kube-proxy会为每一个service创建一个监听的端口，发给service的ip的请求会被iptables规则重定向到kube-proxy监听的端口上，kube-proxy根据算法选择一个提供服务的pod并建立连接，以将请求转发到pod上
kube-proxy相当于一个负载均衡器的样子
 缺点：效率比力低，进行转发处置惩罚时，增长内核和用户空间
 
iptables模式：

 
当请求来的时候，不经过了kube-proxy了，经过clusterip（规则即可），然后进行轮询（随机）转发到pod上面
缺点：没有负载均衡，一但又问题，用户拿到的就是错误的页面
 
ipvs模式：

 
 
 
 开启ipvs模块
  1. 编辑里面的配置文件为mode为ipvs
  2. [root@master /]# kubectl edit cm kube-proxy -n kube-system
  3. #删除里面的pod,带有标签的
  4. [root@master /]# kubectl delete pod -l k8s-app=kube-proxy -n kube-system
  5. root@master /]# ipvsadm -Ln
  6. IP Virtual Server version 1.2.1 (size=4096)
  7. Prot LocalAddress:Port Scheduler Flags
  8.   -> RemoteAddress:Port           Forward Weight ActiveConn InActConn
  9. TCP  172.17.0.1:30203 rr  轮询的规则，就是将地址转发到这里面去即可
  10.   -> 10.244.2.103:80              Masq    1      0          0         
  11. TCP  192.168.109.100:30203 rr
  12.   -> 10.244.2.103:80              Masq    1      0          0         
  13. TCP  10.96.0.1:443 rr
  14.   -> 192.168.109.100:6443         Masq    1      0          0         
  15. TCP  10.96.0.10:53 rr
  16.   -> 10.244.0.44:53               Masq    1      0          0         
  17.   -> 10.244.0.45:53               Masq    1      0          0         
  18. TCP  10.96.0.10:9153 rr
  19.   -> 10.244.0.44:9153             Masq    1      0          0         
  20.   -> 10.244.0.45:9153             Masq    1      0          0         
  21. TCP  10.100.248.78:80 rr
  22.   -> 10.244.2.103:80              Masq    1      0          0         
  23. TCP  10.110.118.76:443 rr
  24.   -> 10.244.1.108:10250           Masq    1      0          0         
  25.   -> 10.244.2.102:10250           Masq    1      0          0         
  26. TCP  10.244.0.0:30203 rr
复制代码
2：service范例


标签选择器只是一个表象，本质就是规则，通过标签，来进行确定里面的pod的ip
session亲和性，假如不配置的话，请求会将轮询到每一个pod上面，特殊的环境下，将多个请求发送到同一个pod上面，就需要session亲和性 
type：就是service范例
　　ClusterIP：默认值，k8s自动分配的虚拟ip,只能在集群内部访问
　　NodePort：将service通过指定的node上面端口暴露给外部，可以实现集群外面访问服务，节点上面的端口暴露给外部
　　LoadBalancer：使用外接负载均衡器完成到服务的负载分发，注意此模式需要外部云环境
　　ExternalName：把集合外部的服务引入集群内部，直接使用
 
1、环境准备


 
三个pod。deploy控制器来创建，　　
  1. [root@master ~]# cat service-example.yaml
  2. apiVersion: apps/v1
  3. kind: Deployment
  4. metadata:
  5.    name: pc-deployment
  6.    namespace: dev
  7. spec:
  8.    replicas: 3
  9.    selector:
  10.        matchLabels:
  11.           app: nginx-pod
  12.    template:
  13.        metadata:
  14.          labels:
  15.            app: nginx-pod
  16.        spec:
  17.           containers:
  18.           - name: nginx
  19.             image: nginx:1.17.1
  20.             ports:
  21.             - containerPort: 80
  22. [root@master ~]# kubectl get pod -n dev -o wide
  23. NAME                             READY   STATUS    RESTARTS   AGE   IP             NODE    NOMINATED NODE   READINESS GATES
  24. pc-deployment-5cb65f68db-959hm   1/1     Running   0          62s   10.244.2.104   node1   <none>           <none>
  25. pc-deployment-5cb65f68db-h6v8r   1/1     Running   0          62s   10.244.1.110   node2   <none>           <none>
  26. pc-deployment-5cb65f68db-z4k2f   1/1     Running   0          62s   10.244.2.105   node1   <none>           <none>
  27. #访问pod的ip和容器里面的端口
  28. [root@master ~]# curl 10.244.2.104:80
  30. 修改里面的网页文件，观察请求发送到哪一个节点上面去了，依次修改网页文件即可
  31. [root@master ~]# kubectl exec -ti -n dev pc-deployment-5cb65f68db-h6v8r  /bin/bash
  32. root@pc-deployment-5cb65f68db-z4k2f:/# echo 10.244.2.10 > /usr/share/nginx/html/index.html　　
复制代码
 2、ClusterIP范例的service


 service的端口可以随便写
  1. [root@master ~]# cat ClusterIP.yaml
  2. apiVersion: v1
  3. kind: Service
  4. metadata:
  5.    name: service-clusterip
  6.    namespace: dev
  7. spec:
  8.    selector:   #service标签选择器
  9.      app: nginx-pod
  10.    clusterIP: 10.96.0.100   #不写的话，默认生成一个ip地址
  11.    type: ClusterIP
  12.    ports:
  13.    - port: 80  #service端口
  14.      targetPort: 80  #pod的端口
  16. [root@master ~]# kubectl create -f ClusterIP.yaml
  17. service/service-clusterip created
  19. [root@master ~]# kubectl get svc -n dev
  20. NAME                TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)   AGE
  21. service-clusterip   ClusterIP   10.96.0.100   <none>        80/TCP    2m7s
  22. #查看service的详细的信息，
  23. [root@master ~]# kubectl describe svc service-clusterip -n dev
  24. Name:              service-clusterip
  25. Namespace:         dev
  26. Labels:            <none>
  27. Annotations:       <none>
  28. Selector:          app=nginx-pod
  29. Type:              ClusterIP
  30. IP Family Policy:  SingleStack
  31. IP Families:       IPv4
  32. IP:                10.96.0.100
  33. IPs:               10.96.0.100
  34. Port:              <unset>  80/TCP
  35. TargetPort:        80/TCP
  36. Endpoints:         10.244.1.110:80,10.244.2.104:80,10.244.2.105:80   #建立pod和service的关联，主要是标签选择器，里面都是记录的Pod的访问地址，实际端点服务的集合
  37. Session Affinity:  None
  38. Events:            <none>
  39. [root@master ~]# kubectl get pod -n dev -o wide
  40. NAME                             READY   STATUS    RESTARTS   AGE   IP             NODE    NOMINATED NODE   READINESS GATES
  41. pc-deployment-5cb65f68db-959hm   1/1     Running   0          25m   10.244.2.104   node1   <none>           <none>
  42. pc-deployment-5cb65f68db-h6v8r   1/1     Running   0          25m   10.244.1.110   node2   <none>           <none>
  43. pc-deployment-5cb65f68db-z4k2f   1/1     Running   0          25m   10.244.2.105   node1   <none>           <none>
  45. [root@master ~]# kubectl get endpoints -n dev
  46. NAME                ENDPOINTS                                         AGE
  47. service-clusterip   10.244.1.110:80,10.244.2.104:80,10.244.2.105:80   4m48s
  49. 真正起作用的就是kube-proxy，创建service的时，会创建对应的规则
  50. [root@master ~]# ipvsadm -Ln
  51. TCP  10.96.0.100:80 rr
  52.   -> 10.244.1.110:80              Masq    1      0          0         
  53.   -> 10.244.2.104:80              Masq    1      0          0         
  54.   -> 10.244.2.105:80              Masq    1      0          0     
  56. #发送一个请求，测试是谁接收了，循环访问，发现是轮询环的状态
  57. [root@master ~]# while true;do curl 10.96.0.100:80; sleep 5;done;
  58. 10.244.2.105
  59. 10.244.2.104
  60. 10.244.1.110
  61. 10.244.2.105
  62. 10.244.2.104
  63. 10.244.1.110　
复制代码
访问service的ip和主机端口
负载分发策略：（session亲和性）
默认的话，访问就是轮询大概随机
有设置的话，就是多个请求到同一个pod里面上面，就不会轮训大概随机
  1. #设置session亲和性
  2. [root@master ~]# cat ClusterIP.yaml
  3. apiVersion: v1
  4. kind: Service
  5. metadata:
  6.    name: service-clusterip
  7.    namespace: dev
  8. spec:
  9.    sessionAffinity: ClientIP   #就是通过哟个请求到同一个节点上面
  10.    selector:
  11.      app: nginx-pod
  12.    clusterIP: 10.96.0.100
  13.    type: ClusterIP
  14.    ports:
  15.    - port: 80
  16.      targetPort: 80
  18. [root@master ~]# kubectl get svc -n dev
  19. NAME                TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)   AGE
  20. service-clusterip   ClusterIP   10.96.0.100   <none>        80/TCP    78s
  21. [root@master ~]# ipvsadm -Ln
  22. TCP  10.96.0.100:80 rr persistent 10800   持久化
  23.   -> 10.244.1.112:80              Masq    1      0          0         
  24.   -> 10.244.2.107:80              Masq    1      0          0         
  25.   -> 10.244.2.108:80              Masq    1      0          0         
  27. 这种类型的service，只能通过集群节点来进行访问，就是内部进行访问，自己的电脑访问不了这个ip
  28. [root@master ~]# curl 10.96.0.100:80
  29. 10.244.2.108
  30. [root@master ~]# curl 10.96.0.100:80
  31. 10.244.2.108
  32. [root@master ~]# curl 10.96.0.100:80
  33. 10.244.2.108
复制代码
3、headliness范例的service

Cluster范例的service，默认是随机的负载均衡分发策略，希望自己来控制这个策略，使用headliness范例的service，不会分发Clusterip。想要访问service，只能通过service的域名来进行访问
  1. [root@master ~]# cat headliness.yaml
  2. apiVersion: v1
  3. kind: Service
  4. metadata:
  5.    name: service-headliness
  6.    namespace: dev
  7. spec:
  8.    selector:
  9.      app: nginx-pod
  10.    clusterIP: None   #设置为None，就能生成headliness类型的service
  11.    type: ClusterIP
  12.    ports:
  13.    - port: 80
  14.      targetPort: 80
  15. [root@master ~]# kubectl get svc -n dev
  16. NAME                 TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
  17. service-headliness   ClusterIP   None         <none>        80/TCP    4s
  19. #查看域名
  20. [root@master ~]# kubectl exec -ti -n dev pc-deployment-5cb65f68db-959hm /bin/bash
  21. root@pc-deployment-5cb65f68db-959hm:/# cat /etc/resolv.conf
  22. search dev.svc.cluster.local svc.cluster.local cluster.local
  23. nameserver 10.96.0.10
  24. options ndots:5
  27. #访问headliness类型的service
  28. #格式为dns服务器，加上service的名字，名称空间，等;; ANSWER SECTION:
  29. [root@master ~]# dig @10.96.0.10 service-headliness.dev.svc.cluster.local
  30. service-headliness.dev.svc.cluster.local. 30 IN        A 10.244.2.108
  31. service-headliness.dev.svc.cluster.local. 30 IN        A 10.244.1.112
  32. service-headliness.dev.svc.cluster.local. 30 IN        A 10.244.2.107
复制代码
4、NodePort范例的service


 就是将service的port映射到node节点上面，通过nodeip+node端口来实现访问service
 请求来到node的端口上面时，会将请求发送到service的端口上面，再来发送到pod上面的端口，实现访问
就将service暴露到外部了

测试：
  1. [root@master ~]# cat nodeport.yaml
  2. apiVersion: v1
  3. kind: Service
  4. metadata:
  5.    name: service-clusterip
  6.    namespace: dev
  7. spec:
  8.    selector:
  9.      app: nginx-pod
  10.    type: NodePort   #NodePort类型的service
  11.    ports:
  12.    - port: 80    #service端口
  13.      targetPort: 80   #pod端口
  14.      nodePort: 30002   默认在一个·1范围内
  15. [root@master ~]# kubectl create -f nodeport.yaml
  16. service/service-clusterip created
  17. [root@master ~]# kubectl get svc -n dev
  18. NAME                TYPE       CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
  19. service-clusterip   NodePort   10.106.183.217   <none>        80:30002/TCP   4s
  21. #访问节点ip+端口就能映射到Clusterip+端口了
  22. [root@master ~]# curl 192.168.109.100:30002
  23. 10.244.2.108
  24. [root@master ~]# curl 192.168.109.101:30002
  25. 10.244.2.108
  26. [root@master ~]# curl 192.168.109.102:30002
  27. 10.244.2.108
  29. 就能实现访问了service,以及内部了pod了　
复制代码
5、LoadBalancer范例的service


 就是在nodeport的基础上面添加了一个负载均衡的设备，经过盘算后得出
6、ExternalName范例的service 


 将这个这个服务引入www.baidu.com这个服务
  1. [root@master ~]# cat service-external.yaml
  2. apiVersion: v1
  3. kind: Service
  4. metadata:
  5.    name: service-externalname
  6.    namespace: dev
  7. spec:
  8.    type: ExternalName
  9.    externalName: www.baidu.com
  10. [root@master ~]# kubectl create -f service-external.yaml
  11. service/service-externalname created
  12. [root@master ~]# kubectl get svc -n dev
  13. NAME                   TYPE           CLUSTER-IP       EXTERNAL-IP     PORT(S)        AGE
  14. service-clusterip      NodePort       10.106.183.217   <none>          80:30002/TCP   17m
  15. service-externalname   ExternalName   <none>           www.baidu.com   <none>         7s
  17. #访问service
  18. [root@master ~]# dig @10.96.0.10 service-externalname.dev.svc.cluster.local
  19. service-externalname.dev.svc.cluster.local. 30 IN CNAME        www.baidu.com.
  20. www.baidu.com.                30        IN        CNAME        www.a.shifen.com.
  21. www.a.shifen.com.        30        IN        A        180.101.50.188
  22. www.a.shifen.com.        30        IN        A        180.101.50.242
  24. #这样就能解析到了
复制代码
 3：Ingress介绍

service对外暴露服务重要就是2种范例的，NodePort和LoadBalancer
缺点：
　　NodePort暴露的是主机的端口，当集群服务很多的时候，这个端口就会更多
　　LB方式就是每一个service都需要LB,浪费
　

 

 用户界说这个请求到service的规则，然后ingress控制器感知将其转换为nginx配置文件，然后动态更新到nginx-proxy里面去即可，这个过程是动态的
1、环境的准备

  1. #下载yaml文件
  2. kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.10.1/deploy/static/provider/cloud/deploy.yaml
  4. [root@master ingress-example]# kubectl get pod,svc -n ingress-nginx
  5. NAME                                           READY   STATUS      RESTARTS   AGE
  6. pod/ingress-nginx-admission-create-jv5n5       0/1     Completed   0          77s
  7. pod/ingress-nginx-admission-patch-tpfv6        0/1     Completed   0          77s
  8. pod/ingress-nginx-controller-597dc6d68-rww45   1/1     Running     0          77s
  10. NAME                                         TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)                      AGE
  11. service/ingress-nginx-controller             NodePort    10.97.10.122   <none>        80:30395/TCP,443:32541/TCP   78s
  12. service/ingress-nginx-controller-admission   ClusterIP   10.96.17.67    <none>        443/TCP
复制代码
　　
service和deployment文件，创建2个service和6个pod
  1. [root@master ~]# cat deploy.yaml
  2. apiVersion: apps/v1
  3. kind: Deployment
  4. metadata:
  5.    name: nginx-deployment
  6.    namespace: dev
  7. spec:
  8.    replicas: 3
  9.    selector:
  10.       matchLabels:
  11.        app: nginx-pod
  12.    template:
  13.       metadata:
  14.          labels:
  15.            app: nginx-pod
  16.       spec:
  17.         containers:
  18.         - name: nginx
  19.           image: nginx:1.17.1
  20.           ports:
  21.           - containerPort: 80
  22. ---
  24. apiVersion: apps/v1
  25. kind: Deployment
  26. metadata:
  27.    name: tomcat-deployment
  28.    namespace: dev
  29. spec:
  30.    replicas: 3
  31.    selector:
  32.       matchLabels:
  33.        app: tocmat-pod
  34.    template:
  35.       metadata:
  36.          labels:
  37.            app: tocmat-pod
  38.       spec:
  39.         containers:
  40.         - name: tomcat
  41.           image: tomcat:8.5-jre10-slim
  42.           ports:
  43.           - containerPort: 8080
  44. ---
  46. apiVersion: v1
  47. kind: Service
  48. metadata:
  49.    name: nginx-service
  50.    namespace: dev
  51. spec:
  52.    selector:
  53.      app: nginx-pod
  54.    clusterIP: None
  55.    type: ClusterIP
  56.    ports:
  57.    - port: 80
  58.      targetPort: 80
  59. ---
  62. apiVersion: v1
  63. kind: Service
  64. metadata:
  65.    name: tomcat-service
  66.    namespace: dev
  67. spec:
  68.    selector:
  69.      app: tomcat-pod
  70.    type: ClusterIP
  71.    clusterIP: None
  72.    ports:
  73.    - port: 8080
  74.      targetPort: 8080
  76. [root@master ~]# kubectl get deployments.apps,pod -n dev
  77. NAME                                READY   UP-TO-DATE   AVAILABLE   AGE
  78. deployment.apps/nginx-deployment    3/3     3            3           86s
  79. deployment.apps/tomcat-deployment   3/3     3            3           86s
  81. NAME                                     READY   STATUS    RESTARTS   AGE
  82. pod/nginx-deployment-5cb65f68db-5lzpb    1/1     Running   0          86s
  83. pod/nginx-deployment-5cb65f68db-75h4m    1/1     Running   0          86s
  84. pod/nginx-deployment-5cb65f68db-nc8pj    1/1     Running   0          86s
  85. pod/tomcat-deployment-5dbff496f4-6msb2   1/1     Running   0          86s
  86. pod/tomcat-deployment-5dbff496f4-7wjc9   1/1     Running   0          86s
  87. pod/tomcat-deployment-5dbff496f4-wlgmm   1/1     Running   0          86s
复制代码
2、http代理 

 创建一个yaml文件就是里面，
 

 访问的就是域名+path 假如path是/xxx的话，访问要带上域名/xxx
 访问的时候，就会将其转发到对应的service加上端口上面即可
3、https代理


 密钥要提前的生成

 
 
 
 
　
 
　　
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

罪恶克星

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表