2.K8s-理论基础

kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
name: demo
nodes:
  - role: control-plane
    image: kindest/node:v1.23.4
    extraPortMappings:  # 将容器内的 Kubernetes API Server 端口(6443)映射到宿主机的 26443 端口
      - containerPort: 6443  # 容器内部端口
        hostPort: 26443      # 宿主机映射端口
        listenAddress: "0.0.0.0"  # 监听所有网络接口
  - role: worker
    image: kindest/node:v1.23.4
  - role: worker
    image: kindest/node:v1.23.4

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
spec:
  containers:
  - name: nginx-container
    image: docker.io/library/nginx:latest
    imagePullPolicy: IfNotPresent

#查看Pod日志
kubectl logs --follow nginx-pod

#利用Pod执行命令
kubectl exec nginx-pod -- ls

#两种方法删除Pod
kubectl delete pod nginx-pod
kubectl delete -f nginx.yaml

#创建命名空间
kubectl create namespace test
kubectl get namespaces

#在 kube-system 命名空间中获取资源
kubectl get pods -n kube-system
kubectl get pods -A
kubectl get pods -A -o wide

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: nginx-rs
  namespace: default
spec:
  replicas: 3   # 期望的 Pod 副本数量
  selector:     # 必须匹配 template.metadata.labels
    matchLabels:
      app: nginx
  template:     # Pod 模板
    metadata:
      labels:   # 必须与 selector.matchLabels 一致
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest  # 建议显式指定版本
        ports:
        - containerPort: 80

kubectl apply -f nginx-rs.yaml
kubectl get rs
kubectl get po -l app=nginx
kubectl describe pod nginx-rs-cmsdp

# 尝试删除其中一个 Pod
kubectl delete pod nginx-rs-cmsdp
# 再查看 Pod 列表
kubectl get po -l app=nginx

# 可以看到又重新出现了一个 Pod，这个就是上面我们所说的 ReplicaSet 控制器为我们做的工作
# 我们在 YAML 文件中声明了 3 个副本，然后现在我们删除了一个副本，就变成了两个，这个时候 
ReplicaSet 控制器监控到控制的 Pod 数量和期望的 3 不一致，所以就需要启动一个新的 Pod 来保持 3 个副本，这个过程上面我们说了就是调谐的过程。

# 查看 RS 的描述信息来查看到相关的事件信息
kubectl describe rs nginx-rs

# 查看一个 Pod 的描述信息可以看到这个 Pod 的所属控制器信息
kubectl get po -l app=nginx
kubectl describe pod xxxxx
# 结果会存在 Controlled By:  ReplicaSet/nginx-rs #从这里可以看到，这个pod是被
ReplicaSet/nginx-rs控制

# 如果要彻底删除 Pod, 我们就只能删除 RS 对象或者把rs里的副本数改为0
kubectl delete rs nginx-rs
kubectl get rs,pod

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deploy
  namespace: default
  labels: #这个标签仅仅用于标记deployment本身这个资源对象。注意：deployment里metadata里的label标签定不定义都无所谓，没有什么实际意义，因为deployment在k8s已经是一个很高级的概念了，没有什么人可以管它了。
    role: deploy  
spec:
  replicas: 3  # 期望的 Pod 副本数量，默认值为1
  selector:  # Label Selector，必须匹配Pod模板中的标签。
    matchLabels:
      app: nginx
  template:  # Pod 模板
    metadata: 
      labels:
        app: nginx #一定要包含上面的 matchLabels里面的标签。
    spec:
      containers:
      - name: nginx
        image: nginx
        ports:
        - containerPort: 80

kubectl apply -f nginx-deploy.yaml 
kubectl get deployments.apps 
kubectl get po
# 到这里我们发现和之前的 RS 对象是否没有什么两样，都是根据spec.replicas 来维持的副本数量。

# 查看一个Pod 的描述信息
kubectl describe po xxxxx
# 仔细查看其中有这样一个信息 Controlled By: ReplicaSet/xxxxx  
# 这个不是表示当前我们这个 Pod 的控制器是一个 ReplicaSet 对象啊，
# 我们不是创建的一个 Deployment 吗？为什么Pod 会被 RS 所控制呢？
# 再去看下这个对应的 RS 对象的详细信息
kubectl describe rs xxxxx
# 其中有这样的一个信息： Controlled By: Deployment/nginx-deploy
# 意思就是我们的 Pod 依赖的控制器 RS 实际上被我们的 Deployment 控制着

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: nginx-ds
  namespace: default
spec:
  selector:
    matchLabels:
      k8s-app: nginx
  template:
    metadata:
      labels:
        k8s-app: nginx
    spec:
      containers:
      - image: nginx
        name: nginx
        ports:
        - name: http
          containerPort: 80

kubectl apply -f nginx-ds.yaml
kubectl get node
kubectl get po -l k8s-app=nginx -owide
# 观察可以发现除了 master 节点之外的2个节点上都有一个相应的 Pod 运行,
# 因为 master 节点上默认被打上了污点（taints）, DaemonSet是受污点的的影响的,
# 所以默认情况下不能调度普通的 Pod 上去，后面讲解调度器的时候会和大家学习如何调度上去

# 先来提前看看污点长什么样
kubectl describe node demo-control-plane |grep Taints
kubectl describe node demo-worker |grep Taints
kubectl describe node demo-worker2 |grep Taints

# 删除一个节点上的 pod, 观察下这个pod是否会被立马重建
kubectl get po -o wide
kubectl delete po xxxxx

apiVersion: batch/v1
kind: Job
metadata:
  name: hello-job
spec:
  parallelism: 3
  completions: 5
  template:
    spec:
      restartPolicy: OnFailure
      containers:
      - name: echo
        image: busybox
        command: ["/bin/sh"]
        args: ["-c", "for i in 9 8 7 6 5 4 3 2 1 ; do echo $i ; done"]

kubectl apply -f hello-job.yaml
kubectl get jobs
kubectl get pods
kubectl logs -f hello-job-xxxx

# ┌───────────── 分钟 (0 - 59)
# │ ┌───────────── 小时 (0 - 23)
# │ │ ┌───────────── 月的某天 (1 - 31)
# │ │ │ ┌───────────── 月份 (1 - 12)
# │ │ │ │ ┌───────────── 周的某天 (0 - 6)（周日到周一；在某些系统上，7 也是星期日）
# │ │ │ │ │                          或者是 sun，mon，tue，web，thu，fri，sat
# │ │ │ │ │
# │ │ │ │ │
# * * * * *

apiVersion: batch/v1
kind: CronJob
metadata:
  name: hello-cronjob
spec:
  schedule: "* * * * *"  # 每分钟执行一次
  jobTemplate:
    spec:
      template:
        spec:
          restartPolicy: OnFailure
          containers:
          - name: echo
            image: busybox
            command: ["/bin/sh"]
            args: ["-c", "for i in 9 8 7 6 5 4 3 2 1 ; do echo $i ; done"]

for {
    desired := getDesiredState()  // 期望的状态
    current := getCurrentState()  // 当前实际状态
    if current == desired {  // 如果状态一致则什么都不做

  } else {  // 如果状态不一致则调整编排，到一致为止
      // 调整编排
  }
}

# nginx-svc-demo.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
      - image: nginx
        imagePullPolicy: IfNotPresent
        name: nginx
        ports:
        - protocol: TCP
          containerPort: 80  # 容器内暴露的端口，这里只是一个标识，真正起作用的还是容器里服务的端口号
          name: nginx-http

---
# 如果有一组 Pod 服务，它们对外暴露了 8080 端口，同时都被打上了 app=myapp 这样的标签，
# 那么我们就可以像下面这样来定义一个 Service 对象，
# myservice 会将请求代理到使用 TCP 端口为 8080 并具有标签 app=myapp 的 Pod 上
apiVersion: v1
kind: Service
metadata:
  name: myservice
spec:
  selector:
    app: web
  type: ClusterIP  # 服务类型，默认就是 ClusterIP
  ports:
  - protocol: TCP
    port: 8080     # 如果没有配置 targetPort，则这里的 port 要和容器内暴露的端口保持一致
    targetPort: 80 # 一定要和容器内应用暴露的端口保持一致
    name: myapp-http

#进入 master 节点
docker exec -it demo-control-plane /bin/bash
#访问 pod
curl 10.244.1.10:80 | grep "<p><em>"
#访问Service
curl 10.96.60.89:8080 | grep "<p><em>"

# 查看 node 的 label
kubectl get node --show-labels

# 给节点 demo-worker2 增加一个 app=test 的标签
kubectl label nodes demo-worker2 app=test
kubectl get node demo-worker2 --show-labels

# 删除标签
kubectl label nodes demo-worker2 app-

apiVersion: v1
kind: Pod
metadata:
  labels:
    app: busybox-pod
  name: test-busybox
spec:
  containers:
  - command:
    - sleep
    - "3600"
    image: busybox
    imagePullPolicy: Always
    name: test-busybox
  nodeSelector:  # 注意：nodeSelector 和 containers 同级，必须放在 containers 定义之后
    app: test

kubectl apply -f 01-node-selector-demo.yaml
kubectl get po -owide

# 查看 Pod 的创建情况, Events 下面的信息
kubectl describe po test-busybox

apiVersion: v1
kind: Pod
metadata:
  name: pod-example
  labels:
    app: nginx
spec:
  nodeName: node1  # 指定Pod调度到node1节点
  containers:
  - name: nginx
    image: nginx:latest  # 建议显式指定镜像版本
    ports:
    - containerPort: 80  # 建议声明容器端口
    resources:           # 建议添加资源限制（生产环境必需）
      limits:
        cpu: "500m"
        memory: "512Mi"
      requests:
        cpu: "100m"
        memory: "128Mi"

apiVersion: apps/v1
kind: Deployment
metadata:
  name: node-affinity
  labels:
    app: node-affinity
spec:
  replicas: 5
  selector:
    matchLabels:
      app: node-affinity
  template:
    metadata:
      labels:
        app: node-affinity
    spec:
      containers:
      - name: nginx
        image: nginx:latest  # 建议显式指定版本
        ports:
        - containerPort: 80
          name: nginxweb
      affinity:
        node:
          # 硬策略：必须满足的条件
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: kubernetes.io/hostname
                operator: NotIn
                values:
                - demo-control-plane  # 禁止调度到控制平面节点
          
          # 软策略：优先满足的条件
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1  # 权重值（1-100）
            preference:
              matchExpressions:
              - key: app
                operator: In
                values:
                - test  # 优先调度到带有 app=test 标签的节点

kubectl apply -f node-affinty-demo.yaml
kubectl get pods -l app=node-affinity -o wide
kubectl delete Deployment node-affinity

apiVersion: v1
kind: Pod
metadata:
  name: my-busybox-pod
  labels:
    app: busybox-pod
spec:
  containers:
  - command:
    - sleep
    - "3600"
    image: busybox:latest  # 建议显式指定镜像版本
    imagePullPolicy: Always
    name: test-busybox
    resources:              # 建议添加资源限制（生产环境必需）
      limits:
        cpu: "100m"
        memory: "128Mi"
      requests:
        cpu: "50m"
        memory: "64Mi"

apiVersion: apps/v1
kind: Deployment
metadata:
  name: pod-affinity
  labels:
    app: pod-affinity
spec:
  replicas: 3
  selector:
    matchLabels:
      app: pod-affinity
  template:
    metadata:
      labels:
        app: pod-affinity
    spec:
      containers:
      - name: nginx
        image: nginx:latest  # 建议显式指定版本
        ports:
        - containerPort: 80
          name: nginxweb
      affinity:
        podAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:  # 硬策略
          - labelSelector:
              matchExpressions:
              - key: app
                operator: In  # 修正操作符缩进
                values:
                - busybox-pod  # 必须与存在 app=busybox-pod Pod 的节点共同运行
            topologyKey: kubernetes.io/hostname  # 根据主机名进行拓扑约束

apiVersion: apps/v1
kind: Deployment
metadata:
  name: pod-antiaffinity
  labels:
    app: pod-antiaffinity
spec:
  replicas: 3
  selector:
    matchLabels:
      app: pod-antiaffinity
  template:
    metadata:
      labels:
        app: pod-antiaffinity
    spec:
      containers:
      - name: nginx
        image: nginx:latest  # 显式指定镜像版本
        ports:
        - containerPort: 80
          name: nginxweb
        resources:           # 添加资源限制（推荐）
          limits:
            cpu: "500m"
            memory: "512Mi"
          requests:
            cpu: "100m"
            memory: "128Mi"
      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:  # 硬性反亲和规则
          - labelSelector:
              matchExpressions:
              - key: app
                operator: In
                values:
                - busybox-pod  # 避免调度到已有 app=busybox-pod Pod 的节点
            topologyKey: kubernetes.io/hostname  # 按节点主机名判断拓扑域