项目 配置
Kubernetes 版本 v1.33.0
操作系统 Ubuntu 22.04 LTS
容器运行时 containerd
CNI 网络插件 Calico（自定义 10.244.0.0/16）
kube-proxy 模式 IPVS
Pod 网段（podSubnet） 10.244.0.0/16 ✅
Service 网段 10.96.0.0/12
Ingress ingress-nginx

🖥️ 节点信息（不变）

IP Hostname Role
192.168.122.96 k8s-master Control-plane
192.168.122.190 k8s-node1 Worker
192.168.122.79 k8s-node2 Worker

✅ 第一步：所有节点通用初始化（3台都执行）

1. 设置主机名（按节点分别执行）

# 在 192.168.122.96 上执行
sudo hostnamectl set-hostname k8s-master

# 在 192.168.122.190 上执行
sudo hostnamectl set-hostname k8s-node1

# 在 192.168.122.79 上执行
sudo hostnamectl set-hostname k8s-node2

2. 配置 hosts（所有节点）

sudo tee /etc/hosts << 'EOF'
192.168.122.96  k8s-master
192.168.122.190 k8s-node1
192.168.122.79  k8s-node2
EOF

3. 关闭 Swap

sudo swapoff -a
sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

4. 加载内核模块（IPVS + 桥接）

cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
br_netfilter
ip_vs
ip_vs_rr
ip_vs_wrr
ip_vs_sh
nf_conntrack
EOF

sudo systemctl restart systemd-modules-load

5. 配置网络参数

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

✅ 第二步：安装 containerd（所有节点）

1. 添加 Docker 仓库

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker.gpg

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

2. 安装 containerd

sudo apt update && sudo apt install -y containerd.io

3. 配置 containerd（systemd + pause 镜像）

sudo mkdir -p /etc/containerd
containerd config default | sudo tee /etc/containerd/config.toml
# cat /etc/containerd/config.toml
# 启用 systemd cgroup，设置 pause 镜像
disabled_plugins = []
imports = []
oom_score = 0
plugin_dir = ""
required_plugins = []
root = "/var/lib/containerd"
state = "/run/containerd"
version = 2

[grpc]
  address = "/run/containerd/containerd.sock"
  gid = 0
  uid = 0
  max_recv_message_size = 16777216
  max_send_message_size = 16777216

[debug]
  address = ""
  format = "json"
  gid = 0
  level = ""
  uid = 0

[metrics]
  address = "127.0.0.1:1338"
  grpc_histogram = false

[cgroup]
  path = ""

[daemon]
  enable_tls_streaming = false
  graceful_shutdown_timeout = -1
  graceful_restart_timeout = -1
  selinux = false

[plugins]

  [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
    selinux_category_range = 1024
    enable_tls_streaming = false
    tolerate_missing_hugetlb_controller = true
    disable_cgroup = false
    disable_apparmor = false
    restrict_oom_score_adj = false
    max_concurrent_downloads = 5
    disable_proc_mount = false
    unset_seccomp_profile = ""
    tolerate_permissions_errors = false

    # 镜像加速器（已修复多余空格问题）
    [plugins."io.containerd.grpc.v1.cri".registry]
      [plugins."io.containerd.grpc.v1.cri".registry.mirrors]
        # Docker 官方镜像加速（推荐使用腾讯云）
        [plugins."io.containerd.grpc.v1.cri".registry.mirrors."docker.io"]
          endpoint = ["https://mirror.ccs.tencentyun.com"]

        # Kubernetes 镜像加速（必须！）
        [plugins."io.containerd.grpc.v1.cri".registry.mirrors."k8s.gcr.io"]
          endpoint = ["https://registry.aliyuncs.com/google_containers"]

        # GCR 镜像加速
        [plugins."io.containerd.grpc.v1.cri".registry.mirrors."gcr.io"]
          endpoint = ["https://gcr.azk8s.cn"]

        # Quay.io 镜像加速
        [plugins."io.containerd.grpc.v1.cri".registry.mirrors."quay.io"]
          endpoint = ["https://quay.mirrors.ustc.edu.cn"]

        # GitHub 容器镜像加速
        [plugins."io.containerd.grpc.v1.cri".registry.mirrors."ghcr.io"]
          endpoint = ["https://ghcr.mirrors.ustc.edu.cn"]

    [plugins."io.containerd.grpc.v1.cri".containerd]
      default_runtime_name = "runc"
      snapshotter = "overlayfs"
      disable_snapshot_annotations = true
      discard_unpacked_layers = false

      [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 = ""
          privileged_without_host_devices = false
          base_runtime_spec = ""
          pod_annotations = []
          container_annotations = []
          cni_conf_dir = ""
          cni_max_conf_num = 0
          dummy_cni_bin_dir = ""
          cni_setup_bin = ""
          cni_cleanup_bin = ""

          [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options]
            SystemdCgroup = true  # ✅ 关键：启用 systemd cgroup 驱动

  [plugins."io.containerd.internal.v1.opt"]
    path = "/opt/containerd"

  [plugins."io.containerd.internal.v1.restart"]
    interval = "10s"

  [plugins."io.containerd.metadata.v1.bolt"]
    content_sharing_policy = "shared"

  [plugins."io.containerd.monitor.v1.cgroups"]
    no_prometheus = false

  [plugins."io.containerd.runtime.v1.linux"]
    shim = "containerd-shim"
    runtime = "runc"
    runtime_root = ""
    no_shim = false
    shim_debug = false

  [plugins."io.containerd.runtime.v2.runc"]
    options = {}

  [plugins."io.containerd.service.v1.diff-service"]
    default = ["walking"]

  [plugins."io.containerd.snapshotter.v1.devmapper"]
    root_path = ""
    pool_name = ""
    base_image_size = "10GB"
    async_remove = false
    delete_check_delay = "1h0m0s"
    discard_blocks = false
    fs_options = ""
    fs_type = ""
    set_xfs_quota = false
    mount_opts = ""

4. 重启并启用

sudo systemctl restart containerd
sudo systemctl enable containerd

✅ 第三步：安装 kubeadm、kubelet、kubectl（所有节点）

1. 添加 Kubernetes v1.33 仓库

curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.33/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

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

2. 安装组件

sudo apt update && sudo apt install -y ipvsadm
sudo apt update && sudo apt install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl
sudo systemctl enable --now kubelet

✅ 第四步：初始化 Master 节点（仅在 k8s-master 执行）

1. 创建 kubeadm 配置文件（使用 10.244.0.0/16 + IPVS）

apiVersion: kubeadm.k8s.io/v1beta4
kind: ClusterConfiguration
kubernetesVersion: v1.33.0
controlPlaneEndpoint: "k8s-master:6443"
imageRepository: registry.aliyuncs.com/google_containers
networking:
  podSubnet: "10.244.0.0/16"
  serviceSubnet: "10.96.0.0/12"
---
apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
cgroupDriver: systemd
---
apiVersion: kubeproxy.config.k8s.io/v1alpha1
kind: KubeProxyConfiguration
mode: ipvs
ipvs:
  excludeCIDRs: null
  minSyncPeriod: 0s
  scheduler: ""
  syncPeriod: 30s
  tcpTimeout: 30m
  tcpFinTimeout: 30s
  udpTimeout: 30s

2.其他配置

cat <<EOF | sudo tee /etc/crictl.yaml
runtime-endpoint: unix:///var/run/containerd/containerd.sock
image-endpoint: unix:///var/run/containerd/containerd.sock
timeout: 2
debug: false
EOF

sudo crictl pull registry.aliyuncs.com/google_containers/pause:3.10
sudo ctr -n k8s.io images tag registry.aliyuncs.com/google_containers/pause:3.10 registry.k8s.io/pause:3.8

3. 初始化集群

root@k8s-master:~# cat re_install.sh 
#!/bin/bash
# 1. 重置
sudo systemctl   stop kubelet
sudo kubeadm reset -f
sudo rm -rf /etc/kubernetes/
sudo rm -rf /var/lib/etcd

# 2. 确保 containerd 正常
sudo systemctl enable containerd --now
sudo systemctl restart containerd

# 3. 手动拉镜像
# （上面的脚本）

# 4. 重新 init
sudo kubeadm init --config kubeadm-config.yaml --node-name k8s-master

3. 配置 kubectl

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

4. 验证 kube-proxy 模式

kubectl get configmap kube-proxy -n kube-system -o yaml | grep mode
# 应输出：mode: ipvs

✅ 第五步：安装 Calico（支持自定义 podSubnet）

Calico 默认使用 192.168.0.0/16，但可通过修改 CALICO_IPV4POOL_CIDR 支持 10.244.0.0/16。

1. 下载 Calico YAML

curl https://raw.githubusercontent.com/projectcalico/calico/v3.27.3/manifests/calico.yaml -O

2. 修改 Calico 的 Pod 网段为 10.244.0.0/16

sed -i 's?value: "192.168.0.0/16"?value: "10.244.0.0/16"?g' calico.yaml

✅ 确保只修改 CALICO_IPV4POOL_CIDR，不要改错其他字段。

3. 部署 Calico

kubectl apply -f calico.yaml

4. 等待 Calico 就绪

watch kubectl get pods -n kube-system -l k8s-app=calico-node

直到所有 calico-node 和 calico-kube-controllers 为 Running。

✅ 第六步：加入 Worker 节点（在 node1 和 node2 执行）

从 master 初始化输出中复制 kubeadm join 命令：

kubeadm join k8s-master:6443 \
  --token 6mushx.pwq1dxomqh39xnd4 \
  --discovery-token-ca-cert-hash sha256:818f86e646c144e3b048394a51054e0c8dd5db58c09166afaabde6d74f8fcc70 \
  --control-plane \
  --certificate-key <你得到的64位密钥>

如忘记，重新生成：

kubeadm token create --print-join-command

验证节点状态

kubectl get nodes

应全部为 Ready。

✅ 第七步：部署 Ingress-Nginx

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.10.0/deploy/static/provider/cloud/deploy.yaml

等待启动：

kubectl get pods -n ingress-nginx

如需 NodePort：

kubectl patch svc ingress-nginx-controller -n ingress-nginx -p '{"spec":{"type":"NodePort"}}'

✅ 第八步：验证 IPVS 和 Pod 网络

1. 验证 IPVS 是否生效

sudo ipvsadm -ln
# 应看到 service 被 IPVS 管理

2. 验证 Pod CIDR 是否为 10.244.0.0/16

kubectl get nodes -o jsonpath='{.items[*].spec.podCIDR}'
# 输出应类似：10.244.1.0/24 10.244.2.0/24 ...

3. 创建测试 Pod 验证 IP 分配

kubectl run testpod --image=nginx:alpine --restart=Never
kubectl get pod testpod -o wide
# IP 应属于 10.244.x.x 范围

✅ 第九步：测试 Ingress（可选）

cat <<EOF | kubectl apply -f -
apiVersion: apps/v1
kind: Deployment
meta:
  name: nginx-demo
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx-demo
  template:
    meta:
      labels:
        app: nginx-demo
    spec:
      containers:
      - name: nginx
        image: nginx:alpine
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
meta:
  name: nginx-svc
spec:
  selector:
    app: nginx-demo
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
---
apiVersion: networking.k8s.io/v1
kind: Ingress
meta:
  name: nginx-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  rules:
  - host: nginx.local
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: nginx-svc
            port:
              number: 80
EOF

本地 hosts 添加：

192.168.122.96 nginx.local

访问 http://nginx.local 应看到 Nginx 页面。

✅ 常见问题

问题 解决方案
Pod CIDR not assigned 检查 Calico 是否正常运行，podSubnet 是否匹配
IPVS not working 检查内核模块是否加载，kube-proxy 配置是否为 ipvs
ImagePullBackOff 使用国内镜像仓库或提前拉取镜像
NodeNotReady 检查 kubelet、containerd、CNI 日志

✅ 总结

你已完成：

✅ Ubuntu 22.04 上部署 Kubernetes v1.33
✅ 使用 10.244.0.0/16 作为 Pod 网段
✅ 使用 Calico CNI（自定义 CIDR）
✅ 使用 containerd + systemd cgroup
✅ 启用 kube-proxy 的 IPVS 模式
✅ 部署 ingress-nginx 对外暴露服务
✅ 所有节点加入集群，状态正常

附加镜像拉取
您当前的 kubeadm init 卡住，是因为 kubeadm 正在尝试从互联网拉取 Kubernetes 核心组件镜像，但由于这些镜像托管在 registry.k8s.io（原 k8s.gcr.io），在国内访问非常困难或完全不可达，导致拉取过程极慢或卡死。

✅ 一、kubeadm 初始化需要拉取哪些镜像？

根据您的 kubeadm-config.yaml 配置，kubeadm 会自动拉取以下核心组件镜像（版本 v1.33.0）：

组件 镜像名称
kube-apiserver registry.k8s.io/kube-apiserver:v1.33.0
kube-controller-manager registry.k8s.io/kube-controller-manager:v1.33.0
kube-scheduler registry.k8s.io/kube-scheduler:v1.33.0
kube-proxy registry.k8s.io/kube-proxy:v1.33.0
pause 容器 registry.k8s.io/pause:3.9（或 3.8，取决于架构）
etcd registry.k8s.io/etcd:3.5.12-0

🔍 这些镜像不会自动从 Docker Hub 或其他镜像仓库获取，必须从 registry.k8s.io 拉取。

❌ 为什么初始化会“卡住”？

  • kubeadm init 默认会在初始化时自动执行 kubeadm config images pull。
  • 它会尝试从 registry.k8s.io 拉取上述镜像。
  • 但 registry.k8s.io 在国内访问极慢或超时，导致：
    • 拉取卡住（长时间无响应）
    • 最终报错：failed to pull image 或 context deadline exceeded

✅ 二、解决方案：提前手动拉取镜像（推荐使用国内镜像源）

✅ 方法 1：使用 kubeadm 提前拉取（配合镜像加速）
# 先尝试使用 kubeadm 自动拉取（如果网络好，可能成功）
sudo kubeadm config images pull --config kubeadm-config.yaml

如果失败，请使用 方法 2。

✅ 方法 2：手动从阿里云等镜像仓库拉取并打标签（推荐）

由于 registry.k8s.io 被墙，我们可以从 阿里云镜像服务 拉取，然后重命名为官方镜像名。

# 定义版本变量
K8S_VERSION=v1.33.0
ETCD_VERSION=3.5.12-0
PAUSE_VERSION=3.9

# 拉取镜像（从阿里云镜像仓库）
sudo ctr -n k8s.io images pull registry.aliyuncs.com/google_containers/kube-apiserver:${K8S_VERSION}
sudo ctr -n k8s.io images pull registry.aliyuncs.com/google_containers/kube-controller-manager:${K8S_VERSION}
sudo ctr -n k8s.io images pull registry.aliyuncs.com/google_containers/kube-scheduler:${K8S_VERSION}
sudo ctr -n k8s.io images pull registry.aliyuncs.com/google_containers/kube-proxy:${K8S_VERSION}
sudo ctr -n k8s.io images pull registry.aliyuncs.com/google_containers/etcd:${ETCD_VERSION}
sudo ctr -n k8s.io images pull registry.aliyuncs.com/google_containers/pause:${PAUSE_VERSION}

# 重新打标签为官方镜像名
sudo ctr -n k8s.io images tag registry.aliyuncs.com/google_containers/kube-apiserver:${K8S_VERSION} registry.k8s.io/kube-apiserver:${K8S_VERSION}
sudo ctr -n k8s.io images tag registry.aliyuncs.com/google_containers/kube-controller-manager:${K8S_VERSION} registry.k8s.io/kube-controller-manager:${K8S_VERSION}
sudo ctr -n k8s.io images tag registry.aliyuncs.com/google_containers/kube-scheduler:${K8S_VERSION} registry.k8s.io/kube-scheduler:${K8S_VERSION}
sudo ctr -n k8s.io images tag registry.aliyuncs.com/google_containers/kube-proxy:${K8S_VERSION} registry.k8s.io/kube-proxy:${K8S_VERSION}
sudo ctr -n k8s.io images tag registry.aliyuncs.com/google_containers/etcd:${ETCD_VERSION} registry.k8s.io/etcd:${ETCD_VERSION}
sudo ctr -n k8s.io images tag registry.aliyuncs.com/google_containers/pause:${PAUSE_VERSION} registry.k8s.io/pause:${PAUSE_VERSION}

🔹 ctr -n k8s.io：k8s.io 是 Kubernetes 使用的 containerd 命名空间，必须指定。

✅ 方法 3：使用脚本一键拉取（推荐）
root@k8s-master:~# cat pull-k8s-images_v4.sh 
#!/bin/bash

# =============== 配置变量 ===============
REGISTRY=registry.cn-hangzhou.aliyuncs.com/google_containers
K8S_VERSION=v1.33.0
PAUSE_VERSION=3.9
COREDNS_VERSION=v1.11.3
ETCD_VERSION=3.5.18-0

echo "🎯 开始拉取 Kubernetes ${K8S_VERSION} 镜像..."

# 要拉取的组件
IMAGES=(
  kube-apiserver
  kube-controller-manager
  kube-scheduler
  kube-proxy
)

# 拉取并重命名主组件
for IMAGE in "${IMAGES[@]}"; do
  SOURCE=${REGISTRY}/${IMAGE}:${K8S_VERSION}
  DEST=k8s.gcr.io/${IMAGE}:${K8S_VERSION}

  echo "🔽 拉取: ${SOURCE}"
  sudo ctr images pull ${SOURCE} || { echo "❌ 拉取失败: ${SOURCE}"; exit 1; }

  echo "🏷️  打标签: ${DEST}"
  sudo ctr images tag ${SOURCE} ${DEST}
done

# 拉取 pause 镜像
echo "🔽 拉取: ${REGISTRY}/pause:${PAUSE_VERSION}"
sudo ctr images pull ${REGISTRY}/pause:${PAUSE_VERSION} || { echo "❌ 拉取失败: pause"; exit 1; }
sudo ctr images tag ${REGISTRY}/pause:${PAUSE_VERSION} k8s.gcr.io/pause:${PAUSE_VERSION}

# 拉取 CoreDNS
echo "🔽 拉取: ${REGISTRY}/coredns:${COREDNS_VERSION}"
sudo ctr images pull ${REGISTRY}/coredns:${COREDNS_VERSION}
sudo ctr images tag ${REGISTRY}/coredns:${COREDNS_VERSION} k8s.gcr.io/coredns:${COREDNS_VERSION}

# 拉取 etcd
echo "🔽 拉取: ${REGISTRY}/etcd:${ETCD_VERSION}"
sudo ctr images pull ${REGISTRY}/etcd:${ETCD_VERSION}
sudo ctr images tag ${REGISTRY}/etcd:${ETCD_VERSION} k8s.gcr.io/etcd:${ETCD_VERSION}

# 列出所有镜像
echo "✅ 所有镜像准备就绪！"
sudo crictl images

保存为 pull-k8s-images.sh，运行即可。

✅ 三、验证镜像是否已就绪

# 查看 containerd 中的镜像（在 k8s.io 命名空间）
sudo ctr -n k8s.io images list | grep registry.k8s.io

应能看到所有 registry.k8s.io/... 开头的镜像。

✅ 四、重新运行 kubeadm init

sudo kubeadm init --config kubeadm-config.yaml --node-name k8s-master

✅ 此时不会再拉取镜像，直接进入初始化流程，速度飞快！

📝 补充建议

  1. 配置 containerd 镜像加速
    在 /etc/containerd/config.toml 中添加：

    [plugins."io.containerd.grpc.v1.cri".registry.mirrors."k8s.gcr.io"]
  endpoint = ["https://registry.aliyuncs.com/google_containers"]

  2. 使用 crictl 查看镜像更方便

    crictl images

✅ 总结

问题 解决方案
初始化卡住 因为拉取 registry.k8s.io 镜像失败
需要哪些镜像 kube-apiserver, kube-controller-manager, kube-scheduler, kube-proxy, etcd, pause
如何解决 手动从阿里云拉取并 ctr tag 为官方名称
推荐工具 ctr -n k8s.io（containerd 命令）

现在您可以运行镜像拉取脚本，再执行 kubeadm init，一定会成功！需要我帮您生成完整脚本吗？

安装软件换国内源

你现在遇到的问题是：

Err:1 https://download.docker.com/linux/ubuntu   jammy InRelease
  Could not handshake: Error in the pull function. [IP: 3.171.76.104 443]
...
E: Unable to locate package containerd.io

🔍 问题分析

❌ 核心原因：

无法连接到 https://download.docker.com，导致 APT 不能下载 Docker 的软件源索引（InRelease 文件），因此 containerd.io 包找不到。

虽然你使用了清华源（tuna）、华为云等镜像，但 containerd.io 来自 Docker 官方源，而这个源目前无法访问。

✅ 解决方案：使用国内镜像替换 Docker 的官方源

你需要将 Docker 的官方源（https://download.docker.com）替换成国内镜像，比如：

  • 清华源（TUNA）
  • 阿里云
  • 华为云

✅ 步骤 1：备份并修改 Docker 的 APT 源

# 备份原来的 sources.list.d/docker 文件（如果有）
sudo mv /etc/apt/sources.list.d/docker.list /etc/apt/sources.list.d/docker.list.bak 2>/dev/null || true

✅ 步骤 2：使用清华源添加 Docker 镜像源

# 创建新的 docker.list 文件，使用清华镜像
cat << EOF | sudo tee /etc/apt/sources.list.d/docker.list
deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/ubuntu jammy stable
EOF

✅ 说明：

  • mirrors.tuna.tsinghua.edu.cn/docker-ce 是 Docker CE 的清华镜像
  • 我们指向的是 /docker-ce/linux/ubuntu，不是 download.docker.com
  • jammy 是你的系统代号（Ubuntu 22.04），确认正确

✅ 步骤 3：导入 GPG 公钥（确保信任）

# 下载并安装 Docker 的 GPG 密钥（从清华镜像获取）
curl -fsSL https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

✅ 步骤 4：更新软件包列表

sudo apt update

你应该会看到类似：

Get:1 https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/ubuntu jammy InRelease [48.8 kB]
...

✅ 表示现在是从清华镜像拉取 Docker 源，不再依赖 download.docker.com。

✅ 步骤 5：安装 containerd.io

sudo apt install -y containerd.io

✅ 这次应该可以成功安装！

🛠️ 额外建议：确认系统架构和版本

确保你用的是 amd64 架构，且系统是 Ubuntu 22.04 (jammy)：

uname -m      # 应该输出 x86_64
lsb_release -cs  # 应该输出 jammy

如果不是，请根据实际调整源中的架构或版本名（如 focal、bionic 等）。

🚫 为什么 download.docker.com 访问失败？

常见原因包括：

原因 说明
🇨🇳 网络屏蔽 download.docker.com 在国内部分地区不稳定或被干扰
🔐 HTTPS 握手失败 TLS 握手失败，可能是中间人、防火墙、时间不准等
⏳ 时间不同步 SSL 证书验证依赖时间，时间错会导致握手失败（你之前已经修过）

所以：使用国内镜像最稳定可靠

✅ 验证安装成功

安装完成后运行：

containerd --version

输出类似：

containerd github.com/containerd/containerd v1.6.21 073594318f5167bb1d26ba8896be7d3994725a83

表示安装成功 ✅

🧹 清理旧错误源（可选）

如果你之前添加过 download.docker.com 的源，建议删除：

sudo rm /etc/apt/sources.list.d/docker.list.bak  # 如果确认新源工作正常再删

或者保留备份以防回滚。

✅ 总结

步骤 操作
1 删除或备份原 Docker 源
2 添加清华镜像源：
https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/ubuntu
3 导入 GPG 密钥
4 sudo apt update
5 sudo apt install -y containerd.io

设置cst时区
sudo timedatectl set-timezone Asia/Shanghai

附加打标签

根据搜索结果，crictl 并没有 tag 命令，但你可以使用 ctr 命令来给镜像打标签。以下是具体操作步骤：

1. 使用 ctr 命令给镜像打标签

你需要使用 ctr 命令，并指定 Kubernetes 的命名空间 k8s.io，来给镜像打标签。命令格式如下：

ctr -n k8s.io i tag <原镜像名> <新镜像名>

对于你的需求，执行以下命令：

ctr -n k8s.io i tag registry.cn-hangzhou.aliyuncs.com/google_containers/pause:3.8 registry.k8s.io/pause:3.8

2. 验证镜像是否打标签成功

使用以下命令验证镜像是否已经成功打标签：

crictl images | grep pause

你应该会看到类似以下的输出，显示新的镜像名 registry.k8s.io/pause:3.8：

registry.cn-hangzhou.aliyuncs.com/google_containers/pause         3.8                 4873874c08efc       311kB
registry.k8s.io/pause                                             3.8                 4873874c08efc       311kB

通过这些步骤，你就可以成功地使用 ctr 命令给镜像打标签，从而让 Kubernetes 能够识别和使用该镜像。

重新初始化集群操作

master节点操作

root@k8s-master:~#  sudo rm -rf /etc/kubernetes/
root@k8s-master:~# sudo kubeadm reset -f
root@k8s-master:~# sudo rm -rf /var/lib/etcd
root@k8s-master:~# iptables -L
root@k8s-master:~# iptables -F

root@k8s-master:~# cat kubeadm-config.yaml 
apiVersion: kubeadm.k8s.io/v1beta4
kind: ClusterConfiguration
kubernetesVersion: v1.33.0
controlPlaneEndpoint: "k8s-master:6443"
imageRepository: registry.aliyuncs.com/google_containers
networking:
  podSubnet: "10.244.0.0/16"
  serviceSubnet: "10.96.0.0/12"
---
apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
cgroupDriver: systemd
---
apiVersion: kubeproxy.config.k8s.io/v1alpha1
kind: KubeProxyConfiguration
mode: ipvs
ipvs:
  excludeCIDRs: null
  minSyncPeriod: 0s
  scheduler: ""
  syncPeriod: 30s
  tcpTimeout: 30m
  tcpFinTimeout: 30s
  udpTimeout: 30s


root@k8s-master:~# sudo kubeadm init --config kubeadm-config.yaml --node-name k8s-master

node节点操作

root@k8s-node1:~# rm -rf /etc/kubernetes
root@k8s-node1:~#sudo systemctl stop containerd 
root@k8s-node1:~#sudo crictl rm -a
root@k8s-node1:~#iptables -L
root@k8s-node1:~#iptables -F
root@k8s-node1:~#sudo systemctl stop kubelet
root@k8s-node1:~#sudo kubeadm reset -f
root@k8s-node1:~#sudo rm -rf /etc/cni/net.d
root@k8s-node1:~#sudo rm -rf /var/lib/kubelet/*
root@k8s-node1:~#sudo umount /var/lib/containerd/io.containerd.grpc.v1.cri/containers/*/rootfs 2>/dev/null || true
root@k8s-node1:~#sudo systemctl start containerd
root@k8s-node1:~#sudo systemctl status containerd
root@k8s-node1:~#sudo crictl info
root@k8s-node1:~#kubeadm join k8s-master:6443 --token b62j9m.0ewbddtc8hdy9pk7 --discovery-token-ca-cert-hash sha256:7b8a27e984ce9c2537042c996fa662dc9a3f661ba240cb818b450ae47a4d5365
# k8s
Logo
2048 AI社区

有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

更多推荐

cover

怎么准备3000行软著源代码？有这个软著AI工具就够了！

avatar 2048 AI社区
cover

U-Net 全解析：从网络架构、核心原理到 PyTorch 代码实现

avatar 2048 AI社区

AI技术：改变未来的智能革命

人工智能（Artificial Intelligence，AI）指通过计算机模拟人类智能的技术，涵盖机器学习、自然语言处理、计算机视觉等领域，目标是实现感知、推理、学习、规划和决策等能力。

avatar 2048 AI社区