Kubernetes中的pod管理及优化

^～^前行者～～～

已于 2024-10-29 17:04:01 修改

阅读量1k

点赞数 30

文章标签： kubernetes 容器云原生

于 2024-10-09 23:41:26 首次发布

本文链接：https://blog.csdn.net/huaz_md/article/details/142766897

版权

华子目录

什么是pod
1.创建`自主式pod`（生产不推荐）
2.利用`控制器`管理`pod`（推荐）
3.利用`yaml`文件部署应用
yaml文件编写示例
`pod`的生命周期
探针
- `存活探针`示例
- `就绪探针`示例

什么是pod

pod是可以创建和管理Kubernetes计算的最小可部署单元
一个pod代表着集群中运行的一个进程，每个pod都有一个唯一的ip
一个pod类似一个豌豆荚，包含一个或多个容器（通常是docker）
多个容器间共享Network，memory和UTC namespace等

查看所有命名空间中的所有pod

[root@k8s-master ~]# kubectl get pods --all-namespaces

1.创建`自主式pod`（生产不推荐）

所谓自主式，就是不是在控制器中的pod

优点

灵活性高
- 可以精确控制pod的各种配置参数，包括容器的镜像、资源限制、环境变量、命令和参数等，满足特定的应用需求。
学习和调试方便
- 对于学习Kubernetes的原理和机制非常有帮助，通过手动创建pod可以深入了解pod的结构和配置方式。在调试问题时，可以更直接地观察和调试pod的设置。
适用于特殊场景
- 在一些特殊情况下，如进行一次性任务、快速验证概念或在资源受限的环境中进行特定配置时，手动创建pod可能是一种有效的方式。

缺点

管理复杂
- 如果需要管理大量的pod，手动创建和维护会变得非常繁琐和耗时。难以实现自动化的扩缩容、故障恢复等操作。
缺乏高级功能
- 无法自动享受Kubernetes提供的高级功能，如自动部署、滚动更新、服务发现等。这可能导致应用的部署和管理效率底下。
可维护性差
- 手动创建的pod在更新应用版本或修改配置时需要手动干预，容易出现错误，并且难以保证一致性。相比之下，通过声明式配置或使用Kubernetes的部署工具可以更方便地进行应用地维护和更新。

示例1

#运行一个名为web的pod
[root@k8s-master ~]# kubectl run web --image nginx
pod/web created

#显示pod的较为详细的信息
[root@k8s-master ~]# kubectl get pods -o wide
NAME   READY   STATUS    RESTARTS   AGE   IP            NODE            NOMINATED NODE   READINESS GATES
web    1/1     Running   0          14s   10.244.1.12   k8s-node1.org   <none>           <none>

示例2

能否在一个pod中运行2个运行两个相同的容器呢？

#在一个pod中运行2个nginx
[root@k8s-master ~]# cat testpod1.yml
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: huazi   #pod的标签
  name: huazi   #pod的名字
spec:
  containers:
    - image: nginx   #pod的第一个镜像
      name: web1   #容器名
    - image: nginx  #pod中的第二个镜像
      name: web2   #容器名

[root@k8s-master ~]# kubectl apply -f testpod1.yml
pod/huazi created

#我们发现一个pod中运行2个nginx，只能运行一个
[root@k8s-master ~]# kubectl get pods -o wide
NAME    READY   STATUS             RESTARTS      AGE     IP            NODE            NOMINATED NODE   READINESS GATES
huazi   1/2     CrashLoopBackOff   5 (19s ago)   3m17s   10.244.2.21   k8s-node2.org   <none>           <none>

#查看日志后，发现80端口被占用
[root@k8s-master ~]# kubectl logs pods/huazi web2

在这里插入图片描述

从侧面可以反应出：pod是一个系统，pod中的容器是一个应用程序，一个系统的一个应用程序只能有一个

[root@k8s-master ~]# kubectl delete -f testpod1.yml
pod "huazi" deleted

[root@k8s-master ~]# kubectl get pods
No resources found in default namespace.

示例3

一个pod中的多个容器，能否实现资源共享吗？

#在一个名为huazi的pod中，运行两个容器，一个是nginx，一个是buysboxplus
[root@k8s-master ~]# vim testpod1.yml
apiVersion: v1   # 指定 Kubernetes API 的版本，此处为 v1，适用于大多数核心 Kubernetes 对象
kind: Pod    # 声明这是一个 Pod 对象
metadata:   # Pod 的元数据
  labels:    # 为 Pod 定义标签，用于组织和选择
    run: huazi   #pod的标签
  name: huazi   #pod的名字
spec:    # 指定 Pod 的规格说明
  containers:    # 容器列表，Pod 中可以包含一个或多个容器
    - image: nginx  #pod中第一个容器镜像
      name: web1     #容器名
    - image: busyboxplus  #pod中第二个容器镜像
      name: test     #容器名
      command: ["/bin/sh","-c","sleep 10000"]  #在容器中执行的命令


[root@k8s-master ~]# kubectl apply -f testpod1.yml
pod/huazi created


[root@k8s-master ~]# kubectl get pods -o wide
NAME    READY   STATUS    RESTARTS   AGE   IP            NODE            NOMINATED NODE   READINESS GATES
huazi   2/2     Running   0          10s   10.244.2.22   k8s-node2.org   <none>           <none>

进入test容器中，test容器是一个busyboxplus的镜像

# -c指定pod中的容器名
[root@k8s-master ~]# kubectl exec -it pods/huazi -c test -- /bin/sh
/ # curl localhost
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

这里我们发现，test是一个busyboxplus的容器，但是为什么可以访问到nginx容器呢？原因就是：busyboxplus和nginx在一个pod中，共用同一个资源。也从侧面可以反应出：pod是一个系统

[root@k8s-master ~]# kubectl delete -f testpod1.yml

示例4

自主式建立的pod，master是否能够自动进行检测呢？

#在一个名为huazi的pod中，运行两个容器，一个是nginx，一个是buysboxplus
[root@k8s-master ~]# vim testpod1.yml
apiVersion: v1  # 指定 Kubernetes API 的版本，此处为 v1，适用于大多数核心 Kubernetes 对象
kind: Pod   # 声明这是一个 Pod 对象
metadata:   # Pod 的元数据
  labels:    # 为 Pod 定义标签，用于组织和选择
    run: huazi   #pod的标签
  name: huazi   #pod的名字
spec:   # 指定 Pod 的规格说明
  containers:   # 容器列表，Pod 中可以包含一个或多个容器
    - image: nginx  #pod中第一个容器镜像
      name: web1     #容器名
    - image: busyboxplus  #pod中第二个容器镜像
      name: test     #容器名
      command: ["/bin/sh","-c","sleep 10000"]  #在容器中执行的命令


[root@k8s-master ~]# kubectl apply -f testpod1.yml
pod/huazi created


[root@k8s-master ~]# kubectl get pods -o wide
NAME    READY   STATUS    RESTARTS   AGE   IP            NODE            NOMINATED NODE   READINESS GATES
huazi   2/2     Running   0          10s   10.244.2.22   k8s-node2.org   <none>           <none>

我们在node2节点上手动删除一个容器

[root@k8s-node2 ~]# docker ps
CONTAINER ID   IMAGE                            COMMAND                   CREATED              STATUS              PORTS     NAMES
7763a4447357   busyboxplus                      "/bin/sh -c 'sleep 1…"   About a minute ago   Up About a minute             k8s_test_huazi_default_37d37ef9-27cc-4fb5-b955-286c192000d8_0
3f5c3411c80a   nginx                            "/docker-entrypoint.…"   About a minute ago   Up About a minute             k8s_web1_huazi_default_37d37ef9-27cc-4fb5-b955-286c192000d8_0


#当我们删除后，它会自动重新建立一个
[root@k8s-node2 ~]# docker rm -f k8s_test_huazi_default_37d37ef9-27cc-4fb5-b955-286c192000d8_0


k8s_test_huazi_default_37d37ef9-27cc-4fb5-b955-286c192000d8_0
[root@k8s-node2 ~]# docker ps
CONTAINER ID   IMAGE                            COMMAND                   CREATED         STATUS         PORTS     NAMES
6b9af5119ad4   busyboxplus                      "/bin/sh -c 'sleep 1…"   5 seconds ago   Up 4 seconds             k8s_test_huazi_default_37d37ef9-27cc-4fb5-b955-286c192000d8_1
3f5c3411c80a   nginx                            "/docker-entrypoint.…"   2 minutes ago   Up 2 minutes             k8s_web1_huazi_default_37d37ef9-27cc-4fb5-b955-286c192000d8_0

但是master上不会发现node2上的容器重新建立过

[root@k8s-master ~]# kubectl get pods -o wide
NAME    READY   STATUS    RESTARTS   AGE    IP            NODE            NOMINATED NODE   READINESS GATES
huazi   2/2     Running   2          4m5s   10.244.2.24   k8s-node2.org   <none>           <none>

2.利用`控制器`管理`pod`（推荐）

高可用性和可靠性：

自动故障恢复：如果一个pod失败或被删除，控制器会自动创建新的pod来维持期望的副本数量。确保应用始终处于可用状态，减少因单个pod故障导致的服务中断。（这里所说的副本就是pod）
健康检查和自愈：可以配置控制器对pod进行健康检查（如存活探针和就绪探针）。如果pod不健康，控制器会采取适当的行动，如重启pod或删除并重新创建它，以保证应用的正常运行。

可扩展性：

轻松扩缩容：可以通过简单的命令或配置更改来增加或减少pod的数量，以满足不同的工作负载需求。例如，在高流量期间可以快速扩展以处理更多请求，在低流量期间可以缩容以节省资源。
水平自动扩缩容（HPA）：可以基于自定义指标（如CPU利用率、内存使用情况或应用特定的指标）自动调整pod的数量，实现动态的资源分配和成本优化。

版本管理和更新：

滚动更新：对于Deployment等控制器，可以执行滚动更新来逐步替换旧版本的pod为新版本，确保应用在更新过程中始终保持可用。可以控制更新的速率和策略，以减少对用户的影响。
回滚：如果更新出现问题，可以轻松回滚到上一个稳定版本，保证应用的稳定性和可靠性。

声明式配置：

简洁的配置方式：使用yaml或json格式的声明式配置文件来定义应用的部署需求。这种方式使得配置易于理解、维护和版本控制，同时也方便团队协作。
期望状态管理：只需要定义应用的期望状态（如副本数量、容器镜像等），控制器会自动调整实际状态与期望状态保持一致。无需手动管理每个pod的创建和删除，提高了管理效率。

服务发现和负载均衡：

自动注册和发现：Kubernetes中的服务（Service）可以自动发现由控制器管理的pod，并将流量路由到它们。这使得应用的服务发现和负载均衡变得简单和可靠，无需手动配置负载均衡器。
流量分发：可以根据不同的策略（如轮询、随机等）将请求分发到不同的pod，提高应用的性能和可用性。

多环境一致性：

一致的部署方式：在不同的环境（如开发、测试、生产）中，可以使用相同的控制器和配置来部署应用，确保应用在不同环境中的行为一致。这有助于减少部署差异和错误，提高开发和运维效率。

`scale`实现在控制器中自动扩缩`pod数量`

建立控制器并在控制器中自动运行一个pod，再使用scale实现自动缩容

#建立控制器并在控制器中自动运行一个pod
[root@k8s-master ~]# kubectl create deployment huazi --image nginx
deployment.apps/huazi created


[root@k8s-master ~]# kubectl get pods -o wide
NAME                    READY   STATUS    RESTARTS   AGE   IP            NODE            NOMINATED NODE   READINESS GATES
huazi-79f7fdf69-4wksw   1/1     Running   0          22s   10.244.1.13   k8s-node1.org   <none>           <none>


#为名为huazi控制器扩容：扩容到3个pod
[root@k8s-master ~]# kubectl scale deployment huazi --replicas 3
deployment.apps/huazi scaled

[root@k8s-master ~]# kubectl get pods -o wide
NAME                    READY   STATUS    RESTARTS   AGE    IP            NODE            NOMINATED NODE   READINESS GATES
huazi-79f7fdf69-4wksw   1/1     Running   0          3m4s   10.244.1.13   k8s-node1.org   <none>           <none>
huazi-79f7fdf69-9qtg9   1/1     Running   0          23s    10.244.1.14   k8s-node1.org   <none>           <none>
huazi-79f7fdf69-mkfnq   1/1     Running   0          23s    10.244.2.19   k8s-node2.org   <none>           <none>


#为huazi控制器缩容：缩容到2个pod
[root@k8s-master ~]# kubectl scale deployment huazi --replicas 2
deployment.apps/huazi scaled


[root@k8s-master ~]# kubectl get pods -o wide
NAME                    READY   STATUS    RESTARTS   AGE     IP            NODE            NOMINATED NODE   READINESS GATES
huazi-79f7fdf69-4wksw   1/1     Running   0          4m58s   10.244.1.13   k8s-node1.org   <none>           <none>
huazi-79f7fdf69-mkfnq   1/1     Running   0          2m17s   10.244.2.19   k8s-node2.org   <none>           <none>

负载均衡示例

[root@k8s-master ~]# kubectl create deployment huazi --image myapp:v1 --replicas 2 --dry-run=client -o yaml > huazi-dp.yml

[root@k8s-master ~]# vim huazi-dp.yml
[root@k8s-master ~]# cat huazi-dp.yml
apiVersion: apps/v1   # 指定 Kubernetes API 的版本，这里是 apps/v1，用于 Deployment 资源
kind: Deployment   # 指定资源的类型，这里是 Deployment
metadata:   # 元数据部分
  labels:   # 为 Deployment 添加标签
    app: huazi   # 标签的键是 app，值是 huazi
  name: huazi   #Deployment 的名称
spec:   # 规格部分，定义了 Deployment 的具体配置
  replicas: 2   # 指定要创建的Pod数量，这里是 2个
  selector:   # 用于选择哪些 Pod 属于这个 Deployment
    matchLabels:   # 通过标签选择器来匹配 Pod
      app: huazi   # 匹配标签 app=huazi 的 Pod
  template:   # Pod 模板部分，定义了 Pod 的具体配置
    metadata:  # Pod 的元数据
      labels:   # 为 Pod 添加标签
        app: huazi   # 标签的键是 app，值是 huazi
    spec:    # Pod 的规格
      containers:  # 容器列表
      - image: myapp:v1
        name: myapp

[root@k8s-master ~]# kubectl apply -f huazi-dp.yml
deployment.apps/huazi created

[root@k8s-master ~]# kubectl get deployments.apps huazi
NAME    READY   UP-TO-DATE   AVAILABLE   AGE
huazi   2/2     2            2           19s

[root@k8s-master ~]# kubectl get pods -o wide
NAME                     READY   STATUS    RESTARTS   AGE   IP            NODE            NOMINATED NODE   READINESS GATES
huazi-646d7864fd-2mnhc   1/1     Running   0          7s    10.244.1.10   k8s-node1.org   <none>           <none>
huazi-646d7864fd-sznrb   1/1     Running   0          7s    10.244.2.8    k8s-node2.org   <none>           <none>

[root@k8s-master ~]# kubectl expose deployment huazi --port 8080 --target-port 80
service/huazi exposed
[root@k8s-master ~]# kubectl get svc huazi
NAME    TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)    AGE
huazi   ClusterIP   10.110.26.53   <none>        8080/TCP   11s

[root@k8s-master ~]# kubectl describe svc
huazi       kubernetes
[root@k8s-master ~]# kubectl describe svc huazi
Name:              huazi
Namespace:         default
Labels:            app=huazi
Annotations:       <none>
Selector:          app=huazi
Type:              ClusterIP    #service的类型为ClusterIP
IP Family Policy:  SingleStack
IP Families:       IPv4
IP:                10.110.26.53    #service中的一个ip地址
IPs:               10.110.26.53
Port:              <unset>  8080/TCP
TargetPort:        80/TCP
Endpoints:         10.244.1.10:80,10.244.2.8:80   #pod中的ip地址
Session Affinity:  None
Events:            <none>

#访问pod的ip地址
[root@k8s-master ~]# curl 10.244.1.10/hostname.html
huazi-646d7864fd-2mnhc
[root@k8s-master ~]# curl 10.244.2.8/hostname.html
huazi-646d7864fd-sznrb

当我们访问service的ip地址时，可以发现实现了负载均衡

[root@k8s-master ~]# curl 10.110.26.53:8080/hostname.html
huazi-646d7864fd-sznrb
[root@k8s-master ~]# curl 10.110.26.53:8080/hostname.html
huazi-646d7864fd-2mnhc
[root@k8s-master ~]# curl 10.110.26.53:8080/hostname.html
huazi-646d7864fd-sznrb
[root@k8s-master ~]# curl 10.110.26.53:8080/hostname.html
huazi-646d7864fd-2mnhc

应用版本的更新和回滚（不常用，一般都是用的yaml文件的方式更新）

利用控制器建立pod，控制器里面运行2个pod

#利用控制器建立pod，控制器里面运行2个pod
[root@k8s-master ~]# kubectl create deployment huazi --image myapp:v1 --replicas 2
deployment.apps/huazi created


[root@k8s-master ~]# kubectl get pods -o wide
NAME                     READY   STATUS    RESTARTS   AGE   IP            NODE            NOMINATED NODE   READINESS GATES
huazi-646d7864fd-5qbzk   1/1     Running   0          16s   10.244.2.25   k8s-node2.org   <none>           <none>
huazi-646d7864fd-vn7dt   1/1     Running   0          16s   10.244.1.15   k8s-node1.org   <none>           <none>

service端口暴露（在暴露端口之前，必须先运行pod或控制器）

[root@k8s-master ~]# kubectl expose deployment huazi --port 8080 --target-port 80
service/huazi exposed


[root@k8s-master ~]# kubectl get services
NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
huazi        ClusterIP   10.97.207.164   <none>        8080/TCP   29s
kubernetes   ClusterIP   10.96.0.1       <none>        443/TCP    4d6h


[root@k8s-master ~]# kubectl describe svc huazi
Name:              huazi
Namespace:         default
Labels:            app=huazi
Annotations:       <none>
Selector:          app=huazi
Type:              ClusterIP   #service的类型
IP Family Policy:  SingleStack
IP Families:       IPv4
IP:                10.97.207.164   #service中的ip地址
IPs:               10.97.207.164
Port:              <unset>  8080/TCP
TargetPort:        80/TCP
Endpoints:         10.244.2.25:80,10.244.1.15:80   #pod的ip地址
Session Affinity:  None
Events:            <none>

访问service服务上的ip

[root@k8s-master ~]# curl 10.97.207.164:8080
Hello MyApp | Version: v1 | <a href="hostname.html">Pod Name</a>

查看历史版本

[root@k8s-master ~]# kubectl rollout history deployment huazi
deployment.apps/huazi
REVISION  CHANGE-CAUSE
1         <none>

更新控制器镜像版本

[root@k8s-master ~]# kubectl set image deployments/huazi myapp=myapp:v2
deployment.apps/huazi image updated


#查看历史版本
[root@k8s-master ~]# kubectl rollout history deployment huazi
deployment.apps/huazi
REVISION  CHANGE-CAUSE
1         <none>
2         <none>

访问内容测试

[root@k8s-master ~]# curl 10.97.207.164:8080
Hello MyApp | Version: v2 | <a href="hostname.html">Pod Name</a>

版本回滚

[root@k8s-master ~]# kubectl rollout undo deployment huazi --to-revision 1
deployment.apps/huazi rolled back


[root@k8s-master ~]# curl 10.97.207.164:8080
Hello MyApp | Version: v1 | <a href="hostname.html">Pod Name</a>


[root@k8s-master ~]# kubectl rollout history deployment huazi
deployment.apps/huazi
REVISION  CHANGE-CAUSE
2         <none>
3         <none>

3.利用`yaml`文件部署应用

优点

声明式配置：

清晰表达期望状态：以声明式的方式描述应用的部署要求，包括pod数量、容器配置、网络设置等。这使得配置易于理解和维护，并且可以方便地查看应用的预期状态。
可重复性和版本控制：配置文件可以被版本控制，确保在不同环境中的部署一致性。可以轻松回滚到以前的版本或在不同环境中重复使用相同的配置
团队协作：便于团队成员之间共享和协作，大家可以对配置文件进行审查和修改，提高部署的可靠性和稳定性。

灵活性和可扩展性（解决create不能创建的资源）

丰富的配置选项：可以通过yaml文件详细地配置各种Kubernetes资源，如Deployment、Service、ConfigMap、Secret等。可以根据应用地特定需求进行高度定制化。（因为有的资源通过create命令的方式建立是有限的，只能通过yaml文件创建）
组合和扩展：可以将多个资源地配置组合在一个或多个yaml文件中，实现复杂地应用部署框架。同时，可以轻松地添加新的资源或修改现有资源以满足不断变化的需求。

与工具集成

与CI/CD流程集成：可以将yaml配置文件与持续集成和持续部署（CI/CD）工具集成，实现自动化的应用部署。例如，可以在代码提交后自动触发部署流程，使用配置文件来部署应用到不同的环境。
命令行工具支持：Kubernetes的命令行工具kubectl对yaml配置文件有很好的支持，可以方便地应用、更新、和删除配置。同时，还可以使用其他工具来验证和分析yaml配置文件，确保其正确性和安全性。

3.1`yaml`配置文件参数

参数名称	类型	参数说明
`apiVersion`	`string`	这里是指的是`k8s api`的`版本`，目前基本上是`v1`，可以用`kubectl api-version`命令查询
`kind`	`string`	这里指的是`yaml文件`定义的`资源类型和角色`，比如：`Pod`
`metadata`	`object`	`元数据对象`，`固定值`，就写`metadata`就行，`冒号后没有值`
`metadata.name`	`string`	`元数据对象`的`名字`，`自定义`，比如`Pod的名字`
`metadata.namespace`	`string`	`元数据对象`的`命名空间`，`自定义`
`spec`	`object`	`详细定义对象`，`固定值`，就写`spec`就行，`冒号后没有值`
`spec.containers[]`	`list`	这里是`spec对象`的`容器列表`定义，是个`列表`。`冒号后没有值`
`spec.containers[].image`	`string`	`镜像名称`
`spec.containers[].name`	`string`	`容器名称`
`spec.containers[].command[]`	`list`	指定`容器运行时`启动的`命令`，若`未指定`则运行容器打包时`指定的命令`
`spec.containers[].imagePullPolicy`	`string`	定义`镜像拉取策略`，`Always`：`每次都尝试重新拉取镜像`；`ifNotPresent`：如果`本地有镜像就使用本地镜像，本地没有再拉取`；`Never`：`仅使用本地镜像`
`spec.containers[].args[]`	`list`	指定容器运行`参数`，可以指定`多个`
`spec.containers[].workingDir`	`string`	指定`容器工作目录`
`spec.containers[].volumeMounts[]`	`list`	指定`容器内部`的`存储卷`配置
`spec.containers[].volumeMounts[].name`	`string`	指定可以`被容器挂载的存储卷`的`名称`
`spec.containers[].volumeMounts[].mountPath`	`string`	可以被`容器`挂载的`存储卷的路径`
`spec.containers[].volumeMounts[].readOnly`	`string`	设置`存储卷路径`的`读写模式`，`true或false`，默认为`读写模式`
`spec.containers[].ports[]`	`list`	指定`容器`需要用到的`端口列表`
`spec.containers[].ports[].name`	`string`	指定`端口名称`，自定义
`spec.containers[].ports[].containerPort`	`string`	指定`容器`需要监听的`端口号`
`spec.containers[].ports[].hostPort`	`string`	指定`容器`所在`node主机`需要监听的`端口号`，默认跟上面`containerPort`相同。注意：设置了`hostPort`，同一台主机无法启动`该容器`的`相同副本`（因为`主机`的`端口号`不能相同，这样会`冲突`）
`spec.containers[].ports[].protocol`	`string`	指定`端口协议`，支持`tcp`和`udp`，默认值为`tcp`
`spec.containers[].env[]`	`list`	指定`容器`运行前需设置的`环境变量列表`
`spec.containers[].env[].name`	`string`	指定`环境变量`名称
`spec.containers[].env[].value`	`string`	指定环境`变量值`
`spec.containers[].resources`	`object`	指定`资源限制`和`资源请求`的`值`（这里开始就是设置`容器`的`资源上限`）
`spec.containers[].resources.limits`	`object`	指定设置`容器`运行时`资源`的`运行上限`
`spec.containers[].resources.limits.cpu`	`string`	指定`cpu`的限制，单位为`核心数`，`1=1000m`，`0.5=500m`
`spec.containers[].resources.limits.memory`	`string`	指定`mem内存`的`限制`，单位为`MIB、GIB`
`spec.containers[].resources.requests`	`object`	指定容器`启动`和`调度`时的`限制设置`
`spec.containers[].resources.requests.cpu`	`string`	`cpu请求`，单位为`core数`，容器`启动时`初始化可用`数量`
`spec.containers[].resources.requests.memory`	`string`	`内存请求`，单位为`MIB、GIB`，容器启动的初始化可用数量
`spec.restartPolicy`	`string`	定义`pod`的`重启策略`，默认值为`Always`。 (1)`Always`：`pod`一旦终止运行，无论容器是如何终止的，`kubelet`服务都将`重启`它 (2)`OnFailure`：只有`pod`以`非零退出码`终止时，`kubelet`才会重启`该容器`。如果`容器正常结束`(`退出码为0`)，则`kubelet`将不会`重启它` (3)`Never`：`pod`终止后，`kubelet`将`退出码`报告给`master`，不会重启该`容器`
`spec.nodeSelector`	`object`	自行选择`pod`在`node`上的`运行节点`。定义`node`的`label`过滤标签，以`key:value`格式指定
`spec.imagePullSecrets`	`object`	定义`pull`镜像时使用`secret`名称，以`name:secretkey`格式指定
`spec.hostNetwork`	`boolean`	定义是否使用`主机网络`模式，默认值为`false`。设置`true`表示使用`宿主机网络`，不使用`docker`网桥，同时设置了`true`将无法在`同一台宿主机`上启动`第二个副本`

[root@k8s-master ~]# kubectl api-resources
资源名称                            名称的缩写     api的版本                         命名空间      资源种类
NAME                                SHORTNAMES   APIVERSION                        NAMESPACED   KIND
bindings                                         v1                                true         Binding
componentstatuses                   cs           v1                                false        ComponentStatus
configmaps                          cm           v1                                true         ConfigMap
endpoints                           ep           v1                                true         Endpoints
events                              ev           v1                                true         Event
limitranges                         limits       v1                                true         LimitRange
namespaces                          ns           v1                                false        Namespace
nodes                               no           v1                                false        Node
persistentvolumeclaims              pvc          v1                                true         PersistentVolumeClaim
persistentvolumes                   pv           v1                                false        PersistentVolume
pods                                po           v1                                true         Pod
podtemplates                                     v1                                true         PodTemplate
replicationcontrollers              rc           v1                                true         ReplicationController
resourcequotas                      quota        v1                                true         ResourceQuota
secrets                                          v1                                true         Secret
serviceaccounts                     sa           v1                                true         ServiceAccount
services                            svc          v1                                true         Service
mutatingwebhookconfigurations                    admissionregistration.k8s.io/v1   false        MutatingWebhookConfiguration
validatingadmissionpolicies                      admissionregistration.k8s.io/v1   false        ValidatingAdmissionPolicy
validatingadmissionpolicybindings                admissionregistration.k8s.io/v1   false        ValidatingAdmissionPolicyBinding
validatingwebhookconfigurations                  admissionregistration.k8s.io/v1   false        ValidatingWebhookConfiguration
customresourcedefinitions           crd,crds     apiextensions.k8s.io/v1           false        CustomResourceDefinition
apiservices                                      apiregistration.k8s.io/v1         false        APIService
controllerrevisions                              apps/v1                           true         ControllerRevision
daemonsets                          ds           apps/v1                           true         DaemonSet
deployments                         deploy       apps/v1                           true         Deployment
replicasets                         rs           apps/v1                           true         ReplicaSet
statefulsets                        sts          apps/v1                           true         StatefulSet
selfsubjectreviews                               authentication.k8s.io/v1          false        SelfSubjectReview
tokenreviews                                     authentication.k8s.io/v1          false        TokenReview
localsubjectaccessreviews                        authorization.k8s.io/v1           true         LocalSubjectAccessReview
selfsubjectaccessreviews                         authorization.k8s.io/v1           false        SelfSubjectAccessReview
selfsubjectrulesreviews                          authorization.k8s.io/v1           false        SelfSubjectRulesReview
subjectaccessreviews                             authorization.k8s.io/v1           false        SubjectAccessReview
horizontalpodautoscalers            hpa          autoscaling/v2                    true         HorizontalPodAutoscaler
cronjobs                            cj           batch/v1                          true         CronJob
jobs                                             batch/v1                          true         Job
certificatesigningrequests          csr          certificates.k8s.io/v1            false        CertificateSigningRequest
leases                                           coordination.k8s.io/v1            true         Lease
endpointslices                                   discovery.k8s.io/v1               true         EndpointSlice
events                              ev           events.k8s.io/v1                  true         Event
flowschemas                                      flowcontrol.apiserver.k8s.io/v1   false        FlowSchema
prioritylevelconfigurations                      flowcontrol.apiserver.k8s.io/v1   false        PriorityLevelConfiguration
bfdprofiles                                      metallb.io/v1beta1                true         BFDProfile
bgpadvertisements                                metallb.io/v1beta1                true         BGPAdvertisement
bgppeers                                         metallb.io/v1beta2                true         BGPPeer
communities                                      metallb.io/v1beta1                true         Community
ipaddresspools                                   metallb.io/v1beta1                true         IPAddressPool
l2advertisements                                 metallb.io/v1beta1                true         L2Advertisement
servicel2statuses                                metallb.io/v1beta1                true         ServiceL2Status
ingressclasses                                   networking.k8s.io/v1              false        IngressClass
ingresses                           ing          networking.k8s.io/v1              true         Ingress
networkpolicies                     netpol       networking.k8s.io/v1              true         NetworkPolicy
runtimeclasses                                   node.k8s.io/v1                    false        RuntimeClass
poddisruptionbudgets                pdb          policy/v1                         true         PodDisruptionBudget
clusterrolebindings                              rbac.authorization.k8s.io/v1      false        ClusterRoleBinding
clusterroles                                     rbac.authorization.k8s.io/v1      false        ClusterRole
rolebindings                                     rbac.authorization.k8s.io/v1      true         RoleBinding
roles                                            rbac.authorization.k8s.io/v1      true         Role
priorityclasses                     pc           scheduling.k8s.io/v1              false        PriorityClass
csidrivers                                       storage.k8s.io/v1                 false        CSIDriver
csinodes                                         storage.k8s.io/v1                 false        CSINode
csistoragecapacities                             storage.k8s.io/v1                 true         CSIStorageCapacity
storageclasses                      sc           storage.k8s.io/v1                 false        StorageClass
volumeattachments                                storage.k8s.io/v1                 false        VolumeAttachment

创建`pod`时，如何指定`namespace`

#创建一个名为huazispace的命名空间
[root@k8s-master ~]# kubectl create namespace huazispace
namespace/huazispace created
[root@k8s-master ~]# kubectl get namespaces
NAME              STATUS   AGE
default           Active   24d
huazispace        Active   10s   #这里
ingress-nginx     Active   3d6h
kube-flannel      Active   24d
kube-node-lease   Active   24d
kube-public       Active   24d
kube-system       Active   24d
metallb-system    Active   6d1h

#运行一个名为huazi的pod
[root@k8s-master ~]# kubectl run huazi --image myapp:v1 --dry-run=client -o yaml > huazi-pod.yml

[root@k8s-master ~]# vim huazi-pod.yml

在这里插入图片描述

[root@k8s-master ~]# kubectl apply -f huazi-pod.yml
pod/huazi created


[root@k8s-master ~]# kubectl -n huazispace get pods
NAME    READY   STATUS    RESTARTS   AGE
huazi   1/1     Running   0          27s


[root@k8s-master ~]# kubectl -n huazispace get pods -o wide
NAME    READY   STATUS    RESTARTS   AGE   IP            NODE            NOMINATED NODE   READINESS GATES
huazi   1/1     Running   0          46s   10.244.2.10   k8s-node2.org   <none>           <none>

指定`command`

[root@k8s-master ~]# kubectl create deployment huazi --image myapp:v1 --replicas 2 --dry-run=client -o yaml > huazi-dp.yml


[root@k8s-master ~]# vim huazi-dp.yml
[root@k8s-master ~]# cat huazi-dp.yml
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: huazi
  name: huazi
spec:
  replicas: 2
  selector:
    matchLabels:
      app: huazi
  template:
    metadata:
      labels:
        app: huazi
    spec:
      containers:
      - image: myapp:v1
        name: myapp
      - image: busybox:latest
        name: busybox
        command: ["/bin/sh","-c","echo hello world"]   #这里指定command

[root@k8s-master ~]# kubectl apply -f huazi-dp.yml
deployment.apps/huazi created
[root@k8s-master ~]# kubectl get deployments.apps huazi
NAME    READY   UP-TO-DATE   AVAILABLE   AGE
huazi   0/2     2            0           10s     #每个pod中的所有容器都要处于运行状态，否则都不会ready
[root@k8s-master ~]# kubectl get pods -o wide
NAME                     READY   STATUS     RESTARTS      AGE   IP            NODE            NOMINATED NODE   READINESS GATES
huazi-65f96f858b-lrcsq   1/2     NotReady   2 (21s ago)   23s   10.244.2.11   k8s-node2.org   <none>           <none>
huazi-65f96f858b-z86nf   1/2     NotReady   2 (22s ago)   23s   10.244.1.12   k8s-node1.org   <none>           <none>
#每个pod中正在运行的容器是myapp，busybox已经运行完了

#那么我们如何证明busybox已经运行完了呢？
# -c指定pod中的容器
[root@k8s-master ~]# kubectl logs huazi-65f96f858b-lrcsq -c busybox
hello world
[root@k8s-master ~]# kubectl logs huazi-65f96f858b-z86nf -c busybox
hello world

`hostNetwork`

[root@k8s-master ~]# kubectl run huazi --image myapp:v1 --dry-run=client -o yaml > huazi-host.yml

[root@k8s-master ~]# vim huazi-host.yml

在这里插入图片描述

[root@k8s-master ~]# kubectl apply -f huazi-host.yml
pod/huazi created


[root@k8s-master ~]# kubectl get pods -o wide
NAME    READY   STATUS    RESTARTS   AGE   IP              NODE            NOMINATED NODE   READINESS GATES
huazi   1/1     Running   0          9s    172.25.254.20   k8s-node2.org   <none>           <none>

我们发现它使用的是node主机的ip

[root@k8s-master ~]# curl 172.25.254.20
Hello MyApp | Version: v1 | <a href="hostname.html">Pod Name</a>

3.2如何获取资源帮助`explain`

[root@k8s-master ~]# kubectl explain pod.spec.containers

yaml文件编写示例

1.运行简单的单个容器pod

用命令获取yaml模板

[root@k8s-master ~]# kubectl run huazi --image myapp:v1 --dry-run=client -o yaml > pod.yml


[root@k8s-master ~]# cat pod.yml
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: huazi  #pod标签
  name: huazi   #pod名称
spec:
  containers:
  - image: myapp:v1   #pod镜像
    name: huazi    #容器名称

[root@k8s-master ~]# kubectl apply -f pod.yml
pod/huazi created


[root@k8s-master ~]# kubectl get pods -o wide
NAME    READY   STATUS    RESTARTS   AGE   IP            NODE            NOMINATED NODE   READINESS GATES
huazi   1/1     Running   0          6s    10.244.1.18   k8s-node1.org   <none>           <none>

2.运行多个容器`pod`

注意：如果多个容器运行在一个pod中，资源共享的同时在使用相同资源时也会干扰，比如端口

一个端口干扰示例：

#在一个pod中运行2个nginx
[root@k8s-master ~]# cat pod.yml
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: huazi   #pod的标签
  name: huazi   #pod的名字
spec:
  containers:
    - image: nginx   #pod的第一个镜像
      name: web1   #容器名
    - image: nginx  #pod中的第二个镜像
      name: web2   #容器名

[root@k8s-master ~]# kubectl apply -f pod.yml
pod/huazi created

#我们发现一个pod中运行2个nginx，只能运行一个
[root@k8s-master ~]# kubectl get pods -o wide
NAME    READY   STATUS             RESTARTS      AGE     IP            NODE            NOMINATED NODE   READINESS GATES
huazi   1/2     CrashLoopBackOff   5 (19s ago)   3m17s   10.244.2.21   k8s-node2.org   <none>           <none>

#查看日志后，发现80端口被占用
[root@k8s-master ~]# kubectl logs pods/huazi web2

在这里插入图片描述

从侧面可以反应出：pod是一个系统，pod中的容器是一个应用程序，一个系统的一个应用程序只能有`一个

在一个pod中开启多个容器时一定要确保容器彼此不能相互干扰

[root@k8s-master ~]# cat pod.yml
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: huazi
  name: huazi
spec:
  containers:
  - image: nginx
    name: web1
  - image: busybox
    name: busybox
    command: ["/bin/sh","-c","sleep 10000"]


[root@k8s-master ~]# kubectl apply -f pod.yml
pod/huazi created


[root@k8s-master ~]# kubectl get pods -o wide
NAME    READY   STATUS    RESTARTS   AGE   IP            NODE            NOMINATED NODE   READINESS GATES
huazi   2/2     Running   0          10s   10.244.1.19   k8s-node1.org   <none>           <none>

3.理解`pod`间的网络整合

同一个pod中的容器公用一个网络

[root@k8s-master ~]# cat pod.yml
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: huazi
  name: huazi
spec:
  containers:
  - image: nginx
    name: web1
  - image: busyboxplus
    name: busyboxplus
    command: ["/bin/sh","-c","sleep 10000"]


[root@k8s-master ~]# kubectl apply -f pod.yml
pod/huazi created


[root@k8s-master ~]# kubectl get pods -o wide
NAME    READY   STATUS    RESTARTS   AGE   IP            NODE            NOMINATED NODE   READINESS GATES
huazi   2/2     Running   0          57s   10.244.2.28   k8s-node2.org   <none>           <none>

#exec进入容器
#-c指定容器
[root@k8s-master ~]# kubectl exec -it huazi -c busyboxplus -- /bin/sh
/ # curl 10.244.2.28
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

这里我们发现，busyboxplus是一个busyboxplus的容器，但是为什么可以访问到nginx容器呢？原因就是：busyboxplus和nginx在一个pod中，共用同一个资源。也从侧面可以反应出：pod是一个系统

4.端口映射（node-容器）(`spec.containers[].ports[]`)

[root@k8s-master ~]# cat pod.yml
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: huazi
  name: huazi
spec:
  containers:
    - image: myapp:v1
      name: myapp1
      ports:
        - name: http   #名字自定义
          containerPort: 80  #容器中的服务端口
          hostPort: 8080   #宿主机的端口
          protocol: TCP


[root@k8s-master ~]# kubectl apply -f pod.yml
pod/huazi created


[root@k8s-master ~]# kubectl get pods -o wide
NAME    READY   STATUS    RESTARTS   AGE   IP            NODE            NOMINATED NODE   READINESS GATES
huazi   1/1     Running   0          12s   10.244.1.20   k8s-node1.org   <none>           <none>


[root@k8s-master ~]# curl k8s-node1.org:8080
Hello MyApp | Version: v1 | <a href="hostname.html">Pod Name</a>

5.如何设定`环境变量`，`spec.containers[].env[]`

[root@k8s-master ~]# cat pod.yml
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: huazi
  name: huazi
spec:
  containers:
    - image: busybox
      name: busybox
      command: ["/bin/sh","-c","echo $NAME;sleep 10000"]
      env:
        - name: NAME  #NAME为变量名
          value: "hello world"  #变量值



[root@k8s-master ~]# kubectl apply -f pod.yml
pod/huazi created

#-c指定pod中的容器
[root@k8s-master ~]# kubectl logs pods/huazi -c busybox
hello world

6.资源限制，`spec.containers[].resources`

资源限制会影响pod的Qos Class资源优先级，资源优先级分为Guaranteed > Burstable > BestEffort

Qos即服务质量

资源设定	优先级类型
`资源限定未设定`	`BestEffort`
`资源限定设定且最大和最小不一致`	`Burstable`
`资源限定设定且最大和最小一致`	`Guaranteed`

limits（容器运行时的最大资源,，cpu: 1或cpu: 1000m）

在这里插入图片描述

requests（期望，指容器运行时的最小资源，不能大于limits）

在这里插入图片描述

[root@k8s-master ~]# cat pod.yml
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: huazi
  name: huazi
spec:
  containers:
    - image: myapp:v1
      name: myapp
      resources:
        limits:       #pod使用资源的最高限制
          cpu: 500m
          memory: 100Mi
        requests:     #pod期望的资源(运行容器的最小资源)，不能大于limits
          cpu: 500m
          memory: 100Mi


[root@k8s-master ~]# kubectl apply -f pod.yml
pod/huazi created


[root@k8s-master ~]# kubectl get pods -o wide
NAME    READY   STATUS    RESTARTS   AGE   IP            NODE            NOMINATED NODE   READINESS GATES
huazi   1/1     Running   0          8s    10.244.1.21   k8s-node1.org   <none>           <none>


[root@k8s-master ~]# kubectl describe pods huazi
......
......
......
    Limits:
      cpu:     500m
      memory:  100Mi
    Requests:
      cpu:        500m
      memory:     100Mi
......
Qos class:       Guaranteed
......
......

7.容器启动管理`spec.restartPolicy`

Always：pod一旦终止运行，无论容器是如何终止的，kubelet服务都将重启它
OnFailure：只有pod以非零退出码终止时，kubelet才会重启该容器。如果容器正常结束(退出码为0)，则kubelet将不会重启它
Never：pod终止后，kubelet将退出码报告给master，不会重启该容器，即只启动一次

示例1：

[root@k8s-master ~]# cat pod.yml
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: huazi
  name: huazi
spec:
  restartPolicy: Always  #pod的重启策略
  containers:
    - image: myapp:v1
      name: myapp

[root@k8s-master ~]# kubectl apply -f pod.yml
pod/huazi created


[root@k8s-master ~]# kubectl get pods -o wide
NAME    READY   STATUS    RESTARTS   AGE   IP            NODE            NOMINATED NODE   READINESS GATES
huazi   1/1     Running   0          8s    10.244.2.30   k8s-node2.org   <none>           <none>

[root@k8s-node2 ~]# docker ps
CONTAINER ID   IMAGE                            COMMAND                   CREATED          STATUS          PORTS     NAMES
d484c3dc3278   d4a5e0eaa84f                     "nginx -g 'daemon of…"   40 seconds ago   Up 39 seconds             k8s_myapp_huazi_default_3382f3a9-c6b0-4875-a58e-53afe799ab3d_0


[root@k8s-node2 ~]# docker rm -f k8s_myapp_huazi_default_3382f3a9-c6b0-4875-a58e-53af
k8s_myapp_huazi_default_3382f3a9-c6b0-4875-a58e-53afe799ab3d_0

#删了之后，又会重新起一个pod
[root@k8s-node2 ~]# docker ps
CONTAINER ID   IMAGE                            COMMAND                   CREATED              STATUS              PORTS     NAMES
c155437452b9   d4a5e0eaa84f                     "nginx -g 'daemon of…"   4 seconds ago        Up 3 seconds                  k8s_myapp_huazi_default_3382f3a9-c6b0-4875-a58e-53afe799ab3d_1

示例2：

[root@k8s-master ~]# kubectl run huazi --image busybox --dry-run=client -o yaml > huazi.yml


[root@k8s-master ~]# vim huazi.yml

在这里插入图片描述

[root@k8s-master ~]# kubectl apply -f huazi.yml
pod/huazi created

#CrashLoopBackOff，表示容器尝试启动但失败了，并且 Kubernetes 正在尝试重新启动它，一直陷入重启状态
[root@k8s-master ~]# kubectl get pods -o wide
NAME    READY   STATUS             RESTARTS     AGE   IP            NODE            NOMINATED NODE   READINESS GATES
huazi   0/1     CrashLoopBackOff   1 (7s ago)   9s    10.244.2.12   k8s-node2.org   <none>           <none>

8.自行选择运行节点，`spec.nodeSelector`

[root@k8s-master ~]# cat pod.yml
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: huazi
  name: huazi
spec:
  nodeSelector:
    kubernetes.io/hostname: k8s-node1.org  #通过键值对的形式，kubernetes.io/hostname是Kubernetes自动为节点添加的标签，用于表示节点的主机名
  containers:
    - image: myapp:v1
      name: myapp


[root@k8s-master ~]# kubectl apply -f pod.yml
pod/huazi created


#我们发现在node1上运行了
[root@k8s-master ~]# kubectl get pods -o wide
NAME    READY   STATUS    RESTARTS   AGE   IP            NODE            NOMINATED NODE   READINESS GATES
huazi   1/1     Running   0          13s   10.244.1.22   k8s-node1.org   <none>           <none>

`nodeSelector` 的使用

要在 YAML 文件中使用 nodeSelector，你需要首先确保目标节点上已经设置了相应的标签。然后，在 Pod 的定义文件中，通过 .spec.nodeSelector 字段来指定这些标签。Pod 将会被调度到至少有一个标签满足 nodeSelector 中所有指定条件的节点上。

YAML 文件示例

以下是一个包含 nodeSelector 的 Pod YAML 文件示例：

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
  labels:
    app: my-app
spec:
  nodeSelector:
    disktype: ssd
    kubernetes.io/hostname: k8s-node1.org
  containers:
  - name: my-container
    image: my-image

在这个示例中，Pod my-pod 将被调度到具有以下两个标签的节点上：

disktype=ssd
kubernetes.io/hostname=k8s-node1.org

设置node节点标签

在使用 nodeSelector 之前，你需要使用 kubectl label 命令为目标节点设置标签。例如，要为名为 k8s-node1.org 的节点设置 disktype=ssd 标签，你可以执行以下命令：

kubectl label nodes k8s-node1.org disktype=ssd

同样地，你可以为节点设置多个标签，例如：

kubectl label nodes k8s-node1.org disktype=ssd kubernetes.io/hostname=k8s-node1.org

但请注意，kubernetes.io/hostname 通常是 Kubernetes 自动为节点添加的标签，用于表示节点的主机名，因此你可能不需要手动设置它。

查看node节点标签

你可以使用 kubectl get nodes --show-labels 命令来列出集群中所有节点的信息，并显示它们的标签。这将帮助你验证是否已正确设置了节点的标签。

注意事项

nodeSelector 提供了基本的调度控制，但它不支持复杂的逻辑表达或集合操作。对于更高级的调度需求，你可以使用节点亲和性（nodeAffinity）或反亲和性（nodeAntiAffinity）规则。
确保 nodeSelector 中指定的标签与节点上的标签完全匹配，否则 Pod 将无法被调度到任何节点上。
在生产环境中，谨慎使用 nodeSelector，因为它可能会限制 Pod 的可用性和容错性。如果可能的话，考虑使用更灵活的调度策略，如节点亲和性或反亲和性。

9.共享宿主机网络`hostNetwork`

[root@k8s-master ~]# cat pod.yml
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: huazi
  name: huazi
spec:
  hostNetwork: true
  containers:
    - image: busybox
      name: busybox
      command: ["/bin/sh","-c","sleep 10000"]


[root@k8s-master ~]# kubectl apply -f pod.yml
pod/huazi created


#我们可以发现eth0，即busybox共享了node宿主节点的网卡
[root@k8s-master ~]# kubectl exec -it pods/huazi -c busybox -- /bin/sh
/ # ifconfig
cni0      Link encap:Ethernet  HWaddr 22:C0:49:80:83:77
          inet addr:10.244.1.1  Bcast:10.244.1.255  Mask:255.255.255.0
          inet6 addr: fe80::20c0:49ff:fe80:8377/64 Scope:Link
          UP BROADCAST MULTICAST  MTU:1500  Metric:1
          RX packets:409 errors:0 dropped:0 overruns:0 frame:0
          TX packets:230 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:29496 (28.8 KiB)  TX bytes:21069 (20.5 KiB)

docker0   Link encap:Ethernet  HWaddr 02:42:A8:49:89:52
          inet addr:172.17.0.1  Bcast:172.17.255.255  Mask:255.255.0.0
          UP BROADCAST MULTICAST  MTU:1500  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0
          RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)

eth0      Link encap:Ethernet  HWaddr 00:0C:29:DB:48:D7
          inet addr:172.25.254.10  Bcast:172.25.254.255  Mask:255.255.255.0
          inet6 addr: fe80::7baa:9520:639b:5e48/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:811130 errors:0 dropped:0 overruns:0 frame:0
          TX packets:429677 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:806703703 (769.3 MiB)  TX bytes:47436488 (45.2 MiB)

flannel.1 Link encap:Ethernet  HWaddr 86:D8:BA:15:B9:0F
          inet addr:10.244.1.0  Bcast:0.0.0.0  Mask:255.255.255.255
          inet6 addr: fe80::84d8:baff:fe15:b90f/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1450  Metric:1
          RX packets:87 errors:0 dropped:0 overruns:0 frame:0
          TX packets:63 errors:0 dropped:81 overruns:0 carrier:0
          collisions:0 txqueuelen:0
          RX bytes:6371 (6.2 KiB)  TX bytes:6801 (6.6 KiB)

lo        Link encap:Local Loopback
          inet addr:127.0.0.1  Mask:255.0.0.0
          inet6 addr: ::1/128 Scope:Host
          UP LOOPBACK RUNNING  MTU:65536  Metric:1
          RX packets:3441 errors:0 dropped:0 overruns:0 frame:0
          TX packets:3441 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:291963 (285.1 KiB)  TX bytes:291963 (285.1 KiB)

`pod`的生命周期

`init`容器

在这里插入图片描述

pod可以包含多个容器，应用运行在这些容器里面，同时pod也可以有一个或多个先于应用容器启动的init容器。
init容器与普通的容器非常像，除了如下两点：
- 它们总是运行到完成
- init容器不支持Readiness，因为它们必须在pod就绪之前运行完成，否则pod运行不起来。一个init容器必须运行成功，下一个init才能运行。
如果pod的init容器失败，Kubernetes会不断地重启该pod，直到init容器成功为止，才开始运行pod中的容器。
但是，如果pod对应地restartPolicy值为Never，它不会重新启动。

`init容器`的功能

init容器可以包含一些安装过程中应用容器中不存在的实用工具或个性化代码
init容器可以安全地运行这些工具，避免这些工具导致应用镜像地安全性降低
应用镜像的创建者和部署者可以各自独立工作，而没有必要联合构建一个单独的应用镜像
init容器能以不同于Pod内应用容器的文件系统视图运行。因此，Init容器可具有访问 Secrets 的权限，而应用容器不能够访问。
由于 Init容器必须在应用容器启动之前运行完成，因此 Init容器提供了一种机制来阻塞或延迟应用容器的启动，直到满足了一组先决条件。一旦前置条件满足，Pod内的所有的应用容器会并行启动。

`init容器`示例

示例1：

默认没有init容器，需要我们自己添加
initContainers

[root@k8s-master ~]# cat pod.yml
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: huazi
  name: huazi
spec:
  containers:
    - image: myapp:v1
      name: myapp
  initContainers:   #添加一个init容器
    - image: busybox
      name: init-myservice
      command: ["sh","-c","until test -e /testfile;do echo wating for myservice;sleep 2;done"]  #判断testfile文件是否存在,其中until是一个循环,当条件不成立时循环echo wating for myservice;sleep 2命令


[root@k8s-master ~]# kubectl apply -f pod.yml
pod/huazi created
[root@k8s-master ~]# kubectl get pods -o wide
NAME    READY   STATUS     RESTARTS   AGE   IP            NODE            NOMINATED NODE   READINESS GATES
huazi   0/1     Init:0/1   0          15s   10.244.2.31   k8s-node2.org   <none>           <none>


#-c指定pod中的容器
[root@k8s-master ~]# kubectl logs pods/huazi -c init-myservice
wating for myservice
wating for myservice
wating for myservice
wating for myservice
wating for myservice
wating for myservice
wating for myservice
wating for myservice
wating for myservice


#当创建完文件后，运行成功
[root@k8s-master ~]# kubectl exec pods/huazi -c init-myservice -- /bin/sh -c "touch /testfile"

[root@k8s-master ~]# kubectl get pods -o wide
NAME    READY   STATUS    RESTARTS   AGE     IP            NODE            NOMINATED NODE   READINESS GATES
huazi   1/1     Running   0          2m24s   10.244.2.31   k8s-node2.org   <none>           <none>

探针

探针是由kubelet对容器执行的定期诊断，以下是检测方式

ExecAction：在容器内执行指定命令。如果命令退出时返回码为0，则认为诊断成功。
TCPSocketAction：对指定端口上的容器的ip地址进行TCP检查，如果端口打开，则诊断被认为是成功的。
HTTPGetAction：对指定的端口和路径上的容器的ip地址执行HTTP Get请求。如果响应的状态码大于等于200且小于400，则诊断被认为是成功的。

每次探测都将获得以下三种结果之一：

成功：容器通过了诊断。
失败：容器未通过诊断。
未知：诊断失败，因此不会采取任何行动。

获得结果后kubelet会做出什么反应呢？

livenessProbe存活探针：指示容器是否正在运行。如果存活探测失败，则kubelet会杀死容器，并且容器将受到其重启策略的影响。如果容器不提供存活探针，则默认状态为 Success。
readinessProbe就绪探针：指示容器是否准备好服务请求。如果就绪探测失败，端点控制器将从与Pod匹配的所有Service的端点中删除该Pod的IP地址。初始延迟之前的就绪状态默认为Failure。如果容器不提供就绪探针，则默认状态为Success。
startupProbe启动探针（不常用）：指示容器中的应用是否已经启动。如果提供了启动探测，则禁用所有其他探测（禁用存活探针和就绪探针），直到它成功为止。如果启动探测失败，kubelet将杀死容器，容器会根据它的重启策略进行重启。如果容器没有提供启动探测，则默认状态为成功Success。

ReadinessProbe就绪探针与LivenessProbe存活探针的区别

ReadinessProbe 当检测失败后，将 Pod 的IP:Port 从service中对应的EndPoint列表中删除。
LivenessProbe 当检测失败后，将杀死容器并根据 Pod 的重启策略来决定作出对应的措施

StartupProbe启动探针与ReadinessProbe就绪探针、LivenessProbe存活探针的区别

如果三个探针同时存在，先执行StartupProbe探针，其他两个探针将会被暂时禁用。直到pod满足StartupProbe探针配置的条件，其他2个探针启动，如果不满足按照规则重启容器。
另外两种探针在容器启动后，会按照配置，直到容器消亡才停止探测，而StartupProbe探针只是在容器启动后按照配置满足一次后，不再进行后续的探测。
StartupProbe启动探针不常用，多用ReadinessProbe就绪探针和LivenessProbe存活探针

`存活探针`示例

[root@k8s-master ~]# kubectl run huazi --image myapp:v1 --dry-run=client -o yaml > huazi.yml

[root@k8s-master ~]# vim huazi.yml
[root@k8s-master ~]# cat huazi.yml
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: huazi
  name: huazi
spec:
  containers:
  - image: myapp:v1
    name: huazi
    livenessProbe:    #存活探针
      tcpSocket:     #检测方式为端口检测
        port: 8080   #这里监听的端口故意写错
      initialDelaySeconds: 3  #容器启动后要等待多少秒后就探针开始工作，默认是0
      periodSeconds: 1  #执行探测的时间间隔，默认为10秒
      timeoutSeconds: 1  #探针执行检测请求后，等待响应的超时时间，默认为1秒

[root@k8s-master ~]# kubectl apply -f huazi.yml
pod/huazi created


#发现一直处于CrashLoopBackOff重启状态
[root@k8s-master ~]# kubectl get pods -o wide
NAME    READY   STATUS             RESTARTS     AGE   IP            NODE            NOMINATED NODE   READINESS GATES
huazi   0/1     CrashLoopBackOff   2 (7s ago)   22s   10.244.2.13   k8s-node2.org   <none>           <none>

[root@k8s-master ~]# kubectl describe pods huazi

在这里插入图片描述

[root@k8s-master ~]# kubectl delete -f huazi.yml
pod "huazi" deleted

[root@k8s-master ~]# vim huazi.yml

在这里插入图片描述

[root@k8s-master ~]# kubectl apply -f huazi.yml
pod/huazi created


#发现检测成功
[root@k8s-master ~]# kubectl get pods -o wide
NAME    READY   STATUS    RESTARTS   AGE   IP            NODE            NOMINATED NODE   READINESS GATES
huazi   1/1     Running   0          43s   10.244.2.14   k8s-node2.org   <none>           <none>
[root@k8s-master ~]# curl 10.244.2.14
Hello MyApp | Version: v1 | <a href="hostname.html">Pod Name</a>

`就绪探针`示例

[root@k8s-master ~]# kubectl delete -f huazi.yml
pod "huazi" deleted


[root@k8s-master ~]# vim huazi.yml
[root@k8s-master ~]# cat huazi.yml
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: huazi
  name: huazi
spec:
  containers:
  - image: myapp:v1
    name: huazi
    readinessProbe:  #就绪探针
      httpGet:     #检测方式为get请求
        path: /test.html    #检测的网页文件
        port: 80      #访问的端口
      initialDelaySeconds: 1  #容器启动后要等待多少秒后就探针开始工作，默认是0秒
      periodSeconds: 3  #执行探测的时间间隔，默认为10秒
      timeoutSeconds: 1  #探针执行检测请求后，等待响应的超时时间，默认为1秒

[root@k8s-master ~]# kubectl apply -f huazi.yml
pod/huazi created


[root@k8s-master ~]# kubectl get pods -o wide
NAME    READY   STATUS    RESTARTS   AGE   IP            NODE            NOMINATED NODE   READINESS GATES
huazi   0/1     Running   0          42s   10.244.2.15   k8s-node2.org   <none>           <none>


[root@k8s-master ~]# kubectl describe pods huazi

在这里插入图片描述

#为名为huazi的pod做端口暴露
[root@k8s-master ~]# kubectl expose pod huazi --port 80 --target-port 80
service/huazi exposed

[root@k8s-master ~]# kubectl describe svc huazi
Name:              huazi
Namespace:         default
Labels:            run=huazi
Annotations:       <none>
Selector:          run=huazi
Type:              ClusterIP
IP Family Policy:  SingleStack
IP Families:       IPv4
IP:                10.110.103.38
IPs:               10.110.103.38
Port:              <unset>  80/TCP
TargetPort:        80/TCP
Endpoints:                  #发现在这个列表中没有pod的ip地址
Session Affinity:  None
Events:            <none>

#创建检测的网页文件
[root@k8s-master ~]# kubectl exec pods/huazi -c huazi -- /bin/sh -c "echo hello > /usr/share/nginx/html/test.html"

[root@k8s-master ~]# kubectl describe svc huazi
Name:              huazi
Namespace:         default
Labels:            run=huazi
Annotations:       <none>
Selector:          run=huazi
Type:              ClusterIP
IP Family Policy:  SingleStack
IP Families:       IPv4
IP:                10.110.103.38
IPs:               10.110.103.38
Port:              <unset>  80/TCP
TargetPort:        80/TCP
Endpoints:         10.244.2.15:80     #发现名为huazi的pod的ip地址回来了
Session Affinity:  None
Events:            <none>

#当删除检测的网页文件时
[root@k8s-master ~]# kubectl exec pods/huazi -c huazi -- /bin/sh -c "rm -rf /usr/share/nginx/html/test.html"


[root@k8s-master ~]# kubectl describe svc huazi
Name:              huazi
Namespace:         default
Labels:            run=huazi
Annotations:       <none>
Selector:          run=huazi
Type:              ClusterIP
IP Family Policy:  SingleStack
IP Families:       IPv4
IP:                10.110.103.38
IPs:               10.110.103.38
Port:              <unset>  80/TCP
TargetPort:        80/TCP
Endpoints:                     #发现名为huazi的pod的ip地址又被移出了
Session Affinity:  None
Events:            <none>