k8s（pod，控制器，service）详解

一：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. nginx.org.<br/>
37. Commercial support is available at
38. nginx.com.</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加上端口上面即可
 
 

1. apiVersion: networking.k8s.io/v1
2. kind: Ingress
3. metadata:
4.   name: ingress-http
5.   namespace: dev
6.   annotations:
7.      nginx.ingress.kubernetes.io/rewrite-target: /
8. spec:
9.   ingressClassName: nginx  #这个ingress由nginx来进行处理
10.   rules:  #定义一组的规则
11.   - host: nginx.com
12.     http:
13.       paths:
14.       - pathType: Prefix   #表示路径匹配是基于前缀的
15.         path: /  #表示匹配所有以/开头的路径
16.         backend:  #指定了请求转发到后端服务
17.           service:
18.             name: nginx-service
19.             port:
20.               number: 80   #后端服务监听的端口
21.   - host: tomcat.com
22.     http:
23.       paths:
24.       - pathType: Prefix
25.         path: /
26.         backend:
27.           service:
28.             name: tomcat-service
29.             port:
30.               number: 8080

复制代码

3、https代理

 
 密钥要提前的生成

 
 
 
 
　
 
　　
 

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

前排留名，哈哈哈