Kubernetes (K8s) 从入门到实战：超详细教程

5. 安装 K8s 组件（kubeadm/kubelet/kubectl）

# 添加 K8s 阿里云源
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
# 安装指定版本（推荐稳定版 v1.28.x）
yum install -y kubelet-1.28.3 kubeadm-1.28.3 kubectl-1.28.3
systemctl enable kubelet && systemctl start kubelet

二、K8s 集群搭建（单 Master+ 多 Worker）

1. 初始化 Master 节点

# 初始化集群（指定国内镜像仓库，避免拉取失败）
kubeadm init \
  --apiserver-advertise-address=192.168.1.100 \
  --image-repository=registry.aliyuncs.com/google_containers \
  --kubernetes-version=v1.28.3 \
  --service-cidr=10.96.0.0/12 \
  --pod-network-cidr=10.244.0.0/16
# 配置 kubectl（普通用户也能使用）
mkdir -p $HOME/.kube
cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
chown $(id -u):$(id -g) $HOME/.kube/config
# 验证 Master 节点状态
kubectl get nodes
# 此时状态为 NotReady，需安装网络插件

2. 安装网络插件（Calico，必装！）

# 下载 Calico 配置文件
curl -O https://raw.githubusercontent.com/projectcalico/calico/v3.27.0/manifests/calico.yaml
# 修改 Pod 网段（需和 kubeadm init 的 pod-network-cidr 一致）
sed -i 's/192.168.0.0\/16/10.244.0.0\/16/g' calico.yaml
# 部署 Calico
kubectl apply -f calico.yaml
# 等待 3-5 分钟，验证网络插件和节点状态
kubectl get pods -n kube-system
kubectl get nodes
# 状态变为 Ready 即成功

3. 添加 Worker 节点到集群

# 在 Master 节点执行，获取加入集群的命令（含 token 和 hash）
kubeadm token create --print-join-command
# 复制输出的命令，在所有 Worker 节点执行（示例）：
kubeadm join 192.168.1.100:6443 --token abcdef.0123456789abcdef \
  --discovery-token-ca-cert-hash sha256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# 回到 Master 节点，验证节点加入
kubectl get nodes
# 输出所有 Master/Worker 节点，状态均为 Ready 即集群搭建完成

三、K8s 核心操作实战

1. 部署第一个应用（Nginx）

（1）创建 Deployment（管理 Pod）

# 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.24-alpine # 轻量版镜像
        ports:
        - containerPort: 80
        resources:
          # 限制资源，避免占用过多
          limits:
            cpu:"0.5"
            memory:"512Mi"
          requests:
            cpu:"0.1"
            memory:"128Mi"

# 创建 Deployment
kubectl apply -f nginx-deployment.yaml
# 查看 Deployment 状态
kubectl get deployments
# 查看 Pod 状态
kubectl get pods -o wide

（2）创建 Service（暴露应用）

# nginx-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  type: NodePort # 暴露到节点端口
  selector:
    app: nginx
  ports:
  - port: 80 # Service 端口
    targetPort: 80 # Pod 端口
    nodePort: 30080 # 节点端口（30000-32767）

# 创建 Service
kubectl apply -f nginx-service.yaml
# 查看 Service
kubectl get svc
# 访问应用（任意节点 IP+NodePort）
curl http://192.168.1.101:30080

2. 核心运维操作

# 查看资源详情
kubectl describe pod nginx-deployment-xxxx-xxxx
kubectl describe svc nginx-service
# 查看 Pod 日志
kubectl logs nginx-deployment-xxxx-xxxx
kubectl logs -f nginx-deployment-xxxx-xxxx # 实时日志
# 进入 Pod 容器
kubectl exec -it nginx-deployment-xxxx-xxxx -- /bin/sh
# 扩缩容（修改 Pod 副本数）
kubectl scale deployment nginx-deployment --replicas=5
# 更新应用镜像
kubectl set image deployment/nginx-deployment nginx=nginx:1.25-alpine
# 回滚更新
kubectl rollout undo deployment/nginx-deployment
# 删除资源
kubectl delete deployment nginx-deployment
kubectl delete svc nginx-service

3. 配置管理（ConfigMap/Secret）

（1）ConfigMap（存储明文配置）

# 创建 ConfigMap（从文件）
kubectl create configmap nginx-config --from-file=nginx.conf=/etc/nginx/nginx.conf
# 或从 yaml 创建
kubectl apply -f - <<EOF
apiVersion: v1
kind: ConfigMap
metadata:
  name: nginx-config
data:
  nginx.conf: |
    worker_processes 1;
    events {
      worker_connections 1024;
    }
    http {
      server {
        listen 80;
        location / {
          return 200 "Hello K8s!\n";
        }
      }
    }
EOF
# 挂载到 Pod
kubectl apply -f - <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-config-demo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx-config
  template:
    metadata:
      labels:
        app: nginx-config
    spec:
      containers:
      - name: nginx
        image: nginx:1.24-alpine
        ports:
        - containerPort: 80
        volumeMounts:
        - name: nginx-config-volume
          mountPath: /etc/nginx/nginx.conf
          subPath: nginx.conf
      volumes:
      - name: nginx-config-volume
        configMap:
          name: nginx-config
EOF

（2）Secret（存储敏感信息）

# 创建 Secret（存储密码/密钥）
kubectl create secret generic mysql-secret \
  --from-literal=username=root \
  --from-literal=password=123456
# 查看 Secret（默认 base64 加密）
kubectl get secret mysql-secret -o yaml
# 挂载到 Pod 使用
kubectl apply -f - <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: secret-demo
spec:
  containers:
  - name: busybox
    image: busybox:1.36
    command: ["sleep", "3600"]
    env:
    - name: MYSQL_USER
      valueFrom:
        secretKeyRef:
          name: mysql-secret
          key: username
    - name: MYSQL_PWD
      valueFrom:
        secretKeyRef:
          name: mysql-secret
          key: password
EOF

四、高级特性实战

1. 持久化存储（PV/PVC）

# 创建 PV（持久卷，管理员创建）
apiVersion: v1
kind: PersistentVolume
metadata:
  name: nginx-pv
spec:
  capacity:
    storage: 1Gi
  accessModes:
  - ReadWriteOnce
  hostPath:
    # 测试环境用主机路径，生产用 NFS/CSI
    path: /data/nginx-pv
    type: DirectoryOrCreate
# 创建 PVC（持久卷声明，用户申请）
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: nginx-pvc
spec:
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
# 挂载 PVC 到 Pod
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-pv-demo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx-pv
  template:
    metadata:
      labels:
        app: nginx-pv
    spec:
      containers:
      - name: nginx
        image: nginx:1.24-alpine
        ports:
        - containerPort: 80
        volumeMounts:
        - name: nginx-storage
          mountPath: /usr/share/nginx/html
      volumes:
      - name: nginx-storage
        persistentVolumeClaim:
          claimName: nginx-pvc

2. 健康检查（探针）

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-probe-demo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx-probe
  template:
    metadata:
      labels:
        app: nginx-probe
    spec:
      containers:
      - name: nginx
        image: nginx:1.24-alpine
        ports:
        - containerPort: 80
        # 存活探针：检测容器是否运行，失败则重启
        livenessProbe:
          httpGet:
            path: /
            port: 80
          initialDelaySeconds: 5
          periodSeconds: 10
        # 就绪探针：检测容器是否就绪，失败则移除 Service 路由
        readinessProbe:
          httpGet:
            path: /
            port: 80
          initialDelaySeconds: 5
          periodSeconds: 10
        # 启动探针：检测容器是否启动完成
        startupProbe:
          httpGet:
            path: /
            port: 80
          failureThreshold: 30
          periodSeconds: 10

3. 命名空间与资源配额

# 创建命名空间（隔离环境）
kubectl create namespace dev
# 在 dev 命名空间部署应用
kubectl apply -f nginx-deployment.yaml -n dev
# 配置资源配额（限制 dev 命名空间资源使用）
kubectl apply -f - <<EOF
apiVersion: v1
kind: ResourceQuota
metadata:
  name: dev-quota
  namespace: dev
spec:
  hard:
    pods: "10" # 最多 10 个 Pod
    requests.cpu: "2" # 总 CPU 请求不超过 2 核
    requests.memory: "2Gi" # 总内存请求不超过 2Gi
    limits.cpu: "4" # 总 CPU 限制不超过 4 核
    limits.memory: "4Gi" # 总内存限制不超过 4Gi
EOF

五、避坑指南（新手必看）

1. 环境搭建类坑

• 坑 1：初始化集群时拉取镜像失败。
  ✅ 避坑方案：kubeadm init 时指定 --image-repository 为阿里云镜像仓库，避免访问国外仓库超时。
• 坑 2：节点状态一直 NotReady。
  ✅ 避坑方案：
  • 检查网络插件是否部署成功：kubectl get pods -n kube-system；
  • 检查 Pod 网段是否和网络插件配置一致；
  • 查看 kubelet 日志：journalctl -u kubelet -f。
• 坑 3：Worker 节点加入集群失败。
  ✅ 避坑方案：
  • 检查 token 是否过期（默认 24 小时），重新生成：kubeadm token create --print-join-command；
  • 检查 Master 节点 6443 端口是否开放；
  • 所有节点时间同步：yum install -y ntp && ntpdate ntp.aliyun.com。

2. 应用部署类坑

• 坑 4：Pod 状态为 ImagePullBackOff。
  ✅ 避坑方案：
  • 使用国内镜像（如阿里云、网易云镜像仓库）；
  • 配置镜像拉取密钥：kubectl create secret docker-registry regcred --docker-server=xxx --docker-username=xxx --docker-password=xxx。
• 坑 5：Service 暴露后无法访问。
  ✅ 避坑方案：
  • 检查 Service 的 selector 是否和 Pod 的 label 匹配；
  • 检查 NodePort 端口是否在 30000-32767 范围内；
  • 检查节点防火墙是否放行 NodePort 端口。

3. 数据持久化类坑

• 坑 6：PV 和 PVC 绑定失败。
  ✅ 避坑方案：
  • 确保 PV 的 accessModes 和 PVC 一致；
  • 确保 PVC 的 storage 请求不超过 PV 的 capacity；
  • 检查 PV 的 storageClassName 是否和 PVC 匹配（若指定）。

六、集群监控与故障排查

1. 基础监控（kubectl 内置命令）

# 查看集群组件状态
kubectl get componentstatuses
# 查看 Pod 事件（排查启动失败原因）
kubectl describe pod <pod-name>
# 查看节点资源使用
kubectl top nodes
# 查看 Pod 资源使用
kubectl top pods

2. 进阶监控（Prometheus+Grafana）

# 一键部署 Prometheus（使用 Prometheus Operator）
kubectl apply -f https://raw.githubusercontent.com/prometheus-operator/kube-prometheus/main/manifests/setup/0namespace-namespace.yaml
kubectl apply -f https://raw.githubusercontent.com/prometheus-operator/kube-prometheus/main/manifests/
# 暴露 Grafana 服务（NodePort）
kubectl patch svc grafana -n monitoring -p '{"spec":{"type":"NodePort"}}'
kubectl get svc grafana -n monitoring
# 获取访问端口
# 默认账号密码：admin/admin（首次登录需修改）

总结

关键点回顾

1. K8s 集群搭建核心步骤：环境初始化 → 安装容器运行时 → kubeadm 初始化 Master → 部署网络插件 → 添加 Worker 节点；
2. 核心资源关系：Deployment 管理 Pod 副本，Service 暴露 Pod 访问，ConfigMap/Secret 管理配置，PV/PVC 实现持久化；
3. 避坑核心：优先使用国内镜像、确保网络互通、匹配资源标签/网段、检查端口和权限。

通过本文的教程，你可以从零搭建 K8s 集群，掌握应用部署、配置管理、持久化存储等核心操作，同时避开新手常见的坑。对于生产环境，建议使用多 Master 节点（高可用）、专业存储方案（如 NFS/CSI）和完善的监控告警体系，确保集群稳定运行。