K8S 安装 部署 文档

victory04312025-10-29 8:38

文章目录

bash 复制代码 
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 ( i d − u ) : (id -u): (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 ( i d − u ) : (id -u): (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 " g r e e n = = = 开始终极清理和重新安装 = = = {green}=== 开始终极清理和重新安装 === green===开始终极清理和重新安装==={reset}"

停止所有服务

echo -e " y e l l o w = = = 停止所有相关服务 = = = {yellow}=== 停止所有相关服务 === 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 " y e l l o w = = = 彻底清理所有相关文件 = = = {yellow}=== 彻底清理所有相关文件 === 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 " y e l l o w = = = 加载必要内核模块 = = = {yellow}=== 加载必要内核模块 === yellow===加载必要内核模块==={reset}"

sudo modprobe overlay

sudo modprobe br_netfilter

更新sysctl设置

echo -e " y e l l o w = = = 更新系统网络设置 = = = {yellow}=== 更新系统网络设置 === 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 " y e l l o w = = = 创建必要目录 = = = {yellow}=== 创建必要目录 === yellow===创建必要目录==={reset}"

sudo mkdir -p /var/lib/containerd/

sudo mkdir -p /run/containerd/

重新初始化containerd

echo -e " y e l l o w = = = 重新初始化 c o n t a i n e r d = = = {yellow}=== 重新初始化containerd === yellow===重新初始化containerd==={reset}"

sudo containerd config default > /tmp/containerd-config.toml

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

echo -e " y e l l o w = = = 配置 c o n t a i n e r d = = = {yellow}=== 配置containerd === 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 " y e l l o w = = = 启动 c o n t a i n e r d 服务 = = = {yellow}=== 启动containerd服务 === yellow===启动containerd服务==={reset}"

sudo systemctl start containerd

sudo systemctl enable containerd

等待containerd完全启动

sleep 10

检查containerd状态

echo -e " y e l l o w = = = 检查 c o n t a i n e r d 状态 = = = {yellow}=== 检查containerd状态 === yellow===检查containerd状态==={reset}"

sudo systemctl status containerd --no-pager

确保kubelet配置正确

echo -e " y e l l o w = = = 配置 k u b e l e t 服务 = = = {yellow}=== 配置kubelet服务 === 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 " y e l l o w = = = 预拉取 K u b e r n e t e s 镜像 = = = {yellow}=== 预拉取Kubernetes镜像 === yellow===预拉取Kubernetes镜像==={reset}"

kubeadm config images pull --image-repository=registry.cn-hangzhou.aliyuncs.com/google_containers --kubernetes-version=v1.28.2

创建kubeadm配置文件

echo -e " y e l l o w = = = 创建 k u b e a d m 配置文件 = = = {yellow}=== 创建kubeadm配置文件 === 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:

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 " y e l l o w = = = 执行 k u b e a d m 初始化 = = = {yellow}=== 执行kubeadm初始化 === yellow===执行kubeadm初始化==={reset}"

sudo kubeadm init --config=/home/user/kubeadm-config.yaml --ignore-preflight-errors=all --v=5

配置kubectl

echo -e " y e l l o w = = = 配置 k u b e c t l = = = {yellow}=== 配置kubectl === yellow===配置kubectl==={reset}"

mkdir -p $HOME/.kube

sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

sudo chown ( i d − u ) : (id -u): (id−u):(id -g) $HOME/.kube/config

等待10秒让组件启动

echo -e " y e l l o w = = = 等待集群组件启动 . . . = = = {yellow}=== 等待集群组件启动... === yellow===等待集群组件启动...==={reset}"

sleep 10

允许主节点调度Pod

echo -e " y e l l o w = = = 允许主节点调度 P o d = = = {yellow}=== 允许主节点调度Pod === yellow===允许主节点调度Pod==={reset}"

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

检查集群状态

echo -e " y e l l o w = = = 检查集群状态 = = = {yellow}=== 检查集群状态 === yellow===检查集群状态==={reset}"

kubectl get nodes

kubectl get pods -n kube-system

检查API服务器端口

echo -e " y e l l o w = = = 检查 A P I 服务器端口 = = = {yellow}=== 检查API服务器端口 === yellow===检查API服务器端口==={reset}"

sudo ss -tuln | grep 6443

echo -e " g r e e n = = = 终极修复完成 = = = {green}=== 终极修复完成 === 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 防火墙。
bash 复制代码 
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. 立即加载参数使其生效。
bash 复制代码 
#!/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.forwarding

echo "Kubernetes内核参数配置完成！"
bash 复制代码 
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 版本确认安装成功。
bash 复制代码 
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-pager

echo "=== containerd 1.7.13 安装完成！==="
Prompt 4：配置 containerd 为 systemd 服务
复制代码 
请生成命令，帮我完成：1. 下载 containerd 官方 systemd 服务文件（containerd.service）到 /usr/local/lib/systemd/system/；2. 重新加载 systemd 配置；3. 设置 containerd 开机自启并立即启动；4. 查看 containerd 服务状态确认运行正常。
bash 复制代码 
#!/bin/bash

echo "=== 开始配置containerd systemd服务 ==="

# 检查当前containerd版本和安装状态
echo "检查当前containerd版本..."
if command -v containerd &> /dev/null; then
  containerd --version
else
  echo "警告：未找到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" ]; then
  echo "系统已存在containerd.service文件（通过apt安装）"
  echo "文件位置: /usr/lib/systemd/system/containerd.service"
  echo "文件内容预览:"
  sudo head -n 20 /usr/lib/systemd/system/containerd.service
  SKIP_DOWNLOAD=true
else
  SKIP_DOWNLOAD=false
fi

# 如果没有现有服务文件，则下载官方systemd服务文件
if [ "$SKIP_DOWNLOAD" = false ]; then
  echo "\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
EOF
  
  echo "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 version

echo "\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 版本确认安装成功。
bash 复制代码 
runc --version
bash 复制代码 
(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 下的插件文件确认安装成功。
bash 复制代码 
#!/bin/bash

echo "=== 开始安装 CNI 插件（使用Ubuntu官方仓库）==="

# 步骤1：创建 /opt/cni/bin 目录（如果不存在）
echo "步骤1：确保 /opt/cni/bin 目录存在..."
sudo mkdir -p /opt/cni/bin
if [ $? -ne 0 ]; then
    echo "错误：创建目录失败！"
    exit 1
fi
echo "目录检查完成：/opt/cni/bin"

# 步骤2：更新apt包索引并安装CNI插件相关包
echo "步骤2：更新apt包索引..."
sudo apt update -y
if [ $? -ne 0 ]; then
    echo "错误：apt更新失败！"
    exit 1
fi

echo "步骤3：从Ubuntu官方仓库安装CNI插件..."
# 安装containernetworking-plugins包，这是Ubuntu官方提供的CNI插件包
sudo apt install -y containernetworking-plugins
if [ $? -ne 0 ]; then
    echo "错误：安装CNI插件包失败！尝试其他方法..."
    
    # 备选方案：安装kubernetes-cni包（如果可用）
    echo "尝试安装kubernetes-cni包..."
    sudo apt install -y kubernetes-cni
    if [ $? -ne 0 ]; then
        echo "错误：所有apt包安装失败！"
        exit 1
    fi
fi

# 步骤4：确保CNI插件文件在正确位置
echo "步骤4：确保CNI插件文件位于正确位置..."

# 检查常见的CNI插件安装路径
CNI_PATHS=("/usr/lib/cni" "/usr/libexec/cni" "/opt/cni/bin")
CNI_FOUND=false

for path in "${CNI_PATHS[@]}"; do
    if [ -d "$path" ] && [ "$(ls -A $path 2>/dev/null)" ]; then
        echo "发现CNI插件目录：$path"
        # 如果插件不在/opt/cni/bin，复制或链接过去
        if [ "$path" != "/opt/cni/bin" ]; then
            echo "复制插件到 /opt/cni/bin..."
            sudo cp -a "$path"/* /opt/cni/bin/
        fi
        CNI_FOUND=true
        break
    fi
done

if [ "$CNI_FOUND" = false ]; then
    echo "警告：未找到已安装的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" ]; then
        echo "找到一些可能的CNI插件，复制到 /opt/cni/bin..."
        for plugin in $CNI_PLUGINS; do
            plugin_dir=$(dirname "$plugin")
            sudo cp -a "$plugin_dir"/* /opt/cni/bin/
            break
        done
    else
        echo "警告：无法确定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=true

for plugin in "${KEY_PLUGINS[@]}"; do
    if [ ! -f "/opt/cni/bin/$plugin" ]; then
        echo "警告：核心插件 $plugin 不存在！"
        INSTALLATION_SUCCESS=false
    else
        echo "✓ 找到核心插件：$plugin"
    fi
done

echo ""
echo "=== CNI 插件安装验证完成 ==="
if [ "$INSTALLATION_SUCCESS" = true ]; then
    echo "✅ CNI 插件（通过Ubuntu官方仓库）安装成功！"
    echo "📁 CNI插件位置：/opt/cni/bin"
    echo "📊 已验证的核心插件：${KEY_PLUGINS[*]}"
else
    echo "⚠️ CNI 插件安装可能不完整，请检查。"
    echo "提示：您可以尝试手动下载并安装特定版本。"
fi

echo ""
echo "=== CNI 插件安装脚本执行完成 ==="
bash 复制代码 
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 使配置生效。
bash 复制代码 
#!/bin/bash

echo "=== 开始配置 containerd ==="

# 步骤1：生成 containerd 默认配置文件
echo "步骤1：生成 containerd 默认配置文件..."
sudo mkdir -p /etc/containerd
sudo containerd config default > /etc/containerd/config.toml
if [ $? -ne 0 ]; then
    echo "错误：生成默认配置文件失败！"
    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 ]; then
    echo "警告：修改 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
fi

echo "✓ 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 ]; then
    echo "警告：修改 sandbox_image 失败，尝试使用其他方式..."
    # 备选方法：直接添加配置
    sudo sed -i '/\[plugins.\"io.containerd.grpc.v1.cri\"\]/a sandbox_image = "'$NEW_SANDBOX_IMAGE'"' /etc/containerd/config.toml
fi

echo "✓ sandbox_image 已修改为华为云镜像"

# 显示修改后的关键配置
echo "\n=== 修改后的关键配置检查 ==="
echo "SystemdCgroup 配置："
grep -A 5 "runc.options" /etc/containerd/config.toml

echo "\nsandbox_image 配置："
grep "sandbox_image" /etc/containerd/config.toml

# 步骤4：重启 containerd 使配置生效
echo "\n步骤4：重启 containerd 服务..."
sudo systemctl restart containerd
if [ $? -ne 0 ]; then
    echo "错误：重启 containerd 服务失败！"
    exit 1
fi

echo "✓ 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. 停止并删除测试容器（避免占用资源）。
bash 复制代码 
#!/bin/bash

echo "=== 开始验证 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 ]; then
    echo "错误：拉取 nginx:alpine 镜像失败！"
    exit 1
fi
echo "✓ 镜像拉取成功"

# 步骤2：查看已拉取的镜像列表
echo "\n步骤2：查看已拉取的镜像列表..."
echo "=== 已拉取的镜像列表：==="
sudo ctr images list
if [ $? -ne 0 ]; then
    echo "错误：查看镜像列表失败！"
    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 ]; then
    echo "错误：镜像未在列表中找到！"
    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 ]; then
    echo "错误：启动测试容器失败！"
    # 尝试清理容器
    sudo ctr container delete test-nginx 2>/dev/null
    exit 1
fi
echo "✓ 容器启动成功"

# 步骤4：查看容器运行状态
echo "\n步骤4：查看容器运行状态..."
echo "=== 容器运行状态：==="
sudo ctr task ls | grep test-nginx
if [ $? -ne 0 ]; then
    echo "错误：未找到 test-nginx 容器任务！"
    # 尝试清理容器
    sudo ctr task delete -f test-nginx 2>/dev/null
    sudo ctr container delete test-nginx 2>/dev/null
    exit 1
fi

# 检查容器状态
task_status=$(sudo ctr task ls | grep test-nginx | awk '{print $3}')
if [ "$task_status" = "RUNNING" ]; then
    echo "✓ 容器正在正常运行"
elif [ "$task_status" = "STOPPED" ]; then
    echo "警告：容器已停止，可能由于镜像架构不匹配或其他原因启动失败"
    echo "提示：尝试使用其他适合当前系统架构的镜像"
else
    echo "警告：容器状态未知: $task_status"
fi

# 步骤5：停止并删除测试容器
echo "\n步骤5：清理测试容器..."
echo "停止容器..."
sudo ctr task delete -f test-nginx
if [ $? -ne 0 ]; then
    echo "警告：停止容器时出现问题！"
fi

echo "删除容器..."
sudo ctr container delete test-nginx
if [ $? -ne 0 ]; then
    echo "警告：删除容器时出现问题！"
fi

echo "✓ 测试容器已清理"

# 最终验证 - 确保容器已被删除
sudo ctr container ls | grep test-nginx > /dev/null
if [ $? -eq 0 ]; then
    echo "警告：容器似乎未被完全删除！"
else
    echo "✓ 容器已成功删除"
fi

echo "\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 组件版本避免自动更新。
bash 复制代码 
#!/bin/bash

set -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; then
    minikube delete || true
    sudo 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 ]; then
    echo "错误：添加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 ]; then
    echo "错误：添加apt源失败！"
    exit 1
fi
echo "✓ apt源添加成功"

# 3. 更新apt缓存
echo "\n步骤3：更新apt缓存..."
sudo apt-get update
if [ $? -ne 0 ]; then
    echo "错误：更新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 ]; then
    echo "错误：安装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 ]; then
    echo "错误：锁定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 || true

echo "\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 状态确认运行正常。
bash 复制代码 
#!/bin/bash

set -e
echo "=== 开始配置 kubelet cgroup 驱动适配 containerd ==="

# 1. 创建必要的目录结构
echo "\n步骤1：创建 kubelet 配置目录..."
sudo mkdir -p /etc/systemd/system/kubelet.service.d/
if [ $? -ne 0 ]; then
    echo "错误：创建目录失败！"
    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"
EOF

if [ $? -ne 0 ]; then
    echo "错误：创建配置文件失败！"
    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 ]; then
    echo "错误：重新加载 systemd 配置失败！"
    exit 1
fi
echo "✓ systemd 配置重新加载成功"

# 4. 重启 kubelet 服务
echo "\n步骤4：重启 kubelet 服务..."
sudo systemctl restart kubelet
if [ $? -ne 0 ]; then
    echo "警告：重启 kubelet 服务失败，但这在集群初始化前可能是正常的"
else
    echo "✓ 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 ]; then
    echo "containerd 配置文件中的 cgroup 驱动："
    grep SystemdCgroup /etc/containerd/config.toml || echo "未在 containerd 配置文件中找到 cgroup 驱动设置"
else
    echo "/etc/containerd/config.toml 文件不存在"
fi

echo "✅ kubelet cgroup 驱动配置已添加：--cgroup-driver=systemd"
echo "配置将在 Kubernetes 集群初始化时完全生效"

echo "\n=== kubelet cgroup 驱动配置完成 ==="
echo "注意：在 Kubernetes 集群初始化前，kubelet 服务可能会显示一些警告，这是正常的"
echo "初始化集群后，kubelet 服务将正常运行并使用 systemd 作为 cgroup 驱动"
bash 复制代码 
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 配置命令（供后续使用）。
bash 复制代码 
#!/bin/bash

set -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/config

echo "kubectl 配置完成，现在可以使用 kubectl 命令管理集群"
EOF

chmod +x ~/kubectl_config_commands.sh

echo "\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 工具包），可通过以下命令快速安装，后续就能正常检查端口：

bash 复制代码 
# 安装 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 的具体状态：

bash 复制代码 
sudo systemctl status kubelet --no-pager

预期输出（类似）：

复制代码 
● kubelet.service - kubelet: The Kubernetes Node Agent
     Loaded: 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 运行（否则无法启动控制平面组件），执行以下命令：

bash 复制代码 
# 启动 kubelet 并设置开机自启
sudo systemctl start kubelet
sudo systemctl enable kubelet

# 再次验证状态（此时应显示 active (running)）
sudo systemctl status kubelet --no-pager | grep "active (running)"

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

bash 复制代码 
# 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)"。
相关推荐
月疯3 小时前
样本熵和泊松指数的计算流程！！！
算法·机器学习·概率论
机器学习之心3 小时前
MATLAB基于自适应动态特征加权的K-means算法
算法·matlab·kmeans
minji...3 小时前
算法题 逆波兰表达式/计算器
数据结构·c++·算法·1024程序员节
编码追梦人4 小时前
基于 STM32 的智能语音唤醒与关键词识别系统设计 —— 从硬件集成到算法实现
stm32·算法·struts
循着风6 小时前
二叉树的多种遍历方式
数据结构·算法
.格子衫.11 小时前
022数据结构之树状数组——算法备赛
数据结构·算法·1024程序员节
黑科技Python11 小时前
生活中的“小智慧”——认识算法
学习·算法·生活
sali-tec12 小时前
C# 基于halcon的视觉工作流-章52-生成标定板
开发语言·图像处理·人工智能·算法·计算机视觉
IT古董12 小时前
【第五章:计算机视觉-项目实战之推荐/广告系统】2.粗排算法-(4)粗排算法模型多目标算法(Multi Task Learning)及目标融合
人工智能·算法·1024程序员节
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03BongoCat - 跨平台键盘猫动画工具04GitLab 零基础入门指南：从安装到项目管理全流程05Linux下V2Ray安装配置指南06NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南07Labelme从安装到标注：零基础完整指南08在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）09jdk21下载、安装（Windows、Linux、macOS）10安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）