你是不是也遇到过这样的困惑：想学 Docker 和 Kubernetes，但网上的教程要么是零散的“Hello World”，要么是复杂的生产级配置，中间缺少一个平滑的过渡？或者，你发现很多教程的版本已经过时，照着操作却报错不断，让人瞬间失去学习的动力？

这正是本文要解决的核心问题。我们不再谈论“容器化是未来”这类空泛的概念，而是直接切入一个更实际的判断： 对于大多数从零开始的开发者和运维人员来说，掌握 Docker 和 K8S 的关键，不在于背诵所有命令，而在于建立一套从“单机容器”到“集群编排”的清晰、可复现的实战路径。 这篇文章将为你提供这样一条路径，它基于当前（2026年）主流稳定的技术栈，目标是让你在理解核心原理的基础上，通过一期视频（或本文）的指引，就能搭建起自己的实验环境，并完成从应用打包到集群部署的完整流程。

无论你是想转型云计算运维、准备面试，还是希望提升自己项目的部署效率，这篇文章都将从最基础的 Linux 环境准备开始，带你一步步通关 Docker 和 K8S 的核心操作。我们会重点讲解那些容易踩坑的环节，比如 Docker 镜像源配置、K8S 集群初始化网络问题等，并提供完整的课件（命令和配置文件）供你实践。读完本文，你将能清晰地回答：我的第一个容器化应用，究竟是如何从开发机跑上 K8S 集群的。

1. 这篇文章真正要解决的问题：从“知道”到“做到”的鸿沟

很多技术文章和视频只解决了“知道”的层面——告诉你 Docker 是什么，K8S 有哪些组件。但当你真正动手时，会发现从“知道”到“做到”之间，横亘着无数细节构成的鸿沟。例如：

  • 环境差异 ：教程用的是 Ubuntu 20.04，你的却是 CentOS 8，一个 yum 和 apt 的差别就能卡住半天。
  • 版本陷阱 ：Docker 的 -H 参数用法变了，K8S 的 kubeadm init 命令需要的参数不同了，旧教程完全失效。
  • 网络迷思 ：为什么容器内访问不了外网？为什么 Pod 之间无法通信？Flannel 和 Calico 到底该选哪个？
  • 概念断层 ：学会了 docker run ，但不知道如何把它变成一个 K8S 的 Deployment 和 Service 。

本文的目标就是填平这道鸿沟。我们不追求大而全的百科全书，而是聚焦于一条 最小可行路径 ：在一台或多台 Linux 机器上，从零开始，搭建一个可工作的 Docker + K8S 实验环境，并部署一个典型的 Web 应用。你会经历完整的“打包 -> 运行 -> 编排 -> 暴露”流程，过程中每一个命令、每一个配置文件都有其明确的目的和解释。当你成功在浏览器中访问到运行在 K8S 集群里的应用时，你对这些技术的理解将不再是空中楼阁。

2. 基础概念与核心原理：容器与编排到底改变了什么？

在动手之前，我们需要统一认知。用最直白的话解释：

  • Docker (容器技术) ：想象一下传统的软件部署。你需要准备一台服务器，安装操作系统，配置运行环境（比如 Java、Python、Node.js），解决各种库依赖冲突，最后才能运行你的应用。这个过程繁琐、易错，且难以复制。Docker 提供了一种“打包”方案。它把你的应用代码、运行环境、系统工具、系统库等所有依赖，一起打包成一个独立的、轻量级的“集装箱”——这就是 容器镜像 。这个镜像可以在任何安装了 Docker 引擎的机器上运行，并保证环境完全一致。它 隔离了应用进程 ，但 与宿主机共享操作系统内核 ，因此比虚拟机更轻、更快。

  • Kubernetes (K8S，容器编排) ：当你的应用从单个容器扩展到成百上千个容器，并且需要部署在多台服务器上时，管理就变成了噩梦。哪个容器运行在哪台机器？挂了怎么办？如何扩容缩容？如何实现负载均衡和滚动更新？Kubernetes 就是来解决这个问题的“集群大脑”和“自动化运维平台”。它负责容器的调度、部署、伸缩、网络和生命周期管理。你只需要告诉 K8S：“我需要 3 个副本的我的应用”，它就会自动在集群中找到合适的节点去创建并维持 3 个 Pod（K8S 的最小调度单元，通常包含一个或多个容器）在运行。

它们的关系可以简单类比：

  • Docker 是“集装箱”的制造和运行标准。
  • Kubernetes 是管理全球港口中成千上万个“集装箱”的“智能物流系统”。

为了更清晰，我们用一个表格对比传统部署、虚拟机部署和容器化部署：

特性 传统物理机/虚拟机部署 容器化部署 (Docker) 容器编排 (Kubernetes)
部署单元 应用 + 完整操作系统环境 容器镜像（应用+精简依赖） Pod（一个或多个容器组）
启动速度 分钟级 秒级 秒级（依赖于镜像拉取）
资源消耗 高（每个VM一个完整OS） 低（共享宿主机内核） 低，并实现集群资源池化
环境一致性 差，依赖手动配置 极强（镜像即环境） 极强，且可跨节点一致
伸缩性 手动，慢 手动，较快 自动，快速（HPA）
故障恢复 手动干预 需外部监控重启 自动重启、迁移（自愈）
学习与管理成本 低（单机）-> 高（集群） 中等（单机容器） 高（概念复杂），但管理效率更高

理解了这些，你就明白为什么这套技术栈会成为云计算和运维领域的核心：它从根本上提升了软件交付和运维的标准化、自动化水平。

3. 环境准备与前置条件

我们的实战目标是搭建一个 1个Master节点 + 2个Worker节点 的 K8S 集群。你可以使用三台云服务器，也可以在一台性能较好的机器上使用虚拟机（如 VirtualBox + Vagrant）来模拟。本文以 CentOS 8 Stream 为例，其他 Linux 发行版（如 Ubuntu 20.04/22.04）命令略有不同，但思路一致。

最低配置要求：

  • 操作系统 ：CentOS 7/8, Ubuntu 18.04/20.04/22.04 等主流 Linux 发行版（本文用 CentOS 8 Stream）。
  • 硬件 ：每个节点至少 2 CPU， 2GB RAM， 20GB 磁盘。Master 节点建议配置更高。
  • 网络 ：所有节点之间网络互通，且可以访问互联网（用于拉取镜像）。
  • 权限 ：所有操作需要在 root 用户下进行，或使用具有 sudo 权限的账户。

关键前置操作（所有节点都需要执行）：

  1. 关闭防火墙 （实验环境为了方便，生产环境需配置安全组和防火墙规则）： 
    systemctl stop firewalld
systemctl disable firewalld
  2. 关闭 SELinux ： 
    setenforce 0
sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
  3. 关闭 swap ：Kubernetes 为了稳定性和性能，要求关闭 swap。 
    swapoff -a
sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab # 注释掉swap行，永久生效
  4. 配置主机名与 hosts 解析 （方便节点间通信）：
    • 假设三台机器 IP 为： 192.168.1.10 (master), 192.168.1.11 (node1), 192.168.1.12 (node2)。
    • 在每台机器上编辑 /etc/hosts ： 
      cat >> /etc/hosts << EOF
192.168.1.10 k8s-master
192.168.1.11 k8s-node1
192.168.1.12 k8s-node2
EOF
    • 分别设置主机名： 
      # 在 master 节点
hostnamectl set-hostname k8s-master
# 在 node1 节点
hostnamectl set-hostname k8s-node1
# 在 node2 节点
hostnamectl set-hostname k8s-node2
  5. 配置内核参数并加载模块 ： 
    cat > /etc/sysctl.d/k8s.conf << EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF
sysctl --system

# 加载 overlay 和 br_netfilter 模块
modprobe overlay
modprobe br_netfilter
    执行 sysctl -p /etc/sysctl.d/k8s.conf 使配置生效。

完成以上步骤后，请 重启所有服务器 ，确保设置永久生效。

4. 核心流程拆解：四步搭建实验环境

整个搭建过程可以清晰地分为四步，我们将在 Master 节点上执行大部分命令，并在需要时扩展到 Worker 节点。

4.1 第一步：在所有节点安装 Docker

Docker 是 K8S 的容器运行时基础。我们安装当前稳定的社区版。

  1. 卸载旧版本 （如果有）： 
    yum remove -y docker docker-client docker-client-latest docker-common docker-latest docker-latest-logrotate docker-logrotate docker-engine
  2. 安装 yum 工具包并添加 Docker 仓库 ： 
    yum install -y yum-utils
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
  3. 安装 Docker Engine ： 
    yum install -y docker-ce docker-ce-cli containerd.io
  4. 配置 Docker 镜像加速器（国内必备，否则拉镜像极慢） ： 
    mkdir -p /etc/docker
tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://registry.docker-cn.com", "https://hub-mirror.c.163.com"],
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "storage-driver": "overlay2"
}
EOF
    关键点 ： "native.cgroupdriver=systemd" 必须与 K8S 的 kubelet 保持一致，否则后续 kubeadm init 会报错。
  5. 启动并设置开机自启 ： 
    systemctl start docker
systemctl enable docker
  6. 验证安装 ： 
    docker run hello-world
    如果能看到 Hello from Docker! 的欢迎信息，说明 Docker 安装成功且可以运行容器。

请在所有节点（master, node1, node2）上重复以上步骤。

4.2 第二步：在所有节点安装 kubeadm, kubelet 和 kubectl

kubeadm 是 K8S 官方提供的集群快速部署工具。 kubelet 是运行在每个节点上的代理，负责管理容器。 kubectl 是命令行工具，用于管理集群。

  1. 添加 Kubernetes 的 yum 仓库 ： 
    cat > /etc/yum.repos.d/kubernetes.repo << EOF
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF
    这里使用了阿里云镜像，加速下载。
  2. 安装指定版本 （建议选择较新的稳定版，避免使用最新的边缘版本）： 
    yum install -y kubelet-1.26.0 kubeadm-1.26.0 kubectl-1.26.0 --disableexcludes=kubernetes
    安装 1.26.0 版本，你可以根据 K8S 官方发布日志 选择其他稳定版本，但请确保所有节点版本一致。
  3. 启动 kubelet 并设置开机自启 ： 
    systemctl enable --now kubelet
    注意：此时 kubelet 会不断重启，因为集群还未初始化，这是正常现象。

请在所有节点上重复以上步骤。

4.3 第三步：在 Master 节点初始化集群

这是最关键的一步，我们将在 k8s-master 节点上创建控制平面。

  1. 使用 kubeadm 初始化集群 ：

    kubeadm init \
  --apiserver-advertise-address=192.168.1.10 \
  --image-repository registry.aliyuncs.com/google_containers \
  --kubernetes-version v1.26.0 \
  --service-cidr=10.96.0.0/12 \
  --pod-network-cidr=10.244.0.0/16

    参数解释 ：

    • --apiserver-advertise-address : Master 节点的 IP 地址。
    • --image-repository : 指定镜像仓库，使用阿里云镜像加速，避免从 k8s.gcr.io 拉取失败。
    • --kubernetes-version : 必须与安装的版本一致。
    • --service-cidr : 集群内部 Service 使用的虚拟 IP 段。
    • --pod-network-cidr : Pod 网络使用的 IP 段，需要与后续安装的网络插件匹配（这里用的是 Flannel 的默认网段）。

  2. 记录关键输出 ：初始化成功后，控制台会输出类似以下信息， 务必保存好 ：

    Your Kubernetes control-plane has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config

Alternatively, if you are the root user, you can run:

  export KUBECONFIG=/etc/kubernetes/admin.conf

You should now deploy a pod network to the cluster.
Run `kubectl apply -f [podnetwork].yaml` with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

Then you can join any number of worker nodes by running the following on each as root:

kubeadm join 192.168.1.10:6443 --token xxxxxx.xxxxxxxxxxxx \
        --discovery-token-ca-cert-hash sha256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    • 上面的 kubeadm join ... 命令就是 Worker 节点加入集群的令牌，后面会用到。

  3. 配置 kubectl （使用 root 用户）：

    export KUBECONFIG=/etc/kubernetes/admin.conf
echo "export KUBECONFIG=/etc/kubernetes/admin.conf" >> ~/.bashrc

  4. 检查集群状态 ：

    kubectl get nodes

    此时应该只有 master 节点，并且状态是 NotReady ，因为网络插件还未安装。

    kubectl get pods -n kube-system

    查看系统 Pod， coredns 会处于 Pending 状态，同样是因为网络未就绪。

4.4 第四步：安装 Pod 网络插件 (CNI) 并加入 Worker 节点

没有网络插件，Pod 之间无法通信。我们选择最常用的 Flannel 。

  1. 在 Master 节点安装 Flannel ： 
    kubectl apply -f https://raw.githubusercontent.com/flannel-io/flannel/master/Documentation/kube-flannel.yml
  2. 等待网络插件就绪 ： 
    kubectl get pods -n kube-system -w
    使用 -w 参数观察 Pod 状态变化，直到所有 Pod（尤其是 kube-flannel-ds-* ）都变为 Running 。按 Ctrl+C 退出观察。
  3. 再次检查节点状态 ： 
    kubectl get nodes
    此时 master 节点的状态应该变为 Ready 。
  4. 让 Worker 节点加入集群 ： 在 每个 Worker 节点 ( k8s-node1 , k8s-node2 ) 上，执行之前在 Master 初始化成功时输出的 kubeadm join 命令。命令类似： 
    kubeadm join 192.168.1.10:6443 --token xxxxxx.xxxxxxxxxxxx \
        --discovery-token-ca-cert-hash sha256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  5. 在 Master 节点验证集群 ： 等待几分钟，让节点完成注册和组件启动，然后在 Master 节点执行： 
    kubectl get nodes
    如果一切顺利，你将看到类似下面的输出，三个节点状态都是 Ready ： 
    NAME          STATUS   ROLES           AGE   VERSION
k8s-master    Ready    control-plane   10m   v1.26.0
k8s-node1     Ready    <none>          5m    v1.26.0
k8s-node2     Ready    <none>          5m    v1.26.0
    恭喜！一个最小化的 Kubernetes 集群已经搭建完成。

5. 完整示例：部署你的第一个应用到 K8S 集群

理论再好，不如亲手部署一个应用。我们将把一个简单的 Nginx Web 服务器部署到集群中，并通过 Service 对外暴露访问。

5.1 创建 Deployment

Deployment 是 K8S 中管理 Pod 副本的控制器，它确保指定数量的 Pod 副本始终运行。

  1. 创建一个名为 nginx-deployment.yaml 的文件： 
    # nginx-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3  # 指定需要运行3个Pod副本
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.21-alpine  # 使用轻量级的Alpine版本镜像
        ports:
        - containerPort: 80  # 容器内部监听的端口
  2. 使用 kubectl apply 命令创建 Deployment： 
    kubectl apply -f nginx-deployment.yaml
  3. 查看 Deployment 和 Pod 状态： 
    kubectl get deployments
kubectl get pods -o wide
    -o wide 可以查看 Pod 运行在哪个节点上。你应该看到 3 个 nginx-deployment-xxxxx 格式的 Pod，状态为 Running ，并且被调度到了不同的节点上（如果节点资源足够）。

5.2 创建 Service

Pod 的 IP 是临时的，且集群外无法直接访问。Service 为 Pod 提供一个稳定的访问入口和负载均衡。

  1. 创建一个名为 nginx-service.yaml 的文件： 
    # nginx-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx  # 这个选择器必须匹配上面Deployment中Pod的标签
  ports:
    - protocol: TCP
      port: 80       # Service对外的端口
      targetPort: 80 # 转发到Pod的端口
  type: NodePort     # 使用NodePort类型，便于从集群外部访问
    NodePort 类型会在每个集群节点的同一个端口（范围 30000-32767）上暴露服务。
  2. 创建 Service： 
    kubectl apply -f nginx-service.yaml
  3. 查看 Service： 
    kubectl get svc nginx-service
    输出类似： 
    NAME            TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
nginx-service   NodePort   10.96.123.456   <none>        80:31234/TCP   2m
    这里 31234 就是随机分配的 NodePort。

5.3 访问你的应用

现在，你可以通过 任意一个集群节点（Master 或 Worker）的 IP 地址 加上 NodePort 来访问 Nginx 了。

打开浏览器，访问： http://<任意节点IP>:31234 ，例如 http://192.168.1.10:31234 或 http://192.168.1.11:31234 。

你应该能看到 Nginx 的欢迎页面。这证明你的应用已经成功运行在 K8S 集群中，并且服务可以被外部访问。

6. 运行结果与效果验证

完成上述部署后，我们进行更深入的验证，理解 K8S 的自动化能力。

  1. 模拟 Pod 故障，验证自愈 ：
    • 手动删除一个 Pod： 
      kubectl delete pod <nginx-pod-name>
    • 立即查看 Pod 状态： 
      kubectl get pods -w
    你会看到被删除的 Pod 状态变为 Terminating ，然后很快有一个新的 Pod 被创建出来并进入 Running 状态。这就是 Deployment 控制器在维持 replicas: 3 的期望状态。
  2. 验证负载均衡 ：
    • 进入一个 Pod 的 Shell，修改其首页内容以作区分： 
      kubectl exec -it <nginx-pod-name> -- /bin/sh
# 在容器内执行
echo "Hello from Pod <pod-name>" > /usr/share/nginx/html/index.html
exit
    • 多次访问 http://<节点IP>:31234 ，刷新页面。由于 Service 的负载均衡，你可能会看到来自不同 Pod 的不同欢迎信息（如果你修改了多个 Pod 的话）。这证明了 Service 的负载均衡功能。
  3. 扩容与缩容 ：
    • 将副本数从 3 扩展到 5： 
      kubectl scale deployment nginx-deployment --replicas=5
kubectl get pods
    • 观察 Pod 数量变化。同样，缩容到 2： 
      kubectl scale deployment nginx-deployment --replicas=2
kubectl get pods
    这个过程完全由 K8S 自动完成，无需手动干预每台机器。

7. 常见问题与排查思路

在搭建和使用过程中，你几乎一定会遇到问题。以下是高频问题及排查方法。

问题现象 可能原因 排查方式 解决方案
kubeadm init 卡在 [preflight] 或拉取镜像失败 1. 网络不通，无法访问镜像仓库。
2. 未关闭 swap 或 SELinux。
3. 内核参数未正确配置。		 1. ping registry.aliyuncs.com 测试网络。
2. 检查 swapoff -a 和 getenforce 。
3. 检查 /etc/sysctl.d/k8s.conf 是否生效。		 1. 配置正确的镜像加速器或代理。
2. 确保前置操作步骤全部完成并重启。
3. 执行 sysctl -p 并加载模块。
kubectl get nodes 显示节点 NotReady 1. Pod 网络插件（如 Flannel）未安装或安装失败。
2. kubelet 服务未正常运行。		 1. kubectl get pods -n kube-system 查看 kube-flannel-ds-* Pod 状态。
2. systemctl status kubelet 查看服务状态和日志 journalctl -xeu kubelet 。		 1. 重新应用 Flannel YAML，或尝试其他 CNI 插件（如 Calico）。
2. 检查 `docker info
Pod 状态一直是 Pending 1. 集群资源不足（CPU/内存）。
2. 没有合适的节点满足调度要求（如节点有污点 taint）。		 1. kubectl describe pod <pod-name> 查看 Events 部分。
2. kubectl describe node <node-name> 查看节点资源分配和污点。		 1. 清理资源或增加节点。
2. 为 Pod 设置资源请求 resources.requests ，或为节点移除污点 kubectl taint nodes <node-name> key- 。
无法通过 NodePort 访问服务 1. 节点防火墙未开放 NodePort 端口。
2. Service 的 selector 与 Pod 的 labels 不匹配。
3. Pod 本身服务未正常启动。		 1. 在节点上 curl 127.0.0.1:<targetPort> 测试 Pod 内部。
2. kubectl describe svc <service-name> 查看 Endpoints 是否关联了 Pod。
3. kubectl logs <pod-name> 查看应用日志。		 1. 实验环境可暂时关闭防火墙，生产环境需配置安全组/防火墙规则。
2. 检查并修正 YAML 文件中的标签。
3. 检查应用配置和日志。
kubectl 命令报错 The connection to the server ... was refused 1. kube-apiserver 未启动。
2. admin.conf 配置文件路径错误或权限问题。		 1. systemctl status kube-apiserver (在 master 节点)。
2. 检查 echo $KUBECONFIG 或 ls -la ~/.kube/config 。		 1. 重启 master 节点相关服务 systemctl restart kubelet 。
2. 重新执行 export KUBECONFIG=/etc/kubernetes/admin.conf 并确认。
Docker 拉取镜像慢或失败 默认 Docker Hub 镜像源在国内访问慢或被限制。 docker info 查看 Registry Mirrors 配置。 修改 /etc/docker/daemon.json ，添加国内镜像加速器地址（如阿里云、中科大），然后 systemctl restart docker 。

通用排查命令链 ：当遇到问题时，按以下顺序排查往往能快速定位：

  1. kubectl get <资源类型> ：查看资源状态。
  2. kubectl describe <资源类型> <资源名称> ：查看详细信息和事件（Events）。
  3. kubectl logs <pod-name> ：查看 Pod 内容器的标准输出日志。
  4. kubectl exec -it <pod-name> -- /bin/sh ：进入容器内部检查。
  5. 查看对应节点的服务日志： journalctl -xeu <服务名> ，如 kubelet , docker 。

8. 最佳实践与工程建议

当你成功运行起第一个应用后，以下建议能帮助你将这套技术栈更好地用于实际项目。

  1. YAML 文件管理 ：

    • 版本化 ：将 K8S 的 YAML 配置文件纳入 Git 版本控制。
    • 使用 Kustomize 或 Helm ：对于复杂应用，使用 Kustomize（K8S 原生）或 Helm（包管理器）来管理多环境（开发、测试、生产）的配置差异，避免手动修改。
    • 添加注释 ：在 YAML 中添加 # 注释，说明关键字段的用途。

  2. 镜像管理 ：

    • 使用私有镜像仓库 ：生产环境务必搭建或使用云厂商提供的私有镜像仓库（如 Harbor, AWS ECR, 阿里云 ACR），避免依赖 Docker Hub 的速率限制和稳定性。
    • 镜像标签策略 ：不要使用 latest 标签。使用语义化版本（如 v1.2.3 ）或 Git 提交哈希（如 commit-abc123 ）作为标签，确保每次部署的可追溯性。

  3. 资源管理与调度 ：

    • 定义资源请求和限制 ：在 Pod 的 spec.containers.resources 中明确设置 requests （调度依据）和 limits （运行上限），防止单个 Pod 耗尽节点资源。 
      resources:
  requests:
    memory: "64Mi"
    cpu: "250m"
  limits:
    memory: "128Mi"
    cpu: "500m"
    • 使用命名空间 ：用 Namespace 隔离不同项目、不同环境（如 dev , staging , prod ）的资源。

  4. 安全与权限 ：

    • 最小权限原则 ：不要长期使用 cluster-admin 权限。为不同用户或服务账户创建具有特定权限的 Role 和 RoleBinding / ClusterRoleBinding 。
    • 避免在镜像中存储密钥 ：使用 K8S 的 Secret 资源来管理密码、令牌、密钥等敏感信息，并通过卷挂载或环境变量注入到 Pod 中。

  5. 监控与日志 ：

    • 集群监控 ：部署 Prometheus + Grafana 来监控集群节点、Pod 的资源使用率（CPU、内存、网络）。
    • 应用日志 ：确保应用日志输出到标准输出（stdout）和标准错误（stderr），便于使用 kubectl logs 查看。对于生产环境，需要集成 EFK（Elasticsearch, Fluentd, Kibana）或 Loki 等日志收集系统。

  6. 持续集成与部署 ：

    • 将 Docker 镜像构建和 K8S 部署流程整合到 CI/CD 工具（如 Jenkins, GitLab CI, GitHub Actions）中。典型的流水线是：代码提交 -> 自动化测试 -> 构建 Docker 镜像 -> 推送至镜像仓库 -> 更新 K8S Deployment 的镜像版本。

从单机 Docker 到 K8S 集群，你走过的这条路径，正是现代应用从开发到部署的标准范式。本文的核心价值在于，它不仅仅是一份命令清单，而是通过一个完整的、可复现的流程，将容器和编排的核心概念串联成了肌肉记忆。你知道了 kubeadm init 背后在初始化什么，明白了 Deployment 和 Service 如何协作，也体验了集群的自愈和伸缩能力。

接下来，你可以沿着这几个方向深入：

  • 深入 K8S 核心概念 ：研究 ConfigMap , Secret , StatefulSet （用于有状态应用如数据库）, DaemonSet , Ingress （更灵活的7层流量入口）。
  • 探索服务网格 ：了解 Istio 或 Linkerd，它们为微服务提供了更强大的流量管理、安全性和可观测性能力。
  • 关注云原生生态 ：学习 Helm 包管理、Operator 模式、GitOps（如 ArgoCD）等，它们能极大提升在 K8S 上管理复杂应用的效率。
  • 动手实践复杂应用 ：尝试在集群中部署一个包含前端、后端、数据库和缓存的完整微服务应用。

学习这套技术栈，最好的方法就是“在问题中学习”。把你遇到的所有报错都当作一次深入理解其工作原理的机会。建议你将本文中的命令和配置文件保存为“课件”，并尝试在全新的环境中从头搭建一遍。当你能够独立解决搭建过程中 90% 的问题时，你就已经跨过了容器化运维的门槛。

Logo
亚马逊云科技技术品牌专区

更多推荐

open-code-review Codex 插件教程：对话式调用评审技能指南

本文是一份面向新手的 **open-code-review Codex 插件教程**，教你在 Codex 中通过对话式方式调用 open-code-review 的 AI 代码评审技能。open-code-review 是阿里巴巴开源的 AI 代码评审工具，采用"确定性流水线 + LLM Agent"混合架构，内置多语言评审规则（NPE、线程安全、XSS、SQL 注入等），可在 Codex 里用一

avatar 亚马逊云科技技术品牌专区

OBS Studio 完整指南：免费开源录屏与直播软件从零上手

想做一场像模像样的直播，或者把屏幕内容录成教程视频，但一想到商用软件的订阅费就有些犹豫？其实你不需要花一分钱。OBS Studio 是一款免费开源的直播与录屏软件，支持 Windows、macOS 和 Linux，采集、混音、编码、推流、录制，一条流水线全包了。## 先搞清楚 OBS Studio 是什么OBS Studio 是一个"场景化"的采集合成工具：你把摄像头、窗口、浏览器、图片、

avatar 亚马逊云科技技术品牌专区

如何用MediaCrawler爬取小红书抖音数据？7大平台爬虫从安装到实战完整指南

MediaCrawler 是一个支持小红书、抖音、快手、B站、微博、百度贴吧、知乎的开源自媒体数据采集工具。它能按关键词、按帖子、按创作者主页三种方式抓取笔记/视频内容、评论甚至二级评论，并把结果存成 JSON、CSV、Excel 或数据库。适合做市场调研、竞品监控、内容选题的运营人员，以及想要现成爬虫框架而不想从零写 JS 逆向的开发者。## 从一次"手动抄数据"说起想象这个场景：你负责

avatar 亚马逊云科技技术品牌专区