4-Kubernetes入门基础之Pod介绍

kubectl explain pod
  # KIND:     Pod
  # VERSION:  v1
  # DESCRIPTION:
  # 		Pod is a collection of containers that can run on a host. This resource is
  # 		created by clients and scheduled onto hosts.

  # FIELDS: 
  # 	apiVersion   <string>
  # 		APIVersion defines the versioned schema of this representation of an
  # 		object. Servers should convert recognized schemas to the latest internal
  # 		value, and may reject unrecognized values. More info:
  # 		https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources

  # 	kind <string>
  # 		Kind is a string value representing the REST resource this object
  # 		represents. Servers may infer this from the endpoint the client submits
  # 		requests to. Cannot be updated. In CamelCase. More info:
  # 		https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds

  # 	metadata     <Object>
  # 		Standard object's metadata. More info:
  # 		https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata

  # 	spec <Object>
  # 		Specification of the desired behavior of the pod. More info:
  # 		https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status

  # 	status       <Object>
  # 		Most recently observed status of the pod. This data may not be up to date.
  # 		Populated by the system. Read-only. More info:
  # 		https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status

kubectl explain pod.apiVersion #查看指定属性说明
  # KIND:     Pod
  # VERSION:  v1

  # FIELD:    apiVersion <string>

  # DESCRIPTION:
  # 		APIVersion defines the versioned schema of this representation of an
  # 		object. Servers should convert recognized schemas to the latest internal
  # 		value, and may reject unrecognized values. More info:
  # 		https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources

$ kubectl api-versions

#常用
apiVersion: apps/v1
# API版本
apps/v1
v1
admissionregistration.k8s.io/v1
admissionregistration.k8s.io/v1beta1
apiextensions.k8s.io/v1
apiextensions.k8s.io/v1beta1
apiregistration.k8s.io/v1
apiregistration.k8s.io/v1beta1
authentication.k8s.io/v1
authentication.k8s.io/v1beta1
authorization.k8s.io/v1
authorization.k8s.io/v1beta1
autoscaling/v1
autoscaling/v2beta1
autoscaling/v2beta2
batch/v1
batch/v1beta1
certificates.k8s.io/v1beta1
coordination.k8s.io/v1
coordination.k8s.io/v1beta1
crd.projectcalico.org/v1
discovery.k8s.io/v1beta1
events.k8s.io/v1beta1
extensions/v1beta1
networking.k8s.io/v1
networking.k8s.io/v1beta1
node.k8s.io/v1beta1
policy/v1beta1
rbac.authorization.k8s.io/v1
rbac.authorization.k8s.io/v1beta1
scheduling.k8s.io/v1
scheduling.k8s.io/v1beta1
storage.k8s.io/v1
storage.k8s.io/v1beta1

kubectl api-versions
admissionregistration.k8s.io/v1
apiextensions.k8s.io/v1
apiregistration.k8s.io/v1
apps/v1
authentication.k8s.io/v1
authorization.k8s.io/v1
autoscaling/v1
autoscaling/v2
autoscaling/v2beta1
autoscaling/v2beta2
batch/v1
batch/v1beta1
certificates.k8s.io/v1
coordination.k8s.io/v1
crd.projectcalico.org/v1
discovery.k8s.io/v1
discovery.k8s.io/v1beta1
events.k8s.io/v1
events.k8s.io/v1beta1
flowcontrol.apiserver.k8s.io/v1beta1
flowcontrol.apiserver.k8s.io/v1beta2
networking.k8s.io/v1
node.k8s.io/v1
node.k8s.io/v1beta1
policy/v1
policy/v1beta1
rbac.authorization.k8s.io/v1
scheduling.k8s.io/v1
storage.k8s.io/v1
storage.k8s.io/v1beta1
v1

metadata:
  name: nginx-deployment   # 创建的资源对象名称
  namespace: nginx-app     # 设置指定的名称空间，默认为default

metadata:
  annotation:
    key1: value1
    key2: value2

#参数名称 	字段类型 	说明
version 	String 	这里是指的是K8SAPI的版本，目前基本上是v1，可以用 `kubectl api-version` 命令查询
kind 	String 	    这里指的是yam文件定义的资源类型和角色，比如：Pod
metadata 	Object 	元数据对象，固定值就写metadata
metadata.name 	String 	元数据对象的名字，这里由我们编写，比如命名Pod的名字
metadata.namespace 	String 	元数据对象的命名空间，由我们自身定义，如果不定义的话则默认是default名称空间
Spec 	Object 	详细定义对象，固定值就写Spec
spec.containers[] 	List 	这里是Spec对象的容器列表定义，是个列表
spec.containers[].name 	String 	这里定义容器的名字
spec.containers[].image 	String 	这里定义要用到的镜像名称

#参数名称 	字段类型 	说明
spec.containers[].name 	String 	这里定义容器的名字
spec.containers[].image 	String 	这里定义要用到的镜像名称
spec.containers[].imagePullPolicy 	String 	定义镜像拉取策略，有Always、Never、 IfNotPresent三个值可选（1）Always:意思是每次都尝试重新拉取镜像（2）Never:表示仅使用本地镜像（3）lfNotPresent:如果本地有镜像就使用本地镜像，没有就拉取在线镜像。上面三个值都没设置的话，默认是Always。
spec.containers[].command[] 	List 	指定容器启动命令，因为是数组可以指定多个，不指定则使用镜像打包时使用的启动命令。
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 	指定容器所在主机需要监听的端口号，默认跟上面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的限制，单位为core数，将用于docker run --cpu-shares参数这里前面文章 Pod资源限制有讲过）
spec.containers[].resources.limits.memory 	String 	指定MEM内存的限制，单位为MlB、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、OnFailure、Never 默认值为Always。1.Always:Pod一旦终止运行，则无论容器是如何终止的，kubelet服务都将重启它。2.OnFailure:只有Pod以非零退出码终止时，kubelet才会重启该容器。如果容器正常结束（退出码为0），则kubelet将不会重启它。3.Never:Pod终止后，kubelet将退出码报告给Master，不会重启该Pod。
spec.nodeSelector 	Object 	定义Node的Label过滤标签，以key:value格式指定，选择node节点去运行
spec.imagePullSecrets 	Object 	定义pull镜像时使用secret名称，以name:secretkey格式指定
spec.hostNetwork 	Boolean 	定义是否使用主机网络模式，默认值为false。设置true表示使用宿主机网络，不使用docker网桥，同时设置了true将无法在同一台宿主机上启动第二个副本。

apiVersion: group/apiversion #定义对象的版本模式; 如果没有给定group名称，那么默认为core可以使用kubectlapi-versions命令获取当前k8s版本上所有的apiversion版本信息（每个版本可能不同）
kind:     #资源类别: 该对象表示的REST资源
metadata: #资源元数据
 name:    #资源自定义名称
 namespace: #资源所属的名称空间
 lables:    #资源
 annotations: #注解:主要目的是方便用户阅读查找
spec:   #期望的状态（disired state)
status: #当前状态，本字段由Kubernetes自身维护，用户不能去定义

apiVersion: v1 
kind: Pod 
metadata:
 name: pod-demo 
 namespace: default 
 1abels:
  app:myapp 
spec:
 containers:
 - name: myapp-1 
   image: harbor.weiyigeek.top/1ibrary/myapp:v1    # 支持多个容器运行在同一个Pod之中
 - name: busybox-1 
   image: busybox:latest 
   command:
   - "/bin/sh"
   - "-c"
   - "sleep 3600"

# 方式1
kubectl create namespace dev-ops
# namespace/dev-ops created

# 方式2
apiVersion: v1
kind: Namespace
metadata:
  name: dev-ops

kubecrl create -f namespace-create.yaml
# namespace/dev-ops created

~$ kubectl get ns
  # NAME                   STATUS   AGE
  # default                Active   89d
  # dev-ops                Active   16s

~$ kubectl describe ns dev-ops
  # Name:         dev-ops
  # Labels:       <none>
  # Annotations:  <none>
  # Status:       Active

  # No resource quota.  # 后续讲解资源配额

  # No LimitRange resource.

kubectl delete namespace dev-ops # 慎用 -force,-f 选项;
kubectl delete -f namespace-create.yaml

# (1) 创建名称空间
kubectl create namespace dev-ops

# (2) resource-quote-demo.yaml | 资源清单yaml文件
cat > K8s/Day1/resource-quote-demo.yaml <<'end'
apiVersion: v1
kind: ResourceQuota
metadata:
  name: resource-quote-demo
spec:
  hard:
    # 表示全部Container的内存requests总和不能超过1G，而内存Limits的总和不能超过2GiB (CPU 与之相同)
    requests.cpu: "1"
    requests.memory: 1Gi
    limits.cpu: "2"
    limits.memory: 2Gi
end

# (3) 创建ResourceQuota并为其指定名称空间
~/K8s/Day1$ kubectl create -f resource-quote-demo.yaml -n dev-ops
  # resourcequota/resource-quote-demo created

# (4) 获取名称空间的配额信息
~/K8s/Day1$ kubectl get resourcequota -n dev-ops  # -o yaml 可以查看到使用的情况
  # NAME                  AGE   REQUEST                                     LIMIT
  # resource-quote-demo   73s   requests.cpu: 0/1, requests.memory: 0/1Gi   limits.cpu: 0/2, limits.memory: 0/2Gi
~/K8s/Day1$ kubectl describe resourcequota -n dev-ops
  # Name:            resource-quote-demo
  # Namespace:       dev-ops
  # Resource         Used  Hard
  # --------         ----  ----
  # limits.cpu       0     2
  # limits.memory    0     2Gi
  # requests.cpu     0     1
  # requests.memory  0     1Gi

# (5) 如果在该名称空间中创建Pod并设置了resource，则 通过 -o yaml 可以查看到该名称空间使用的情况
~/K8s/Day1$ kubectl get resourcequota -n dev-ops -o yaml 
# status:
#   hard:
#     limits.cpu: "2"
#     limits.memory: 2Gi
#     requests.cpu: "1"
#     requests.memory: 1Gi
#   used:
#     limits.cpu: "1"
#     limits.memory: "1.5Gi"
#     requests.cpu: "800m"
#     requests.memory: "700Mi"

resources:
  # 限制
  limits:
    cpu: 500m
    memory: 500Mi
  # 请求(依赖)
  requests:
    cpu: 500m
    memory: 6Gi

apiVersion: apps/v1        # apiserver版本
kind: Deployment           # 绑定动作
metadata:
  name: nginx-deployment   # 应用 + 绑定类型 
  namespace: nginx-app     # 名称空间
  labels:
    app: nginx
spec:
  selector:      # 选择器，匹配Pod模板中的标签才知道运行了几个副本实例;
    matchLabels:
      app: nginx
      role: master
      tier: backend
  replicas: 2    # 运行 2 个容器化应用程序副本
  template:      # Pod 模板
    metadata:
      labels:
        app: nginx
        role: master
        tier: backend
    spec:
      containers:
      - name: nginx
        image: nginx:1.7.9
        resources:
          requests:
            cpu: 100m
            memory: 100Mi
          limits:
            cpu: 800m
            memory: 800Mi
        ports:
        - containerPort: 8080  # 暴露的端口

#1.使用 kube apply 命令可以创建该 .yaml 文件中的 Deployment 对象
kubectl apply -f deployment.yaml
kubectl apply -f https://weiyigeek.top/k8s/deployment.yaml

kubectl run nginx --image nginx:latest --port=80 --replicas=2

sudo tee /etc/kubernetes/manifests/static-pod.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: static-nginx-web
  lables:
    app: nginx
spec:
  containers:
  - name : web
    image: nginx:latest
    imagePullPolicy: IfNotPresent
    ports:
      - name: nginx-port
        containerPort: 80
        protocol: TCP
EOF

$ systemctl status kubelet
# ● kubelet.service - kubelet: The Kubernetes Node Agent
#      Loaded: loaded (/lib/systemd/system/kubelet.service; enabled; vendor preset: enabled)
#     Drop-In: /etc/systemd/system/kubelet.service.d
#              └─10-kubeadm.conf
#      Active: active (running) since Wed 2021-01-20 03:18:21 UTC; 1h 24min ago
#        Docs: https://kubernetes.io/docs/home/
#    Main PID: 1436080 (kubelet)
#       Tasks: 19 (limit: 9450)
#      Memory: 50.7M
#      CGroup: /system.slice/kubelet.service
#              └─1436080 /usr/bin/kubelet --bootstrap-kubeconfig=/etc/kubernetes/bootstrap-kubelet.conf --kubeconfig=/etc/kubernetes/kubelet.conf --config=/var/lib/kubelet/config.yaml --network-plugin=cni --pod-infra-container-image=

$ ls /etc/kubernetes/manifests
etcd.yaml  kube-apiserver.yaml  kube-controller-manager.yaml  kube-scheduler.yaml  static-pod.yaml

$ kubectl get pod -o wide | grep "static"
# static-nginx-web-weiyigeek-107   1/1  Running   0   82m  172.16.0.197  weiyigeek-107   <none>  <none>

# 注意:移除静态Pod虽然用api server可以删除静态Pod，但他很快自动重新生成Pod,所以通过删除静态Pod的yaml配置资源文件则完成移除静态Pod;
$ rm /etc/kubernetes/manifests/static-pod.yaml
$ kubectl get pod

$ kubectl get  pod redis-cluster-operator-6669898858-rwm7s -o yaml  | grep " phase"
  phase: Running

$ kubectl describe pod redis-cluster-operator-6669898858-rwm7s | grep "^Status"
  Status: Running

kubectl explain statefulset.spec.template.spec | grep "restartPolicy"
  restartPolicy. The name for an init container or normal container must be
  restartPolicy <string> # only Support Always

·记录事件完成 
·如果restartPolicy为： 
　Always：重启容器；   #Pod phase 仍为 Running 
  OnFailure:         #Pod phase 变成 Succeeded 
　Never:              #Pod phase 变成 Succeeded

·记录失败事件
·如果restartPolicy为：
  Always:重启容器；    #Pod phase 仍为 Running
  OnFailure：重启容器；#Pod phase 仍为 Running
  Never:              #Pod phase 变成 Failed

记录失败事件·
如果restartPolicy为：
  Always：重启容器；   #Pod phase仍为Running 
  OnFailure：重启容器；#Pod phase仍为Running
  Never：不重启容器；  #Pod phase仍为Running

记录失败事件
如果restartPolicy为：
  Always：重启容器；     #Pod phase仍为Running
  OnFailure：重启容器；  #Pod phase仍为Running
  Never：               #Pod phase变成Failed

·容器以失败状态终止记录0OM事件
·如果restartPolicy为：
  Always:重启容器；   #Pod phase仍为Running 
  OnFailure:重启容器；#Pod phase仍为Running
  Never：记录失败事件；#Pod phase仍为Failed

·杀掉所有容器，记录适当事件
·Pod phase 变成 Failed
·如果使用控制器来运行 Pod 将在其他节点重建

·节点控制器等待直到超时
·节点控制器将Pod phase设置为Failed
·如果是用控制器来运行，Pod 将在别处重建

$ kubectl edit -n test pod myapp-pod
......
# 以一个 init C 容器 为例
initContainers:
  - command:
    - sh
    - -c
    - until nslookup myservice;do echo waiting for myservice;sleep 2; done;
    image: busybox  # 表明的意思是只有在更改镜像名称时 Init 容器才会重新执行init C阶段, 修改其他字段无任何效果;
    imagePullPolicy: Always
    name: init-myservice
    resources: {}
    terminationMessagePath: /dev/termination-log
    terminationMessagePolicy: File
    volumeMounts:
    - mountPath: /var/run/secrets/kubernetes.io/serviceaccount
      name: default-token-bk9vl
      readOnly: true

cat > ~/K8s/Day3/initC.yaml <<'EOF'
# 名称空间的创建
apiVersion: v1
kind: Namespace
metadata:   
  name: test     # 创建的名称空间的名称(注意建议和labels保持一致并且为小写)
  labels:     
    name: test
---
kind: Pod         # 对象的REST资源类型注意首字母必须大小(坑)
apiVersion: v1
metadata:
  name: myapp-pod  # pod的名称
  namespace: test  # 该Pod加入的名称空间
  labels:
    app: myapp     #该pod所拥有的标签
    version: v1    
    author: weiyigeek
spec:
  containers:       # 要运行容器的列表
  - name: myapp-main-container 
    image: busybox 
    command: ['sh','-c','echo The app is running!&& sleep 3600'] 
  initContainers:   # 在Main C容器创建前运行的Init C容器，注意安装定义的顺序依次执行;
  - name: init-myservice   # 阶段1.以简单的探测服务是否存再来运行主容器以达到容器间依赖问题的解决;
    image: busybox 
    command: ['sh','-c','until nslookup myservice;do echo waiting for myservice;sleep 2; done;']  # 返回为0时候进入下一init C容器阶段
  - name: init-mydb        # 阶段2
    image: busybox  
    command: ['sh','-c','until nslookup mydb;do echo waiting for mydb;sleep 2;done;']
  - name: init-serverA
    images: busybox
    command: ['sh','-c',"curl --connect-timeout 3 --max-time 5 --retry 10 --retry-delay 5 --retry-max-time 60 http://serverB:port/Path/"]
EOF

cat > ~/K8s/Day3/dependService.yaml <<'EOF'
kind: Service
apiVersion: v1
metadata:
 name: myservice
 namespace: test
spec:
 selector:
    app: myapp
 ports:
  - protocol: TCP
    port: 80 
    targetPort: 9376
---
kind: Service 
apiVersion: v1 
metadata:
  name: mydb
  namespace: test
spec:
 selector:
    author: weiyigeek
 ports:
  - protocol: TCP 
    port: 80 
    targetPort: 9377
EOF

# 0.部署测试init C的pod资源清单
weiyigeek@ubuntu:~/K8s/Day3$ kubectl create -f initC.yaml
  # namespace/test created
  # pod/myapp-pod created

# 1.查看 名称空间与Pod 状态(此时可以看见Init0/2还未通过则该Pod的状态为Not Ready, 是由于Init 容器检测未通过)
weiyigeek@ubuntu:~/K8s/Day3$ kubectl get pod -n test
  # NAME        READY   STATUS     RESTARTS   AGE
  # myapp-pod   0/1     Init:0/3   0          33s


# 2.部署测试init C的Service资源清单
kubectl create -f dependService.yaml
  # service/myservice created
  # service/mydb created

# 3.查其容器运行流程日志以及状态
weiyigeek@ubuntu:~$ kubectl describe pod -n test myapp-pod
  # Init Containers:
  #   init-myservice:  # 阶段1
  #     Container ID:  docker://70ab169e9359e448c55267ff818f210a54b0348dc436cd4abd2b4db27fc4932c
  #     Image:         busybox
  #     Image ID:      docker-pullable://busybox@sha256:a9286defaba7b3a519d585ba0e37d0b2cbee74ebfe590960b0b1d6a5e97d1e1d
  #     Port:          <none>
  #     Host Port:     <none>
  #     Command:
  #       sh
  #       -c
  #       until nslookup myservice;do echo waiting for myservice;sleep 2; done;
  #     State:          Terminated
  #       Reason:       Completed
  #       Exit Code:    0    # 正常退出
  #       Started:      Sun, 08 Nov 2020 22:49:58 +0800
  #       Finished:     Sun, 08 Nov 2020 22:51:06 +0800
  #     Ready:          True  # 容器状态
  #     Restart Count:  0
  #     Environment:    <none>
  #     Mounts:
  #       /var/run/secrets/kubernetes.io/serviceaccount from default-token-bk9vl (ro)
  #   init-mydb:       # 阶段2 
  #     Container ID:  docker://306e36d57d75c92f3df10756140f3901dbcc22c1fd89439b8e365a348ca4cb6b
  #     Image:         busybox
  #     Image ID:      docker-pullable://busybox@sha256:a9286defaba7b3a519d585ba0e37d0b2cbee74ebfe590960b0b1d6a5e97d1e1d
  #     Port:          <none>
  #     Host Port:     <none>
  #     Command:
  #       sh
  #       -c
  #       until nslookup mydb;do echo waiting for mydb;sleep 2;done;
  #     State:          Terminated
  #       Reason:       Completed
  #       Exit Code:    0
  #       Started:      Sun, 08 Nov 2020 22:51:12 +0800
  #       Finished:     Sun, 08 Nov 2020 22:51:17 +0800
  #     Ready:          True
  #     Restart Count:  0
  #     Environment:    <none>
  #     Mounts:
  #       /var/run/secrets/kubernetes.io/serviceaccount from default-token-bk9vl (ro)
...
Events:  # Pod 创建 以及 容器创建的事件过程
  Type    Reason     Age   From               Message
  ----    ------     ----  ----               -------
  Normal  Scheduled  113s  default-scheduler  Successfully assigned test/myapp-pod to k8s-node-4

  Normal  Pulling    113s  kubelet            Pulling image "busybox"
  Normal  Pulled     108s  kubelet            Successfully pulled image "busybox" in 4.499850144s
  Normal  Created    108s  kubelet            Created container init-myservice
  Normal  Started    108s  kubelet            Started container init-myservice

  Normal  Pulling    40s   kubelet            Pulling image "busybox"
  Normal  Pulled     34s   kubelet            Successfully pulled image "busybox" in 5.078096509s
  Normal  Created    34s   kubelet            Created container init-mydb
  Normal  Started    34s   kubelet            Started container init-mydb

  Normal  Pulling    28s   kubelet            Pulling image "busybox"
  Normal  Pulled     25s   kubelet            Successfully pulled image "busybox" in 3.215811094s
  Normal  Created    25s   kubelet            Created container myapp-main-container
  Normal  Started    25s   kubelet            Started container myapp-main-container

# 4.在Init C容器启动完毕后，Main C进行启动正常后状态为Runing
weiyigeek@ubuntu:~$ kubectl get pod -n test
  # NAME        READY   STATUS    RESTARTS   AGE
  # myapp-pod   1/1     Running   0          2m8s

$ kubectl explain pod.spec.containers.readinessProbe | egrep "FIELDS|>"
RESOURCE: readinessProbe <Object>
FIELDS:
   exec <Object>
   httpGet      <Object>
   tcpSocket    <Object>
   initialDelaySeconds  <integer>
   periodSeconds        <integer>
   timeoutSeconds       <integer>
   failureThreshold     <integer>
   successThreshold     <integer>

# (1) httpGet 检测方案 
cat > readinessProbe-httpget.yaml<<'EOF'
apiVersion: v1 
kind: Pod 
metadata:
  name: readiness-httpget-pod 
  namespace: test
spec:
  containers:
  - name: readiness-httpget-container 
    image: harbor.weiyigeek.top/test/nginx:v2.2
    imagePullPolicy: IfNotPresent #镜像下载策略如果存在则不下载
    readinessProbe: # 就绪探针
      httpGet:      # 检测方案
        port: 80             # 请求端口
        path: /index1.html   # 请求路径
      initialDelaySeconds: 1 # 初始化检测延时（1秒以后）
      timeoutSeconds: 1      # 请求等待超时时间 （1秒以后）
      periodSeconds: 3       # 重试的检测时间（3秒以后）
EOF


# (2) 部署资源清单
~/K8s/Day4$ kubectl create -f readinessProbe-httpget.yaml
pod/readiness-httpget-pod created


# (3) 查看 & 结果
~/K8s/Day4$ kubectl get pod -n test | grep "readiness-httpget-pod"
NAME                    READY   STATUS    RESTARTS   AGE   IP            NODE         NOMINATED NODE   READINESS GATES
readiness-httpget-pod   1/1     Running   0          40m   10.244.1.14   k8s-node-4   <none>  <none>  # 可以看见READY不是就绪的 


~/K8s/Day4$ kubectl describe -n test pod readiness-httpget-pod
  # Events:
  #   Type     Reason     Age                      From               Message
  #   ----     ------     ----                     ----               -------
  #   Normal   Scheduled  7m35s                    default-scheduler  Successfully assigned test/readiness-httpget-pod to k8s-node-4
  #   Normal   Pulling    7m35s                    kubelet            Pulling image "harbor.weiyigeek.top/test/nginx:v2.2"
  #   Normal   Pulled     7m35s                    kubelet            Successfully pulled image "harbor.weiyigeek.top/test/nginx:v2.2" in 179.781569ms
  #   Normal   Created    7m34s                    kubelet            Created container readiness-httpget-container
  #   Normal   Started    7m34s                    kubelet            Started container readiness-httpget-container
  Warning  Unhealthy  2m32s (x101 over 7m32s)  kubelet            Readiness probe failed: HTTP probe failed with statuscode: 404  # 关键点


# (4) 进入容器中创建index1.html文件
~/K8s/Day4$ kubectl exec -n test readiness-httpget-pod -it sh
  # echo "readiness-httpget-pod" > /usr/share/nginx/html/index1.html
  # ls /usr/share/nginx/html/
  # 50x.html  host.html  index.html  index1.html

~/K8s/Day4$ curl http://10.244.1.14/index1.html
# readiness-httpget-pod

# (5) 添加文件后容器状态的转变
~/K8s/Day4$ kubectl get pod -n test
  # NAME                    READY   STATUS    RESTARTS   AGE
  # readiness-httpget-pod   1/1     Running   0          9m28s  # 此时可以看见READY已经就绪

~/K8s/Day4$  kubectl logs -n test readiness-httpget-pod
  # 2020/11/09 08:37:06 [error] 9#9: *128 open() "/usr/share/nginx/html/index1.html" failed (2: No such file or directory), client: 10.244.1.1, server: localhost, request: "GET /index1.html HTTP/1.1", host: "10.244.1.14:80"
  # 10.244.1.1 - - [09/Nov/2020:08:37:06 +0000] "GET /index1.html HTTP/1.1" 404 153 "-" "kube-probe/1.19" "-"
  # 10.244.1.1 - - [09/Nov/2020:08:37:09 +0000] "GET /index1.html HTTP/1.1" 200 22 "-" "kube-probe/1.19" "-"

apiVersion: v1 
kind: Pod 
metadata:
  name: liveness-httpget-pod 
  namespace: default 
spec:
  containers: 
  - name: liveness-httpget-container 
    image: harbor.weiyigeek.top/test/nginx:v2.2
    imagePu11Policy: IfNotPresent 
    ports:
    - name: http 
      containerPort: 80 
    1ivenessProbe:
      httpGet:
        port: http 
        path: /index.html 
        httpHeaders:
        - name: X-Custom-Header
          value: WeiyiGeek
      initialDelaySeconds: 1  # 延迟1秒以后开始检测
      timeoutSeconds: 10      # 每次访问时最大的超时时间
      periodSeconds: 3        # 每3秒重复检测一次

apiVersion: v1 
kind: Pod 
metadata:
  name: liveness-exec-pod 
  namespace: test 
spec:
  containers: 
  - name: liveness-exec-container 
    image: hub.coreqi.cn/1ibrary/busybox 
    imagePullPolicy: IfNotPresent 
    command: ["/bin/sh","-c","touch /tmp/live;sleep 60;rm -rf /tmp/live;sleep 3600"] 
    livenessProbe:  #探活指针
      exec: #执行命令
        command: ["test","-e","/tmp/live"] #检测文件是否存在
      initialDelaySeconds: 1     # 容器启动1秒后执行
      periodSeconds: 3           # 重试的循环时间为3秒

cat > ~/K8s/Day4/livenessProbe-tcpSocket.yaml <<'EOF'
apiVersion: v1 
kind: Pod 
metadata:
  name: livenessprobe-tcpsocket  # 注意只能小写
  namespace: test
spec:
  containers:
  - name: nginx 
    image: harbor.weiyigeek.top/test/nginx:v2.2
    livenessProbe:
      tcpSocket:
        port: 81             # 检测 81 端口 (实际启动的端口是80所以它会一直重试检测)
      initialDelaySeconds: 5 # 初始化后5s执行 
      timeoutSeconds: 1      # 连接超时
      periodSeconds: 3       # 重试间隔3s 
EOF

# 1.部署资源清单
~/K8s/Day4$ kubectl create -f livenessProbe-tcpSocket.yaml
  # pod/livenessprobe-tcpsocket created

# 2.结果查看(关键点)
~/K8s/Day4$ kubectl get pod -n test -o wide
  # NAME                      READY   STATUS    RESTARTS   AGE     IP            NODE         NOMINATED NODE   READINESS GATES
  # livenessprobe-tcpsocket   1/1     Running   0   起初       23s     10.244.1.15   k8s-node-4   <none>           <none>

~/K8s/Day4$  kubectl get pod -n test -o wide -w  #  生命周期内探测为满足条件退出 重启 
  # NAME                      READY   STATUS    RESTARTS   AGE     IP            NODE         NOMINATED NODE   READINESS GATES
  # livenessprobe-tcpsocket   1/1     Running   2  关键点   91s     10.244.1.15   k8s-node-4   <none>           <none>
  # ....
  # livenessprobe-tcpsocket   1/1     Running   3          2m7s    10.244.1.15   k8s-node-4   <none>           <none>
  # .... 5次重启后探测还未通过，返回崩溃循环 并且此时状态NotReady  
  # livenessprobe-tcpsocket   0/1     CrashLoopBackOff   5   4m13s   10.244.1.15   k8s-node-4   <none>           <none>
  # livenessprobe-tcpsocket   1/1     Running            6   5m42s   10.244.1.15   k8s-node-4   <none>           <none>
  # livenessprobe-tcpsocket   0/1     CrashLoopBackOff   6   6m26s   10.244.1.15   k8s-node-4   <none>           <none>

# 3.Pod 运行事件查看详细信息
~/K8s/Day4$ kubectl describe pod -n test livenessprobe-tcpsocket
  # Events:  # 通过Eventsxiang详细描述信息可知Contianer liveness不健康，其将被Kill掉重新生成。
  #   Type     Reason     Age                    From               Message
  #   ----     ------     ----                   ----               -------
  #   Normal   Scheduled  8m7s                   default-scheduler  Successfully assigned test/livenessprobe-tcpsocket to k8s-node-4
  #   Normal   Killing    6m30s (x3 over 7m54s)  kubelet            Container nginx failed liveness probe, will be restarted
  #   Normal   Pulled     6m (x4 over 8m6s)      kubelet            Container image "harbor.weiyigeek.top/test/nginx:v2.2" already present on machine
  #   Normal   Created    6m (x4 over 8m6s)      kubelet            Created container nginx
  #   Normal   Started    6m (x4 over 8m6s)      kubelet            Started container nginx
  #  Liveness probe 检测信息
  # Warning  Unhealthy  5m54s (x10 over 8m)    kubelet            Liveness probe failed: dial tcp 10.244.1.15:81: connect: connection refused
  # Warning  BackOff    3m5s (x6 over 3m54s)   kubelet            Back-off restarting failed container

apiVersion: v1
kind: Pod
metadata:
  name: myapp-pod
  labels:
    app: myapp
spec:
  containers:
  - name: reservation-server
    image: weiyigeek/activityreservation:dev
    ports:
      - name: http
        containerPort: 80
        protocol: TCP
    livenessProbe:
        httpGet:
            path: /health
            port: http
        initialDelaySeconds: 60
        periodSeconds: 10
    readinessProbe:
        httpGet:
            path: /api/notice
            port: http
        initialDelaySeconds: 60
        periodSeconds: 10
  initContainers:
    - name: init-redis
      image: busybox:1.31
      command: ['sh', '-c', 'until nslookup redis-server; do echo waiting for redis; sleep 2; done;']
    - name: init-mysql
      image: busybox:1.31
      command: ['sh', '-c', 'until nslookup mysql-server; do echo waiting for mysql; sleep 2; done;']

$ docker tag nginx:latest harbor.weiyigeek.top/test/nginx:latest
$ docker push harbor.weiyigeek.top/test/nginx:latest

$ kubectl explain Pod.spec.containers.lifecycle

cat > ~/K8s/Day4/lifecycle-demoStartStop.yaml<<'EOF'
apiVersion: v1 
kind: Pod 
metadata:
  name: lifecycle-demo 
  namespace: test
  labels: 
    app: nginx
spec:
  containers:
  - name: lifecycle-demo-container 
    image: harbor.weiyigeek.top/test/nginx
    imagePullPolicy: IfNotPresent
    lifecycle:    # [重点生存周期] 
      postStart:  # 启动时运行
        exec:
          command: ["/bin/sh","-c","echo ${HOSTNAME},${NGINX_VERSION}> /usr/share/nginx/html/info.html"] 
      preStop:    # 退出时运行(需要正常退出防止数据损坏)
        exec: 
          command: ["/usr/sbin/nginx","-s","quit"]
  restartPolicy: OnFailure
EOF

# (1) 执行部署
weiyigeek@ubuntu:~/K8s/Day4$ kubectl create -f lifecycle-demoStartStop.yaml
  # pod/lifecycle-demo created

weiyigeek@ubuntu:~/K8s/Day4$ kubectl get pod -n test -o wide | grep "lifecycle-demo"
  # lifecycle-demo   1/1     Running   0          41s   10.244.1.13   k8s-node-4   <none>           <none>

weiyigeek@ubuntu:~/K8s/Day4$ kubectl logs -n test lifecycle-demo
  # /docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
  # /docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
  # /docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
  # 10-listen-on-ipv6-by-default.sh: Getting the checksum of /etc/nginx/conf.d/default.conf
  # 10-listen-on-ipv6-by-default.sh: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf
  # /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
  # /docker-entrypoint.sh: Configuration complete; ready for start up

# (2) 访问查看
~/K8s/Day4$ curl http://10.244.1.13/info.html
  # lifecycle-demo,1.19.4

# (3) 停止主容器然后删除Pod
kubectl delete -f lifecycle-demoStartStop.yaml
  # pod "lifecycle-demo" deleted

# 删除Deployment创建的所有Pod
~$ kubectl get deployment
  NAME               READY   UP-TO-DATE   AVAILABLE   AGE
  nginx-deployment   3/3     3            3           2d14h

~$ kubectl delete deployment --all # 先删除deployment
  deployment.apps "nginx-deployment" deleted

~$ kubectl delete pod --all
  pod "nginx-deployment-7f5d9779c6-dr5h8" deleted
  pod "nginx-deployment-7f5d9779c6-hhl7k" deleted
  pod "nginx-deployment-7f5d9779c6-sk2f4" deleted

~$ kubectl delete svc nginx-deployment

~$ kubectl exec nginx-deployment-7f5d9779c6-dr5h8 -it -- /bin/sh env
  # KUBERNETES_SERVICE_PORT=443
  # KUBERNETES_PORT=tcp://10.96.0.1:443
  # HOSTNAME=nginx-deployment-7f5d9779c6-dr5h8
  # HOME=/root
  # PKG_RELEASE=1~buster
  # TERM=xterm
  # KUBERNETES_PORT_443_TCP_ADDR=10.96.0.1
  # NGINX_VERSION=1.19.4
  # PATH=/usr/local/nginx/sbin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
  # KUBERNETES_PORT_443_TCP_PORT=443
  # NJS_VERSION=0.4.4
  # KUBERNETES_PORT_443_TCP_PROTO=tcp
  # IMAGE_VERSION=2.2
  # KUBERNETES_SERVICE_PORT_HTTPS=443
  # KUBERNETES_PORT_443_TCP=tcp://10.96.0

# 创建pod的Init容器查看
kubectl get pod
kubecrl describe pod