Kubernetes生产级完整实战指南

1
2

# 示例：创建一个简单的Nginx Pod
kubectl run mynginx --image=nginx:1.14.2 --restart=Never

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

apiVersion: v1          # API版本，v1是稳定核心版本
kind: Pod               # 资源类型为Pod
metadata:
  name: mynginx         # Pod名称，同一命名空间下唯一
  namespace: default    # 命名空间，默认为default
  labels:               # 标签键值对，用于Service选择器
    app: frontend
    tier: web
    version: v1
  annotations:          # 注释信息，不影响功能，用于记录元数据
    description: "Production nginx pod"
    monitoring: "true"
spec:
  containers:
  - name: nginx         # 容器名称，Pod内唯一
    image: nginx:1.14.2 # 镜像地址，支持Docker Hub和私有仓库
    imagePullPolicy: IfNotPresent  # 镜像拉取策略
    # IfNotPresent: 本地不存在才拉取（生产推荐）
    # Always: 每次都拉取（开发环境）
    # Never: 仅使用本地镜像
    ports:
    - containerPort: 80 # 容器暴露的端口
      name: http        # 端口名称，便于引用
      protocol: TCP     # 协议类型
    env:                # 环境变量注入
    - name: NGINX_ENV
      value: "production"
    - name: POD_IP
      valueFrom:
        fieldRef:
          fieldPath: status.podIP  # 引用Pod自身信息
    resources:          # 资源限制（生产环境必须设置）
      requests:
        memory: "64Mi"  # 请求内存，调度依据（软限制）
        cpu: "50m"      # 请求CPU，1核=1000m（50m=0.05核）
      limits:
        memory: "128Mi" # 内存硬限制，超过会触发OOMKill
        cpu: "100m"     # CPU硬限制，超过会被限流（不重启）
    volumeMounts:       # 存储卷挂载
    - name: cache
      mountPath: /cache  # 容器内挂载路径
      readOnly: false    # 是否只读
    livenessProbe:      # 存活探针（检测容器是否存活）
      httpGet:
        path: /healthz
        port: 80
      initialDelaySeconds: 10  # 启动后延迟10秒开始探测
      periodSeconds: 5         # 每5秒探测一次
      timeoutSeconds: 3        # 请求超时时间
      failureThreshold: 3      # 连续3次失败才重启
    readinessProbe:     # 就绪探针（检测容器是否准备好接收流量）
      httpGet:
        path: /ready
        port: 80
      initialDelaySeconds: 5
      periodSeconds: 3
    startupProbe:       # 启动探针（保护慢启动应用）
      httpGet:
        path: /startup
        port: 80
      initialDelaySeconds: 10
      periodSeconds: 10
      failureThreshold: 30  # 最多容忍300秒启动时间
  volumes:              # 存储卷定义
  - name: cache
    emptyDir: {}       # 临时目录，Pod删除时清空
  restartPolicy: Always # 重启策略
  # Always: 无论何原因退出都重启（默认）
  # OnFailure: 仅错误退出时重启
  # Never: 从不重启
  nodeSelector:         # 节点选择器
    disktype: ssd       # 只调度到有ssd标签的节点
  tolerations:          # 污点容忍（允许调度到污点半径节点）
  - key: "node-role.kubernetes.io/master"
    operator: "Exists"
    effect: "NoSchedule"

1
2
3
4
5

# 创建工作目录
mkdir 1119 && cd 1119

# 创建emptyDir配置文件
vim emptydir.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

apiVersion: v1
kind: Pod
metadata:
  name: pod-empty
spec:
  containers:
  - name: container-empty
    image: nginx:1.19.5
    imagePullPolicy: IfNotPresent
    volumeMounts:
    - mountPath: /cache      # 容器内挂载路径
      name: cache-volume    # 引用的卷名称
  volumes:
  - name: cache-volume
    emptyDir:
      sizeLimit: 500Mi      # 限制最大容量（可选）
      # medium: Memory      # 可选：存储在tmpfs（内存）中，速度极快但会消耗内存

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 创建Pod
kubectl apply -f emptydir.yaml

# 查看Pod调度节点
kubectl get pods -o wide | grep pod-empty
# 输出示例：pod-empty   1/1   Running   0   2m   10.244.1.5   k8s-node1

# 查看Pod的UID（用于定位节点上的实际路径）
kubectl get pods pod-empty -o yaml | grep uid
# 输出：uid: 8f9c8d8a-1b2c-3d4e-5f6g-7h8i9j0k1l2m

# 在对应节点上查看emptyDir实际路径（需要SSH到节点）
# 路径：/var/lib/kubelet/pods/<uid>/volumes/kubernetes.io~empty-dir/<volume-name>
# 例如：/var/lib/kubelet/pods/8f9c8d8a-1b2c-3d4e-5f6g-7h8i9j0k1l2m/volumes/kubernetes.io~empty-dir/cache-volume

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 将tomcat镜像分发到节点（因使用IfNotPresent策略）
ll tomcat.tar.gz
scp -r tomcat.tar.gz k8s-node1:/root/
scp -r tomcat.tar.gz k8s-node2:/root/
# 在节点上加载镜像
# ssh k8s-node1 "docker load -i /root/tomcat.tar.gz"
# ssh k8s-node2 "docker load -i /root/tomcat.tar.gz"

# 创建hostPath配置文件
vim hostpath.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

apiVersion: v1
kind: Pod
metadata:
  name: test-hostpath
spec:
  containers:
  - image: nginx:1.19.5
    imagePullPolicy: IfNotPresent
    name: test-nginx
    volumeMounts:
    - mountPath: /test-nginx   # 第一个容器挂载路径
      name: test-volume
  - image: tomcat:latest
    imagePullPolicy: IfNotPresent
    name: test-tomcat
    volumeMounts:
    - mountPath: /test-tomcat  # 第二个容器挂载路径
      name: test-volume
  volumes:
  - name: test-volume
    hostPath:
      path: /data1             # 节点上的真实目录路径
      type: DirectoryOrCreate  # 目录不存在时自动创建
      # 其他type选项：
      # Directory: 目录必须存在
      # FileOrCreate: 文件不存在时自动创建
      # File: 文件必须存在
      # Socket: UNIX套接字必须存在
      # CharDevice: 字符设备必须存在
      # BlockDevice: 块设备必须存在

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

kubectl apply -f hostpath.yaml
kubectl get pod -owide

# 进入Nginx容器写入数据
kubectl exec -it test-hostpath -c test-nginx -- bash
# 命令解析：
# exec: 在运行容器中执行命令
# -it: 交互式终端
# -c test-nginx: 指定容器名（Pod内有多个容器时必须指定）
# -- bash: 在容器内执行bash shell

# 在容器内执行
echo "I am test-nginx test data write" > /test-nginx/mslinux-data
exit

# 进入Tomcat容器读取数据
kubectl exec -it test-hostpath -c test-tomcat -- bash
cat /test-tomcat/mslinux-data
# 输出：I am test-nginx test data write
echo "I am test-tomcat test data write" >> /test-tomcat/mslinux-data
exit

# 在节点上验证文件实际位置
# SSH到Pod所在节点
# cat /data1/mslinux-data
# 输出包含两行数据，证明两个容器共享同一主机目录

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

# 步骤1：安装NFS服务组件
yum install -y nfs-utils rpcbind
# nfs-utils: 提供NFS服务器和客户端工具
# rpcbind: 端口映射服务，NFS依赖的RPC服务

# 步骤2：创建共享目录并设置权限
mkdir -p /nfs/data
chmod -R 755 /nfs/data
chown nfsnobody:nfsnobody /nfs/data
# 权限详解：
# 755: 所有者可读写执行，其他用户只读执行
# nfsnobody: NFS服务的匿名用户，容器以root写入时映射为此用户

# 步骤3：配置exports文件（访问控制列表）
cat >> /etc/exports <<EOF
/nfs/data/ 192.168.200.0/24(insecure,rw,sync,no_root_squash)
# 参数详解：
# /nfs/data: 共享目录路径
# 192.168.200.0/24: 允许访问的网段
# insecure: 允许客户端使用大于1024的端口（容器常用）
# rw: 读写权限
# sync: 同步写入，数据安全但性能较低（async性能高但可能丢数据）
# no_root_squash: 容器root用户保持root权限（默认root_squash会映射为nobody）
EOF

# 步骤4：启动服务并设置开机自启
systemctl enable --now rpcbind nfs-server
# enable --now: 相当于 enable + start，设置开机启动并立即启动

# 步骤5：验证共享配置
exportfs -v
# 输出示例：
# /nfs/data 	192.168.200.0/24(sync,wdelay,hide,no_subtree_check,sec=sys,rw,secure,no_root_squash,no_all_squash)
# 每个参数含义：
# sync: 同步模式
# wdelay: 延迟写入，优化性能
# hide: 隐藏下级目录
# no_subtree_check: 禁用子树检查，提升性能
# sec=sys: 使用系统UID/GID认证
# secure: 要求客户端使用安全端口（与insecure互斥，以exports配置为准）

# 步骤6：检查NFS共享是否可用
showmount -e localhost
# 应输出：/nfs/data 192.168.200.0/24

1
2
3
4
5
6
7
8
9

# 故障1：showmount -e 超时
# 解决：检查防火墙 firewall-cmd --add-service=nfs --permanent && firewall-cmd --reload
# 或 systemctl stop firewalld

# 故障2：容器内Permission denied
# 解决：检查exports权限是否为no_root_squash，检查目录chmod权限

# 故障3：挂载后文件所有者错乱
# 解决：确保chown nfsnobody:nfsnobody已执行，检查/etc/idmapd.conf配置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

# 在k8s-node1和k8s-node2上执行：

# 步骤1：验证NFS服务器可用性
showmount -e 192.168.200.100
# -e: 显示导出列表
# 输出应包含：/nfs/data 192.168.200.0/24
# 如果超时，检查Master节点防火墙和NFS服务状态

# 步骤2：创建本地挂载点
mkdir -p /nfs/data

# 步骤3：手动挂载测试（临时）
mount -t nfs 192.168.200.100:/nfs/data /nfs/data
# -t nfs: 指定文件系统类型
# 格式：server:remote-dir local-dir

# 验证挂载是否成功
df -h | grep nfs
# 输出示例：192.168.200.100:/nfs/data   50G  10G  40G  20% /nfs/data

# 步骤4：配置开机自动挂载（生产必备）
cat >> /etc/fstab <<EOF
192.168.200.100:/nfs/data /nfs/data nfs defaults,_netdev 0 0
# /etc/fstab字段说明：
# 第1列：远程NFS路径
# 第2列：本地挂载点
# 第3列：文件系统类型
# 第4列：挂载选项
#   defaults: 默认选项(rw, suid, dev, exec, auto, nouser, async)
#   _netdev: 网络设备，网络就绪后再挂载（避免开机卡死）
# 第5列：是否备份（0不备份）
# 第6列：fsck检查顺序（0不检查）
EOF

# 测试fstab配置
mount -a
# 无输出表示配置正确

# 步骤5：测试写入权限
touch /nfs/data/test.txt
# 在所有节点验证文件是否同步出现
ls -l /nfs/data/test.txt
# 检查文件大小、时间戳是否一致

# 步骤6：性能优化（可选）
cat >> /etc/fstab <<EOF
192.168.200.100:/nfs/data /nfs/data nfs rw,_netdev,rsize=1048576,wsize=1048576,hard,intr,nolock 0 0
# 优化参数：
# rsize/wsize: 读写块大小（字节），增大提升性能
# hard: 硬挂载，NFS服务器不可用时程序等待（soft会超时）
# intr: 允许中断等待操作
# nolock: 禁用文件锁，提升性能但可能不安全
EOF

1
2

# 创建PV配置文件
vi pv-nfs.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

apiVersion: v1
kind: PersistentVolume
metadata:
  name: nfs-pv
  labels:
    type: nfs         # 自定义标签，供PVC选择性绑定
    environment: prod # 可添加多个标签
spec:
  capacity:
    storage: 1Gi      # 存储容量，PVC申请量必须≤此值
  volumeMode: Filesystem  # 卷模式：Filesystem（文件系统）或Block（块设备）
  accessModes:
    - ReadWriteMany   # 访问模式：
    # ReadWriteOnce (RWO): 单节点读写（如AWS EBS）
    # ReadOnlyMany (ROX): 多节点只读
    # ReadWriteMany (RWX): 多节点读写（NFS支持）
  persistentVolumeReclaimPolicy: Retain  # 回收策略：
    # Retain: PVC删除后PV和数据保留（需手动清理，生产推荐）
    # Delete: PVC删除后自动删除PV和数据（云盘推荐）
    # Recycle: PVC删除后清空数据（已废弃，不推荐使用）
  storageClassName: nfs  # 存储类名称，必须与PVC匹配
  mountOptions:
    - hard              # 硬挂载（NFS服务不可用时程序会等待）
    - nfsvers=4.1       # 使用NFS v4.1协议（性能更好）
    - noatime           # 不更新访问时间，提升性能
  nfs:
    path: /nfs/data      # NFS服务器共享路径
    server: 192.168.200.100  # NFS服务器IP
    # readOnly: false   # 是否只读（默认false）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

kubectl apply -f pv-nfs.yaml
kubectl get pv -w
# 状态流转：
# Available → Bound → Released → Available（手动清理后）

# 查看PV详情
kubectl describe pv nfs-pv
# 关键信息：
# Source: NFS路径
# Claim: 绑定的PVC
# Status: 当前状态
# Access Modes: 支持的访问模式
# Capacity: 容量

1
2

# 创建PVC配置文件
vi pvc-nfs.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: nfs-pvc
  namespace: default  # PVC是命名空间资源，不同NS可同名
spec:
  resources:
    requests:
      storage: 500Mi  # 申请500Mi存储（PV容量必须≥此值）
      # 注意：对于NFS，这只是逻辑限制，实际可超过
  accessModes:
    - ReadWriteMany   # 必须与PV的accessModes完全匹配
  storageClassName: nfs  # 必须与PV的storageClassName相同
  selector:           # 标签选择器（可选，精确匹配PV）
    matchLabels:
      type: nfs
    # matchExpressions:  # 复杂匹配规则
    #   - {key: environment, operator: In, values: [prod, staging]}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

kubectl apply -f pvc-nfs.yaml
kubectl get pvc -w
# 状态：
# Pending → Bound（成功绑定PV）

# 查看PVC绑定详情
kubectl get pvc nfs-pvc -o yaml
# 关键字段：
# volumeName: 绑定的PV名称
# capacity.storage: 实际分配的容量

# 查看绑定关系
kubectl get pvc nfs-pvc -o yaml | grep volumeName
# 输出：  volumeName: nfs-pv

# 查看PV的绑定状态
kubectl get pv nfs-pv -o yaml | grep claimRef
# 输出包含绑定的PVC的namespace、name等信息

1
2

# 创建使用PVC的Pod
vi pod-with-pvc.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

apiVersion: v1
kind: Pod
metadata:
  name: app-with-storage
spec:
  containers:
  - name: app
    image: nginx:1.19.5
    imagePullPolicy: IfNotPresent
    volumeMounts:
    - name: data-volume
      mountPath: /data  # 容器内挂载路径
      subPath: nginx    # 可选：使用卷中的子目录，避免数据污染
    - name: data-volume
      mountPath: /cache
      subPath: cache
  volumes:
  - name: data-volume
    persistentVolumeClaim:
      claimName: nfs-pvc  # 引用已创建的PVC名称
      readOnly: false     # 是否只读（默认false）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

kubectl apply -f pod-with-pvc.yaml

# 验证数据持久化
kubectl exec -it app-with-storage -- bash
echo "Persistent data test" > /data/test.txt
exit

# 删除Pod后重建
kubectl delete pod app-with-storage
kubectl apply -f pod-with-storage.yaml

# 验证数据是否保留
kubectl exec -it app-with-storage -- cat /data/test.txt
# 输出：Persistent data test （数据持久化成功）

1
2

# 创建StorageClass
vi storageclass-nfs.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-dynamic
provisioner: k8s-sigs.io/nfs-subdir-external-provisioner
# provisioner: 指定动态供给驱动，需提前部署
parameters:
  archiveOnDelete: "true"  # PVC删除时归档而非真正删除
  pathPattern: "${.PVC.namespace}/${.PVC.name}"  # 目录命名模式
reclaimPolicy: Retain      # 回收策略
volumeBindingMode: Immediate  # 绑定模式：Immediate或WaitForFirstConsumer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: dynamic-pvc
spec:
  storageClassName: nfs-dynamic  # 指定StorageClass
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 2Gi

1
2
3

kubectl apply -f dynamic-pvc.yaml
kubectl get pvc dynamic-pvc
# 自动创建PV并绑定，无需手动创建PV

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 快速创建Deployment（生产不推荐，仅用于测试）
kubectl create deployment my-tomcat \
  --image=tomcat:9.0.55 \
  --replicas=3  # 创建3个副本保证高可用

# 与Pod的本质区别：
# - 自愈能力：节点宕机时自动重建
# - 滚动更新：逐个替换Pod，业务不中断
# - 版本管理：记录ReplicaSet历史，支持回滚
# - 扩缩容：手动或自动调整副本数

1
2
3
4
5

Deployment (my-tomcat)
  ↓ 管理
ReplicaSet (my-tomcat-1v1wf)  # 版本控制层，带随机哈希
  ↓ 管理
Pods (my-tomcat-1v1wf-xxx)    # 实际运行实例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 查看Deployment管理的ReplicaSet
kubectl get rs -l app=my-tomcat
# 输出：my-tomcat-1v1wf   3   3   3   5m

# 查看Pod的ownerReferences
kubectl get pod my-tomcat-1v1wf-xxxx -o yaml | grep -A 5 ownerReferences
# 输出显示该Pod由哪个ReplicaSet管理

# 验证自愈能力
kubectl delete pod my-tomcat-1v1wf-74gp9
kubectl get pod -l app=my-tomcat -w
# 立即出现新Pod，名称后缀变化

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-tomcat
  namespace: default
  labels:
    app: my-tomcat
    version: v1
spec:
  replicas: 3
  # 滚动更新策略
  strategy:
    type: RollingUpdate  # 或Recreate（全量删除再创建）
    rollingUpdate:
      maxUnavailable: 1  # 最大不可用Pod数（绝对值或百分比）
      maxSurge: 1        # 最大超出Pod数（可临时多创建1个）
  # 版本回滚策略
  revisionHistoryLimit: 10  # 保留的历史版本数
  # 选择器（必须匹配template.labels）
  selector:
    matchLabels:
      app: my-tomcat
  # Pod模板
  template:
    metadata:
      labels:
        app: my-tomcat
        version: v1
      annotations:
        prometheus.io/scrape: "true"  # 监控采集注解
        prometheus.io/port: "8080"
    spec:
      # 镜像拉取Secret（私有仓库）
      imagePullSecrets:
      - name: aliyun-registry
      # 存储卷定义
      volumes:
      - name: data
        persistentVolumeClaim:
          claimName: tomcat-pvc
      - name: config
        configMap:
          name: tomcat-config
      # 初始化容器（在主容器启动前执行）
      initContainers:
      - name: init-data
        image: busybox
        command: ['sh', '-c', 'cp /tmp/index.html /data']
        volumeMounts:
        - name: data
          mountPath: /data
      # 主容器
      containers:
      - name: tomcat
        image: tomcat:9.0.55
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 8080
          name: http
          protocol: TCP
        # 环境变量
        env:
        - name: JAVA_OPTS
          value: "-Xmx512m -Xms512m"
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: password
        # 资源限制
        resources:
          requests:
            memory: "512Mi"
            cpu: "250m"
          limits:
            memory: "1Gi"
            cpu: "500m"
        # 存储挂载
        volumeMounts:
        - name: data
          mountPath: /usr/local/tomcat/webapps
          subPath: webapps  # 使用PV中的子目录
        - name: config
          mountPath: /usr/local/tomcat/conf/server.xml
          subPath: server.xml
        # 健康检查
        livenessProbe:
          httpGet:
            path: /healthz
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
          failureThreshold: 3
        readinessProbe:
          httpGet:
            path: /ready
            port: 8080
          initialDelaySeconds: 10
          periodSeconds: 5
        # 安全上下文
        securityContext:
          runAsNonRoot: false  # 是否以非root运行
          runAsUser: 0         # 运行用户ID
          privileged: false    # 是否特权模式
      # 重启策略
      restartPolicy: Always
      # 节点亲和性（调度策略）
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: disktype
                operator: In
                values: ["ssd"]
        podAntiAffinity:  # Pod反亲和（避免同一应用调度到同节点）
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 100
            podAffinityTerm:
              labelSelector:
                matchLabels:
                  app: my-tomcat
              topologyKey: kubernetes.io/hostname
      # 容忍设置
      tolerations:
      - key: "node.kubernetes.io/unreachable"
        operator: "Exists"
        effect: "NoExecute"
        tolerationSeconds: 300  # 容忍300秒后驱逐

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 查看当前版本
kubectl get deployment my-tomcat -o wide

# 更新镜像版本
kubectl set image deployment/my-tomcat tomcat=tomcat:9.0.56 --record
# 或修改YAML后 apply

# 查看滚动更新状态
kubectl rollout status deployment/my-tomcat
# 输出：Waiting for deployment "my-tomcat" rollout to finish: 1 out of 3 new replicas have been updated...

# 查看ReplicaSet历史
kubectl get rs -l app=my-tomcat
# 输出：my-tomcat-1v1wf   0   0   0   10m  (旧版本)
#       my-tomcat-2b2cg   3   3   3   5m   (新版本)

# 回滚到上一个版本
kubectl rollout undo deployment/my-tomcat
# 回滚到指定版本
kubectl rollout undo deployment/my-tomcat --to-revision=2

# 查看历史版本
kubectl rollout history deployment/my-tomcat

1
2
3
4
5
6

# 创建Service暴露Deployment
kubectl expose deployment my-tomcat \
  --name=tomcat-svc \
  --port=8080 \        # Service端口（集群内访问）
  --target-port=8080 \ # Pod端口（容器端口）
  --type=NodePort      # Service类型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 默认范围：30000-32767（共2768个端口）

# 修改端口范围（避免与业务端口冲突）
# 编辑kube-apiserver配置
vi /etc/kubernetes/manifests/kube-apiserver.yaml
# 在command下添加：
- --service-node-port-range=30000-39999

# 修改后apiserver会自动重启
kubectl get pod -n kube-system kube-apiserver-master -w

# 验证新范围
kubectl expose deployment test --port=80 --type=NodePort --dry-run=client -o yaml
# 查看nodePort是否在30000-39999范围内

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

apiVersion: v1
kind: Service
metadata:
  name: my-tomcat
  namespace: default
  labels:
    app: my-tomcat
  annotations:
    prometheus.io/scrape: "true"  # 监控注解
spec:
  type: NodePort
  # ClusterIP: None  # 设置为None可创建Headless Service，直接访问Pod IP
  # 端口定义（可定义多个）
  ports:
  - port: 8080        # Service的集群内端口
    targetPort: 8080  # 转发到Pod的端口
    nodePort: 30001   # 手动指定节点端口（可选，不指定则随机分配）
    protocol: TCP     # 协议：TCP或UDP
    name: http        # 端口名称，用于识别（多端口时必须命名）
  - port: 8443
    targetPort: 8443
    nodePort: 30002
    protocol: TCP
    name: https
  # 会话保持
  sessionAffinity: ClientIP  # 或None（默认）
  sessionAffinityConfig:
    clientIP:
      timeoutSeconds: 10800  # 会话保持超时时间
  # 外部IP（LoadBalancer类型使用）
  externalIPs:
  - 192.168.200.201
  # 后端Pod选择器（核心）
  selector:
    app: my-tomcat  # 匹配Pod的label，Service通过此字段找到后端Pod
  # 健康检查（1.21+）
  publishNotReadyAddresses: false  # 是否将未就绪Pod加入Endpoints

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# Service通过标签选择器动态维护后端Pod列表
kubectl get endpoints my-tomcat -o yaml
# 输出包含所有就绪Pod的IP和端口

# 集群内DNS访问
# 格式：<service-name>.<namespace>.svc.cluster.local
curl http://my-tomcat.default.svc.cluster.local:8080

# 在不同命名空间访问
curl http://my-tomcat.prod.svc.cluster.local:8080

# 查看Service的IPTables规则（NodePort模式）
iptables-save | grep tomcat
# 显示KUBE-SVC-XXX链和DNAT规则

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# 步骤1：下载官方部署文件
wget https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v0.47.0/deploy/static/provider/baremetal/deploy.yaml
# 文件内容详解：
# - Namespace: ingress-nginx
# - Deployment: ingress-nginx-controller
# - Service: ingress-nginx-controller (LoadBalancer类型)
# - ConfigMap: 存储Nginx配置
# - RBAC: 权限配置

# 步骤2：替换镜像为国内源（避免墙）
sed -i 's#k8s.gcr.io/ingress-nginx/controller#registry.cn-hangzhou.aliyuncs.com/lfy_k8s_images/ingress-nginx-controller#g' deploy.yaml
sed -i 's#k8s.gcr.io/ingress-nginx/kube-webhook-certgen#registry.cn-hangzhou.aliyuncs.com/lfy_k8s_images/kube-webhook-certgen#g' deploy.yaml

# 步骤3：修改部署模式为hostNetwork（生产推荐）
vi deploy.yaml
# 在spec.template.spec下添加：
hostNetwork: true          # 使用主机网络，性能更好，端口不冲突
dnsPolicy: ClusterFirstWithHostNet  # DNS策略
# 优势：
# - 避免NodePort的端口限制
# - 减少一层NAT，性能提升
# - 直接使用节点80/443端口
# 劣势：
# - 每个节点只能运行一个Controller实例
# - 与节点其他服务可能端口冲突

# 步骤4：应用并验证
kubectl apply -f deploy.yaml

# 步骤5：查看部署状态
kubectl get pod -n ingress-nginx -w
# 等待Controller Pod进入Running状态

# 步骤6：查看Service
kubectl get svc -n ingress-nginx ingress-nginx-controller
# 注意：使用hostNetwork模式时，此Service可能仍为ClusterIP，实际通过节点IP访问

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-tomcat-ingress
  namespace: default
  annotations:  # 注解用于配置Nginx行为
    nginx.ingress.kubernetes.io/rewrite-target: /  # URL重写
    nginx.ingress.kubernetes.io/ssl-redirect: "true"  # 强制HTTP跳转HTTPS
    nginx.ingress.kubernetes.io/rate-limit: "100"  # 限速100rps
    nginx.ingress.kubernetes.io/whitelist-source-range: "10.0.0.0/8"  # IP白名单
    nginx.ingress.kubernetes.io/proxy-body-size: "10m"  # 上传大小限制
    nginx.ingress.kubernetes.io/cors-allow-origin: "*"  # CORS配置
spec:
  ingressClassName: nginx  # 指定使用的Controller（支持多Controller）
  # TLS配置
  tls:
  - secretName: tls-secret  # 包含证书密钥的Secret
    hosts:
    - tomcat.example.com
  # 路由规则
  rules:
  - host: tomcat.example.com  # 域名路由（基于Host头）
    http:
      paths:
      - path: /                 # 路径匹配
        pathType: Prefix        # 路径类型：Prefix（前缀）、Exact（精确）、ImplementationSpecific（依赖实现）
        backend:
          service:
            name: my-tomcat     # 后端Service名称
            port:
              number: 8080      # Service端口
  - host: api.example.com
    http:
      paths:
      - path: /v1
        pathType: Prefix
        backend:
          service:
            name: api-service-v1
            port:
              number: 80
      - path: /v2
        pathType: Prefix
        backend:
          service:
            name: api-service-v2
            port:
              number: 80
  # 默认后端（无匹配规则时）
  defaultBackend:
    service:
      name: default-http-backend
      port:
        number: 80

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 方式1：使用现有证书
kubectl create secret tls tls-secret \
  --cert=tls.crt \
  --key=tls.key

# 方式2：自签名证书（测试）
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
  -keyout tls.key -out tls.crt -subj "/CN=tomcat.example.com"

kubectl create secret tls tls-secret --cert=tls.crt --key=tls.key

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 本地hosts文件（开发测试）
# 编辑 /etc/hosts
192.168.200.101 tomcat.example.com  # 任意Node IP

# 内网DNS（生产环境）
# 添加A记录：tomcat.example.com → NodeIP

# 访问
curl http://tomcat.example.com  # 自动跳转到HTTPS
curl -k https://tomcat.example.com  # -k忽略自签名证书警告

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 方式1：命令行创建（少量键值）
kubectl create secret generic db-secret \
  --from-literal=username=admin \
  --from-literal=password='Admin@123!'
# 命令详解：
# generic: 通用类型的Secret
# --from-literal: 从字面量创建，格式key=value
# Secret名称：db-secret

# 方式2：文件创建（证书、大文件）
kubectl create secret generic ssl-cert \
  --from-file=tls.crt=/path/to/cert.pem \
  --from-file=tls.key=/path/to/key.pem
# --from-file: 从文件创建，文件名作为key，内容作为value

# 方式3：目录批量创建
kubectl create secret generic configs \
  --from-file=./config/dir/
# 目录下所有文件都会被加入Secret

# 方式4：YAML创建（不推荐，需手动base64编码）
echo -n 'admin' | base64  # YWRtaW4=
echo -n 'Admin@123!' | base64  # QWRtaW5AMTIzIQ==
# 然后创建YAML

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 查看Secret（值会base64编码）
kubectl get secret db-secret -o yaml
# 输出：
# data:
#   password: QWRtaW5AMTIzIQ==
#   username: YWRtaW4=

# 解码查看
echo 'QWRtaW5AMTIzIQ==' | base64 -d
# 输出：Admin@123!

# 直接获取某个key
kubectl get secret db-secret -o jsonpath='{.data.password}' | base64 -d

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 创建阿里云私有仓库凭证
kubectl create secret docker-registry aliyun-registry \
  --docker-server=registry.cn-hangzhou.aliyuncs.com \
  --docker-username=fox666 \
  --docker-password='AliyunPwd123' \
  --docker-email=fox@example.com
# 参数详解：
# --docker-server: 仓库地址（域名+端口）
# --docker-username: 登录用户名
# --docker-password: 登录密码或访问令牌
# --docker-email: 邮箱（部分仓库要求）

# 查看凭证结构
kubectl get secret aliyun-registry --output="jsonpath={.data.\.dockerconfigjson}" | base64 -d
# 输出JSON格式：
# {
#   "auths": {
#     "registry.cn-hangzhou.aliyuncs.com": {
#       "username": "fox666",
#       "password": "AliyunPwd123",
#       "email": "fox@example.com"
#     }
#   }
# }

# 在Pod中使用（两种方式）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

apiVersion: v1
kind: Pod
metadata:
  name: private-registry-pod
spec:
  imagePullSecrets:  # 在spec级别定义
  - name: aliyun-registry
  containers:
  - name: app
    image: registry.cn-hangzhou.aliyuncs.com/fox666/app:v1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

apiVersion: v1
kind: Pod
metadata:
  name: secret-env-pod
spec:
  containers:
  - name: app
    image: nginx:1.19.5
    imagePullPolicy: IfNotPresent
    env:
    - name: DB_USER          # 容器内变量名
      valueFrom:
        secretKeyRef:
          name: db-secret    # Secret名称
          key: username      # Secret中的key
    - name: DB_PASS
      valueFrom:
        secretKeyRef:
          name: db-secret
          key: password
    command:
    - sh
    - -c
    - echo "Database: $DB_USER/$DB_PASS && nginx -g 'daemon off;'"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

apiVersion: v1
kind: Pod
metadata:
  name: secret-volume-pod
spec:
  containers:
  - name: app
    image: nginx:1.19.5
    imagePullPolicy: IfNotPresent
    volumeMounts:
    - name: secret-volume
      mountPath: /etc/secrets  # 挂载路径
      readOnly: true          # 必须为只读
  volumes:
  - name: secret-volume
    secret:
      secretName: db-secret
      defaultMode: 0400       # 文件权限（八进制）
      items:  # 自定义文件名（可选）
      - key: username
        path: db-user.txt     # /etc/secrets/db-user.txt
        mode: 0444
      - key: password
        path: db-pass.txt     # /etc/secrets/db-pass.txt
        mode: 0400

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# 1. 启动Pod
kubectl apply -f secret-volume-pod.yaml

# 2. 进入Pod查看文件
kubectl exec -it secret-volume-pod -- ls -l /etc/secrets/
# 输出：-r--r--r-- 1 root root 5 Dec 1 10:00 db-user.txt

# 3. 更新Secret
kubectl create secret generic db-secret \
  --from-literal=username=newadmin \
  --from-literal=password='NewPass123!' \
  --dry-run=client -o yaml | kubectl apply -f -

# 4. 等待约60秒（kubelet同步周期）
# 5. 验证文件内容已更新
kubectl exec -it secret-volume-pod -- cat /etc/secrets/db-user.txt
# 输出：newadmin

# 注意：环境变量方式不支持热更新，必须重启Pod

1
2
3
4
5
6
7
8
9

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: secret-reader
rules:
- apiGroups: [""]
  resources: ["secrets"]
  resourceNames: ["db-secret"]
  verbs: ["get"]

1
2
3
4
5
6

# 创建ConfigMap
kubectl create configmap tomcat-config \
  --from-file=server.xml=./server.xml \
  --from-literal=env=prod

# 使用ConfigMap（与Secret类似）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

apiVersion: v1
kind: Pod
metadata:
  name: liveness-http
spec:
  containers:
  - name: app
    image: nginx:1.19.5
    livenessProbe:
      # 探测方式：httpGet、exec、tcpSocket
      httpGet:
        path: /healthz
        port: 8080
        scheme: HTTP      # 或HTTPS
        httpHeaders:      # 自定义请求头
        - name: X-Custom-Header
          value: Awesome
      # 探测时机参数
      initialDelaySeconds: 30  # 容器启动后等待30秒开始探测
      periodSeconds: 10        # 每10秒探测一次
      timeoutSeconds: 5        # 请求超时5秒
      successThreshold: 1      # 连续1次成功认为健康
      failureThreshold: 3      # 连续3次失败重启容器
      # 总失败容忍时间 = initialDelaySeconds + (periodSeconds * failureThreshold)
      # 本例：30 + (10*3) = 60秒

1
2
3
4
5
6

readinessProbe:
  tcpSocket:
    port: 8080
  initialDelaySeconds: 5
  periodSeconds: 5
  failureThreshold: 2  # 连续2次失败从Service移除

1
2
3
4
5
6
7
8
9

startupProbe:
  httpGet:
    path: /startup
    port: 8080
  initialDelaySeconds: 10
  periodSeconds: 10
  failureThreshold: 30  # 最多容忍300秒启动时间
  timeoutSeconds: 5
# 成功一次后，不再执行startupProbe，转由liveness/readiness接管

1
2
3
4
5

# 创建测试目录
mkdir -pv 1117 && cd 1117

# 1. Exec探针（检测文件存在）
vi liveness-exec.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

apiVersion: v1
kind: Pod
metadata:
  name: liveness-exec
spec:
  containers:
  - name: liveness
    image: busybox:1.35
    imagePullPolicy: IfNotPresent
    args:
    - /bin/sh
    - -c
    - touch /tmp/healthy; sleep 30; rm -rf /tmp/healthy; sleep 600
    # 容器启动流程：
    # 1. 创建健康标志文件
    # 2. 等待30秒（模拟正常运行）
    # 3. 删除文件（模拟故障）
    # 4. 等待600秒（保持容器运行）
    livenessProbe:
      exec:
        command:
        - cat
        - /tmp/healthy
      initialDelaySeconds: 10
      periodSeconds: 5
      failureThreshold: 1  # 立即重启

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 分发镜像到节点（因使用IfNotPresent策略）
# scp busybox.tar k8s-node1:/root/
# scp busybox.tar k8s-node2:/root/
# ssh k8s-node1 "docker load -i /root/busybox.tar"
# ssh k8s-node2 "docker load -i /root/busybox.tar"

kubectl apply -f liveness-exec.yaml

# 实时监控Pod状态
kubectl get pod liveness-exec -w
# 30秒后开始重启：
# NAME            READY   STATUS    RESTARTS   AGE
# liveness-exec   1/1     Running   0          25s
# liveness-exec   1/1     Running   1          40s  # 第一次重启
# liveness-exec   1/1     Running   2          55s  # 第二次重启

# 查看重启原因
kubectl describe pod liveness-exec
# Events中显示：Liveness probe failed: cat: can't open '/tmp/healthy': No such file or directory

# 清理
kubectl delete -f liveness-exec.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

apiVersion: v1
kind: Pod
metadata:
  name: liveness-http
spec:
  containers:
  - name: liveness
    image: mydlqclub/springboot-helloworld:0.0.1
    imagePullPolicy: IfNotPresent
    livenessProbe:
      httpGet:
        path: /actuator/health  # Spring Boot健康检查端点
        port: 8080              # 实际端口，文档中8081可能是笔误
        scheme: HTTP
      initialDelaySeconds: 20   # 应用启动时间通常较长
      periodSeconds: 5
      timeoutSeconds: 10        # 请求超时10秒
      failureThreshold: 3       # 允许3次失败（共15秒）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 启动Pod
kubectl apply -f liveness-http.yaml

# 等待Pod Running
kubectl get pod liveness-http -owide
# 获取Pod IP

# 手动测试健康接口
curl http://10.244.1.5:8080/actuator/health
# 应返回：{"status":"UP"}

# 实时查看日志
kubectl logs -f liveness-http --tail 100
# 观察日志确认接口正常响应

# 查看探针事件
kubectl describe pod liveness-http | grep -A 10 Liveness

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

apiVersion: v1
kind: Pod
metadata:
  name: liveness-tcp
spec:
  containers:
  - name: liveness
    image: nginx:1.19.5
    imagePullPolicy: IfNotPresent
    livenessProbe:
      tcpSocket:
        port: 80        # 只需端口可连接即认为健康
      initialDelaySeconds: 1
      periodSeconds: 20   # 较长间隔，减少资源消耗
      timeoutSeconds: 5
      failureThreshold: 2