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

Kubernetes（简称K8s）是容器编排领域的事实标准，能够自动化容器的部署、扩缩容、运维和故障恢复。本文从环境搭建、核心概念、实战操作到高级特性，全方位讲解K8s的使用，适合零基础入门到企业级实战。

一、前置知识与环境准备

1. 核心概念预热（新手必看）

先掌握3个核心概念，避免后续操作迷茫：

Pod：K8s最小部署单元，可包含1个或多个容器，共享网络和存储；
Node：运行Pod的服务器（物理机/虚拟机），分为Master（控制节点）和Worker（工作节点）；
Controller：控制器，用于管理Pod的生命周期（如Deployment确保Pod数量稳定）。

2. 环境要求

角色	配置建议	系统要求
Master节点	2核4G以上，1台	CentOS7+/Ubuntu20.04+，64位
Worker节点	2核2G以上，至少1台（推荐2+台）	同上
网络	所有节点互通，禁用防火墙/SELinux	–

3. 环境初始化（所有节点执行）

# 1. 关闭防火墙
systemctl stop firewalld && systemctl disable firewalld

# 2. 关闭SELinux
setenforce 0
sed -i 's/^SELINUX=enforcing$/SELINUX=disabled/' /etc/selinux/config

# 3. 关闭swap（K8s强制要求）
swapoff -a
sed -i '/swap/s/^/#/' /etc/fstab

# 4. 配置主机名（Master节点示例，Worker节点改名称）
hostnamectl set-hostname k8s-master
# 配置hosts解析（所有节点）
cat >> /etc/hosts << EOF
192.168.1.100 k8s-master
192.168.1.101 k8s-worker1
192.168.1.102 k8s-worker2
EOF

# 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

4. 安装Docker/Containerd（容器运行时）

K8s需要容器运行时，推荐Containerd（Docker已逐步淘汰）：

# 安装依赖
yum install -y yum-utils device-mapper-persistent-data lvm2

# 添加阿里云源
yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

# 安装Containerd
yum install -y containerd.io

# 配置Containerd
mkdir -p /etc/containerd
containerd config default > /etc/containerd/config.toml
# 修改sandbox镜像为国内源（关键！避免拉取镜像失败）
sed -i 's/registry.k8s.io\/pause/registry.aliyuncs.com\/google_containers\/pause/g' /etc/containerd/config.toml
# 启用SystemdCgroup
sed -i 's/SystemdCgroup = false/SystemdCgroup = true/g' /etc/containerd/config.toml

# 重启并设置开机自启
systemctl restart containerd && systemctl enable containerd

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（首次登录需修改）

总结

关键点回顾

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

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

转载自CSDN-专业IT技术社区

原文链接：https://blog.csdn.net/sinat_39327967/article/details/158390297