3 kubectl 命令行工具

参考: https://blog.csdn.net/LG_15011399296/article/details/123875831
https://blog.csdn.net/zhengzaifeidelushang/article/details/122545110

3.1 命令介绍

kubectl 是Kubernetes 集群的命令行工具，通过kubectl 能够对集群本身进行管理，并能够在集群上进行容器化应用的安装部署。

3.2 使用语法

  1. #command：指定要对一个或多个资源执行的操作，比如create、get、describe、delete。
  2. #TYPE：指定资源类型。资源类型不区分大小写，可以指定单数、复数或缩写形式。
  3. #NAME: 指定资源的名称。名称区分大小写。如果省略名称，则显示所有资源的详细信息
  4. #flags:  指定可选的参数，例如，可以使用-s 或-server参数指定Kubernetes API服务器的地址入口
  5. kubectl [command] [TYPE] [NAME] [flags]
  1. #查看全局help命令
  2. kubectl --help
  3. #查看某个具体操作的命令
  4. kubectl get --help
  1. # 以纯文本输出格式列出所有 pod。
  2. kubectl get pods
  3. # 以纯文本输出格式列出所有 pod，并包含附加信息(如节点名)。
  4. kubectl get pods -o wide
  5. #常看pod当前信息
  6. kubectl get pod,svc
  7. # 以纯文本输出格式列出所有 deploy
  8. kubectl get deploy
  9. # 以纯文本输出格式列出所有副本控制器和服务。
  10. kubectl get rc,services
  11. # 列出在节点 server01 上运行的所有 pod
  12. kubectl get pods --field-selector=spec.nodeName=server01
  13. #查看节点信息
  14. kubectl get node
  15. #查看集群基本状态
  16. kubectl get cs
  19. #创建一个pod
  20. kubectl create deployment nginx --image=nginx
  21. #创建一个pod 并且对外暴露端口
  22. kubectl expose deployment nginx --port=80 --type=NodePort
  23. # 使用 <directory> 路径下的任意 .yaml, .yml, 或 .json 文件 创建对象。
  24. kubectl apply -f <directory>
  25. # 使用 example-service.yaml 中的定义创建服务。
  26. kubectl apply -f example-service.yaml
  28. # 显示名称为 <node-name> 的节点的详细信息。
  29. kubectl describe nodes <node-name>
  30. # 显示名为 <pod-name> 的 pod 的详细信息。
  31. kubectl describe pods <pod-name>
  32. # 显示由名为 <rc-name> 的副本控制器管理的所有 pod 的详细信息。
  33. # 记住：副本控制器创建的任何 pod 都以复制控制器的名称为前缀。
  34. kubectl describe pods <rc-name>
  35. # 描述所有的 pod，不包括未初始化的 pod
  36. kubectl describe pods
  39. # 使用 pod.yaml 文件中指定的类型和名称删除 pod。
  40. kubectl delete -f pod.yaml
  41. # 删除所有带有 '<label-key>=<label-value>' 标签的 Pod 和服务。
  42. kubectl delete pods,services -l <label-key>=<label-value>
  43. # 删除所有 pod，包括未初始化的 pod。
  44. kubectl delete pods --all
  45. # 删除名称为nginx的deployment
  46.  kubectl delete deployment nginx
  49. # 从 pod <pod-name> 中获取运行 'date' 的输出。默认情况下，输出来自第一个容器。
  50. kubectl exec <pod-name> -- date
  51. # 运行输出 'date' 获取在容器的 <container-name> 中 pod <pod-name> 的输出。
  52. kubectl exec <pod-name> -c <container-name> -- date
  53. # 获取一个交互 TTY 并运行 /bin/bash <pod-name >。默认情况下，输出来自第一个容器。
  54. kubectl exec -ti <pod-name> -- /bin/bash
  57. # 从 pod 返回日志快照。
  58. kubectl logs <pod-name>
  59. # 从 pod <pod-name> 开始流式传输日志。这类似于 'tail -f' Linux 命令。
  60. kubectl logs -f <pod-name>
  1. # kubectl exec：进入pod启动的容器
  2. kubectl exec -it podName -n nsName /bin/sh    #进入容器
  3. kubectl exec -it podName -n nsName /bin/bash  #进入容器
  5. # kubectl label：添加label值
  6. kubectl label nodes k8s-node01 zone=north  #为指定节点添加标签
  7. kubectl label nodes k8s-node01 zone-       #为指定节点删除标签
  8. kubectl label pod podName -n nsName role-name=test    #为指定pod添加标签
  9. kubectl label pod podName -n nsName role-name=dev --overwrite  #修改lable标签值
  10. kubectl label pod podName -n nsName role-name-        #删除lable标签
  12. # kubectl滚动升级； 通过 kubectl apply -f myapp-deployment-v1.yaml 启动deploy
  13. kubectl apply -f myapp-deployment-v2.yaml     #通过配置文件滚动升级
  14. kubectl set image deploy/myapp-deployment myapp="registry.cn-beijing.aliyuncs.com/google_registry/myapp:v3"   #通过命令滚动升级
  15. kubectl rollout undo deploy/myapp-deployment 或者 kubectl rollout undo deploy myapp-deployment    #pod回滚到前一个版本
  16. kubectl rollout undo deploy/myapp-deployment --to-revision=2  #回滚到指定历史版本
  18. # kubectl scale：动态伸缩
  19. kubectl scale deploy myapp-deployment --replicas=5  # 动态伸缩
  20. kubectl scale --replicas=8 -f myapp-deployment-v2.yaml  #动态伸缩【根据资源类型和名称伸缩，其他配置「如：镜像版本不同」不生效】

4 yaml文件详解

参考: https://blog.csdn.net/xxb249/article/details/116232493

4.1 YAML 文件概述

k8s 集群中对资源管理和资源对象编排部署都可以通过声明样式（YAML）文件来解决，也就是可以把需要对资源对象操作编辑到YAML 格式文件中，我们把这种文件叫做资源清单文件，通过kubectl 命令直接使用资源清单文件就可以实现对大量的资源对象进行编排部署了。

4.2 YAML 文件组成部分

  1. #使用kubectl create 命令生成yaml文件
  2. kubectl create deployment web --image=nginx -o yaml --dry-run
  3. #使用kubectl create 命令生成yaml文件 生成到指定文件里面去
  4. kubectl create deployment web --image=nginx -o yaml --dry-run > m1.yaml
  5. #使用kubectl get命令导出yaml文件
  6. kubectl get deploy nginx -o=yaml --export >my2.yaml

image.png

  1. apiVersion: apps/v1
  2. kind: Deployment
  3. metadata:
  4.   creationTimestamp: null
  5.   labels:
  6.     app: web
  7.   name: web
  8. spec:
  9.   replicas: 1
  10.   selector:
  11.     matchLabels:
  12.       app: web
  13.   strategy: {}
  14.   template:
  15.     metadata:
  16.       creationTimestamp: null
  17.       labels:
  18.         app: web
  19.     spec:
  20.       containers:
  21.       - image: nginx
  22.         name: nginx
  23.         resources: {}
  24. status: {}

4.2.1 控制器定义

  1. apiVersion: apps/v1
  2. kind: Deployment
  3. metadata:
  4.   creationTimestamp: null
  5.   labels:
  6.     app: web
  7.   name: web
  8. spec:
  9.   replicas: 1
  10.   selector:
  11.     matchLabels:
  12.       app: web

4.2.2 被控制对象

  1.   template:
  2.     metadata:
  3.       creationTimestamp: null
  4.       labels:
  5.         app: web
  6.     spec:
  7.       containers:
  8.       - image: nginx
  9.         name: nginx
  10.         resources: {}

4.3 常用字段含义

  1. apiVersion: v1 #指定api版本，此值必须在kubectl apiversion中
  2. kind: Pod #指定创建资源的角色/类型
  3. metadata: #资源的元数据/属性
  4.   name: web04-pod #资源的名字，在同一个namespace中必须唯一
  5.   labels: #设定资源的标签，详情请见http://blog.csdn.net/liyingke112/article/details/77482384
  6.     k8s-app: apache
  7.     version: v1
  8.     kubernetes.io/cluster-service: "true"
  9.   annotations:            #自定义注解列表
  10.     - name: String        #自定义注解名字
  11. spec:   #specification of the resource content 指定该资源的内容
  12.   restartPolicy: Always #表明该容器一直运行，默认k8s的策略，在此容器退出后，会立即创建一个相同的容器  
  13.   nodeSelector:     #节点选择，先给主机打标签kubectl label nodes kube-node1 zone=node1
  14.     zone: node1
  15.   containers:
  16.   - name: web04-pod #容器的名字
  17.     image: web:apache #容器使用的镜像地址
  18.     imagePullPolicy: Never #三个选择Always、Never、IfNotPresent，每次启动时检查和更新（从registery）images的策略，
  19.                            # Always，每次都检查
  20.                            # Never，每次都不检查（不管本地是否有）
  21.                            # IfNotPresent，如果本地有就不检查，如果没有就拉取
  22.     command: ['sh'] #启动容器的运行命令，将覆盖容器中的Entrypoint,对应Dockefile中的ENTRYPOINT  
  23.     args: ["$(str)"] #启动容器的命令参数，对应Dockerfile中CMD参数
  24.     env: #指定容器中的环境变量
  25.     - name: str #变量的名字
  26.       value: "/etc/run.sh" #变量的值
  27.     resources: #资源管理，请求请见http://blog.csdn.net/liyingke112/article/details/77452630
  28.       requests: #容器运行时，最低资源需求，也就是说最少需要多少资源容器才能正常运行
  29.         cpu: 0.1 #CPU资源（核数），两种方式，浮点数或者是整数+m，0.1=100m，最少值为0.001核（1m）
  30.         memory: 32Mi #内存使用量
  31.       limits: #资源限制
  32.         cpu: 0.5
  33.         memory: 32Mi
  34.     ports:
  35.     - containerPort: 80 #容器开发对外的端口
  36.       name: httpd  #名称
  37.       protocol: TCP
  38.     livenessProbe: #pod内容器健康检查的设置，详情请见http://blog.csdn.net/liyingke112/article/details/77531584
  39.       httpGet: #通过httpget检查健康，返回200-399之间，则认为容器正常
  40.         path: / #URI地址
  41.         port: 80
  42.         #host: 127.0.0.1 #主机地址
  43.         scheme: HTTP
  44.       initialDelaySeconds: 180 #表明第一次检测在容器启动后多长时间后开始
  45.       timeoutSeconds: 5 #检测的超时时间
  46.       periodSeconds: 15  #检查间隔时间
  47.       #也可以用这种方法
  48.       #exec: 执行命令的方法进行监测，如果其退出码不为0，则认为容器正常
  49.       #  command:
  50.       #    - cat
  51.       #    - /tmp/health
  52.       #也可以用这种方法
  53.       #tcpSocket: //通过tcpSocket检查健康
  54.       #  port: number
  55.     lifecycle: #生命周期管理
  56.       postStart: #容器运行之前运行的任务
  57.         exec:
  58.           command:
  59.             - 'sh'
  60.             - 'yum upgrade -y'
  61.       preStop: #容器关闭之前运行的任务
  62.         exec:
  63.           command: ['service httpd stop']
  64.     volumeMounts:  #详情请见http://blog.csdn.net/liyingke112/article/details/76577520
  65.     - name: volume #挂载设备的名字，与volumes[*].name 需要对应
  66.       mountPath: /data #挂载到容器的某个路径下
  67.       readOnly: True
  68.   volumes: #定义一组挂载设备
  69.   - name: volume #定义一个挂载设备的名字
  70.     #meptyDir: {}
  71.     hostPath:
  72.       path: /opt #挂载设备类型为hostPath，路径为宿主机下的/opt,这里设备类型支持很多种

5 k8s 核心技术概念 pod

参考：https://blog.csdn.net/qq_37419449/article/details/122157277

5.1 pod概述

  1. pod是k8s 系统中可以创建和管理的最小单元
  2. pod由一个或多个容器组成
  3. 每个pod都包含一个根容器pause ,通过Pause容器 一个pod中的容器共享网络资源
  4. pod是短暂的

image.png
pod创建流程
16-创建Pod流程.png

5.2 pod存在的意义

  1. 创建容器使用docker,一个docker对应一个容器，一个容器有进程，一个容器运行一个应用程序
  2. pod是多进程设计，运行多个应用程序
    1. 一个pod里面多个容器，一个容器里面运行一个应用程序

  3. pod存在为了亲密性应用

    1. 两个应用之间进行交互
    2. 网络之间调用
    3. 两个应用需要频繁调用

      5.3 pod实现机制

  4. 共享网络

    1. 通过Pause容器，把其他业务容器加入到Pause容器里面，让所有业务容器在同一个容器名称空间中，可以实现网络共享。
  5. 共享存储
    1. 引入数据卷Volumn,使用数据卷进行持久化存储

image.png

5.4 pod拉取镜像策略

  1. spec:   #specification of the resource content 指定该资源的内容  
  2.   containers:  
  3.   - name: web04-pod #容器的名字  
  4.     image: web:apache #容器使用的镜像地址  
  5.     imagePullPolicy: Never #三个选择Always、Never、IfNotPresent，每次启动时检查和更新（从registery）images的策略，
  6.                            # Always，每次都检查
  7.                            # Never，每次都不检查（不管本地是否有）
  8.                            # IfNotPresent，默认值，如果本地有就不检查，如果没有就拉取

5.5 pod资源限制

  1. spec:   #specification of the resource content 指定该资源的内容  
  2.   containers:  
  3.     resources: #资源管理，请求请见http://blog.csdn.net/liyingke112/article/details/77452630
  4.       requests: #调度 容器运行时，最低资源需求，也就是说最少需要多少资源容器才能正常运行  
  5.         cpu: 0.1 #CPU资源（核数），两种方式，浮点数或者是整数+m，0.1=100m，最少值为0.001核（1m）
  6.         memory: 32Mi #内存使用量  
  7.       limits: #资源限制  最大
  8.         cpu: 0.5  
  9.         memory: 32Mi

5.6 pod重启机制

  1. spec:   #specification of the resource content 指定该资源的内容  
  2.   restartPolicy: Always # Always   OnFailure   Naver
  3.                 # Always     当容器终止退出后，总是重启容器，默认策略
  4.                 # OnFailure  当容器异常退出(退出状态码非0)时，才重启容器
  5.                 # Naver      当容器终止退出，从不重启容器

5.7 pod健康检查

  1. spec:   #specification of the resource content 指定该资源的内容  
  2.   containers:  #pod内容器健康检查的设置，详情请见http://blog.csdn.net/liyingke112/article/details/77531584
  3.     livenessProbe: #如果检查失败，将杀死容器，根据Pod的restartPolicy来操作
  4.       httpGet: #通过httpget检查健康，返回200-399之间，则认为容器正常  
  5.         path: / #URI地址  
  6.         port: 80  
  7.         #host: 127.0.0.1 #主机地址  
  8.         scheme: HTTP  
  9.       initialDelaySeconds: 180 #表明第一次检测在容器启动后多长时间后开始  
  10.       timeoutSeconds: 5 #检测的超时时间  
  11.       periodSeconds: 15  #检查间隔时间  
  12.       #也可以用这种方法  
  13.       #exec: 执行命令的方法进行监测，如果其退出码不为0，则认为容器正常  
  14.       #  command:  
  15.       #    - cat  
  16.       #    - /tmp/health  
  17.       #也可以用这种方法  
  18.       #tcpSocket: //通过tcpSocket检查健康   
  19.       #  port: number
  20.      readinessProbe: #如果检查失败，kubernetes会把Pod从service endpoints中剔除
  21.        httpGet:
  22.          path: /
  23.          port: 80
  24.          scheme: HTTP
  25.          initialDelaySeconds: 120  #容器启动后第一次执行探测是需要等待多少秒。
  26.          periodSeconds: 15     #执行探测的频率。默认是10秒，最小1秒。
  27.          timeoutSeconds: 5     #探测超时时间。默认1秒，最小1秒。

5.8 pod调度

5.8.1 影响调度的属性

  • pod资源对pod调用产生影响，根据requests找到足够node节点进行调度
  • 节点选择器标签影响Pod的调度
    1. spec:   #specification of the resource content 指定该资源的内容  
    2. #影响节点调度
    3. nodeSelector: #节点选择，先给主机打标签 kubectl label nodes kube-node1 zone=node1  
    4.   zone: node1  
    5. containers:  
    6.   #影响节点调度
    7.   resources: 
    8.       cpu: 0.1 #CPU资源（核数），两种方式，浮点数或者是整数+m，0.1=100m，最少值为0.001核（1m）
    9.       memory: 32Mi #内存使用量

    5.8.2 节点亲和性影响调度

    1. spec:
    2. containers:
    3. affinity:
    4.   nodeAffinity: #和nodeSelector基本差不多
    5.     # 硬亲和性  约束条件必须满足
    6.     requiredDuringSchedulingIgnoredDuringExecution:
    7.       nodeSelectorTerms:
    8.       - matchExpressions:
    9.         - key: node1 # 标签键名
    10.           operator: NotIn  # label的值不在某个列表中
    11.                    # In  label的值在某个列表中
    12.                    # Exists  某个 label 存在
    13.                    # Gt  label 的值大于某个值
    14.                    # Lt  label 的值小于某个值
    15.                    # DoesNotExists  某个 label 不存在
    16.           values:
    17.           - dev  # 标签键值
    18.           - test # 标签键值
    19.     # 软亲和性  约束条件尝试满足，不保证
    20.     preferredDuringSchedulingIgnoredDuringExecution:
    21.     - weight: 1   #权重，权重越大越亲和(多个软策略的情况)
    22.       preference: 
    23.         matchExpressions:
    24.         - key: node1
    25.           operator: In
    26.           values:
    27.           - prod  # 期望是prod

    5.8.3 污点和污点容忍

    节点亲和性，是pod的一种属性（偏好或硬性要求），它使pod被吸引到一类特定的节点。Taint 则相反，它使节点能够排斥一类特定的 pod
    Taint 和 toleration 相互配合，可以用来避免 pod 被分配到不合适的节点上。每个节点上都可以应用一个或多个taint ，这表示对于那些不能容忍这些 taint 的 pod，是不会被该节点接受的。如果将 toleration 应用于 pod上，则表示这些 pod 可以（但不要求）被调度到具有匹配 taint 的节点上 ```shell

    查看节点污点

    kubectl describe node k8snode1 | grep Taints

设置污点 kubectl taint nodes [node] key=value:NoExecute value 可以为空

NoExecute:不会调度，并且还会驱逐Node已有Pod

PreferNoSchedule：尽量不会调度

NoExecute：一点不被调度

kubectl taint nodes k8snode1 check=nck:NoExecute

因为pod是自主式pod，没有控制器控制的pod。去除后就不存在了,如果是Deployment和StatefullSet，它就会在node02上创建，维持副本数

节点说明中，查找 Taints 字段

kubectl describe node k8snode1

去除污点

kubectl taint nodes k8snode1 check=nck:NoExecute-

  2. ```yaml
  3. spec:
  4. #  key, vaule, effect 要与 Node 上设置的 taint 保持一致
  5.   tolerations:  
  6.   - key: "check"  #能容忍的污点key
  7.     operator: "Equal"  #Equal等于表示key=value ， Exists不等于，表示当值不等于下面value正常
  8.     value: "nck"  #值
  9.     effect: "NoExecute"  #effect策略
  10.     tolerationSeconds: 3600  #原始的pod多久驱逐，注意只有effect: "NoExecute"才能设置，不然报错

6 k8s 核心技术概念 controller

6.1 什么是controller

controller是在集群上管理和运行容器的对象，是一个实体存在的，而pod是一个抽象概念。controller有分跟多种类

  1. deployment：适合无状态的服务部署
  2. StatefulSet：适合有状态的服务部署
  3. DaemonSet：在每一个node上运行一个pod，新加入的node也同样会自动运行一个pod。例如一些典型的应用场景：
    1. 运行集群存储 daemon，例如在每个Node上运行 glusterd、ceph
    2. 在每个Node上运行日志收集 daemon，例如 fluentd、 logstash
    3. 在每个Node上运行监控 daemon，例如 Prometheus Node Exporter
  4. Job：一次性的执行任务
  5. Cronjob：周期性的执行任务

    6.2 pod和controller关系

  • controllers：在集群上管理和运行容器的对象通过label-selector相关联
  • 控制器又被称为工作负载，pod通过控制器实现应用的运维，比如伸缩、升级等

image.png

6.3 deployment控制器应用场景

  • 部署无状态应用
  • 管理Pod和ReplicaSet
  • 部署，滚动升级等功能

  • 应用场景：web服务，微服务

    6.4 deployment控制器部署应用(yaml)

    1. # 第一步 导出yaml
    2. kubectl create deployment web --image=nginx --dry-run -o yaml >web.yaml
    3. # 第二步 使用yaml部署应用
    4. kubectl apply -f web.yaml
    5. # 第三步 对外发布（暴露对外端口）
    6. kubectl expose deployment web --port=80 --type=NodePort --target-port=80 --name=web1 -o yaml >web1.yaml
    7. kubectl apply -f web1.yaml

    image.png

    6.5 升级回滚与弹性伸缩

    初始版本 nginx:1.14 副本数量：2
    image.png

    1. # 创建应用
    2. kubectl apply -f web.yaml
    3. # 应用升级
    4. kubectl set image deployment web nginx=nginx:1.15
    5. # 查看升级状态
    6. kubectl rollout status deployment web
    7. # 查看升级版本
    8. kubectl rollout history deployment web
    9. # 回滚到上一个版本
    10. kubectl rollout undo deployment web
    11. # 回滚到指定版本
    12. kubectl rollout undo deployment --to-revision=2
    13. # 弹性伸缩
    14. kubectl scale deployment web --replicas=6

    image.png
    image.png

    6.6 部署有状态应用 StatefulSet

    6.6.1 有状态和无状态的区别

    无状态

  • 认为所有的pod都是一样的

  • 不用考虑顺序的要求
  • 不用考虑在哪个node节点上运行
  • 可以随意扩容和缩容

有状态

  • 每个pod都是独立的，保持pod启动顺序性和唯一性
    • 唯一网络标识符，持久存储
    • 有序，比如mysql主从

  • pod与pod之间关系不对等，以及依靠外部存储的应用

    6.6.2 常规service和无头服务区别

  • service：一组Pod访问策略，提供cluster-IP群集之间通讯，还提供负载均衡和服务发现。

  • headless service：无头服务， 不需要cluster-IP，直接绑定具体的Pod的IP（当Pod的IP地址是动态变化时，所以常用于绑定DNS访问）
  1. apiVersion: v1
  2. kind: Service
  3. metadata:
  4.   name: nginx
  5.   labels:
  6.     app: nginx
  7. spec:
  8.   ports:
  9.   - port: 80
  10.     name: web
  11.   clusterIP: None  #无头service
  12.   selector:
  13.     app: nginx
  15. #分隔符
  16. ---
  17. apiVersion: apps/v1
  18. kind: StatefulSet
  19. metadata:
  20.   name: nginx-statefulset
  21.   namespace: default
  22. spec:
  23.   serviceName: nginx
  24.   replicas: 3
  25.   selector:
  26.     matchLabels:
  27.       app: nginx
  28.   template:
  29.     metadata:
  30.       labels:
  31.         app: nginx
  32.     spec:
  33.       containers:
  34.       - name: nginx
  35.         image: nginx:latest
  36.         ports:
  37.         - containerPort: 80

查看pod，有三个pod，每个都是唯一名称，CLUSTER-IP为None表示无头service
image.png
image.png

6.7 守护式进程DaemonSet

DaemonSet确保集群中每个（部分）node运行一份pod副本，当node加入集群时创建pod，当node离开集群时回收pod。如果删除DaemonSet，其创建的所有pod也被删除，DaemonSet中的pod覆盖整个集群。
使用场景：

  • 运行集群存储守护进程，如glusterd、ceph。
  • 运行集群日志收集守护进程，如fluentd、logstash。
  • 运行节点监控守护进程，如Prometheus Node Exporter, collectd, Datadog agent, New Relic agent, or Ganglia gmond。
    1. apiVersion: apps/v1
    2. kind: DaemonSet
    3. metadata:
    4. name: ds-test 
    5. labels:
    6.   app: filebeat
    7. spec:
    8. selector:
    9.   matchLabels:
    10.     app: filebeat
    11. template:
    12.   metadata:
    13.     labels:
    14.       app: filebeat
    15.   spec:
    16.     containers:
    17.     - name: logs
    18.       image: nginx
    19.       ports:
    20.       - containerPort: 80
    21.       volumeMounts:
    22.       - name: varlog
    23.         mountPath: /tmp/log
    24.     volumes:
    25.     - name: varlog
    26.       hostPath:
    27.         path: /var/log

采集日志demo
image.png

6.8 一次性任务 job

打印圆周率2000位

  1. apiVersion: batch/v1
  2. kind: Job
  3. metadata:
  4.   name: pi
  5. spec:
  6.   template:
  7.     spec:
  8.       containers:
  9.       - name: pi
  10.         image: perl
  11.         command: ["perl",  "-Mbignum=bpi", "-wle", "print bpi(2000)"]
  12.       restartPolicy: Never
  13.   backoffLimit: 4 #表示失败之后再尝试4次

image.png
一次性任务 完成后变成 Comleted
image.png

6.9 定时任务 cronjob

每秒钟输出 Hello from the Kubernetes cluster

  1. apiVersion: batch/v1beta1
  2. kind: CronJob
  3. metadata:
  4.   name: hello
  5. spec:
  6.   schedule: "*/1 * * * *"
  7.   jobTemplate:
  8.     spec:
  9.       template:
  10.         spec:
  11.           containers:
  12.           - name: hello
  13.             image: busybox
  14.             args:
  15.             - /bin/sh
  16.             - -c
  17.             - date; echo Hello from the Kubernetes cluster
  18.           restartPolicy: OnFailure

image.png

image.png

7 k8s 核心技术概念 service

service 是kubernetes 最核心概念，通过创建service,可以为一组具有相同功能的容器应
用提供一个统一的入口地址，并且将请求负载分发到后端的各个容器应用上。

7.1 service 存在的意义

  1. 防止pod失联（服务发现）

  2. 定义一组pod访问策略（负载均衡）

    7.2 pod和service的关系

    通过 Label 和 Selector进行标签选择，选择出具有相同标签属性的pod组成的一个集合，以一个身份为用户提供服务访问。

    7.3 常用service类型

  3. ClusterIP:集群内部使用 (默认模式)

  4. NodePort: 对外访问应用使用
  5. LoadBalancer:对外访问应用使用，将请求转发到NodeIP+NodePort，为若干个以NodeIP+NodePort为代表的集群节点做负载