#一个pod如果管理多个容器，多个容器之间的端口不能相同，容器的名字也不能一样
cat nginx-pod.yaml
apiVersion: v1  #pod 的apiVersion版本号是V1，不同资源所属的apiVersion组是不一样的，可以使用kubectl api-resources查看
kind: Pod  #指定要创建资源的类型是Pod，告诉Kubernetes这个YAML文件创建的是一个Pod资源
metadata:  #定义pod的元数据，可以包含名称、标签、注释等
  labels:  #标签
    run: nginx-pod  #key=value的格式，可以根据标签筛选过滤出不同的pod
  name: nginx-pod  # 指定pod的名字是nginx-run，pod的名字要唯一
spec:  #必选，定义pod的详细信息
  containers:  #定义 Pod 里运行的全部容器，数组形式，可以配置一个或多个容器
  - image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:1.24.0  #指定容器的镜像
    name: nginx  #指定容器的名字
    ports:   #可选，声明容器暴露的端口号，可以有个多。
      - containerPort: 80  #声明容器内部监听的端口号是80（必选）
      	protocol: TCP #协议类型，默认是 TCP，也可以是 UDP 或 SCTP （可选）
      	name: http # 端口的名称，便于在 Service 等资源中引用（可选）
      - containerPort: 443
      	protocol: TCP
      	name: https
        
#提示：如果在创建资源时忘记该资源对应的apiVersion是什么，可以使用kubectl api-resources查看
#kubectl api-resources   #查看所有资源对应的apiVersion
#kubectl api-resources|grep pod  #查看pod对应的apiVersion，使用|grep过滤要找到的资源

cat pod.yaml
# 下面是pod.yaml文件中的配置
apiVersion: v1  #pod 的apiVersion版本号是V1，不同资源所属的apiVersion组是不一样的，可以使用kubectl api-resources查看
kind: Pod  #指定要创建资源的类型是Pod，告诉Kubernetes这个YAML文件创建的是一个Pod资源
metadata:  #定义pod的元数据，可以包含名称、标签、注释等
  labels:  #标签
    run: nginx-redis  #key=value的格式，可以根据标签筛选过滤出不同的pod
  name: nginx-redis-pod   # 指定pod的名字是nginx-redis-pod ，名字要唯一
spec:  #必选，定义pod的详细信息
  containers:  #定义 Pod 里运行的全部容器，数组形式，可以配置一个或多个容器
    - name: nginx  #指定容器的名字
      image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:1.24.0  #指定容器的镜像
      ports:   #可选，声明容器暴露的端口号，可以有个多。
        - containerPort: 80  #声明容器内部监听的端口号是80（必选）
          protocol: TCP #协议类型，默认是 TCP，也可以是 UDP 或 SCTP （可选）
          name: http # 端口的名称，便于在 Service 等资源中引用（可选）
        - containerPort: 443
          protocol: TCP
          name: https
    - name: redis  #指定第二个容器的名字
	  image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/redis:5.0.14  #指定第二个容器的镜像  
      ports:   #可选，声明容器暴露的端口号
        - containerPort: 6379  #声明容器内部监听的端口号是6379（必选）
          protocol: TCP #协议类型，默认是 TCP，也可以是 UDP 或 SCTP （可选）
          name: redis # 端口的名称，便于在 Service 等资源中引用（可选）

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: my-container
    image: nginx:latest
    resources:  #资源配置，是容器级别的字段，用于定义 资源请求（requests） 和 资源限制（limits）。 
      requests:  #容器启动和调度时最少需要的资源量
        memory: "128Mi"  # 最小内存请求，十进制单位E、P、T、G、M、K；二进制单位Ei、Pi、Ti、Gi、Mi、Ki，建议使用二进制单位
        cpu: "500m"      # 最小 CPU 请求（0.5 核）,一核cpu=1000m
      limits:   #容器运行时最多能使用的资源上限
        memory: "256Mi"  # 最大内存限制
        cpu: "1"         # 最大 CPU 限制（1 核）

[root@k8s-master01 10-pod]# cat env-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx-env
  name: nginx-env
spec:
  containers:
  - image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:1.24.0
    name: nginx-env
    env:  #env 里的变量名和值完全由你自定义，但必须与应用程序所期望的变量名对应，否则程序不会识别这些值。
    - name: APP_MODE  #环境变量的名称，这里设置的字段应该与应用程序中定义的保持一致，这样程序才会识别
      value: "prod"  #环境变量的值，字符串类型
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always
status: {}

[root@k8s-master01 10-pod]# cat env-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx-env
  name: nginx-env
spec:
  containers:
  - image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:1.24.0
    name: nginx-env
    env:
    - name: APP_MODE
      value: "prod"
    - name: POD_NAME  #定义变量的名字
      valueFrom:
        fieldRef:
          fieldPath: metadata.name  # 引用 Pod 元数据中的 'name'
    - name: POD_NAMESPACE
      valueFrom:
        fieldRef:
          fieldPath: metadata.namespace # 引用 Pod 元数据中的 'namespace'
    - name: POD_IP
      valueFrom:
        fieldRef:
          fieldPath: status.podIP  # 引用 Pod 状态中的 'podIP'
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always
status: {}

#假设 Pod 标签如下：
  labels:
    app: web-ui
    version: v1
    env: prod
    run: nginx-pod
#你想在容器里通过环境变量拿到标签中 env 值（即 prod），就可以用：fieldPath: metadata.labels['env']，pod中定义如下：
cat nginx-pod.yaml
#yaml文件内容如下：
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    app: web-ui
    version: v1
    env: prod
    run: nginx-pod
  name: nginx-pod
spec:
  containers:
  - image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:1.27-alpine
    name: nginx-pod
    env:
    - name: ENV  #容器中的变量名是ENV，ENV的值是从pod标签中获取：metadata.labels['env']，也就是ENV=prod
      valueFrom:
        fieldRef:
          fieldPath: metadata.labels['env']  #通过metadata.labels['env']拿到pod标签中的值作为环境变量，也就是把pod标签中env: prod的prod赋值给ENV这个环境变量，必须单引号包裹key
  dnsPolicy: ClusterFirst
  restartPolicy: Always
status: {}

#app-config.yaml配置如下：
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  # 应用配置
  APP_MODE: "prod"
  APP_PORT: "8080"
  API_URL: "https://api.example.com"
  # 数据库配置
  DB_HOST: "mysql-prod.default.svc.cluster.local"
  DB_NAME: "mydatabase"
  
 
# 创建 ConfigMap
kubectl apply -f app-config.yaml

# cm-env.yaml 配置如下：
apiVersion: v1
kind: Pod
metadata:
  name: env-cm-demo
spec:
  containers:
  - name: my-app
    image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:1.24.0
    env:
    - name: DATABASE_HOSTNAME # 在容器内最终的环境变量名，这里定义的环境变量要与程序中设置的值保持一致。
      valueFrom:
        configMapKeyRef:
          name: app-config # 引用上面创建的 ConfigMap的名字
          key: DB_HOST    # 引用该 ConfigMap 里的 'DB_HOST' 这个 Key，也就是把DB_HOST的值赋值给DATABASE_HOSTNAME

# cm-env.yaml配置示例如下：
apiVersion: v1
kind: Pod
metadata:
  name: env-cm-demo
spec:
  containers:
  - name: my-app
    image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:1.24.0
	envFrom: # 使用 envFrom 批量导入
      - configMapRef:  #从configMap中导入
          name: app-config  # 导入名字是app-config 的ConfigMap中所有的 Key-Value

# mysql-secret.yaml配置如下
apiVersion: v1
kind: Secret
metadata:
  name: mysql-secret
type: Opaque
stringData:
  # 数据库凭据
  DB_USER: "root"
  DB_PASSWORD: "S!p3rS3cretPa$$w0rd"
  
  
# 创建 Secret
kubectl apply -f mysql-secret.yaml

# secret-env.yaml配置示例如下：
apiVersion: v1
kind: Pod
metadata:
  name: env-cm-demo
spec:
  containers:
  - name: my-app
    image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:1.24.0
    env:
    - name: DATABASE_USER # 在容器内最终的环境变量名，这里定义的环境变量要与程序中设置的值保持一致。
      valueFrom:
        secretKeyRef:
          name: mysql-secret # 引用上面创建的 Secret 的名字
          key: DB_USER    # 引用该 Secret 里的 'DB_USER' 这个 Key，也就是把DB_USER的值赋值给DATABASE_USER

# secret-env.yaml配置示例如下：
apiVersion: v1
kind: Pod
metadata:
  name: env-cm-demo
spec:
  containers:
    - name: my-app
      image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:1.24.0
      envFrom:  # 使用 envFrom 批量导入
        - secretRef:  #从Secret中导入
            name: mysql-secret  #从名字是mysql-secret的Secret中所有的 Key-Value，容器中的环境变量就是mysql-secret中定义的所有key和value

apiVersion: v1
kind: Pod
metadata:
  name: env-demo
spec:
  containers:
  - name: nginx
    image: nginx:latest
    envFrom:  #定义批量导入环境变量
    - configMapRef:  #从ConfigMap批量导入
        name: app-config  # app-config是引用的ConfigMap的名字
    - secretRef:  #从Secret批量导入
        name: mysql-secret  #mysql-secret 是引用的Secret的名字
    env: 
    - name: POD_IP
      valueFrom:
        fieldRef:
          fieldPath: status.podIP
    - name: CUSTOM_MESSAGE
      value: "Hello from mixed env"

vim pod.yaml
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: nginx-run
  name: nginx
spec:
  containers:
  - image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:1.24.0
    name: nginx-run
    imagePullPolicy: Always  #镜像拉取策略，Always表示总是拉取

#pod的yaml文件如下：
[root@k8s-master01 pra]# cat pod.yaml
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: nginx-run
  name: nginx
spec:
  containers:
  - image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:1.24.0
    name: nginx-run
    
#创建pod
[root@k8s-master01 pra]# kubectl create -f pod.yaml
pod/nginx created

查看pod的yaml文件的imagePullPolicy是否为Always
[root@k8s-master01 pra]# kubectl get po nginx -oyaml|grep "imagePullPolicy"
    imagePullPolicy: IfNotPresent

#一个pod如果管理多个容器，多个容器之间的端口不能相同，容器的名字也不能一样
apiVersion: v1  #apiVersion版本号
kind: Pod  #指定资源的类型，告诉Kubernetes这个YAML文件创建的是一个Pod资源
metadata:  #pod的元数据
  labels:  #标签
    run: nginx-run  #key=value的格式，可以根据标签筛选过滤出不同的pod
  name: nginx-run  # 指定pod的名称
spec:  #用于指定期望pod的规格
  restartPolicy: Always #不配置也默认是Always策略
  containers:  #定义配置容器，复数表示可以配置一个或多个容器
  - image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:1.24.0  #指定容器的镜像
    name: nginx-run  #指定容器的名字
    ports:   #可选，容器需要暴露的端口号列表
      - containerPort: 80  #指定了容器内部的 Nginx 服务监听 80 端口
  - image: redis:6.0.0
    name: redis

#一个pod如果管理多个容器，多个容器之间的端口不能相同，容器的名字也不能一样
apiVersion: v1  #apiVersion版本号
kind: Pod  #指定资源的类型，告诉Kubernetes这个YAML文件创建的是一个Pod资源
metadata:  #pod的元数据
  labels:  #标签
    run: nginx-run  #key=value的格式，可以根据标签筛选过滤出不同的pod
  name: nginx-run  # 指定pod的名称
spec:  #用于指定期望pod的规格
  restartPolicy: OnFailure #配置重启策略为OnFailure
  containers:  #定义配置容器，复数表示可以配置一个或多个容器
  - image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:1.24.0  #指定容器的镜像
    name: nginx-run  #指定容器的名字
    ports:   #可选，容器需要暴露的端口号列表
      - containerPort: 80  #指定了容器内部的 Nginx 服务监听 80 端口
  - image: redis:6.0.0
    name: redis

#一个pod如果管理多个容器，多个容器之间的端口不能相同，容器的名字也不能一样
apiVersion: v1  #apiVersion版本号
kind: Pod  #指定资源的类型，告诉Kubernetes这个YAML文件创建的是一个Pod资源
metadata:  #pod的元数据
  labels:  #标签
    run: nginx-run  #key=value的格式，可以根据标签筛选过滤出不同的pod
  name: nginx-run  # 指定pod的名称
spec:  #用于指定期望pod的规格
  restartPolicy: Never #配置重启策略为Never
  containers:  #定义配置容器，复数表示可以配置一个或多个容器
  - image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:1.24.0  #指定容器的镜像
    name: nginx-run  #指定容器的名字
    ports:   #可选，容器需要暴露的端口号列表
      - containerPort: 80  #指定了容器内部的 Nginx 服务监听 80 端口
  - image: redis:6.0.0
    name: redis

# pod的yaml配置如下：
cat slow-pod.yaml
apiVersion: v1  #apiVersion版本号
kind: Pod  #指定资源的类型，告诉Kubernetes这个YAML文件创建的是一个Pod资源
metadata:  #pod的元数据
  name: slow-pod  #定义pod的名字是slow-pod
  labels:  #定义pod的标签
  	app: slow
spec:   #用于指定期望pod的规格
  containers:   ##定义配置容器，可以配置一个或多个容器
  - name: slow-container  #定义容器的名字
    image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/slow:latest  #定义容器使用的镜像，slow 这个程序启动很慢
    imagePullPolicy: IfNotPresent  #镜像的下载策略，IfNotPresent表示如果镜像存在就不拉取
    ports: # 声明容器的端口
    - containerPort: 8080  #声明容器的端口，这里指定的端口号不会改变容器运行的实际端口，同时要和容器的真实端口保持一致
      name: http 
      
      
# 上述pod没有配置任何健康检查，创建该pod
[root@k8s-master01 10-pod]# kubectl create -f slow-pod.yaml
pod/slow-pod created

#pod的状态是Running，READY也是 1/1 ,此时service就会向该pod分发流量，但是通过kubectl logs -f slow-pod查看该容器还没有启动成功
[root@k8s-master01 10-pod]# kubectl get pod -owide
NAME                                READY   STATUS    RESTARTS        AGE    IP               NODE           NOMINATED NODE   READINESS GATES
slow-pod                            1/1     Running   0               22s    172.16.58.247    k8s-node02     <none>           <none>


#kubectl logs -f slow-pod看到日志还没有启动成功
[root@k8s-master01 10-pod]# kubectl logs -f slow-pod
Starting...
Start initializing basic data...

#此时通过pod的ip地址请求也是不可用的，程序无法处理流量，生产环境会造成宕机风险，所以生产中必须要配置健康检查
[root@k8s-master01 ~]# curl  172.16.195.51:8080/ping
curl: (7) Failed to connect to 172.16.195.51 port 8080: Connection refused

#一个pod如果管理多个容器，多个容器之间的端口不能相同，容器的名字也不能一样
cat slow-pod.yaml
apiVersion: v1  #apiVersion版本号
kind: Pod  #指定资源的类型，告诉Kubernetes这个YAML文件创建的是一个Pod资源
metadata:  #pod的元数据
  name: slow-pod  #定义pod的名字是slow-pod
  labels:  #定义pod的标签
  	app: slow
spec:   #用于指定期望pod的规格
  containers:   ##定义配置容器，可以配置一个或多个容器
  - name: slow-container  #定义容器的名字
    image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/slow:latest  #定义容器使用的镜像，slow 这个程序启动很慢
    imagePullPolicy: IfNotPresent  #镜像的下载策略，IfNotPresent表示如果镜像存在就不拉取
    ports: # 声明容器的端口
    - containerPort: 8080  #声明容器的端口，这里指定的端口号不会改变容器运行的实际端口，同时要和容器的真实端口保持一致
      name: http     
      readinessProbe: # 就绪探针，可选，该探针检测不通过会重启pod，pod状态“Running”并不代表健康，只代表容器进程还在运行。
        httpGet: # 接口检测方式，注意4种检查方式同时只能使用一种，例如httpGet、tcpsocket只能选一种。
          path: /index.html # 检查路径
          port: 80
          scheme: HTTP # HTTP or HTTPS
          #httpHeaders: # 可选, 检查的请求头，这里请求到用法见下文《生产案例》
          #  - name: X-Auth
          #    value: SecretToken123
        initialDelaySeconds: 10 # 初始化时间, 执行第一次健康检查前等待的时间，也就是10秒后再执行健康检查
        timeoutSeconds: 2 # 超时时间，两秒内得不到相应就认为超时
        periodSeconds: 5 # 检测间隔，即每 periodSeconds(这里是5秒) 秒执行一次探针检查。
        successThreshold: 2 # 检查成功为 2 次表示就绪，连续2次成功则认为合格
        failureThreshold: 2 # 检测失败 2 次表示未就绪，连续2次失败则认为不合格，不会重启pod，只是不接受流量
      livenessProbe: # 存活探针，可选，readinessProbe 决定 Pod 是否 Ready。只有该探针通过K8s会把这个 Pod 加入到 	Service 的 endpoint 列表；接受流量。
        tcpSocket: # 端口检测方式
		  port: 8080
        initialDelaySeconds: 10 # 初始化时间，等待10秒执行第一次探测
        timeoutSeconds: 2 # 超时时间
        periodSeconds: 5 # 检测间隔
        successThreshold: 1 # 检查成功为 1次表示就绪
        failureThreshold: 2 # 检测失败 2次表示未就绪,会重启pod

readinessProbe:
  httpGet:
    path: /healthz
    port: 8080
    httpHeaders:  #配置带有请求头进行探测请求
      - name: X-Auth
        value: SecretToken123
  initialDelaySeconds: 5
  periodSeconds: 10

cat slow-pod.yaml
apiVersion: v1  #apiVersion版本号
kind: Pod  #指定资源的类型，告诉Kubernetes这个YAML文件创建的是一个Pod资源
metadata:  #pod的元数据
  name: slow-pod  #定义pod的名字是slow-pod
  labels:  #定义pod的标签
  	app: slow
spec:   #用于指定期望pod的规格
  restartPolicy: Always #配置pod重启策略为Always
  containers:   ##定义配置容器，可以配置一个或多个容器
  - name: slow-container  #定义容器的名字
    image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/slow:latest  #定义容器使用的镜像，slow 这个程序启动很慢
    imagePullPolicy: IfNotPresent  #镜像的下载策略，IfNotPresent表示如果镜像存在就不拉取
    ports: # 声明容器的端口
    - containerPort: 8080  #声明容器的端口，这里指定的端口号不会改变容器运行的实际端口，同时要和容器的真实端口保持一致
      name: http
      startupProbe:  #先执行启动探针，它执行时会先禁用readinessProbe和livenessProbe探针，直到它探测通过。
        tcpSocket: # startupProbe建议使用tcpSocket检测方式，端口起来了证明程序已经启动
          port: 8080  #定义探测的端口，端口起来了表示程序成功启动
        initialDelaySeconds: 20 # 初始化时间, 创建pod后等待20秒再开始执行健康检查
        timeoutSeconds: 2 # 超时时间
        periodSeconds: 5 # 检测间隔时间
        successThreshold: 1 # 探测成功 1 次表示通过健康检查
        failureThreshold: 20 # 探测失败 20 次表示未通过检查，根据重启策略重启pod
      readinessProbe: # 就绪探针，可选，该探针检测不通过会重启pod，pod状态“Running”并不代表健康，只代表容器进程还在运行。
        httpGet: # 接口检测方式，注意4种检查方式同时只能使用一种，例如httpGet、tcpsocket只能选一种。
          path: /ping # 检查路径
          port: 8080
          scheme: HTTP # HTTP or HTTPS
          #httpHeaders: # 可选, 检查的请求头，这里请求到用法见下文《生产案例》
          #  - name: X-Auth
          #    value: SecretToken123
        initialDelaySeconds: 3 # 初始化时间, 执行第一次健康检查前等待的时间，也就是3秒后再执行健康检查，如果配置了startupProbe，这里就可以缩短初始化的时间
        timeoutSeconds: 2 # 超时时间，两秒内得不到相应就认为超时
        periodSeconds: 5 # 检测间隔，即每 periodSeconds(这里是5秒) 秒执行一次探针检查。
        successThreshold: 2 # 检查成功为 2 次表示就绪，连续2次成功则认为合格
        failureThreshold: 2 # 检测失败 2 次表示未就绪，连续2次失败则认为不合格，不会重启pod，只是不接受流量
      livenessProbe: # 存活探针，可选，readinessProbe 决定 Pod 是否 Ready。只有该探针通过K8s会把这个 Pod 加入到 	Service 的 endpoint 列表；接受流量。
        tcpSocket: # 端口检测方式
		  port: 8080
        initialDelaySeconds: 3 # 初始化时间，等待3秒执行第一次探测，如果配置了startupProbe，这里就可以缩短初始化的时间
        timeoutSeconds: 2 # 超时时间
        periodSeconds: 5 # 检测间隔
        successThreshold: 1 # 检查成功为 1次表示就绪
        failureThreshold: 2 # 检测失败 2次表示未就绪,会重启pod

apiVersion: v1  #apiVersion版本号
kind: Pod  #指定资源的类型，告诉Kubernetes这个YAML文件创建的是一个Pod资源
metadata:  #pod的元数据
  labels:  #标签
    run: nginx-run  #key=value的格式，可以根据标签筛选过滤出不同的pod
  name: nginx  # 指定pod的名称
spec:  #用于指定期望pod的规格
  restartPolicy: Always #配置重启策略为Never
  containers:  #定义配置容器，复数表示可以配置一个或多个容器
  - image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:1.27-alpine #指定容器的镜像
    name: nginx-run  #指定容器的名字
    ports:   #可选，容器需要暴露的端口号列表
      - containerPort: 80  #指定了容器内部的 Nginx 服务监听 80 端口
    lifecycle:
      postStart:  #postStart不会等容器完全 Ready 在执行，而是在容器进程启动后立即执行。生产中该参数使用的不多，如果容器启动需要初始化用initContainers做初始化更好。
        exec:
          command:
            - sh
            - -c
            - mkdir /data/postStart -p
      preStop:  #preStop 一定在容器被 kill 前执行（默认会等待一段 terminationGracePeriodSeconds 时间）；
        exec:
          command:
            - sh
            - -c
            - sleep 20 #生产场景可能根据开发提供的接口配置
    startupProbe:
      tcpSocket: # 接口检测方式
        port: 80
      initialDelaySeconds: 10 # 初始化时间, 健康检查延迟执行时间
      timeoutSeconds: 2 # 超时时间
      periodSeconds: 5 # 检测间隔
      successThreshold: 1 # 检查成功为 2 次表示就绪
      failureThreshold: 2 # 检测失败 1 次表示未就绪
    readinessProbe: # 可选，健康检查。注意三种检查方式同时只能使用一种。
      httpGet: # 接口检测方式
        path: /index.html # 检查路径
        port: 80
        scheme: HTTP # HTTP or HTTPS
       #httpHeaders: # 可选, 检查的请求头
       #- name: end-user
       # value: Jason
      initialDelaySeconds: 10 # 初始化时间, 健康检查延迟执行时间
      timeoutSeconds: 2 # 超时时间
      periodSeconds: 5 # 检测间隔
      successThreshold: 1 # 检查成功为 2 次表示就绪
      failureThreshold: 2 # 检测失败 1 次表示未就绪
    livenessProbe: # 可选，健康检查
      httpGet:
        path: /index.html
        port: 80
        scheme: HTTP
      initialDelaySeconds: 10 # 初始化时间
      timeoutSeconds: 2 # 超时时间
      periodSeconds: 5 # 检测间隔
      successThreshold: 1 # 检查成功为 2 次表示就绪
      failureThreshold: 2 # 检测失败 1 次表示未就绪

apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
  labels:
    app: user-service
spec:
  replicas: 2
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      terminationGracePeriodSeconds: 40
      containers:
        - name: user-service
          image: user-service:latest
          env:
            - name: SERVICE_NAME
              value: "user-service"
            - name: SERVICE_PORT
              value: "8080"
            - name: REGISTRY_URL
              value: "http://registry:8500"
          lifecycle:
            postStart:
              exec:
                command:
                  - "/bin/sh"
                  - "-c"
                  - |
                    # 等待应用真正就绪
                    until curl -f http://localhost:8080/actuator/health; do
                      echo "Waiting for app to be ready..."
                      sleep 1
                    done
                    # 注册到服务中心
                    curl -X POST ${REGISTRY_URL}/register \
                      -d "service=${SERVICE_NAME}&port=${SERVICE_PORT}" || true

            preStop:
              exec:
                command:
                  - "/bin/sh"
                  - "-c"
                  - |
                    echo "[$(date)] Starting graceful shutdown..."
                    
                    # 1. 从注册中心摘除（停止接收新流量）
                    curl -X DELETE ${REGISTRY_URL}/deregister?service=${SERVICE_NAME} || true
                    
                    # 2. 等待现有连接处理完成
                    sleep 5
                    
                    # 3. 触发应用关闭
                    curl -X POST http://localhost:8080/actuator/shutdown || true
                    
                    # 4. 最后等待确保清理完成
                    sleep 2
                    
                    echo "[$(date)] Graceful shutdown completed"
          livenessProbe:
            httpGet:
              path: /actuator/health
              port: 8080
            initialDelaySeconds: 30
            periodSeconds: 10
          readinessProbe:
            httpGet:
              path: /actuator/health
              port: 8080
            initialDelaySeconds: 30
            periodSeconds: 10

spec:
  terminationGracePeriodSeconds: 30