<think>根据日志，我们发现了几个问题：
1
. 在下载Kubernetes组件时，虽然yumdownloader报错（错误：未知仓库：'k8s-*'），但之前已经通过wget下载了部分组件（从阿里云镜像源下载），但日志中显示wget下载失败，然后尝试使用yumdownloader，但是yumdownloader因为仓库名称问题失败。
2
. 在yumdownloader失败后，脚本尝试
重命名
文件，但出现“mv:
... 与
... 为同一
文件”的错误，
说明文件已经存在，但之前wget可能并未成功下载（因为尝试多个URL，其中某个可能成功？），但日志中每个组件的多次尝试都是404之类的错误（未明确显示，但可以推断），所以实际上并没有下载成功，而yumdownloader也失败了，所以最终是手动创建了一个空
文件？然后
重命名时因为目标
文件已经存在（可能是之前失败时创建的空
文件）而报错。
解决方案：
1
. 调整yumdownloader的仓库参数：之前使用`--disablerepo=* --enablerepo=${type}-*`，其中`${type}`是"k8s"或"docker"，但我们在仓库配置中使用的仓库名称是"kubernetes"和"docker-ce-stable"，所以应该使用正确的仓库名称。
2
. 避免
重复
文件：在yumdownloader下载之前，先删除可能存在的空
文件或无效
文件。
3
. 增强下载逻辑：在wget下载失败后，使用yumdownloader时指定正确的仓库。
修改点：
- 在`download_component`函数中，将yumdownloader的`--enablerepo`参数根据类型映射为实际的仓库名称：
- 对于k8s类型，使用仓库名称"kubernetes"
- 对于docker类型，使用仓库名称"docker-ce-stable"
- 在yumdownloader之前，先删除可能存在的空
文件（大小为0的
文件）或之前下载失败的
文件。
具体修改如下：
在`download_component`函数中，修改yumdownloader部分：
```bash
# 终极回退：使用yumdownloader
echo "🔄 使用yumdownloader下载: $component"
# 根据类型设置仓库名称
local repo_name
case $type in
k8s
) repo_name="kubernetes" ;;
docker
) repo_name="docker-ce-stable" ;;
*
) repo_name="" ;;
esac
# 清理空
文件
find "$PACKAGE_DIR" -name "${component}-*
.rpm" -size 0 -delete
# 使用正确的仓库名称下载
yumdownloader --disablerepo=* --enablerepo="${repo_name}" \
--destdir="$PACKAGE_DIR" \
${component} || true
```
同时，在wget循环中，如果下载的
文件大小为0，则删除，避免影响后续步骤。
另外，在wget下载时，增加`--tries=1`以避免
重试浪费时间，因为我们要尝试多个URL。
修改wget命令：
```bash
if wget --tries=1 --timeout=10 -q -c -O "$target_file" "$url"; then
```
这样，每个URL只尝试一次，快速失败，然后尝试下一个。
此外，在wget下载成功后，检查
文件大小，如果为0则删除并继续尝试。
在wget成功后的处理中，我们已经检查了
文件大小，如果为0则删除。所以不需要额外修改。
最后，在yumdownloader之后，我们检查下载的
文件，如果存在并且大小大于0，才进行
重命名。否则，不
重命名，避免覆盖或
重命名无效
文件。
修改
重命名部分：
```bash
#
重命名下载的
文件
local downloaded_file=$
(find "$PACKAGE_DIR" -name "${component}-*
.rpm" -size +1k -print -quit
)
if [[ -f $downloaded_file ]]; then
# 如果目标
文件已存在且不是同一个
文件，则删除
if [[ -f "$PACKAGE_DIR/$component-$version
.rpm" && ! "$downloaded_file" -ef "$PACKAGE_DIR/$component-$version
.rpm" ]]; then
rm -f "$PACKAGE_DIR/$component-$version
.rpm"
fi
mv -f "$downloaded_file" "$PACKAGE_DIR/$component-$version
.rpm"
echo "✅ yumdownloader下载成功: $component-$version
.rpm"
return 0
else
echo "⚠️ 警告：yumdownloader未下载到有效
文件"
fi
```
这里，我们使用`-size +1k`来确保
文件大小大于1KB，避免空
文件。并且使用`-ef`比较
文件是否相同，避免同一个
文件时删除。
但是，注意在wget下载时，我们可能已经有一个
文件（但大小为0），在yumdownloader之前已经删除了空
文件，所以这里应该可以安全操作。
由于日志中显示在wget尝试所有URL都失败后，使用yumdownloader时出现“错误：未知仓库：'k8s-*'”，所以我们需要将`--enablerepo=${type}-*`改为正确的仓库名称。如上修改，使用`repo_name`变量。
此外，在配置仓库时，我们配置的docker仓库是`[docker-ce-stable]`，所以对于docker类型，仓库名称就是`docker-ce-stable`；对于kubernetes，仓库名称是`kubernetes`。
我们还需要确保在yumdownloader之前，这些仓库是可用的。因为我们在脚本中已经配置了这些仓库，所以应该是可用的。
另外，在`
configure_repositories`函数中，我们添加了`epel-release`，但可能还需要添加`docker-ce`仓库？实际上我们已经添加了。所以不需要额外操作。
最后，在`download_k8s_components`和`download_docker_components`中，我们调用`download_component`时传入的type参数是字符串"k8s"或"docker"，在case语句中处理，并映射到正确的仓库名称。
根据以上分析，我们修改脚本。
由于整个脚本较长，这里只提供修改后的`download_component`函数，并调整了wget的参数和yumdownloader的仓库设置。
注意：在yumdownloader命令中，`--enablerepo`参数可以接受仓库名称，我们直接使用`$repo_name`。
完整修改后的`download_component`函数如下：</think>### 终极修复版 Kubernetes 离线部署脚本
```bash
#!/bin/bash
# Kubernetes 离线部署包生成脚本（修复仓库配置问题）
set -euo pipefail
# ==================== 配置区域 ====================
REPO_DIR="/opt/k8s-offline"
PACKAGE_DIR="$REPO_DIR/packages"
IMAGES_DIR="$REPO_DIR/images"
STATE_FILE="$REPO_DIR/
.state"
mkdir -p {$PACKAGE_DIR,$IMAGES_DIR}
# ==================== 状态管理 ====================
mark_state
() {
echo "$1" >> $STATE_FILE
}
check_state
() {
[[ -f $STATE_FILE ]] && grep -q "^$1$" $STATE_FILE
}
# ==================== 核心功能 ====================
configure_repositories
() {
if ! check_state "repos_
configured"; then
echo "🔄 配置系统仓库
..."
# 修复仓库名称配置
cat > /etc/yum
.repos
.d/kubernetes
.repo <<'EOF'
[kubernetes]
name=Kubernetes
baseurl=https://mirrors
.aliyun
.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=0
repo_gpgcheck=0
EOF
cat > /etc/yum
.repos
.d/docker-ce
.repo <<'EOF'
[docker-ce-stable]
name=Docker CE Stable
baseurl=https://mirrors
.aliyun
.com/docker-ce/linux/centos/7/x86_64/stable
enabled=1
gpgcheck=0
EOF
# 添加 EPEL 仓库
yum install -y https://mirrors
.aliyun
.com/epel/epel-release-latest-8
.noarch
.rpm
# 修复仓库缓存问题
echo "🔄 创建 yum 缓存
..."
yum clean all
yum makecache || {
echo "⚠️ 标准 makecache 失败，使用替代方法
..."
yum list available > /dev/null
}
mark_state "repos_
configured"
echo "✅ 仓库配置完成"
fi
}
install_essential_tools
() {
if ! check_state "tools_installed"; then
echo "🛠️ 安装必要工具
..."
yum install -y yum-utils createrepo wget curl jq
mark_state "tools_installed"
echo "✅ 工具安装完成"
fi
}
select_k8s_version
() {
if ! check_state "version_selected"; then
echo "🔍 检测可用 Kubernetes 版本
..."
# 获取官方版本列表
OFFICIAL_VERSIONS=
($
(curl -s https://api
.github
.com/repos/kubernetes/kubernetes/releases |
jq -r '
.[]
.tag_name' |
grep -E '^v[0-9]+\
.[0-9]+\
.[0-9]+$' |
sort -V -r |
head -10
))
# 获取镜像源版本
MIRROR_VERSIONS=
($
(curl -s https://mirrors
.aliyun
.com/kubernetes/yum/repos/kubernetes-el7-x86_64/Packages/ |
grep -oP 'kubelet-\K[0-9]+\
.[0-9]+\
.[0-9]+-[0-9]+' |
sort -V -r | uniq
))
# 合并并
去重
ALL_VERSIONS=
($
(printf "%s\n" "${OFFICIAL_VERSIONS[@]#v}" "${MIRROR_VERSIONS[@]}" | sort -V -r | uniq
))
if [ ${#ALL_VERSIONS[@]} -eq 0 ]; then
echo "❌ 错误：未找到可用的Kubernetes版本"
exit 1
fi
echo "📋 可用 Kubernetes 版本:"
for i in "${!ALL_VERSIONS[@]}"; do
printf "%2d
) %s\n" $
((i+1
)) "${ALL_VERSIONS[$i]}"
done
read -p "👉 请选择版本号 [1-${#ALL_VERSIONS[@]}, 默认1]: " choice
choice=${choice:-1}
if [[ ! $choice =~ ^[0-9]+$ ]] ||
((choice < 1 || choice > ${#ALL_VERSIONS[@]}
)); then
echo "⚠️ 无效选择，使用默认版本"
choice=1
fi
K8S_RPM_VERSION=${ALL_VERSIONS[$
((choice-1
))]}
K8S_VERSION="v${K8S_RPM_VERSION%%-*}"
# 保存版本信息
echo "K8S_RPM_VERSION=$K8S_RPM_VERSION" > $REPO_DIR/version
.info
echo "K8S_VERSION=$K8S_VERSION" >> $REPO_DIR/version
.info
mark_state "version_selected"
echo "✅ 已选择版本: Kubernetes $K8S_VERSION"
else
source $REPO_DIR/version
.info
echo "ℹ️ 使用之前选择的版本: Kubernetes $K8S_VERSION"
fi
}
download_component
() {
local type=$1
local component=$2
local version=$3
local target_file
# 尝试不同后缀格式
local suffixes=
("" "
.el7" "
.el7
.x86_64" "
.el8
.x86_64" "
.x86_64"
)
case $type in
k8s
)
mirrors=
(
"https://mirrors
.aliyun
.com/kubernetes/yum/repos/kubernetes-el7-x86_64/Packages"
"https://download
.docker
.com/linux/centos/7/x86_64/stable/Packages"
"https://dl
.k8s
.io/release"
)
file_pattern="$component-$version"
;;
docker
)
mirrors=
(
"https://download
.docker
.com/linux/centos/7/x86_64/stable/Packages"
"https://mirrors
.aliyun
.com/docker-ce/linux/centos/7/x86_64/stable/Packages"
)
file_pattern="$component-$version"
;;
*
)
echo "❌ 未知组件类型: $type"
return 1
;;
esac
# 检查是否已下载
existing_file=$
(find $PACKAGE_DIR -name "$component-*
.rpm" -size +1k -print -quit
)
if [[ -f $existing_file ]]; then
echo "📦 已存在: $
(basename $existing_file
)"
return 0
fi
echo "⬇️ 下载: $component-$version"
# 尝试多个镜像源和多个后缀
for mirror in "${mirrors[@]}"; do
for suffix in "${suffixes[@]}"; do
local url="$mirror/${file_pattern}${suffix}
.rpm"
target_file="$PACKAGE_DIR/$component-$version${suffix}
.rpm"
echo "🔗 尝试: $url"
if wget --tries=1 --timeout=10 -q -O "$target_file" "$url"; then
if [[ -s $target_file ]]; then
echo "✅ 下载成功: $
(basename $target_file
)"
return 0
else
rm -f "$target_file"
fi
fi
done
done
# 终极回退：使用yumdownloader
echo "🔄 使用yumdownloader下载: $component"
# 修复仓库名称问题
local repo_name=""
case $type in
k8s
) repo_name="kubernetes" ;;
docker
) repo_name="docker-ce-stable" ;;
esac
if [[ -n "$repo_name" ]]; then
yumdownloader --disablerepo=* --enablerepo="$repo_name" \
--destdir="$PACKAGE_DIR" \
"${component}" || true
else
yumdownloader --destdir="$PACKAGE_DIR" "${component}" || true
fi
#
重命名下载的
文件
local downloaded_file=$
(find "$PACKAGE_DIR" -name "${component}-*
.rpm" -size +1k -print -quit
)
if [[ -f $downloaded_file ]]; then
# 避免
重复
文件错误
if [[ ! "$downloaded_file" -ef "$PACKAGE_DIR/$component-$version
.rpm" ]]; then
mv -f "$downloaded_file" "$PACKAGE_DIR/$component-$version
.rpm"
fi
echo "✅ yumdownloader下载成功: $component-$version
.rpm"
return 0
fi
echo "⚠️ 警告：无法下载 $component-$version"
return 1
}
download_k8s_components
() {
if ! check_state "k8s_components_downloaded"; then
echo "📦 下载Kubernetes组件
..."
components=
("kubelet" "kubeadm" "kubectl"
)
for comp in "${components[@]}"; do
download_component "k8s" "$comp" "$K8S_RPM_VERSION" || true
done
# 特殊处理cri-tools
download_component "k8s" "cri-tools" "1
.26
.0" || true
mark_state "k8s_components_downloaded"
echo "✅ Kubernetes组件下载完成"
fi
}
download_docker_components
() {
if ! check_state "docker_components_downloaded"; then
echo "🐳 下载Docker组件
..."
# 获取最新的Docker版本
DOCKER_VERSION=$
(curl -s https://download
.docker
.com/linux/centos/7/x86_64/stable/ |
grep -oP 'docker-ce-\K[0-9]+\
.[0-9]+\
.[0-9]+' |
sort -V -r | head -1
)
if [[ -z $DOCKER_VERSION ]]; then
DOCKER_VERSION="20
.10
.23"
fi
echo "ℹ️ 使用Docker版本: $DOCKER_VERSION"
docker_components=
(
"docker-ce:$DOCKER_VERSION"
"docker-ce-cli:$DOCKER_VERSION"
"containerd
.io:1
.6
.21"
)
for comp in "${docker_components[@]}"; do
comp_name=${comp%:*}
comp_version=${comp#*:}
download_component "docker" "$comp_name" "$comp_version" || true
done
mark_state "docker_components_downloaded"
echo "✅ Docker组件下载完成"
fi
}
download_dependencies
() {
if ! check_state "dependencies_downloaded"; then
echo "📚 下载系统依赖
..."
dependencies=
("socat" "conntrack-tools" "ebtables" "ipset" "nfs-utils" "device-mapper-persistent-data" "lvm2"
)
for dep in "${dependencies[@]}"; do
dep_file=$
(find $PACKAGE_DIR -name "${dep}-*
.rpm" -size +1k -print -quit
)
if [[ ! -f $dep_file ]]; then
echo "⬇️ 下载依赖: $dep"
yumdownloader --destdir=$PACKAGE_DIR $dep || echo "⚠️ 警告：无法下载 $dep"
else
echo "📦 已存在: $
(basename $dep_file
)"
fi
done
mark_state "dependencies_downloaded"
echo "✅ 系统依赖下载完成"
fi
}
create_local_repo
() {
if ! check_state "repo_created"; then
echo "🏗️ 创建本地YUM仓库
..."
# 清理0字节
文件
find $PACKAGE_DIR -size 0 -delete
# 创建仓库
createrepo $PACKAGE_DIR || {
echo "⚠️ 标准createrepo失败，尝试跳过
文件检查
..."
createrepo --skip-stat $PACKAGE_DIR
}
mark_state "repo_created"
echo "✅ 本地仓库创建完成"
fi
}
install_kubeadm_temp
() {
if ! check_state "kubeadm_installed"; then
echo "⚙️ 临时安装kubeadm
..."
kubeadm_rpm=$
(find $PACKAGE_DIR -name 'kubeadm-*
.rpm' -size +1k | head -1
)
if [[ -z $kubeadm_rpm ]]; then
kubeadm_rpm=$
(find $PACKAGE_DIR -name '*kubeadm*
.rpm' -size +1k | head -1
)
fi
if [[ -f $kubeadm_rpm ]]; then
rpm -ivh --nodeps --force "$kubeadm_rpm" || true
mark_state "kubeadm_installed"
echo "✅ kubeadm临时安装完成"
else
echo "❌ 错误：找不到有效的kubeadm RPM"
exit 1
fi
fi
}
install_docker
() {
if ! check_state "docker_installed"; then
echo "🐳 安装Docker
..."
# 安装依赖
yum install -y yum-utils device-mapper-persistent-data lvm2
# 安装组件
for comp in "containerd
.io" "docker-ce-cli" "docker-ce"; do
rpm_file=$
(find $PACKAGE_DIR -name "${comp}-*
.rpm" -size +1k | head -1
)
if [[ -f $rpm_file ]]; then
echo "🔧 安装: $
(basename $rpm_file
)"
rpm -ivh --nodeps --force "$rpm_file" || true
else
echo "⚠️ 警告：找不到 $comp RPM"
fi
done
mark_state "docker_installed"
echo "✅ Docker安装完成"
fi
}
start_docker
() {
if ! check_state "docker_started"; then
echo "🚀 启动Docker服务
..."
# 创建docker组
groupadd docker 2>/dev/null || true
# 配置存储驱动
mkdir -p /etc/docker
cat > /etc/docker/daemon
.json <<'EOF'
{
"exec-opts": ["native
.cgroupdriver=systemd"],
"log-driver": "json-file",
"log-opts": {
"max-size": "100m"
},
"
storage-driver": "overlay2",
"registry-mirrors": [
"https://registry
.aliyuncs
.com",
"https://docker
.mirrors
.ustc
.edu
.cn"
]
}
EOF
# 启动Docker
systemctl start docker || {
echo "⚠️ systemctl启动失败，尝试手动启动
..."
nohup dockerd &> /var/log/dockerd
.log &
sleep 10
}
# 验证Docker运行
if docker info &>/dev/null; then
mark_state "docker_started"
echo "✅ Docker启动成功"
else
echo "❌ Docker启动失败，请检查日志: /var/log/dockerd
.log"
exit 1
fi
fi
}
download_k8s_images
() {
if ! check_state "images_downloaded"; then
echo "🐳 下载Kubernetes镜像
..."
# 获取镜像列表
kubeadm
config images list --kubernetes-version=$K8S_VERSION | tee $IMAGES_DIR/image-list
.txt
while read image; do
filename=$
(echo $image | sed 's|/|_|g; s|:|_|g'
).tar
# 检查是否已存在
if [[ -f "$IMAGES_DIR/$filename" && -s "$IMAGES_DIR/$filename" ]]; then
echo "📦 已存在: $filename"
continue
fi
echo "⬇️ 拉取镜像: $image"
# 尝试官方源
if docker pull $image; then
docker save -o $IMAGES_DIR/$filename $image
continue
fi
# 尝试阿里云镜像源
ali_image="registry
.aliyuncs
.com/google_containers/$
(basename $image
)"
echo "🔄 尝试阿里云镜像: $ali_image"
if docker pull $ali_image; then
docker tag $ali_image $image
docker rmi $ali_image
docker save -o $IMAGES_DIR/$filename $image
else
echo "⚠️ 警告：无法拉取镜像 $image"
fi
done < $IMAGES_DIR/image-list
.txt
mark_state "images_downloaded"
echo "✅ Kubernetes镜像下载完成"
fi
}
generate_checksums
() {
if ! check_state "checksums_generated"; then
echo "🔒 生成校验
文件..."
find $REPO_DIR -type f -exec sha256sum {} \; > $REPO_DIR/checksums
.txt
mark_state "checksums_generated"
echo "✅ 校验
文件生成完成"
fi
}
cleanup_temporary
() {
if ! check_state "cleanup_done"; then
echo "🧹 清理临时安装
..."
# 卸载kubeadm
if command -v kubeadm &> /dev/null; then
rpm -e --nodeps kubeadm 2>/dev/null || true
fi
# 卸载Docker
systemctl stop docker 2>/dev/null || true
yum remove -y docker-ce docker-ce-cli containerd
.io 2>/dev/null || true
mark_state "cleanup_done"
echo "✅ 清理完成"
fi
}
generate_deployment_scripts
() {
if ! check_state "scripts_generated"; then
echo "📜 生成部署脚本
..."
# 安装Docker脚本
cat > $REPO_DIR/install_docker
.sh <<'EOF'
#!/bin/bash
set -e
echo "=== Docker 离线安装脚本 ==="
# 1
. 安装依赖
echo "🛠️ 安装系统依赖
..."
yum install -y yum-utils device-mapper-persistent-data lvm2
# 2
. 安装Docker组件
components=
("containerd
.io" "docker-ce-cli" "docker-ce"
)
for comp in "${components[@]}"; do
rpm_file=$
(find packages/ -name "${comp}-*
.rpm" -size +1k -print -quit
)
if [[ -f $rpm_file ]]; then
echo "🔧 安装: $
(basename $rpm_file
)"
rpm -ivh --nodeps --force "$rpm_file"
else
echo "❌ 错误：找不到 $comp RPM"
exit 1
fi
done
# 3
. 配置Docker
echo "⚙️ 配置Docker
..."
mkdir -p /etc/docker
cat > /etc/docker/daemon
.json <<'EOD'
{
"exec-opts": ["native
.cgroupdriver=systemd"],
"log-driver": "json-file",
"log-opts": {
"max-size": "100m"
},
"
storage-driver": "overlay2",
"registry-mirrors": [
"https://registry
.aliyuncs
.com",
"https://docker
.mirrors
.ustc
.edu
.cn"
]
}
EOD
# 4
. 启动Docker
echo "🚀 启动Docker服务
..."
systemctl enable --now docker || {
echo "⚠️ systemctl启动失败，尝试手动启动
..."
nohup dockerd &> /var/log/dockerd
.log &
sleep 10
}
# 5
. 验证安装
if docker info &>/dev/null; then
echo "✅ Docker 安装成功!"
else
echo "❌ Docker 启动失败，请检查日志: /var/log/dockerd
.log"
exit 1
fi
EOF
# 部署Kubernetes脚本
cat > $REPO_DIR/deploy_k8s
.sh <<'EOF'
#!/bin/bash
set -e
echo "=== Kubernetes 离线安装脚本 ==="
# 1
. 加载版本信息
source version
.info
echo "ℹ️ Kubernetes 版本: $K8S_VERSION"
# 2
. 安装Kubernetes组件
components=
("kubelet" "kubeadm" "kubectl" "cri-tools"
)
for comp in "${components[@]}"; do
rpm_file=$
(find packages/ -name "${comp}-*
.rpm" -size +1k -print -quit
)
if [[ -f $rpm_file ]]; then
echo "🔧 安装: $
(basename $rpm_file
)"
rpm -ivh --nodeps --force "$rpm_file"
else
echo "❌ 错误：找不到 ${comp} RPM"
exit 1
fi
done
# 3
. 启用kubelet
echo "⚙️ 启用kubelet服务
..."
systemctl enable --now kubelet
# 4
. 加载容器镜像
echo "🐳 加载容器镜像
..."
for img in images/*
.tar; do
if [[ -f $img && -s $img ]]; then
echo "⬆️ 加载: $
(basename $img
)"
docker load -i "$img"
else
echo "⚠️ 警告：未找到镜像
文件或
文件为空"
fi
done
# 5
. 初始化集群
echo "🚀 初始化Kubernetes集群
..."
NODE_IP=$
(hostname -I | awk '{print $1}'
)
cat > kubeadm-
config
.yaml <<EOC
apiVersion: kubeadm
.k8s
.io/v1beta3
kind: Init
Configuration
nodeRegistration:
kubeletExtraArgs:
node-ip: $NODE_IP
---
apiVersion: kubeadm
.k8s
.io/v1beta3
kind: Cluster
Configuration
kubernetesVersion: $K8S_VERSION
networking:
podSubnet: "10
.244
.0
.0/16"
controlPlaneEndpoint: "$
(hostname -f
):6443"
imageRepository: registry
.aliyuncs
.com/google_containers
EOC
kubeadm init --
config=kubeadm-
config
.yaml --upload-certs || {
echo "⚠️ 初始化失败，尝试
重置后
重试
..."
kubeadm reset -f
sleep 5
kubeadm init --
config=kubeadm-
config
.yaml --upload-certs
}
# 6
. 配置kubectl
echo "🔧 配置kubectl
..."
mkdir -p $HOME/
.kube
cp -i /etc/kubernetes/admin
.conf $HOME/
.kube/
config
chown $
(id -u
):$
(id -g
) $HOME/
.kube/
config
# 7
. 安装网络插件
echo "🌐 安装网络插件
(Flannel
)..."
kubectl apply -f https://raw
.githubusercontent
.com/coreos/flannel/master/Documentation/kube-flannel
.yml
# 8
. 完成提示
echo "✅ Kubernetes 集群初始化完成!"
echo "👉 使用以下命令加入节点:"
kubeadm token create --print-join-command
echo ""
echo "🚨 注意: 如果节点有多个IP地址，请确保使用正确的内部IP"
EOF
chmod +x $REPO_DIR/*
.sh
mark_state "scripts_generated"
echo "✅ 部署脚本生成完成"
fi
}
# ==================== 主执行流程 ====================
main
() {
echo "========================================"
echo " Kubernetes 离线部署包生成脚本
(v3
.2
) "
echo "========================================"
# 执行所有步骤
configure_repositories
install_essential_tools
select_k8s_version
download_k8s_components
download_docker_components
download_dependencies
create_local_repo
install_kubeadm_temp
install_docker
start_docker
download_k8s_images
generate_checksums
cleanup_temporary
generate_deployment_scripts
# 生成报告
echo "========================================"
echo "✅ 离线包创建成功! 目录: $REPO_DIR"
echo "🔸 Kubernetes版本: $K8S_VERSION"
echo ""
echo "📦 组件列表:"
find $PACKAGE_DIR -name '*
.rpm' -size +1k -exec basename {} \; | sort
echo ""
echo "🐳 镜像列表:"
find $IMAGES_DIR -name '*
.tar' -size +1k -exec basename {} \; | sort
echo ""
echo "🚀 部署
说明:"
echo "1
. 复制整个目录到目标机器: scp -r $REPO_DIR user@target:/opt"
echo "2
. 在目标机器上执行:"
echo " cd /opt/k8s-offline"
echo "
./install_docker
.sh # 安装Docker"
echo "
./deploy_k8s
.sh # 部署Kubernetes集群"
echo "========================================"
}
# 执行主函数
main
```
### 关键修复
说明
#### 1
. 修复仓库配置问题
```bash
# 修复仓库名称配置
cat > /etc/yum
.repos
.d/kubernetes
.repo <<'EOF'
[kubernetes] # 使用正确的仓库名称
name=Kubernetes
baseurl=https://mirrors
.aliyun
.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=0
repo_gpgcheck=0
EOF
```
**问题分析**：
- 之前的脚本中使用 `k8s` 作为仓库名称，但实际配置的是 `kubernetes`
- 导致 `yumdownloader` 无法找到仓库
**修复方案**：
- 统一使用 `kubernetes` 作为仓库名称
- 在下载组件时使用正确的仓库名称
#### 2
. 增强下载组件逻辑
```bash
# 修复仓库名称问题
local repo_name=""
case $type in
k8s
) repo_name="kubernetes" ;;
docker
) repo_name="docker-ce-stable" ;;
esac
if [[ -n "$repo_name" ]]; then
yumdownloader --disablerepo=* --enablerepo="$repo_name" \
--destdir="$PACKAGE_DIR" \
"${component}" || true
fi
```
**改进点**：
- 明确指定仓库名称，避免模糊匹配
- 添加
文件大小检查，避免处理空
文件
- 优化错误处理逻辑
#### 3
. 文件处理增强
```bash
# 避免
重复
文件错误
if [[ ! "$downloaded_file" -ef "$PACKAGE_DIR/$component-$version
.rpm" ]]; then
mv -f "$downloaded_file" "$PACKAGE_DIR/$component-$version
.rpm"
fi
```
**问题分析**：
- 当
文件已存在时，`mv` 命令会报错
- 导致脚本中断
**修复方案**：
- 使用 `-ef` 检查
文件是否相同
- 使用 `-f` 参数强制覆盖
#### 4
. EPEL 仓库修复
```bash
# 添加 EPEL 仓库
yum install -y https://mirrors
.aliyun
.com/epel/epel-release-latest-8
.noarch
.rpm
```
**问题分析**：
- CentOS 8 默认不
包含 EPEL 仓库
- 导致某些依赖无法下载
**修复方案**：
- 显式添加 EPEL 仓库
- 使用阿里云镜像源确保可用性
### 部署脚本优化
#### 1
. 安装 Docker 脚本增强
```bash
rpm_file=$
(find packages/ -name "${comp}-*
.rpm" -size +1k -print -quit
)
if [[ -f $rpm_file ]]; then
echo "🔧 安装: $
(basename $rpm_file
)"
rpm -ivh --nodeps --force "$rpm_file"
fi
```
**改进点**：
- 添加
文件大小检查
(`-size +1k`
)
- 使用 `-quit` 确保只处理第一个匹配项
#### 2
. 集群初始化增强
```bash
kubeadm init --
config=kubeadm-
config
.yaml --upload-certs || {
echo "⚠️ 初始化失败，尝试
重置后
重试
..."
kubeadm reset -f
sleep 5
kubeadm init --
config=kubeadm-
config
.yaml --upload-certs
}
```
**改进点**：
- 添加
重置和
重试逻辑
- 增加延时确保资源释放
### 使用
说明
1
. **执行脚本**：
```bash
chmod +x k8s-offline-generator
.sh
./k8s-offline-generator
.sh
```
2
. **选择版本**：
```
📋 可用 Kubernetes 版本:
1
) 1
.33
.3
2
) 1
.33
.2
...
👉 请选择版本号 [1-365, 默认1]: 11
```
3
. **在离线环境部署**：
```bash
cd /opt/k8s-offline
./install_docker
.sh
./deploy_k8s
.sh
```
### 验证集群状态
```bash
kubectl get nodes
kubectl get pods -A
```
### 错误处理指南
**问题：组件安装失败**
```bash
# 手动安装缺失组件
rpm -ivh --force /opt/k8s-offline/packages/<package-name>
.rpm
```
**问题：kubeadm 初始化失败**
```bash
#
重置集群
kubeadm reset -f
# 清理网络配置
ip link delete cni0
ip link delete flannel
.1
rm -rf /var/lib/cni/
#
重新初始化
./deploy_k8s
.sh
```
**问题：Docker 无法启动**
```bash
# 检查存储驱动
grep overlay /proc/filesystems
# 检查内核模块
lsmod | grep overlay
# 临时启用内核模块
modprobe overlay
```
此版本修复了仓库配置问题，增强了
文件处理逻辑，并优化了错误处理机制。
最低0.47元/天 解锁文章
扫一扫
1162
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
