Docker与Kubernetes从零到一实战：容器化与集群编排保姆级教程

最近在帮团队做容器化改造时，发现很多刚接触云原生的小伙伴对 Docker 和 Kubernetes 的学习路径感到迷茫。网上的资料要么过于零散，要么版本老旧，照着操作总是遇到各种环境问题。为了让大家能快速上手，我结合最新的技术栈和实战经验，整理了这份从零到一的保姆级教程。无论你是想转型运维、提升后端技能，还是单纯想掌握容器编排技术，这篇文章都能带你系统性地走完全程。我们将从最基础的 Docker 概念讲起，一步步搭建环境、操作镜像，最终部署一个高可用的 K8S 集群并运行实际应用。文末还提供了完整的课件和命令清单，方便你随时查阅。

1. 容器与编排技术核心概念

在开始动手之前，我们需要先理解几个核心概念，这能帮你建立正确的知识框架，避免后续操作中“知其然不知其所以然”。

1.1 什么是 Docker？它解决了什么问题？

Docker 是一个开源的应用容器引擎。你可以把它想象成一个超级轻量级的“虚拟机”。但与传统虚拟机（VM）不同，Docker 容器直接运行在宿主机的操作系统内核之上，它通过“容器化”技术，将应用及其所有依赖（库、环境变量、配置文件等）打包成一个标准化的单元。

它主要解决了以下痛点：

• 环境一致性：“在我机器上能跑，为什么到你那就报错？” Docker 通过镜像保证了从开发、测试到生产环境的高度一致。
• 资源高效：容器共享宿主机内核，无需为每个应用加载完整的操作系统，启动速度快，资源占用极低。
• 快速部署与扩展：镜像一旦构建完成，可以在任何安装了 Docker 的平台上秒级启动，非常适合微服务和持续集成/持续部署（CI/CD）。

1.2 什么是 Kubernetes (K8S)？为什么需要它？

当你的应用从几个容器扩展到几十、上百个时，手动管理这些容器的启动、停止、网络互联、负载均衡和故障恢复就变得异常困难。这时就需要 Kubernetes。

Kubernetes（常简称为 K8S）是一个开源的容器编排引擎，用于自动化容器化应用的部署、扩缩和管理。它就像一个容器集群的“大脑”或“操作系统”。

K8S 的核心价值：

• 服务发现与负载均衡：自动为容器组分配 IP 地址和 DNS 名称，并能在多个容器实例间分配流量。
• 存储编排：允许你自动挂载你选择的存储系统，如本地存储、云存储等。
• 自动部署和回滚：你可以描述应用的期望状态（比如运行 3 个副本），K8S 会以可控的速率将实际状态变更至期望状态。如果出问题，可以一键回滚。
• 自动扩缩容：根据 CPU 使用率或自定义指标，自动调整运行应用的容器数量。
• 自我修复：重启失败的容器、替换容器、杀死不响应用户健康检查的容器。

1.3 Docker 与 Kubernetes 的关系

简单来说，Docker 负责“造砖”（创建容器），而 Kubernetes 负责“用这些砖盖房子并管理整栋楼”（编排调度容器集群）。在 K8S 的早期版本中，它直接使用 Docker 作为容器运行时。现在，K8S 通过标准的 CRI（容器运行时接口）与多种容器运行时交互，包括 containerd（Docker 的底层运行时）、CRI-O 等。对于学习者而言，从 Docker 入门再过渡到 K8S 是最平滑的路径。

2. 环境准备与版本说明

工欲善其事，必先利其器。我们将在一个干净的 Linux 环境下进行所有操作。本教程以CentOS 7.9作为基础操作系统，但核心命令和思路同样适用于 Ubuntu 等主流发行版。

重要提示：生产环境请务必选择与你的团队技术栈和云平台兼容的稳定版本。以下版本为当前（2026年视角）的长期支持（LTS）或稳定版本，具有较好的社区支持和资料。

• 操作系统：CentOS 7.9 Minimal 安装
• Docker 版本：26.0.0 (CE版本)
• Kubernetes 版本：1.30.x （最新稳定版系列）
• 容器运行时：containerd 1.7.x （K8S 推荐）
• 网络插件：Calico 3.27.x
• 硬件要求：
  • 至少 2 GB RAM（建议 4 GB+）
  • 至少 2 个 CPU 核心
  • 至少 20 GB 磁盘空间
• 集群规划：我们将搭建一个最简单的单 Master 集群。
  • Master 节点 (k8s-master): 192.168.1.100
  • Worker 节点 (k8s-node1): 192.168.1.101
  • （可选）Worker 节点 (k8s-node2): 192.168.1.102

请确保所有节点之间网络互通，主机名解析正确，并关闭防火墙和 SELinux（学习环境，生产环境需按安全策略配置）。

# 在所有节点上执行：关闭防火墙和 SELinux systemctl stop firewalld systemctl disable firewalld setenforce 0 sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config # 设置主机名（分别在对应节点执行） # 在 Master 节点 hostnamectl set-hostname k8s-master # 在 Node1 节点 hostnamectl set-hostname k8s-node1 # 编辑 /etc/hosts，添加所有节点的 IP 和主机名映射 cat >> /etc/hosts << EOF 192.168.1.100 k8s-master 192.168.1.101 k8s-node1 192.168.1.102 k8s-node2 EOF

3. Docker 核心实战：从安装到应用部署

掌握了概念，我们立刻进入实战。Docker 的学习核心在于“镜像”和“容器”两个对象。

3.1 安装与配置 Docker

我们将使用官方仓库进行安装，确保获得最新稳定版本。

# 1. 卸载旧版本（如有） sudo yum remove -y docker docker-client docker-client-latest docker-common docker-latest docker-latest-logrotate docker-logrotate docker-engine # 2. 安装必要的依赖包 sudo yum install -y yum-utils device-mapper-persistent-data lvm2 # 3. 设置稳定的 Docker 仓库 sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo # 4. 安装 Docker Engine 和 CLI sudo yum install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin # 5. 启动 Docker 并设置开机自启 sudo systemctl start docker sudo systemctl enable docker # 6. 验证安装 sudo docker --version # 输出类似：Docker version 26.0.0, build xxxxxxx # 7. （可选）配置镜像加速器，国内环境建议配置以提升拉取速度 sudo mkdir -p /etc/docker sudo tee /etc/docker/daemon.json <<-'EOF' { "registry-mirrors": ["https://your-mirror.mirror.aliyuncs.com"] } EOF sudo systemctl daemon-reload sudo systemctl restart docker

3.2 镜像（Image）基础操作

镜像是容器的模板，是一个只读的静态文件。

# 搜索镜像，例如搜索 Nginx docker search nginx # 拉取镜像（从 Docker Hub） docker pull nginx:latest docker pull alpine:3.18 # 拉取一个极小的Linux发行版 # 查看本地所有镜像 docker images # 或使用更强大的格式 docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.ID}}\t{{.CreatedAt}}" # 删除本地镜像 docker rmi alpine:3.18 # 强制删除（即使有容器基于此镜像） docker rmi -f nginx:latest

3.3 容器（Container）生命周期管理

容器是镜像的运行实例。

# 1. 运行一个容器 # -d: 后台运行 # --name: 给容器起个名字 # -p: 端口映射 (宿主机端口:容器端口) docker run -d --name my-nginx -p 8080:80 nginx:latest # 2. 查看容器 docker ps # 查看运行中的容器 docker ps -a # 查看所有容器（包括已停止的） # 3. 查看容器日志 docker logs my-nginx docker logs -f my-nginx # 实时跟踪日志（类似 tail -f） # 4. 进入正在运行的容器内部 docker exec -it my-nginx /bin/bash # 进入后就是一个独立的shell，可以执行命令，退出用 exit # 5. 停止和启动容器 docker stop my-nginx docker start my-nginx docker restart my-nginx # 6. 删除容器 docker rm my-nginx # 删除已停止的容器 docker rm -f my-nginx # 强制删除运行中的容器

3.4 构建自定义镜像：Dockerfile 实战

这是 Docker 的核心技能。我们通过一个简单的 Python Web 应用来演示。

项目结构：

my-python-app/ ├── app.py ├── requirements.txt └── Dockerfile

1. 编写应用代码 (app.py):

from flask import Flask import os app = Flask(__name__) @app.route('/') def hello(): return f"Hello from Docker! Hostname: {os.uname().nodename}" if __name__ == '__main__': app.run(host='0.0.0.0', port=5000)

2. 编写依赖文件 (requirements.txt):

flask==2.3.3

3. 编写 Dockerfile (Dockerfile):

# 第一阶段：使用官方 Python 精简版作为基础镜像 FROM python:3.11-slim AS builder # 设置工作目录 WORKDIR /app # 复制依赖文件 COPY requirements.txt . # 安装依赖到 /usr/local RUN pip install --no-cache-dir --user -r requirements.txt # 第二阶段：使用更小的基础镜像，只复制运行所需 FROM python:3.11-slim # 设置环境变量，确保从`--user`安装的包在路径中 ENV PATH=/root/.local/bin:$PATH # 从构建阶段复制已安装的包 COPY --from=builder /root/.local /root/.local # 复制应用代码 COPY app.py . # 声明容器运行时监听的端口 EXPOSE 5000 # 定义容器启动时执行的命令 CMD ["python", "app.py"]

Dockerfile 指令解析：

• FROM: 指定基础镜像，多阶段构建可以显著减小最终镜像体积。
• WORKDIR: 设置工作目录，后续命令在此目录下执行。
• COPY: 将宿主机文件复制到镜像内。
• RUN: 在构建镜像时执行命令，常用于安装软件包。
• ENV: 设置环境变量。
• EXPOSE: 声明容器对外暴露的端口（仅声明，实际映射在run时指定）。
• CMD: 指定容器启动时的默认命令，一个 Dockerfile 只能有一个CMD。

4. 构建镜像：

# 在 my-python-app 目录下执行 # -t: 给镜像打标签，格式为 name:tag docker build -t my-python-app:v1 .

5. 运行自定义镜像的容器：

docker run -d --name my-app -p 5000:5000 my-python-app:v1 # 访问 http://<你的服务器IP>:5000 查看效果

4. Kubernetes 集群部署实战

有了 Docker 基础，我们现在进军 K8S。手动部署一个集群是理解其架构的最佳方式。

4.1 所有节点前置配置

在所有 Master 和 Worker 节点上执行以下步骤。

# 1. 关闭交换分区，K8S 要求 swapoff -a sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab # 2. 配置内核参数并加载模块 cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf overlay br_netfilter EOF sudo modprobe overlay sudo modprobe br_netfilter cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf net.bridge.bridge-nf-call-iptables = 1 net.bridge.bridge-nf-call-ip6tables = 1 net.ipv4.ip_forward = 1 EOF sudo sysctl --system # 3. 安装容器运行时 containerd（替代Docker） # 配置 containerd 的源 sudo yum install -y yum-utils sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo sudo yum install -y containerd.io # 生成默认配置并修改 sudo mkdir -p /etc/containerd containerd config default | sudo tee /etc/containerd/config.toml # 修改 config.toml，将 SystemdCgroup 设置为 true，并配置 sandbox_image 镜像地址（国内可用） sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml sudo sed -i 's|registry.k8s.io/pause|registry.aliyuncs.com/google_containers/pause|g' /etc/containerd/config.toml # 启动 containerd sudo systemctl daemon-reload sudo systemctl enable --now containerd # 4. 安装 kubeadm, kubelet, kubectl cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo [kubernetes] name=Kubernetes baseurl=https://pkgs.k8s.io/core:/stable:/v1.30/rpm/ enabled=1 gpgcheck=1 gpgkey=https://pkgs.k8s.io/core:/stable:/v1.30/rpm/repodata/repomd.xml.key EOF sudo yum install -y kubelet kubeadm kubectl --disableexcludes=kubernetes sudo systemctl enable --now kubelet

4.2 Master 节点初始化

仅在 Master 节点执行。

# 使用 kubeadm 初始化集群 # --apiserver-advertise-address: Master 节点的 IP # --pod-network-cidr: Pod 网络的 CIDR，需要与后续安装的网络插件匹配，Calico 常用 192.168.0.0/16 sudo kubeadm init \ --apiserver-advertise-address=192.168.1.100 \ --pod-network-cidr=192.168.0.0/16 \ --image-repository=registry.aliyuncs.com/google_containers # 初始化成功后会输出类似以下信息，请务必保存好最后的 kubeadm join 命令！ # Your Kubernetes control-plane has initialized successfully! # ... # Then you can join any number of worker nodes by running the following on each as root: # kubeadm join 192.168.1.100:6443 --token xxxxxx.xxxxxxxxxxxx \ # --discovery-token-ca-cert-hash sha256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # 配置 kubectl 命令（普通用户） mkdir -p $HOME/.kube sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config sudo chown $(id -u):$(id -g) $HOME/.kube/config # 查看节点状态，此时 Master 节点应为 NotReady，因为网络插件未安装 kubectl get nodes

4.3 安装 Pod 网络插件 (Calico)

Pod 之间需要网络才能通信。在 Master 节点执行。

# 下载 Calico 的 Operator 安装清单 curl https://raw.githubusercontent.com/projectcalico/calico/v3.27.3/manifests/tigera-operator.yaml -O # 如果网络问题，可以先将文件下载到本地再上传 # 安装 Calico Operator kubectl create -f tigera-operator.yaml # 下载并安装自定义资源（CR），需要修改其中的 CIDR 以匹配初始化时的 --pod-network-cidr curl https://raw.githubusercontent.com/projectcalico/calico/v3.27.3/manifests/custom-resources.yaml -O # 编辑 custom-resources.yaml，确保 spec.calicoNetwork.ipPools.cidr 为 192.168.0.0/16 # 可以使用 sed 命令快速修改 sed -i 's|cidr:.*|cidr: \"192.168.0.0/16\"|g' custom-resources.yaml kubectl create -f custom-resources.yaml # 等待所有 Calico 相关的 Pod 变为 Running 状态 kubectl get pods -n calico-system -w # 按 Ctrl+C 退出 watch 模式后，再次检查节点状态，应变为 Ready kubectl get nodes

4.4 Worker 节点加入集群

在每个 Worker 节点上，执行 Master 节点初始化成功后输出的kubeadm join命令。

# 在 k8s-node1 和 k8s-node2 上执行（命令示例，请替换为你的实际token和hash） sudo kubeadm join 192.168.1.100:6443 --token xxxxxx.xxxxxxxxxxxx \ --discovery-token-ca-cert-hash sha256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

加入成功后，在 Master 节点上查看集群节点状态：

kubectl get nodes

输出应显示所有节点状态为Ready。

5. Kubernetes 核心对象与操作实战

集群就绪，我们来学习 K8S 中最核心的几个资源对象。

5.1 Pod：K8S 的最小调度单元

Pod 是 K8S 中创建和管理的最小单元，它包含一个或多个容器（通常是一个），共享存储、网络和命名空间。

创建第一个 Pod：

# pod-demo.yaml apiVersion: v1 kind: Pod metadata: name: nginx-pod labels: app: nginx spec: containers: - name: nginx-container image: nginx:latest ports: - containerPort: 80

# 应用 YAML 文件创建 Pod kubectl apply -f pod-demo.yaml # 查看 Pod kubectl get pods kubectl get pods -o wide # 查看更详细信息，包括 IP 和节点 # 查看 Pod 描述 kubectl describe pod nginx-pod # 查看 Pod 日志 kubectl logs nginx-pod # 进入 Pod 的容器（如果只有一个容器，可省略 -c） kubectl exec -it nginx-pod -- /bin/bash # 删除 Pod kubectl delete -f pod-demo.yaml # 或 kubectl delete pod nginx-pod

5.2 Deployment：无状态应用的管家

直接管理 Pod 很不方便，Deployment 提供了声明式的更新、回滚和副本管理。

创建 Deployment：

# deployment-demo.yaml apiVersion: apps/v1 kind: Deployment metadata: name: nginx-deployment spec: replicas: 3 # 期望的 Pod 副本数 selector: matchLabels: app: nginx template: # Pod 模板 metadata: labels: app: nginx spec: containers: - name: nginx image: nginx:1.25 ports: - containerPort: 80

kubectl apply -f deployment-demo.yaml kubectl get deployments kubectl get pods # 会看到 3 个由 Deployment 创建的 Pod # 扩容到 5 个副本 kubectl scale deployment nginx-deployment --replicas=5 # 更新镜像版本（触发滚动更新） kubectl set image deployment/nginx-deployment nginx=nginx:1.26 # 查看更新状态 kubectl rollout status deployment nginx-deployment # 回滚到上一个版本 kubectl rollout undo deployment nginx-deployment

5.3 Service：服务的抽象与访问入口

Pod 的 IP 是临时的，Service 为一组 Pod 提供一个稳定的访问端点（ClusterIP、NodePort、LoadBalancer）。

创建 ClusterIP Service：

# service-clusterip.yaml apiVersion: v1 kind: Service metadata: name: nginx-service spec: selector: app: nginx # 选择标签为 app: nginx 的 Pod ports: - port: 80 # Service 端口 targetPort: 80 # Pod 端口 type: ClusterIP # 默认类型，集群内部访问

kubectl apply -f service-clusterip.yaml kubectl get svc # 在集群内部的其他 Pod 中，可以通过 `nginx-service` 这个 DNS 名称访问这组 Nginx Pod。

创建 NodePort Service（外部可访问）：

# service-nodeport.yaml apiVersion: v1 kind: Service metadata: name: nginx-nodeport spec: selector: app: nginx ports: - port: 80 targetPort: 80 nodePort: 30080 # 范围 30000-32767 type: NodePort

应用后，可以通过http://<任意节点IP>:30080访问 Nginx 服务。

5.4 Ingress：HTTP/HTTPS 路由管理器

Service 的 NodePort 或 LoadBalancer 通常用于暴露服务，而 Ingress 提供了更强大的 HTTP 层路由能力（基于域名和路径）。

安装 Ingress Controller（以 Nginx Ingress 为例）：

# 使用官方清单安装 kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.10.0/deploy/static/provider/baremetal/deploy.yaml # 等待 Pod 就绪 kubectl get pods -n ingress-nginx -w

创建 Ingress 规则：

# ingress-demo.yaml apiVersion: networking.k8s.io/v1 kind: Ingress metadata: name: demo-ingress annotations: nginx.ingress.kubernetes.io/rewrite-target: / spec: rules: - host: myapp.example.com # 配置的域名（本地测试需修改 hosts 文件） http: paths: - path: / pathType: Prefix backend: service: name: nginx-service # 指向之前创建的 Service port: number: 80

应用后，将域名myapp.example.com指向集群任意节点 IP，即可通过该域名访问服务。

6. 完整项目实战：部署一个微服务应用

我们将部署一个简单的“投票应用”，它包含一个 Web 前端、一个后端 API 和一个 Redis 缓存。这个例子涵盖了 ConfigMap、Secret 和持久化存储卷（PersistentVolume）的简单使用。

6.1 应用架构说明

• 前端 (vote-ui): Python Flask 应用，提供投票界面。
• 后端 (vote-api): Python Flask 应用，提供投票 API，并连接 Redis。
• 缓存 (redis): Redis 数据库，存储投票数据。

6.2 创建命名空间

kubectl create namespace vote-app

6.3 部署 Redis

# redis-deployment.yaml apiVersion: apps/v1 kind: Deployment metadata: name: redis namespace: vote-app spec: replicas: 1 selector: matchLabels: app: redis template: metadata: labels: app: redis spec: containers: - name: redis image: redis:alpine ports: - containerPort: 6379 resources: requests: memory: "64Mi" cpu: "50m" limits: memory: "128Mi" cpu: "100m" --- apiVersion: v1 kind: Service metadata: name: redis-service namespace: vote-app spec: selector: app: redis ports: - port: 6379 targetPort: 6379

kubectl apply -f redis-deployment.yaml

6.4 部署后端 API

# api-deployment.yaml apiVersion: apps/v1 kind: Deployment metadata: name: vote-api namespace: vote-app spec: replicas: 2 selector: matchLabels: app: vote-api template: metadata: labels: app: vote-api spec: containers: - name: api image: your-dockerhub-username/vote-api:v1 # 请替换为你自己构建的镜像 ports: - containerPort: 5000 env: - name: REDIS_HOST value: "redis-service.vote-app.svc.cluster.local" # K8S 内部 DNS - name: REDIS_PORT value: "6379" resources: requests: memory: "128Mi" cpu: "100m" limits: memory: "256Mi" cpu: "200m" --- apiVersion: v1 kind: Service metadata: name: api-service namespace: vote-app spec: selector: app: vote-api ports: - port: 5000 targetPort: 5000

注意：你需要先根据 3.4 节的 Dockerfile 示例，编写后端 API 代码（连接 Redis，提供/vote和/results接口），构建镜像并推送到可访问的镜像仓库（如 Docker Hub），然后替换 YAML 中的镜像地址。

6.5 部署前端 Web

# ui-deployment.yaml apiVersion: apps/v1 kind: Deployment metadata: name: vote-ui namespace: vote-app spec: replicas: 2 selector: matchLabels: app: vote-ui template: metadata: labels: app: vote-ui spec: containers: - name: ui image: your-dockerhub-username/vote-ui:v1 # 请替换 ports: - containerPort: 80 env: - name: API_HOST value: "api-service.vote-app.svc.cluster.local" - name: API_PORT value: "5000" --- apiVersion: v1 kind: Service metadata: name: ui-service namespace: vote-app spec: type: NodePort # 方便外部访问 selector: app: vote-ui ports: - port: 80 targetPort: 80 nodePort: 31000

6.6 访问应用

1. 应用所有 YAML 文件：kubectl apply -f ./
2. 查看部署状态：kubectl get all -n vote-app
3. 通过http://<节点IP>:31000访问投票界面。

7. 常见问题与排查思路

在学习和使用 Docker 与 K8S 的过程中，你一定会遇到各种问题。以下是高频问题的排查指南。

通用排查命令：

• kubectl get <resource>：获取资源列表。
• kubectl describe <resource> <name>：查看资源详细信息，特别是Events部分。
• kubectl logs <pod-name> [-c <container-name>]：查看 Pod 或容器日志。
• kubectl exec -it <pod-name> -- <command>：进入 Pod 执行命令。
• journalctl -u kubelet -f：实时查看 kubelet 服务日志。

8. 最佳实践与工程建议

掌握了基础操作后，以下经验能帮助你在实际项目中走得更好更稳。

8.1 Docker 最佳实践

1. 使用多阶段构建：如 3.4 节所示，这能显著减小生产镜像体积，提高安全性。
2. 指定精确的镜像标签：避免使用latest标签，应使用具体的版本号（如nginx:1.25-alpine），保证构建的可重复性。
3. 以非 root 用户运行容器：在 Dockerfile 中使用USER指令，减少安全风险。
4. 合理利用.dockerignore文件：避免将不必要的文件（如.git,node_modules, 日志）复制进镜像，加速构建。
5. 扫描镜像安全漏洞：使用docker scan或集成 Trivy、Clair 等工具到 CI/CD 流程中。

8.2 Kubernetes 最佳实践

1. 使用声明式配置（YAML）并纳入版本控制：所有资源的 YAML 文件都应使用kubectl apply管理，并存储在 Git 仓库中。
2. 为资源设置合理的资源请求和限制：每个 Pod 的spec.containers.resources中定义requests和limits，这是调度和稳定的基础。

   resources: requests: memory: "64Mi" cpu: "250m" limits: memory: "128Mi" cpu: "500m"

3. 使用 Namespace 进行逻辑隔离：将不同项目、不同环境（dev/staging/prod）的资源划分到不同的命名空间。
4. 为 Pod 配置就绪和存活探针：确保流量只被发送到已准备好的 Pod，并能自动重启不健康的 Pod。

   livenessProbe: httpGet: path: /healthz port: 8080 initialDelaySeconds: 3 periodSeconds: 3 readinessProbe: httpGet: path: /ready port: 8080 initialDelaySeconds: 5 periodSeconds: 5

5. 使用 ConfigMap 和 Secret 管理配置与敏感信息：避免将配置和密码硬编码在镜像或 YAML 中。
6. 考虑使用 Helm 进行应用打包：对于复杂的多服务应用，Helm 图表能简化部署和管理。
7. 实施网络策略：默认情况下 Pod 间网络是全通的，使用NetworkPolicy实现最小权限访问控制。
8. 做好日志和监控：确保所有容器日志被收集（如使用 Fluentd + Elasticsearch），并部署监控系统（如 Prometheus + Grafana）监控集群和应用状态。

8.3 生产环境注意事项

• 高可用集群：生产环境至少需要 3 个 Master 节点，以防止控制平面单点故障。
• 持久化存储：认真规划PersistentVolume (PV)和StorageClass，确保有状态应用的数据安全。
• 备份与恢复：定期备份 etcd 数据（存储所有集群状态），并测试恢复流程。
• 升级策略：制定详细的 K8S 版本升级计划，并在测试环境充分验证。
• 安全加固：启用 Pod 安全标准，使用服务账户（ServiceAccount）最小权限原则，定期轮换证书。

这份教程涵盖了从零入门到实战的核心路径。技术栈更新很快，但基础概念和核心操作是稳定的。建议你按照步骤亲手操作一遍，遇到问题多查官方文档和社区。真正的理解来源于实践和踩坑。课件和完整的命令清单已整理好，你可以从我的 GitHub 仓库获取，方便离线查阅和复习。下一步，你可以深入研究 Service Mesh（如 Istio）、GitOps（如 ArgoCD）、Operator 模式等更高级的主题，逐步构建起自己的云原生知识体系。