一、实验环境与核心目标

1. 环境准备

• 虚拟化工具：VMware Workstation 17 Pro
• 操作系统：Ubuntu 20.04.5 LTS（64 位）
• 集群规划：3 台服务器（1 主 2 从）
  • 主节点（cka-master）：IP 192.168.30.130，4GB 内存，2 核 CPU，200GB 硬盘
  • 从节点 1（cka-worker1）：IP 192.168.30.131，配置同上
  • 从节点 2（cka-worker2）：IP 192.168.30.132，配置同上
• 依赖工具：Docker CE、CRI-Docker、kubeadm、Ansible

2. 核心目标

1. 完成 3 台虚拟机的创建与 Linux 系统安装
2. 配置 Linux 服务器（静态 IP、SSH、系统更新）
3. 部署 Docker 与 K8s 组件，手动搭建 K8s 集群
4. 使用 Ansible 脚本实现 K8s 自动化部署，提升效率

二、详细步骤：从 0 到 1 搭建 K8s 集群

1. 第 1 步：创建虚拟机（VMware）

1. 打开 VMware，选择「新建虚拟机」→「自定义（高级）」，硬件兼容性选「Workstation 17.x」。
2. 安装来源选择「使用 ISO 映像文件」，加载 Ubuntu 20.04.5 镜像。
3. 客户机操作系统选「Linux」→「Ubuntu 64 位」，虚拟机名称设为cka-master，位置选E:\VMware VMS\cka-master。
4. 硬件配置：2 核 CPU、4GB 内存、200GB 硬盘（单个文件存储），网络适配器选「NAT 模式」。
5. 完成创建后，进入「虚拟网络编辑器」，修改 VMnet8 的子网 IP 为192.168.30.0，子网掩码255.255.255.0。
6. 重复上述步骤，创建cka-worker1和cka-worker2，仅需修改名称与 IP（后续配置）。

2. 第 2 步：安装 Linux 操作系统（Ubuntu）

1. 开启虚拟机，选择语言为「English」，键盘布局默认「English (US)」。
2. 网络配置：选择ens33网卡，暂不配置代理，Ubuntu 镜像源默认（后续替换国内源）。
3. 存储配置：选择「Use an entire disk」→「Set up this disk as an LVM group」，不加密，确认分区（/boot 2GB，剩余空间给 LVM）。
4. Profile 设置：
   • Your name：user1
   • Server's name：cka-master（worker 节点对应 cka-worker1/2）
   • Username：user1，设置密码（后续 SSH 登录用）
5. 软件选择：务必勾选「Install OpenSSH server」，允许 SSH 密码登录。
6. 等待安装完成，重启时若报错「Failed unmounting /cdrom」，进入「虚拟机设置」→「CD/DVD」，取消「已连接」，再重启即可。

3. 第 3 步：配置 Linux 服务器（关键）

3.1 设置 root 用户密码

用 user1 登录后，执行以下命令切换 root 并设置密码：

sudo -i  # 切换root用户
passwd root  # 输入并确认root密码

3.2 配置静态 IP（K8s 需固定 IP）

1. 查看当前网卡 IP：ip a s，记录 ens33 的动态 IP（如 192.168.30.128）。
2. 编辑 netplan 配置文件，设置静态 IP：

cat > /etc/netplan/00-installer-config.yaml <<EOF
network:
  ethernets:
    ens33:
      dhcp4: false
      addresses: [192.168.30.130/24]  # 主节点IP，worker对应131/132
      gateway4: 192.168.30.2
      nameservers:
        addresses: [223.5.5.5, 114.114.114.114]
  version: 2
EOF
# 应用配置
netplan apply

注意：配置后 SSH 会断开，需用新静态 IP 重新连接。

3.3 配置 SSH 客户端（MobaXterm）

1. 解压 MobaXterm，打开后新建「SSH Session」，远程主机填静态 IP（如 192.168.30.130）。
2. 登录用户选 root，输入密码后连接，执行以下命令开启 root SSH 权限：

sed -i 's/^#PermitRootLogin.*/PermitRootLogin yes/' /etc/ssh/sshd_config
systemctl restart sshd

3.4 更新系统与安装工具

替换国内源（南京大学），加速下载：

# 备份原源
cp /etc/apt/sources.list /etc/apt/sources.list.bak
# 替换为南大源
sed -i 's/^deb.*archive.ubuntu.com/deb https:\/\/mirror.nju.edu.cn/' /etc/apt/sources.list
# 更新并安装工具
apt update
apt install open-vm-tools vim wget curl bash-completion -y

3.5 集群域名解析

所有节点添加主机映射，确保节点间互通：

cat >> /etc/hosts <<EOF
192.168.30.130 cka-master
192.168.30.131 cka-worker1
192.168.30.132 cka-worker2
EOF

建议拍摄虚拟机快照（VMware「快照」→「拍摄快照」），后续出错可快速恢复。

4. 第 4 步：部署 Docker CE 与 CRI-Docker

K8s 需通过 CRI（容器运行时接口）与 Docker 交互，需安装 CRI-Docker。

4.1 添加 Docker 国内源（南大）

sudo apt-get update
sudo apt-get install -y ca-certificates curl gnupg lsb-release
sudo mkdir -p /etc/apt/keyrings
# 导入Docker GPG密钥
curl -fsSL https://mirror.nju.edu.cn/docker-ce/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
# 添加Docker源
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://mirror.nju.edu.cn/docker-ce/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

4.2 安装 Docker CE

sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

4.3 配置 Docker 镜像加速器与 Cgroup 驱动

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://tehurc7d.mirror.aliyuncs.com"],
  "exec-opts": ["native.cgroupdriver=systemd"]  # 与K8s统一Cgroup驱动
}
EOF
# 重启Docker
sudo systemctl daemon-reload
sudo systemctl restart docker
sudo systemctl enable docker

4.4 安装 CRI-Dock

# 下载CRI-Docker deb包
wget https://ghproxy.com/https://github.com/Mirantis/cri-dockerd/releases/download/v0.3.10/cri-dockerd_0.3.10.3-0.ubuntu-focal_amd64.deb
# 安装
dpkg -i cri-dockerd_0.3.10.3-0.ubuntu-focal_amd64.deb
# 配置CRI-Docker服务
sed -i 's/ExecStart=.*/ExecStart=\/usr\/bin\/cri-dockerd --container-runtime-endpoint fd:\/\/ --network-plugin=cni --pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com\/google_containers\/pause:3.8/' /lib/systemd/system/cri-docker.service
# 重启CRI-Docker
systemctl daemon-reload
systemctl restart cri-docker.service
systemctl enable cri-docker.service

4.5 验证 Docker（可选）

创建 Nginx 容器，测试 Docker 是否正常：

docker run -d -p 8000:80 --name container1 nginx
curl http://127.0.0.1:8000  # 应返回Nginx默认页面

5. 第 5 步：手动部署 K8s 集群

5.1 初始化前置配置（所有节点执行）

1. 关闭 Swap 分区（K8s 要求）：

swapoff -a
sed -i 's/.*swap.*/#&/' /etc/fstab  # 永久关闭

1. 允许 iptables 检查桥接流量：

cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
br_netfilter
EOF
modprobe br_netfilter
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF
sudo sysctl --system

5.2 安装 kubeadm、kubelet、kubectl（所有节点）

# 添加K8s国内源（阿里云）
apt-get update && apt-get install -y apt-transport-https curl
cat > /etc/apt/sources.list.d/k8s.list <<EOF
deb https://mirrors.aliyun.com/kubernetes-new/core/stable/v1.32/deb/ /
EOF
# 导入密钥
curl -fsSL https://mirrors.aliyun.com/kubernetes-new/core/stable/v1.32/deb/Release.key | apt-key add -
apt-get update
# 安装指定版本（1.28.0，避免版本兼容问题）
apt-get install -y kubelet=1.28.0-00 kubeadm=1.28.0-00 kubectl=1.28.0-00
# 锁定版本，防止自动更新
apt-mark hold kubelet kubeadm kubectl

5.3 主节点初始化 K8s 集群

1. 集成 CRI-Docker：

crictl config runtime-endpoint unix:///run/cri-dockerd.sock

1. 生成 kubeadm 配置文件并修改：

kubeadm config print init-defaults > kubeadm.yaml
# 修改主节点IP、名称、镜像源（阿里云）、CRI socket
sed -i 's/.*advert.*/ advertiseAddress: 192.168.30.130/g' kubeadm.yaml
sed -i 's/.*name.*/ name: cka-master/g' kubeadm.yaml
sed -i 's/imageRepo.*/imageRepository: registry.cn-hangzhou.aliyuncs.com\/google_containers/g' kubeadm.yaml
sed -i 's/ criSocket.*/ criSocket: unix:\/\/\/run\/cri-dockerd.sock/' kubeadm.yaml

1. 初始化集群：

modprobe br_netfilter
kubeadm init --config kubeadm.yaml

初始化成功后，会生成 worker 节点加入集群的命令（含 token 和 hash），务必保存！示例：

bash

kubeadm join 192.168.30.130:6443 --token abcdef.0123456789abcdef --discovery-token-ca-cert-hash sha256:xxx

1. 配置 kubectl 权限（主节点）：

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

1. 部署 Calico 网络插件（主节点）：

kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml

1. 验证主节点状态：

kubectl get node  # 主节点应显示Ready状态，ROLES为control-plane
kubectl get pod -A  # 所有kube-system下的Pod应Running

5.4 从节点加入集群

在cka-worker1和cka-worker2上执行主节点初始化时保存的kubeadm join命令，需添加 CRI socket 参数：

kubeadm join 192.168.30.130:6443 --token abcdef.0123456789abcdef --discovery-token-ca-cert-hash sha256:xxx --cri-socket=unix:///var/run/cri-dockerd.sock

若 token 过期，主节点执行kubeadm token create --print-join-command重新生成。

1. 主节点添加 worker 角色标签：

kubectl label nodes cka-worker1 cka-worker2 node-role.kubernetes.io/worker=
# 验证所有节点
kubectl get node  # 3个节点均为Ready，ROLES分别为control-plane、worker、worker

三、自动化部署：用 Ansible 脚本一键搭建

手动部署步骤繁琐，生产环境常用 Ansible 实现自动化。以下是核心脚本与操作：

1. 准备工作

1. 主节点还原到「第 3 步配置完成」的快照（确保环境干净）。
2. 主节点安装 Ansible 与依赖：

apt install sshpass wget bash-completion ansible -y

2. 自动化脚本（create-k8s-cluster.sh）

脚本功能：自动配置源、安装 Docker/CRI-Docker/K8s 组件、初始化集群、添加 worker 节点。核心代码：

#!/bin/bash
# 云原生Kubernetes集群自动化部署脚本
# 适用环境：Ubuntu 20.04.5 LTS，1主2从架构（cka-master/cka-worker1/cka-worker2）
# 脚本功能：自动配置源、安装Docker/CRI-Docker/K8s组件、初始化集群、添加Worker节点

echo -ne "\033[4;96m 警告：若任何步骤失败，请先还原干净系统快照（第3.5节状态）后重新执行！\033[0m\n"
echo -n "是否已还原快照？（yes/no）："
read input

# 检查快照还原状态
case $input in
  yes)
    echo -ne "\033[32m 开始部署K8s集群...\033[0m\n"
    ;;
  no)
    echo -ne "\033[31m 请先还原快照，脚本退出！\033[0m\n"
    exit 1
    ;;
  *)
    echo -ne "\033[31m 输入错误，仅支持yes/no，脚本退出！\033[0m\n"
    exit 1
    ;;
esac

# 切换至root目录执行
cd /root || exit 1

# 1. 配置Ubuntu国内源（南京大学），加速软件下载
cat > /etc/apt/sources.list <<EOF
deb https://mirror.nju.edu.cn/ubuntu focal main restricted
deb https://mirror.nju.edu.cn/ubuntu focal-updates main restricted
deb https://mirror.nju.edu.cn/ubuntu focal universe
deb https://mirror.nju.edu.cn/ubuntu focal-updates universe
deb https://mirror.nju.edu.cn/ubuntu focal multiverse
deb https://mirror.nju.edu.cn/ubuntu focal-updates multiverse
deb https://mirror.nju.edu.cn/ubuntu focal-backports main restricted universe multiverse
deb https://mirror.nju.edu.cn/ubuntu focal-security main restricted
deb https://mirror.nju.edu.cn/ubuntu focal-security universe
deb https://mirror.nju.edu.cn/ubuntu focal-security multiverse
EOF

# 2. 安装Ansible及依赖工具（主节点）
echo -ne "\033[32m 安装Ansible与SSH工具...\033[0m\n"
apt update &> /dev/null
apt install sshpass wget bash-completion ansible -y &> /dev/null

# 3. 配置Ansible免密登录（主节点→所有节点）
# 3.1 生成SSH密钥（若未存在）
if [ ! -f /root/.ssh/id_rsa.pub ]; then
  ssh-keygen -t rsa -f /root/.ssh/id_rsa -N '' &> /dev/null
  echo -ne "\033[32m SSH密钥生成完成...\033[0m\n"
else
  echo -ne "\033[32m SSH密钥已存在，跳过生成...\033[0m\n"
fi

# 3.2 推送密钥至所有节点（默认root密码为1，可根据实际修改）
SSH_PASS="1"
sshpass -p "$SSH_PASS" ssh-copy-id -o StrictHostKeyChecking=no root@cka-master &> /dev/null
sshpass -p "$SSH_PASS" ssh-copy-id -o StrictHostKeyChecking=no root@cka-worker1 &> /dev/null
sshpass -p "$SSH_PASS" ssh-copy-id -o StrictHostKeyChecking=no root@cka-worker2 &> /dev/null

if [ $? -ne 0 ]; then
  echo -ne "\033[31m SSH密钥推送失败，请检查节点网络或密码！\033[0m\n"
  exit 1
fi
echo -ne "\033[32m SSH免密登录配置完成...\033[0m\n"

# 4. 配置Ansible主机清单（/etc/ansible/hosts）
cat > /etc/ansible/hosts <<EOF
[master]
cka-master ansible_user=root ansible_password=$SSH_PASS

[worker]
cka-worker1 ansible_user=root ansible_password=$SSH_PASS
cka-worker2 ansible_user=root ansible_password=$SSH_PASS

[all:vars]
ansible_python_interpreter=/usr/bin/python3
EOF

# 5. 配置Ansible（关闭主机密钥检查、命令警告）
cp /etc/ansible/ansible.cfg /root/ansible.cfg &> /dev/null
sed -i 's/^#host_key_checking = False/host_key_checking = False/' /root/ansible.cfg
sed -i '/^# command_warnings.*/a\command_warnings = False' /root/ansible.cfg

# 6. 生成Ansible Playbook（create-k8s.yaml）：核心部署逻辑
cat > create-k8s.yaml <<'EOF'
- hosts: all
  name: Kubernetes集群全量部署（Docker+CRI-Docker+K8s）
  become: yes
  remote_user: root
  tasks:
    # 任务1：清理APT锁文件（避免安装冲突）
    - name: 清理APT锁文件
      shell: |
        rm -rf /var/lib/apt/lists/lock
        rm -rf /var/lib/dpkg/lock*
        rm -rf /var/cache/apt/archives/lock
        dpkg --configure -a
      args:
        executable: /bin/bash

    # 任务2：替换Ubuntu源为南京大学源（所有节点）
    - name: 替换Ubuntu软件源
      shell: |
        cp /etc/apt/sources.list /etc/apt/sources.list.bak
        sed -i 's/^deb.*archive.ubuntu.com/deb https:\/\/mirror.nju.edu.cn/' /etc/apt/sources.list
      args:
        executable: /bin/bash

    # 任务3：安装Docker依赖工具（CA证书、curl等）
    - name: 安装Docker依赖
      apt:
        name:
          - apt-transport-https
          - ca-certificates
          - curl
          - software-properties-common
        state: present
        update_cache: yes

    # 任务4：添加Docker国内源（南京大学）
    - name: 添加Docker GPG密钥
      apt_key:
        url: https://mirror.nju.edu.cn/docker-ce/linux/ubuntu/gpg
        state: present

    - name: 添加Docker软件源
      apt_repository:
        repo: "deb [arch=amd64] https://mirror.nju.edu.cn/docker-ce/linux/ubuntu {{ ansible_lsb.codename }} stable"
        state: present
        filename: docker
        update_cache: yes

    # 任务5：安装Docker CE及组件
    - name: 安装Docker CE
      apt:
        name:
          - docker-ce
          - docker-ce-cli
          - containerd.io
          - docker-compose-plugin
        state: present
        update_cache: yes

    # 任务6：配置Docker镜像加速器（阿里云）+ Cgroup驱动（与K8s兼容）
    - name: 配置Docker daemon
      copy:
        content: |
          {
            "registry-mirrors": ["http://hub-mirror.c.163.com"],
            "exec-opts": ["native.cgroupdriver=systemd"]
          }
        dest: /etc/docker/daemon.json
        mode: '0644'

    # 任务7：重启Docker服务并设置开机自启
    - name: 重启Docker服务
      systemd:
        name: docker
        state: restarted
        enabled: yes
        daemon_reload: yes

    # 任务8：安装CRI-Docker（K8s与Docker的桥梁）
    - name: 下载CRI-Docker deb包（v0.3.10，适配Ubuntu 20.04）
      get_url:
        url: https://ghproxy.com/https://github.com/Mirantis/cri-dockerd/releases/download/v0.3.10/cri-dockerd_0.3.10.3-0.ubuntu-focal_amd64.deb
        dest: /root/cri-dockerd.deb
        mode: '0755'

    - name: 安装CRI-Docker
      apt:
        deb: /root/cri-dockerd.deb
        state: present

    # 任务9：修改CRI-Docker配置（使用阿里云Pause镜像）
    - name: 配置CRI-Docker启动参数
      lineinfile:
        path: /lib/systemd/system/cri-docker.service
        regexp: '^ExecStart=.*'
        line: 'ExecStart=/usr/bin/cri-dockerd --container-runtime-endpoint fd:\/\/ --network-plugin=cni --pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com\/google_containers\/pause:3.8'
        state: present

    # 任务10：重启CRI-Docker服务
    - name: 重启CRI-Docker
      systemd:
        name: cri-docker
        state: restarted
        enabled: yes
        daemon_reload: yes

    # 任务11：关闭Swap分区（K8s强制要求）
    - name: 临时关闭Swap
      shell: swapoff -a
      args:
        executable: /bin/bash

    - name: 永久关闭Swap（注释/etc/fstab中的Swap行）
      lineinfile:
        path: /etc/fstab
        regexp: '.*swap.*'
        state: absent

    # 任务12：配置K8s所需内核参数（桥接流量检查）
    - name: 加载br_netfilter模块
      modprobe:
        name: br_netfilter
        state: present

    - name: 配置内核参数（桥接流量）
      copy:
        content: |
          net.bridge.bridge-nf-call-ip6tables = 1
          net.bridge.bridge-nf-call-iptables = 1
          net.ipv4.ip_forward = 1
        dest: /etc/sysctl.d/k8s.conf
        mode: '0644'

    - name: 应用内核参数
      shell: sysctl --system
      args:
        executable: /bin/bash

    # 任务13：添加K8s国内源（南京大学）
    - name: 添加K8s GPG密钥
      apt_key:
        url: https://mirrors.aliyun.com/kubernetes/apt/doc/apt-key.gpg
        state: present

    - name: 添加K8s软件源
      apt_repository:
        repo: "deb https://mirror.nju.edu.cn/kubernetes/apt/ kubernetes-xenial main"
        state: present
        filename: k8s
        update_cache: yes

    # 任务14：安装K8s组件（kubeadm、kubelet、kubectl，指定版本1.26.4）
    - name: 安装K8s工具集
      apt:
        name:
          - kubeadm=1.26.4-00
          - kubelet=1.26.4-00
          - kubectl=1.26.4-00
        state: present
        update_cache: yes

    # 任务15：锁定K8s版本（防止自动更新）
    - name: 锁定K8s版本
      dpkg_selections:
        name: "{{ item }}"
        selection: hold
      loop:
        - kubeadm
        - kubelet
        - kubectl

    # 任务16：集成CRI-Docker与K8s（配置runtime-endpoint）
    - name: 配置CRI-Docker为K8s运行时
      shell: crictl config runtime-endpoint unix:///run/cri-dockerd.sock
      args:
        executable: /bin/bash

    # -------------------------- 主节点专属任务 --------------------------
    - name: 主节点：生成kubeadm配置文件
      shell: kubeadm config print init-defaults > /root/kubeadm.yaml
      args:
        executable: /bin/bash
      when: "'master' in group_names"

    - name: 主节点：修改kubeadm配置（主节点IP、镜像源、CRI Socket）
      lineinfile:
        path: /root/kubeadm.yaml
        regexp: "{{ item.regexp }}"
        line: "{{ item.line }}"
        state: present
      loop:
        - { regexp: '^  advertiseAddress:.*', line: '  advertiseAddress: 192.168.30.130' }
        - { regexp: '^  name:.*', line: '  name: cka-master' }
        - { regexp: '^imageRepository:.*', line: 'imageRepository: registry.cn-hangzhou.aliyuncs.com/google_containers' }
        - { regexp: '^  criSocket:.*', line: '  criSocket: unix:///run/cri-dockerd.sock' }
      when: "'master' in group_names"

    - name: 主节点：初始化K8s集群
      shell: kubeadm init --config /root/kubeadm.yaml | tee /root/k8s-init.log
      args:
        executable: /bin/bash
      when: "'master' in group_names"

    - name: 主节点：配置kubectl权限（root用户）
      shell: |
        mkdir -p $HOME/.kube
        cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
        chown $(id -u):$(id -g) $HOME/.kube/config
      args:
        executable: /bin/bash
      when: "'master' in group_names"

    - name: 主节点：部署Calico网络插件（必需，否则节点NotReady）
      shell: kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml && sleep 30
      args:
        executable: /bin/bash
      when: "'master' in group_names"

    - name: 主节点：生成Worker节点加入命令（含CRI Socket）
      shell: |
        kubeadm token create --print-join-command > /root/join-command.sh
        sed -i 's/$/ --cri-socket=unix:\/\/\/var\/run\/cri-dockerd.sock/' /root/join-command.sh
      args:
        executable: /bin/bash
      when: "'master' in group_names"

    - name: 主节点：将加入命令复制到Worker节点
      copy:
        src: /root/join-command.sh
        dest: /root/join-command.sh
        mode: '0755'
      delegate_to: "{{ item }}"
      loop:
        - cka-worker1
        - cka-worker2
      when: "'master' in group_names"

    # -------------------------- Worker节点专属任务 --------------------------
    - name: Worker节点：加入K8s集群
      shell: /root/join-command.sh
      args:
        executable: /bin/bash
      when: "'worker' in group_names"

    # -------------------------- 全节点：重启K8s相关服务 --------------------------
    - name: 重启kubelet服务
      systemd:
        name: kubelet
        state: restarted
        enabled: yes
        daemon_reload: yes
EOF

# 7. 执行Ansible Playbook，开始自动化部署
echo -ne "\033[32m 执行Ansible Playbook，部署过程约5-10分钟...\033[0m\n"
ansible-playbook -i /etc/ansible/hosts create-k8s.yaml -c paramiko

if [ $? -ne 0 ]; then
  echo -ne "\033[31m Playbook执行失败，请查看日志排查问题！\033[0m\n"
  exit 1
fi

# 8. 主节点：添加Worker角色标签（便于kubectl识别节点角色）
echo -ne "\033[32m 配置Worker节点角色标签...\033[0m\n"
kubectl label nodes cka-worker1 cka-worker2 node-role.kubernetes.io/worker= --overwrite

# 9. 清理临时文件
rm -rf /root/ansible.cfg /root/create-k8s.yaml /root/kubeadm.yaml /root/cri-dockerd.deb

# 10. 配置kubectl命令自动补全（主节点）
kubectl completion bash > /etc/bash_completion.d/kubectl
kubeadm completion bash > /etc/bash_completion.d/kubeadm
source /etc/bash_completion.d/kubectl
source /etc/bash_completion.d/kubeadm

# 11. 等待集群就绪并验证状态
echo -ne "\033[32m 集群部署完成，等待1分钟后验证节点状态...\033[0m\n"
sleep 60

# 12. 输出集群状态
echo -ne "\033[4;32m Kubernetes集群部署结果如下：\033[0m\n"
kubectl get nodes
echo -ne "\033[32m 若所有节点状态为Ready，说明集群部署成功！\033[0m\n"

3. 执行自动化部署

# 赋予脚本执行权限
chmod +x create-k8s-cluster.sh
# 运行脚本
bash create-k8s-cluster.sh

执行完成后，用kubectl get nodes验证，3 个节点应均为 Ready 状态，自动化部署完成！

四、常见问题与注意事项

1. 虚拟机重启后 IP 变化：务必配置静态 IP，否则 K8s 集群会故障。
2. Docker 与 K8s 版本兼容：本文用 Docker CE+K8s 1.28.0，避免版本不匹配（参考 K8s 官方兼容列表）。
3. 初始化集群报错：检查 Swap 是否关闭、CRI-Docker 是否启动、镜像源是否可用。
4. worker 节点无法加入：确认 token 有效、主节点 IP 可达、防火墙未拦截 6443 端口。