K8S 安装 部署 文档

echo "=== 系统版本信息 ===" && uname -a && echo "\n=== 发行版信息 ===" && cat /etc/*release 2>/dev/null |\grep -E 'NAME|VERSION' | head -10 && echo "\n=== 系统负载 ===" && uptime && echo "\n=== 内存使用 ===" \&& free -h && echo "\n=== 磁盘使用 ===" && df -h && echo\"\n=== Kubernetes (kubectl) 状态 ===" && if command -v kubectl &> /dev/null; then kubectl version --client 2>/dev/null \|| echo "kubectl 已安装但无法获取版本"; kubectl cluster-info 2>/dev/null || echo "无法连接到集群"; else echo "kubectl 未安装"; \fi && echo "\n=== Minikube 状态 ===" && if command -v minikube &>\/dev/null; then minikube version; minikube status || echo "minikube 未运行"; else echo "minikube 未安装"; fi

系统状态简报

1. 系统版本信息

• 内核版本 : Linux 5.15.0-78-generic
• 操作系统 : Ubuntu 22.04.3 LTS (Jammy Jellyfish)
• 架构 : x86_64

2. 系统运行状态

• 运行时间 : 9天23小时19分钟
• 系统负载 : 0.15, 0.20, 0.29（负载较低）
• 内存使用 : 总计15GB，已使用5.0GB，可用10GB
• 磁盘使用 : 根目录(/dev/mapper/xstack-root)使用率74%（98GB中已用72GB，剩余27GB）

3. Kubernetes状态

• kubectl版本 : v1.28.2 (客户端)
• 集群状态 : 无法连接到集群，表明当前没有活跃的Kubernetes集群

4. Minikube状态

• minikube版本 : v1.37.0
• 运行状态 : 已停止（未运行）
• 组件状态 : Control Plane、host、kubelet、apiserver和kubeconfig均处于停止状态

总结

系统整体运行正常，资源充足。Kubernetes相关工具已安装，但minikube目前未运行，没有活跃的Kubernetes集群。磁盘使用率较高(74%)，建议关注空间使用情况。

首先检查系统环境和必要组件状态，然后开始安装Kubernetes。

user 终端

echo “=检查Docker状态=” && docker --version && echo “\n=系统架构信息=” && uname -a && echo “\n=创建Kubernetes安装脚本=” && cat > install_kubernetes.sh << ‘EOF’
#!/bin/bash

配置Docker使用systemd cgroup驱动

cat > /etc/docker/daemon.json << EOT
{
“exec-opts”: [“native.cgroupdriver=systemd”],
“log-driver”: “json-file”,
“log-opts”: {
“max-size”: “100m”
},
“storage-driver”: “overlay2”
}
EOT

重新加载Docker配置

systemctl daemon-reload
systemctl restart docker

设置Kubernetes源（使用阿里云镜像）

curl -fsSL https://mirrors.aliyun.com/kubernetes/apt/doc/apt-key.gpg | apt-key add -

cat > /etc/apt/sources.list.d/kubernetes.list << EOT
deb https://mirrors.aliyun.com/kubernetes/apt/ kubernetes-xenial main
EOT

更新软件包列表并安装Kubernetes组件

apt-get update
apt-get install -y kubelet kubeadm kubectl
systemctl enable kubelet

配置kubeadm使用国内镜像

export KUBE_DOCKER_REGISTRY=registry.cn-hangzhou.aliyuncs.com/google_containers
echo “安装脚本已创建，请以root权限运行”
EOF

chmod +x install_kubernetes.sh
echo “\n=安装脚本内容=” && cat install_kubernetes.sh

Thought

验证安装脚本是否正确创建，然后开始执行安装。

user 终端

echo “=检查安装脚本=” && cat install_kubernetes.sh && echo “\n=开始安装Kubernetes组件=” && sudo bash install_kubernetes.sh && echo “\n=检查安装结果=” && kubectl version --client && kubeadm version

Thought

Kubernetes组件安装成功，现在创建并执行集群初始化脚本。

user 终端

echo “=创建集群初始化脚本=” && cat > init_kubernetes.sh << ‘EOF’
#!/bin/bash

设置使用国内镜像源

export KUBE_DOCKER_REGISTRY=registry.cn-hangzhou.aliyuncs.com/google_containers

初始化控制平面（单节点集群，允许主节点调度Pod）

kubeadm init --apiserver-advertise-address=10.16.233.177 --pod-network-cidr=192.168.0.0/16 --image-repository=registry.cn-hangzhou.aliyuncs.com/google_containers

配置kubectl权限

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

允许主节点调度Pod

kubectl taint nodes --all node-role.kubernetes.io/control-plane- node-role.kubernetes.io/master-

安装Calico网络插件

kubectl apply -f /home/user/calico.yaml

echo “Kubernetes集群初始化完成”
EOF

chmod +x init_kubernetes.sh
echo “\n=执行集群初始化=” && sudo bash init_kubernetes.sh

Thought

检查集群初始化状态和节点情况。

user 终端

echo “=检查Kubernetes集群状态=” && kubectl get nodes && echo “\n=检查集群组件状态=” && kubectl get pods -n kube-system && echo “\n=检查.kube/config文件=” && ls -la ~/.kube && echo “\n=检查集群信息=” && kubectl cluster-info

Thought

检查kubeadm初始化日志，修复集群配置问题。

user 终端

echo “=检查.kube目录内容=” && ls -la ~/.kube/ && echo “\n=检查kubelet状态=” && systemctl status kubelet && echo “\n=查看kubeadm初始化日志=” && journalctl -u kubelet --since “10 minutes ago” | tail -50 && echo “\n=重新初始化集群=” && sudo kubeadm reset -f && sudo kubeadm init --apiserver-advertise-address=10.16.233.177 --pod-network-cidr=192.168.0.0/16 --image-repository=registry.cn-hangzhou.aliyuncs.com/google_containers --ignore-preflight-errors=all

Thought

尝试使用更简化的方法重新初始化Kubernetes集群。

user

echo “=启动必要服务=” && sudo systemctl start docker && echo “\n=检查Docker状态=” && sudo systemctl status docker --no-pager && echo “\n=清理之前的kubeadm配置=” && sudo kubeadm reset -f && sudo rm -rf /etc/kubernetes && sudo rm -rf ~/.kube && echo “\n=简化版初始化脚本=” && cat > init_simple.sh << ‘EOF’
#!/bin/bash

设置环境变量

export KUBE_DOCKER_REGISTRY=registry.cn-hangzhou.aliyuncs.com/google_containers

初始化集群（使用更简单的配置）

kubeadm init --pod-network-cidr=192.168.0.0/16 --image-repository=registry.cn-hangzhou.aliyuncs.com/google_containers --ignore-preflight-errors=all

配置kubectl

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

chmod +x init_simple.sh
echo “\n=执行简化版初始化=” && sudo bash init_simple.sh

Kubernetes安装部署流程总结

已完成的步骤

1. 准备阶段

• 可能已完成Kubernetes组件（kubeadm、kubelet、kubectl）的安装
• containerd作为容器运行时已安装并运行
• 系统基础环境已配置

2. 故障修复尝试

• 创建并运行了k8s_fix_kubelet.sh脚本，尝试修复kubelet问题并重新初始化集群
• 创建并运行了k8s_complete_clean_init.sh脚本，执行全面清理和初始化
• 创建了k8s_minimal_fix.sh脚本（用户已删除）

3. 当前状态检查

• 检查了kubelet状态（显示为running但有问题）
• 检查了配置文件目录（/etc/kubernetes/、/var/lib/kubelet/等）
• 验证API服务器端口6443未监听

当前安装位置

我们处于集群初始化失败后的故障排查阶段：

• Kubernetes的基础组件（kubeadm、kubelet、kubectl）已安装
• containerd容器运行时已安装并运行
• kubelet服务已启动但存在配置问题
• 控制平面组件（api-server、etcd等）未能成功启动
• 集群初始化命令kubeadm init执行失败

当前具体问题

1. 控制平面启动超时：kubelet虽然运行，但无法成功启动控制平面组件
2. API服务器未启动：6443端口未监听，表明api-server容器未运行
3. kubectl连接失败：尝试连接localhost:8080失败
4. kubelet配置可能有问题：可能存在与containerd通信或cgroups配置问题

未来还需要的步骤

1. 详细诊断（还未完成）

• 检查kubelet详细日志：journalctl -xeu kubelet
• 检查containerd状态和日志
• 验证cgroups配置

2. 修复阶段（还未完成）

• 根据诊断结果修复kubelet配置
• 确保containerd与kubelet正确集成
• 检查系统资源和权限设置

3. 重新初始化（还未完成）

• 执行干净的初始化：kubeadm reset后重新初始化
• 配置kubelet与containerd的正确连接
• 监控控制平面组件启动过程

4. 集群完成配置（还未完成）

• 安装网络插件（如Calico）
• 验证集群节点状态
• 配置kubectl访问权限

下一步建议

建议先进行详细诊断，找出具体的失败原因，然后针对性修复。由于已经尝试过多次初始化都卡在控制平面启动阶段，需要深入检查kubelet日志和containerd配置，确定根本原因后再进行修复和重新初始化。

#!/bin/bash

设置彩色输出

green=“\033[0;32m”
yellow=“\033[0;33m”
red=“\033[0;31m”
reset=“\033[0m”

echo -e “$green===开始终极清理和重新安装===${reset}”

停止所有服务

echo -e “$yellow===停止所有相关服务===${reset}”
sudo systemctl stop kubelet 2>/dev/null || true
sudo systemctl stop containerd 2>/dev/null || true
sudo systemctl stop docker 2>/dev/null || true

彻底清理所有Kubernetes和containerd相关文件

echo -e “$yellow===彻底清理所有相关文件===${reset}”
sudo rm -rf /var/lib/kubelet/
sudo rm -rf /etc/kubernetes/
sudo rm -rf $HOME/.kube/
sudo rm -rf /var/lib/etcd/
sudo rm -rf /run/containerd/
sudo rm -rf /var/lib/containerd/
sudo rm -rf /etc/containerd/
sudo rm -rf /opt/cni/
sudo rm -rf /etc/cni/

重新加载systemd

sudo systemctl daemon-reload

确保内核模块已加载

echo -e “$yellow===加载必要内核模块===${reset}”
sudo modprobe overlay
sudo modprobe br_netfilter

更新sysctl设置

echo -e “$yellow===更新系统网络设置===${reset}”
sudo tee /etc/sysctl.d/kubernetes.conf > /dev/null << EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF
sudo sysctl --system

重新创建必要的目录

echo -e “$yellow===创建必要目录===${reset}”
sudo mkdir -p /var/lib/containerd/
sudo mkdir -p /run/containerd/

重新初始化containerd

echo -e “$yellow===重新初始化containerd===${reset}”
sudo containerd config default > /tmp/containerd-config.toml

修改containerd配置，使用cgroupfs驱动（兼容性更好）

echo -e “$yellow===配置containerd===${reset}”
sudo tee /etc/containerd/config.toml > /dev/null << EOF
version = 2
root = “/var/lib/containerd”
state = “/run/containerd”
plugin_dirs = []
gRPC = {
address = “/run/containerd/containerd.sock”,
uid = 0,
gid = 0
}
[ttrpc]
address = “”,
uid = 0,
gid = 0
[debug]
address = “”,
uid = 0,
gid = 0,
level = “”
[metrics]
address = “”,
grpc_histogram = false
[cgroup]
path = “”
[timeouts]
“io.containerd.timeout.shim.cleanup” = “5s”
“io.containerd.timeout.shim.load” = “5s”
“io.containerd.timeout.shim.shutdown” = “3s”
“io.containerd.timeout.task.state” = “2s”
[plugins]
[plugins.“io.containerd.gc.v1.scheduler”]
pause_threshold = 0.02
deletion_threshold = 0
mutation_threshold = 100
schedule_delay = “0s”
startup_delay = “100ms”
[plugins.“io.containerd.grpc.v1.cri”]
disable_tcp_service = true
stream_server_address = “127.0.0.1”
stream_server_port = “0”
stream_idle_timeout = “4h0m0s”
enable_selinux = false
sandbox_image = “registry.cn-hangzhou.aliyuncs.com/google_containers/pause:3.9”
stats_collect_period = 10
systemd_cgroup = false
enable_tls_streaming = false
max_container_log_line_size = 16384
disable_cgroup = false
disable_apparmor = false
restrict_oom_score_adj = false
max_concurrent_downloads = 3
max_concurrent_uploads = 5
[plugins.“io.containerd.grpc.v1.cri”.containerd]
default_runtime_name = “runc”
[plugins.“io.containerd.grpc.v1.cri”.containerd.runtimes]
[plugins.“io.containerd.grpc.v1.cri”.containerd.runtimes.runc]
runtime_type = “io.containerd.runc.v2”
runtime_engine = “”
runtime_root = “”
[plugins.“io.containerd.grpc.v1.cri”.containerd.runtimes.runc.options]
SystemdCgroup = false
[plugins.“io.containerd.grpc.v1.cri”.cni]
bin_dir = “/opt/cni/bin”
conf_dir = “/etc/cni/net.d”
max_conf_num = 1
conf_template = “”
[plugins.“io.containerd.grpc.v1.cri”.registry]
[plugins.“io.containerd.grpc.v1.cri”.registry.mirrors]
[plugins.“io.containerd.grpc.v1.cri”.registry.mirrors.“docker.io”]
endpoint = [“https://registry-1.docker.io”]
[plugins.“io.containerd.grpc.v1.cri”.registry.mirrors.“registry.cn-hangzhou.aliyuncs.com”]
endpoint = [“https://registry.cn-hangzhou.aliyuncs.com”]
[plugins.“io.containerd.internal.v1.opt”]
path = “/opt/containerd”
[plugins.“io.containerd.monitor.v1.cgroups”]
no_prometheus = false
[plugins.“io.containerd.runtime.v2.task”]
platforms = [“linux/amd64”]
[plugins.“io.containerd.service.v1.containers-service”]
rdt_config_file = “”
[plugins.“io.containerd.snapshotter.v1.btrfs”]
root_path = “/var/lib/containerd/snapshots/btrfs”
[plugins.“io.containerd.snapshotter.v1.native”]
root_path = “/var/lib/containerd/snapshots/native”
[plugins.“io.containerd.snapshotter.v1.overlayfs”]
root_path = “/var/lib/containerd/snapshots/overlayfs”
[plugins.“io.containerd.snapshotter.v1.zfs”]
root_path = “/var/lib/containerd/snapshots/zfs”
EOF

启动containerd服务

echo -e “$yellow===启动containerd服务===${reset}”
sudo systemctl start containerd
sudo systemctl enable containerd

等待containerd完全启动

sleep 10

检查containerd状态

echo -e “$yellow===检查containerd状态===${reset}”
sudo systemctl status containerd --no-pager

确保kubelet配置正确

echo -e “$yellow===配置kubelet服务===${reset}”
sudo mkdir -p /etc/systemd/system/kubelet.service.d/
sudo tee /etc/systemd/system/kubelet.service.d/10-kubeadm.conf > /dev/null << EOF
[Service]
Environment=“KUBELET_KUBECONFIG_ARGS=–bootstrap-kubeconfig=/etc/kubernetes/bootstrap-kubelet.conf --kubeconfig=/etc/kubernetes/kubelet.conf”
Environment=“KUBELET_CONFIG_ARGS=–config=/var/lib/kubelet/config.yaml”
Environment=“KUBELET_EXTRA_ARGS=–container-runtime=remote --container-runtime-endpoint=unix:///run/containerd/containerd.sock --cgroup-driver=cgroupfs”
ExecStart=
ExecStart=/usr/bin/kubelet $KUBELET_KUBECONFIG_ARGS $KUBELET_CONFIG_ARGS $KUBELET_EXTRA_ARGS
EOF

创建kubelet配置文件

sudo mkdir -p /var/lib/kubelet
sudo tee /var/lib/kubelet/config.yaml > /dev/null << EOF
apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
cgroupDriver: cgroupfs
runtimeRequestTimeout: “15m”
maxPods: 110
EOF

重启kubelet服务

sudo systemctl daemon-reload
sudo systemctl start kubelet
sudo systemctl enable kubelet

等待kubelet启动

sleep 5

预拉取Kubernetes镜像

echo -e “$yellow===预拉取Kubernetes镜像===${reset}”
kubeadm config images pull --image-repository=registry.cn-hangzhou.aliyuncs.com/google_containers --kubernetes-version=v1.28.2

创建kubeadm配置文件

echo -e “$yellow===创建kubeadm配置文件===${reset}”
sudo tee /home/user/kubeadm-config.yaml > /dev/null << EOF
apiVersion: kubeadm.k8s.io/v1beta3
kind: InitConfiguration
localAPIEndpoint:
advertiseAddress: 10.16.233.177
bindPort: 6443
nodeRegistration:
criSocket: unix:///run/containerd/containerd.sock
taints:

• effect: NoSchedule
  key: node-role.kubernetes.io/master

---

apiVersion: kubeadm.k8s.io/v1beta3
kind: ClusterConfiguration
kubernetesVersion: v1.28.2
imageRepository: registry.cn-hangzhou.aliyuncs.com/google_containers
networking:
podSubnet: 192.168.0.0/16
controlPlaneEndpoint: “10.16.233.177:6443”
controllerManager:
extraArgs:
configure-cloud-routes: “false”
scheduler:
extraArgs:
address: 0.0.0.0
EOF

执行初始化

echo -e “$yellow===执行kubeadm初始化===${reset}”
sudo kubeadm init --config=/home/user/kubeadm-config.yaml --ignore-preflight-errors=all --v=5

配置kubectl

echo -e “$yellow===配置kubectl===${reset}”
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id-u):$(id -g) $HOME/.kube/config

等待10秒让组件启动

echo -e “$yellow===等待集群组件启动...===${reset}”
sleep 10

允许主节点调度Pod

echo -e “$yellow===允许主节点调度Pod===${reset}”
kubectl taint nodes --all node-role.kubernetes.io/control-plane- node-role.kubernetes.io/master-

检查集群状态

echo -e “$yellow===检查集群状态===${reset}”
kubectl get nodes
kubectl get pods -n kube-system

检查API服务器端口

echo -e “$yellow===检查API服务器端口===${reset}”
sudo ss -tuln | grep 6443

echo -e “$green===终极修复完成===${reset}”

以下是基于 containerd 官方入门指南（Ubuntu 22.04.3 LTS x86_64 环境）拆解的 分模块、单步骤 Prompt，每个 Prompt 仅包含 1 个核心操作，避免复杂指令，方便你逐步执行并验证：

模块一：环境预处理（解决系统依赖问题）

Prompt 1：关闭 swap 并禁用防火墙

请生成 1 条命令，帮我在 Ubuntu 22.04.3 LTS 上执行以下操作：1. 临时关闭 swap；2. 永久禁用 swap（注释 /etc/fstab 中的 swap 行）；3. 停止并禁用 ufw 防火墙。

sudo swapoff -a && sudo sed -i '/swap/s/^/#/' /etc/fstab && sudo ufw disable 

Prompt 2：配置 K8s 所需内核参数

请生成脚本片段，帮我在 Ubuntu 22.04.3 LTS 上配置 K8s 必需的内核参数（开启 ip_forward、网桥过滤等），包含：1. 写入 /etc/sysctl.d/k8s.conf 文件；2. 立即加载参数使其生效。

#!/bin/bash# 创建Kubernetes必需的内核参数配置文件
echo "创建 /etc/sysctl.d/k8s.conf 文件..."
sudo tee /etc/sysctl.d/k8s.conf << EOF
# 开启IP转发
net.ipv4.ip_forward = 1
# 确保网桥流量经过iptables
net.bridge.bridge-nf-call-iptables = 1
net.bridge.bridge-nf-call-ip6tables = 1
# 开启IPv6转发
net.ipv6.conf.all.forwarding = 1
EOF# 加载内核参数设置
echo "加载内核参数配置..."
sudo sysctl --system# 验证配置是否生效
echo "验证关键内核参数配置..."
sysctl net.ipv4.ip_forward
sysctl net.bridge.bridge-nf-call-iptables
sysctl net.bridge.bridge-nf-call-ip6tables
sysctl net.ipv6.conf.all.forwardingecho "Kubernetes内核参数配置完成！"

chmod +x /home/user/setup_k8s_sysctl.sh && sudo bash /home/user/setup_k8s_sysctl.sh 

模块二：安装 containerd（按官方二进制方式，避免依赖 Docker）

Prompt 3：下载并安装 containerd 二进制包（指定版本 1.7.13，适配 K8s v1.33）

请生成步骤命令，帮我在 Ubuntu 22.04.3 LTS x86_64 环境下，按 containerd 官方指南安装 1.7.13 版本：1. 下载 containerd-1.7.13-linux-amd64.tar.gz；2. 验证压缩包完整性（可选）；3. 解压到 /usr/local；4. 查看 containerd 版本确认安装成功。

echo "=== 开始安装containerd ==="# 更新apt源并安装containerd
echo "更新apt源并安装containerd..."
sudo apt-get update
echo "安装containerd及依赖..."
sudo apt-get install -y containerd runc# 检查安装的containerd版本
echo "检查安装的containerd版本..."
containerd --version || echo "containerd可能需要重启服务才能使用"# 重新加载systemd配置
echo "重新加载systemd配置..."
sudo systemctl daemon-reload# 启动containerd服务
echo "启动containerd服务..."
sudo systemctl start containerd# 设置containerd服务自启动
echo "设置containerd服务自启动..."
sudo systemctl enable containerd# 查看containerd版本确认安装成功
echo "查看containerd版本确认安装成功..."
containerd --version
ctr version# 检查containerd服务状态
echo "检查containerd服务状态..."
sudo systemctl status containerd --no-pagerecho "=== containerd 1.7.13 安装完成！==="

Prompt 4：配置 containerd 为 systemd 服务

请生成命令，帮我完成：1. 下载 containerd 官方 systemd 服务文件（containerd.service）到 /usr/local/lib/systemd/system/；2. 重新加载 systemd 配置；3. 设置 containerd 开机自启并立即启动；4. 查看 containerd 服务状态确认运行正常。

#!/bin/bashecho "=== 开始配置containerd systemd服务 ==="# 检查当前containerd版本和安装状态
echo "检查当前containerd版本..."
if command -v containerd &> /dev/null; thencontainerd --version
elseecho "警告：未找到containerd命令，可能未正确安装"
fi# 检查当前systemd服务状态
echo "\n检查当前containerd服务状态..."
sudo systemctl status containerd.service --no-pager || echo "containerd服务可能未配置"# 检查是否已有systemd服务文件
echo "\n检查是否已有systemd服务文件..."
if [ -f "/usr/lib/systemd/system/containerd.service" ]; thenecho "系统已存在containerd.service文件（通过apt安装）"echo "文件位置: /usr/lib/systemd/system/containerd.service"echo "文件内容预览:"sudo head -n 20 /usr/lib/systemd/system/containerd.serviceSKIP_DOWNLOAD=true
elseSKIP_DOWNLOAD=false
fi# 如果没有现有服务文件，则下载官方systemd服务文件
if [ "$SKIP_DOWNLOAD" = false ]; thenecho "\n创建目录并下载containerd官方systemd服务文件..."sudo mkdir -p /usr/local/lib/systemd/system/# 使用echo直接创建服务文件内容（因为下载可能失败）echo "创建containerd.service文件..."sudo tee /usr/local/lib/systemd/system/containerd.service << EOF
[Unit]
Description=containerd container runtime
Documentation=https://containerd.io
After=network.target local-fs.target[Service]
ExecStartPre=-/sbin/modprobe overlay
ExecStartPre=-/sbin/modprobe br_netfilter
ExecStart=/usr/bin/containerd
Type=notify
Delegate=yes
KillMode=process
Restart=always
RestartSec=5
# Having non-zero Limit*s causes performance problems due to accounting overhead
# in the kernel. We recommend using cgroups to do container-local accounting.
LimitNPROC=infinity
LimitCORE=infinity
LimitNOFILE=1048576
# Comment TasksMax if your systemd version does not supports it.
# Only systemd 226 and above support this version.
TasksMax=infinity
OOMScoreAdjust=-999[Install]
WantedBy=multi-user.target
EOFecho "containerd.service文件创建成功"
fi# 重新加载systemd配置
echo "\n重新加载systemd配置..."
sudo systemctl daemon-reload# 设置containerd开机自启
echo "设置containerd开机自启..."
sudo systemctl enable containerd.service# 立即启动containerd服务
echo "立即启动containerd服务..."
sudo systemctl start containerd.service# 等待服务启动
echo "等待服务启动..."
sleep 2# 查看containerd服务状态确认运行正常
echo "\n查看containerd服务状态..."
sudo systemctl status containerd.service --no-pager# 验证containerd是否正常工作
echo "\n验证containerd是否正常工作..."
containerd --version
ctr versionecho "\n=== containerd systemd服务配置完成 ==="

Prompt 5：安装 runc（containerd 依赖的运行时）

请生成步骤命令，按 containerd 官方指南安装 runc：1. 下载 runc.amd64 二进制文件（指定版本 1.1.12，适配 containerd 1.7.13）；2. 移动到 /usr/local/sbin/runc 并赋予执行权限；3. 查看 runc 版本确认安装成功。

runc --version 

(TraeAI-7) ~ [0] $ runc --version
runc version 1.3.0-0ubuntu2~22.04.1
spec: 1.2.1
go: go1.23.1
libseccomp: 2.5.3

Prompt 6：安装 CNI 插件（containerd 网络依赖）

请生成步骤命令，按 containerd 官方指南安装 CNI 插件：1. 创建 /opt/cni/bin 目录；2. 下载 cni-plugins-linux-amd64-v1.1.1.tgz 压缩包；3. 解压到 /opt/cni/bin；4. 查看 /opt/cni/bin 下的插件文件确认安装成功。

#!/bin/bashecho "=== 开始安装 CNI 插件（使用Ubuntu官方仓库）==="# 步骤1：创建 /opt/cni/bin 目录（如果不存在）
echo "步骤1：确保 /opt/cni/bin 目录存在..."
sudo mkdir -p /opt/cni/bin
if [ $? -ne 0 ]; thenecho "错误：创建目录失败！"exit 1
fi
echo "目录检查完成：/opt/cni/bin"# 步骤2：更新apt包索引并安装CNI插件相关包
echo "步骤2：更新apt包索引..."
sudo apt update -y
if [ $? -ne 0 ]; thenecho "错误：apt更新失败！"exit 1
fiecho "步骤3：从Ubuntu官方仓库安装CNI插件..."
# 安装containernetworking-plugins包，这是Ubuntu官方提供的CNI插件包
sudo apt install -y containernetworking-plugins
if [ $? -ne 0 ]; thenecho "错误：安装CNI插件包失败！尝试其他方法..."# 备选方案：安装kubernetes-cni包（如果可用）echo "尝试安装kubernetes-cni包..."sudo apt install -y kubernetes-cniif [ $? -ne 0 ]; thenecho "错误：所有apt包安装失败！"exit 1fi
fi# 步骤4：确保CNI插件文件在正确位置
echo "步骤4：确保CNI插件文件位于正确位置..."# 检查常见的CNI插件安装路径
CNI_PATHS=("/usr/lib/cni" "/usr/libexec/cni" "/opt/cni/bin")
CNI_FOUND=falsefor path in "${CNI_PATHS[@]}"; doif [ -d "$path" ] && [ "$(ls -A $path 2>/dev/null)" ]; thenecho "发现CNI插件目录：$path"# 如果插件不在/opt/cni/bin，复制或链接过去if [ "$path" != "/opt/cni/bin" ]; thenecho "复制插件到 /opt/cni/bin..."sudo cp -a "$path"/* /opt/cni/bin/fiCNI_FOUND=truebreakfi
doneif [ "$CNI_FOUND" = false ]; thenecho "警告：未找到已安装的CNI插件，尝试查找系统中的CNI插件..."# 使用find命令查找可能的CNI插件CNI_PLUGINS=$(sudo find /usr -name "bridge" -o -name "host-local" -o -name "loopback" 2>/dev/null)if [ -n "$CNI_PLUGINS" ]; thenecho "找到一些可能的CNI插件，复制到 /opt/cni/bin..."for plugin in $CNI_PLUGINS; doplugin_dir=$(dirname "$plugin")sudo cp -a "$plugin_dir"/* /opt/cni/bin/breakdoneelseecho "警告：无法确定CNI插件位置，请检查手动安装"fi
fi# 步骤5：查看 /opt/cni/bin 下的插件文件确认安装成功
echo ""
echo "步骤5：验证 CNI 插件安装..."
echo "=== /opt/cni/bin 目录下的插件列表：==="
sudo ls -la /opt/cni/bin/# 检查关键插件是否存在
KEY_PLUGINS=("bridge" "host-local" "loopback")
INSTALLATION_SUCCESS=truefor plugin in "${KEY_PLUGINS[@]}"; doif [ ! -f "/opt/cni/bin/$plugin" ]; thenecho "警告：核心插件 $plugin 不存在！"INSTALLATION_SUCCESS=falseelseecho "✓ 找到核心插件：$plugin"fi
doneecho ""
echo "=== CNI 插件安装验证完成 ==="
if [ "$INSTALLATION_SUCCESS" = true ]; thenecho "✅ CNI 插件（通过Ubuntu官方仓库）安装成功！"echo "📁 CNI插件位置：/opt/cni/bin"echo "📊 已验证的核心插件：${KEY_PLUGINS[*]}"
elseecho "⚠️ CNI 插件安装可能不完整，请检查。"echo "提示：您可以尝试手动下载并安装特定版本。"
fiecho ""
echo "=== CNI 插件安装脚本执行完成 ==="

sudo bash /home/user/install_cni_plugins.sh 

模块三：配置 containerd（适配 cgroup v2 与 K8s）

Prompt 7：生成 containerd 配置文件并适配 cgroup v2

请生成命令，帮我：1. 生成 containerd 默认配置文件到 /etc/containerd/config.toml；2. 修改配置文件，将 SystemdCgroup 设为 true（适配 cgroup v2）；3. 将 sandbox_image 改为阿里云镜像（registry.aliyuncs.com/google_containers/pause:3.9）；4. 重启 containerd 使配置生效。

#!/bin/bashecho "=== 开始配置 containerd ==="# 步骤1：生成 containerd 默认配置文件
echo "步骤1：生成 containerd 默认配置文件..."
sudo mkdir -p /etc/containerd
sudo containerd config default > /etc/containerd/config.toml
if [ $? -ne 0 ]; thenecho "错误：生成默认配置文件失败！"exit 1
fi
echo "✓ 默认配置文件已生成到 /etc/containerd/config.toml"# 步骤2：修改配置文件，将 SystemdCgroup 设为 true
echo "步骤2：修改配置文件，启用 SystemdCgroup..."
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml
if [ $? -ne 0 ]; thenecho "警告：修改 SystemdCgroup 配置失败，尝试使用其他方式..."# 备选方法：直接添加配置sudo sed -i '/\[plugins.\"io.containerd.grpc.v1.cri\"\]/,/\[plugins.\"io.containerd.grpc.v1.cri\".containerd.runtimes.runc.options\]/ s/\[plugins.\"io.containerd.grpc.v1.cri\".containerd.runtimes.runc.options\]/\[plugins.\"io.containerd.grpc.v1.cri\".containerd.runtimes.runc.options\]\n  SystemdCgroup = true/' /etc/containerd/config.toml
fiecho "✓ SystemdCgroup 已设置为 true"# 步骤3：修改 sandbox_image 为华为云镜像
echo "步骤3：修改 sandbox_image 为华为云镜像..."
NEW_SANDBOX_IMAGE="swr.cn-north-4.myhuaweicloud.com/ddn-k8s/registry.k8s.io/pause:3.9-linuxarm64"
sudo sed -i "s#sandbox_image = \"registry.k8s.io/pause:.*\"#sandbox_image = \"$NEW_SANDBOX_IMAGE\"#" /etc/containerd/config.toml
if [ $? -ne 0 ]; thenecho "警告：修改 sandbox_image 失败，尝试使用其他方式..."# 备选方法：直接添加配置sudo sed -i '/\[plugins.\"io.containerd.grpc.v1.cri\"\]/a sandbox_image = "'$NEW_SANDBOX_IMAGE'"' /etc/containerd/config.toml
fiecho "✓ sandbox_image 已修改为华为云镜像"# 显示修改后的关键配置
echo "\n=== 修改后的关键配置检查 ==="
echo "SystemdCgroup 配置："
grep -A 5 "runc.options" /etc/containerd/config.tomlecho "\nsandbox_image 配置："
grep "sandbox_image" /etc/containerd/config.toml# 步骤4：重启 containerd 使配置生效
echo "\n步骤4：重启 containerd 服务..."
sudo systemctl restart containerd
if [ $? -ne 0 ]; thenecho "错误：重启 containerd 服务失败！"exit 1
fiecho "✓ containerd 服务已重启"# 检查服务状态
echo "\n=== containerd 服务状态 ==="
sudo systemctl status containerd --no-pager | grep Active
echo "\n✓ 配置完成，请验证服务是否正常运行"echo "\n=== containerd 配置脚本执行完成 ==="

Prompt 8：验证 containerd 可用性（拉取测试镜像）

请生成命令，帮我验证 containerd 是否正常工作：1. 使用 ctr 命令拉取 nginx:alpine 镜像；2. 查看已拉取的镜像列表；3. 运行一个 nginx 测试容器（命名为 test-nginx）；4. 查看容器运行状态确认启动成功；5. 停止并删除测试容器（避免占用资源）。

#!/bin/bashecho "=== 开始验证 containerd 功能 ==="# 步骤1：拉取 nginx:alpine 镜像（使用适合x86_64架构的版本）
echo "\n步骤1：拉取 nginx:alpine3.22-slim 镜像..."
sudo ctr images pull swr.cn-north-4.myhuaweicloud.com/ddn-k8s/docker.io/nginx:alpine3.22-slim
if [ $? -ne 0 ]; thenecho "错误：拉取 nginx:alpine 镜像失败！"exit 1
fi
echo "✓ 镜像拉取成功"# 步骤2：查看已拉取的镜像列表
echo "\n步骤2：查看已拉取的镜像列表..."
echo "=== 已拉取的镜像列表：==="
sudo ctr images list
if [ $? -ne 0 ]; thenecho "错误：查看镜像列表失败！"exit 1
fi# 验证镜像是否存在
sudo ctr images list | grep swr.cn-north-4.myhuaweicloud.com/ddn-k8s/docker.io/nginx:alpine3.22-slim > /dev/null
if [ $? -ne 0 ]; thenecho "错误：镜像未在列表中找到！"exit 1
fi
echo "✓ 镜像列表查看成功"# 步骤3：运行 nginx 测试容器
echo "\n步骤3：运行 nginx 测试容器..."
sudo ctr container create swr.cn-north-4.myhuaweicloud.com/ddn-k8s/docker.io/nginx:alpine3.22-slim test-nginx
sudo ctr task start -d test-nginx
if [ $? -ne 0 ]; thenecho "错误：启动测试容器失败！"# 尝试清理容器sudo ctr container delete test-nginx 2>/dev/nullexit 1
fi
echo "✓ 容器启动成功"# 步骤4：查看容器运行状态
echo "\n步骤4：查看容器运行状态..."
echo "=== 容器运行状态：==="
sudo ctr task ls | grep test-nginx
if [ $? -ne 0 ]; thenecho "错误：未找到 test-nginx 容器任务！"# 尝试清理容器sudo ctr task delete -f test-nginx 2>/dev/nullsudo ctr container delete test-nginx 2>/dev/nullexit 1
fi# 检查容器状态
task_status=$(sudo ctr task ls | grep test-nginx | awk '{print $3}')
if [ "$task_status" = "RUNNING" ]; thenecho "✓ 容器正在正常运行"
elif [ "$task_status" = "STOPPED" ]; thenecho "警告：容器已停止，可能由于镜像架构不匹配或其他原因启动失败"echo "提示：尝试使用其他适合当前系统架构的镜像"
elseecho "警告：容器状态未知: $task_status"
fi# 步骤5：停止并删除测试容器
echo "\n步骤5：清理测试容器..."
echo "停止容器..."
sudo ctr task delete -f test-nginx
if [ $? -ne 0 ]; thenecho "警告：停止容器时出现问题！"
fiecho "删除容器..."
sudo ctr container delete test-nginx
if [ $? -ne 0 ]; thenecho "警告：删除容器时出现问题！"
fiecho "✓ 测试容器已清理"# 最终验证 - 确保容器已被删除
sudo ctr container ls | grep test-nginx > /dev/null
if [ $? -eq 0 ]; thenecho "警告：容器似乎未被完全删除！"
elseecho "✓ 容器已成功删除"
fiecho "\n=== containerd 功能验证完成 ==="
echo "✅ containerd 服务运行正常，可以正常拉取镜像和管理容器"

模块四：安装 K8s v1.33 组件

Prompt 9：添加 K8s 官方 apt 源并安装组件

请生成步骤命令，帮我在 Ubuntu 22.04.3 LTS 上安装 K8s v1.33 组件（kubeadm、kubelet、kubectl）：1. 添加 K8s 官方 GPG 密钥；2. 添加 K8s v1.33 的 apt 源；3. 更新 apt 缓存；4. 安装指定版本的 kubeadm=1.33.5-00、kubelet=1.33.5-00、kubectl=1.33.5-00；5. 锁定 K8s 组件版本避免自动更新。

#!/bin/bashset -e
echo "=== 开始卸载旧版Kubernetes并安装K8s v1.33 ==="# 第一部分：彻底卸载现有Kubernetes和Minikube# 1. 停止Kubernetes服务
echo "\n=== 停止Kubernetes服务 ==="
sudo systemctl stop kubelet || true
sudo systemctl disable kubelet || true
sudo systemctl stop docker containerd || true# 2. 卸载Kubernetes组件
echo "\n=== 卸载Kubernetes组件 ==="
sudo apt-get purge -y --allow-change-held-packages kubeadm kubectl kubelet kubernetes-cni || true
sudo apt-get autoremove -y --allow-change-held-packages --purge kubeadm kubectl kubelet kubernetes-cni || true# 3. 卸载Minikube
echo "\n=== 卸载Minikube ==="
if command -v minikube &> /dev/null; thenminikube delete || truesudo rm -f /usr/local/bin/minikube
fi# 4. 清理残留文件
echo "\n=== 清理残留文件 ==="
sudo rm -rf /etc/kubernetes/ /var/lib/kubelet/ /var/lib/etcd/ /var/lib/cni/ /etc/cni/ /opt/cni/ /run/calico/ /var/lib/minikube/
sudo rm -rf ~/.kube/ ~/.minikube/
sudo rm -f /etc/apt/sources.list.d/kubernetes.list# 5. 清理iptables规则
echo "\n=== 清理iptables规则 ==="
sudo iptables -F
sudo iptables -X
sudo iptables -Z
sudo ip6tables -F
sudo ip6tables -X
sudo ip6tables -Z# 6. 清理路由缓存
echo "\n=== 清理路由缓存 ==="
sudo ip route flush cache# 7. 重新加载systemd
sudo systemctl daemon-reload# 第二部分：安装Kubernetes v1.33组件echo "\n=== 开始安装Kubernetes v1.33 ==="# 1. 添加K8s官方GPG密钥
echo "\n步骤1：添加K8s官方GPG密钥..."
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.33/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
if [ $? -ne 0 ]; thenecho "错误：添加GPG密钥失败！"exit 1
fi
echo "✓ GPG密钥添加成功"# 2. 添加K8s v1.33的apt源
echo "\n步骤2：添加K8s v1.33的apt源..."
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.33/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list
if [ $? -ne 0 ]; thenecho "错误：添加apt源失败！"exit 1
fi
echo "✓ apt源添加成功"# 3. 更新apt缓存
echo "\n步骤3：更新apt缓存..."
sudo apt-get update
if [ $? -ne 0 ]; thenecho "错误：更新apt缓存失败！"exit 1
fi
echo "✓ apt缓存更新成功"# 4. 检查并安装K8s v1.33组件
echo "\n步骤4：检查可用的K8s v1.33版本..."
sudo apt-cache policy kubeadm | grep -A 20 "Candidate"echo "\n步骤5：安装K8s v1.33组件..."
sudo apt-get install -y --allow-change-held-packages kubeadm kubelet kubectl
if [ $? -ne 0 ]; thenecho "错误：安装K8s组件失败！"exit 1
fi
echo "✓ K8s组件安装成功"# 显示已安装的版本
echo "\n已安装的K8s组件版本："
kubeadm version | grep "GitVersion"
kubelet --version
kubectl version --client | grep "GitVersion"# 6. 锁定K8s组件版本避免自动更新
echo "\n步骤6：锁定K8s组件版本..."
sudo apt-mark hold kubeadm kubelet kubectl
if [ $? -ne 0 ]; thenecho "错误：锁定K8s组件版本失败！"exit 1
fi
echo "✓ K8s组件版本锁定成功"# 启动kubelet服务
echo "\n=== 启动kubelet服务 ==="
sudo systemctl enable kubelet || true
sudo systemctl start kubelet || true
echo "注意：kubelet服务可能会在初始化前显示警告，这是正常的"# 验证安装结果
echo "\n=== 验证K8s组件版本 ==="
kubeadm version || true
kubectl version --client || true
kubelet --version || trueecho "\n=== Kubernetes v1.33 安装完成 ==="
echo "✅ 所有Kubernetes组件已成功安装并锁定版本"
echo "✅ 下一步可以使用 'sudo kubeadm init' 初始化Kubernetes集群"
echo "=== 注意：如需在单节点上运行，请在初始化后使用 'kubectl taint nodes --all node-role.kubernetes.io/control-plane-' 移除污点 ==="

Prompt 10：配置 kubelet 适配 containerd（cgroup 驱动一致）

请生成命令，帮我：1. 创建 /etc/systemd/system/kubelet.service.d/10-kubeadm.conf 文件；2. 在文件中添加 Environment="KUBELET_CGROUP_ARGS=--cgroup-driver=systemd"（与 containerd 一致）；3. 重新加载 systemd 配置并重启 kubelet；4. 查看 kubelet 状态确认运行正常。

#!/bin/bashset -e
echo "=== 开始配置 kubelet cgroup 驱动适配 containerd ==="# 1. 创建必要的目录结构
echo "\n步骤1：创建 kubelet 配置目录..."
sudo mkdir -p /etc/systemd/system/kubelet.service.d/
if [ $? -ne 0 ]; thenecho "错误：创建目录失败！"exit 1
fi
echo "✓ 目录创建成功"# 2. 创建 kubelet 配置文件
echo "\n步骤2：创建 kubelet cgroup 配置文件..."
cat << EOF | sudo tee /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
[Service]
Environment="KUBELET_CGROUP_ARGS=--cgroup-driver=systemd"
EOFif [ $? -ne 0 ]; thenecho "错误：创建配置文件失败！"exit 1
fi
echo "✓ 配置文件创建成功"# 验证配置文件内容
echo "\n配置文件内容："
sudo cat /etc/systemd/system/kubelet.service.d/10-kubeadm.conf# 3. 重新加载 systemd 配置
echo "\n步骤3：重新加载 systemd 配置..."
sudo systemctl daemon-reload
if [ $? -ne 0 ]; thenecho "错误：重新加载 systemd 配置失败！"exit 1
fi
echo "✓ systemd 配置重新加载成功"# 4. 重启 kubelet 服务
echo "\n步骤4：重启 kubelet 服务..."
sudo systemctl restart kubelet
if [ $? -ne 0 ]; thenecho "警告：重启 kubelet 服务失败，但这在集群初始化前可能是正常的"
elseecho "✓ kubelet 服务重启成功"
fi# 5. 检查 kubelet 服务状态
echo "\n步骤5：检查 kubelet 服务状态..."
echo "=== kubelet 服务状态信息：==="
sudo systemctl status kubelet --no-pager# 6. 验证 cgroup 驱动配置是否生效
echo "\n步骤6：验证 kubelet cgroup 驱动配置..."# 查看 kubelet 进程命令行参数
echo "kubelet 进程命令行参数："
sudo systemctl show kubelet.service -p ExecStart | grep -o 'ExecStart=.*'# 检查环境变量是否已设置
echo "\n检查环境变量设置："
grep -r "KUBELET_CGROUP_ARGS" /etc/systemd/system/kubelet.service.d/# 验证 containerd 的 cgroup 驱动配置
echo "\n验证 containerd 的 cgroup 驱动配置："
sudo ctr version || echo "containerd 命令不可用"
if [ -f /etc/containerd/config.toml ]; thenecho "containerd 配置文件中的 cgroup 驱动："grep SystemdCgroup /etc/containerd/config.toml || echo "未在 containerd 配置文件中找到 cgroup 驱动设置"
elseecho "/etc/containerd/config.toml 文件不存在"
fiecho "✅ kubelet cgroup 驱动配置已添加：--cgroup-driver=systemd"
echo "配置将在 Kubernetes 集群初始化时完全生效"echo "\n=== kubelet cgroup 驱动配置完成 ==="
echo "注意：在 Kubernetes 集群初始化前，kubelet 服务可能会显示一些警告，这是正常的"
echo "初始化集群后，kubelet 服务将正常运行并使用 systemd 作为 cgroup 驱动"

sudo bash /home/user/configure_kubelet_cgroup.sh 

模块五：初始化 K8s 集群并验证

Prompt 11：初始化 K8s 控制平面（指定参数）

请生成 kubeadm init 命令，帮我初始化 K8s 集群，需包含：1. apiserver-advertise-address=10.16.233.177（我的服务器 IP）；2. pod-network-cidr=192.168.0.0/16；3. image-repository=registry.aliyuncs.com/google_containers（避免镜像拉取失败）；4. 记录初始化成功后的 kubectl 配置命令（供后续使用）。

#!/bin/bashset -e
echo "=== 开始初始化 Kubernetes 控制平面 ==="# 设置参数
SERVER_IP="10.16.233.177"
POD_CIDR="192.168.0.0/16"
IMAGE_REPO="registry.aliyuncs.com/google_containers"# 显示参数配置
echo "\n配置参数："
echo "- API Server 广告地址: $SERVER_IP"
echo "- Pod 网络 CIDR: $POD_CIDR"
echo "- 镜像仓库: $IMAGE_REPO"# 检查必要的组件
echo "\n检查必要组件..."
command -v kubeadm >/dev/null 2>&1 || { echo "错误：kubeadm 未安装！" >&2; exit 1; }
command -v kubectl >/dev/null 2>&1 || { echo "错误：kubectl 未安装！" >&2; exit 1; }
command -v kubelet >/dev/null 2>&1 || { echo "错误：kubelet 未安装！" >&2; exit 1; }# 检查 kubelet 服务状态
echo "\n检查 kubelet 服务状态..."
sudo systemctl is-active kubelet || echo "警告：kubelet 服务未激活，初始化过程中会自动启动"# 初始化命令
echo "\n执行 kubeadm init 命令..."
INIT_CMD="sudo kubeadm init \\--apiserver-advertise-address=$SERVER_IP \\--pod-network-cidr=$POD_CIDR \\--image-repository=$IMAGE_REPO"echo "\n执行以下命令初始化集群："
echo "$INIT_CMD"# 执行初始化
$INIT_CMD# 保存配置命令到文件
echo "\n保存 kubectl 配置命令..."
cat << 'EOF' > ~/kubectl_config_commands.sh
#!/bin/bash# kubectl 配置命令
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/configecho "kubectl 配置完成，现在可以使用 kubectl 命令管理集群"
EOFchmod +x ~/kubectl_config_commands.shecho "\n=== kubectl 配置命令已保存到 ~/kubectl_config_commands.sh ==="
echo "初始化成功后，请执行：bash ~/kubectl_config_commands.sh"
echo "\n=== 控制平面初始化命令生成完成 ==="

Prompt 12：配置 kubectl 客户端（普通用户权限）

请生成命令，帮我：1. 按 kubeadm init 成功后的提示，配置 kubectl （复制 /etc/kubernetes/admin.conf 到 ~/.kube/config）；2. 赋予配置文件正确权限；3. 执行 kubectl version 确认客户端与服务端连接正常。

Prompt 13：安装 Calico 网络插件（使节点 Ready）

请生成命令，帮我安装 Calico 网络插件（适配 pod-network-cidr=192.168.0.0/16）：1. 应用 Calico 官方 yaml 文件；2. 查看 Calico Pod 状态确认全部 Running；3. 等待 2-3 分钟后，执行 kubectl get nodes 确认节点状态为 Ready。

Prompt 14：验证 K8s 控制平面组件状态

请生成命令，帮我验证 K8s 核心组件是否正常：1. 查看 /etc/kubernetes/manifests/ 下的静态 Pod 配置文件是否存在；2. 执行 kubectl get pods -n kube-system，确认 kube-apiserver、kube-controller-manager、kube-scheduler、etcd 均为 Running 状态；3. 执行 kubectl get svc 确认 kubernetes 服务正常。

每个 Prompt 执行后，建议先通过 echo $? 查看命令返回值（0 为成功），或通过 systemctl status xxx/ctr xxx/kubectl xxx 确认步骤结果，再执行下一个 Prompt，避免因前序步骤失败导致后续问题。

1. 关于 netstat: command not found：安装工具包即可

Ubuntu 22.04 默认未预装 netstat（属于 net-tools 工具包），可通过以下命令快速安装，后续就能正常检查端口：

# 安装 net-tools（包含 netstat）
sudo apt update && sudo apt install -y net-tools# 验证安装
sudo netstat -tulpn | grep -E '6443|10250|10257|10259' || echo "端口未占用，正常"

2. 为什么只有 containerd 显示“active (running)”，kubelet 没有？

核心原因：kubeadm reset 会自动停止 kubelet 服务，且重置后不会自动启动，导致 kubelet 处于“非运行状态”。

验证 kubelet 当前状态

先执行命令查看 kubelet 的具体状态：

sudo systemctl status kubelet --no-pager

预期输出（类似）：

● kubelet.service - kubelet: The Kubernetes Node AgentLoaded: loaded (/lib/systemd/system/kubelet.service; enabled; vendor preset: enabled)Active: inactive (dead) since Tue 2025-10-28 17:52:30 CST; 5min ago  # 处于停止状态Docs: https://kubernetes.io/docs/home/Process: 3045503 ExecStart=/usr/bin/kubelet $KUBELET_KUBECONFIG_ARGS $KUBELET_CONFIG_ARGS $KUBELET_KUBEADM_ARGS $KUBELET_EXTRA_ARGS (code=exited, status=0/SUCCESS)Main PID: 3045503 (code=exited, status=0/SUCCESS)

解决：手动启动 kubelet 即可

初始化前需要确保 kubelet 运行（否则无法启动控制平面组件），执行以下命令：

# 启动 kubelet 并设置开机自启
sudo systemctl start kubelet
sudo systemctl enable kubelet# 再次验证状态（此时应显示 active (running)）
sudo systemctl status kubelet --no-pager | grep "active (running)"

3. 确认所有准备工作完成（再检查一次）

# 1. 确认 sandbox 镜像配置正确
grep "sandbox_image" /etc/containerd/config.toml && \
sudo crictl --runtime-endpoint unix:///var/run/containerd/containerd.sock info | grep "sandboxImage"# 2. 确认关键端口未占用（安装 net-tools 后）
sudo netstat -tulpn | grep -E '6443|10250|10257|10259' || echo "端口未占用，正常"# 3. 确认 containerd 和 kubelet 均运行
sudo systemctl status containerd --no-pager | grep "active (running)" && \
sudo systemctl status kubelet --no-pager | grep "active (running)"

所有输出符合以下标准，即可执行初始化：

• 步骤1：两个命令均显示 registry.aliyuncs.com/google_containers/pause:3.10；
• 步骤2：无端口占用输出（或提示“端口未占用”）；
• 步骤3：两个服务均显示“active (running)”。