<th
ink>根据日志，我们发现了几个问题：
1
. 在下载Kubernetes组件时，虽然yumdownloader报错（错误：未知仓库：'k8s-*'），但之前已经通过wget下载了部分组件（从阿里云镜像源下载），但日志中显示wget下载
失败，然后尝试使用yumdownloader，但是yumdownloader因为仓库名称问题
失败。
2
. 在yumdownloader
失败后，脚本尝试重命名文件，但出现“mv
: ... 与
... 为同一文件”的错误，说明文件已经存在，但之前wget可能并未成功下载（因为尝试多个URL，其中某个可能成功？），但日志中每个组件的多次尝试都是
40
4之类的错误（未明确显示，但可以推断），所以实际上并没有下载成功，而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
# 清理空文件
f
ind "$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=$
(f
ind "$PACKAGE_DIR" -name "${
component}-*
.rpm" -size +1k -pr
int -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`函数如下：</th
ink>### 终极修复版 Kubernetes 离线部署脚本
```bash
#!/b
in/bash
# Kubernetes 离线部署包生成脚本（修复仓库配置问题）
set -euo pipefail
# ==================== 配置区域 ====================
REPO_DIR="/opt/k8s-offl
ine"
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_6
4/
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/l
inux/centos/7/x86_6
4/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_6
4/Packages/
|
grep -oP 'kubelet-\K[0-9]+\
.[0-9]+\
.[0-9]+-[0-9]+'
|
sort -V -r
| uniq))
# 合并并去重
ALL_VERSIONS=
($
(pr
intf "%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
pr
intf "%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_6
4" "
.el8
.x86_6
4" "
.x86_6
4")
case $type
in
k8s)
mirrors=
(
"https
://mirrors
.aliyun
.com/kubernetes/yum/repos/kubernetes-el7-x86_6
4/Packages"
"https
://download
.docker
.com/l
inux/centos/7/x86_6
4/stable/Packages"
"https
://dl
.k8s
.io/release"
)
file_pattern="$
component-$version"
;;
docker)
mirrors=
(
"https
://download
.docker
.com/l
inux/centos/7/x86_6
4/stable/Packages"
"https
://mirrors
.aliyun
.com/docker-ce/l
inux/centos/7/x86_6
4/stable/Packages"
)
file_pattern="$
component-$version"
;;
*)
echo "❌ 未知组件类型
: $type"
return 1
;;
esac
# 检查是否已下载
exist
ing_file=$
(f
ind $PACKAGE_DIR -name "$
component-*
.rpm" -size +1k -pr
int -quit)
if [[ -f $exist
ing_file ]]; then
echo "📦 已存在
: $
(basename $exist
ing_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=$
(f
ind "$PACKAGE_DIR" -name "${
component}-*
.rpm" -size +1k -pr
int -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/l
inux/centos/7/x86_6
4/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"
"conta
inerd
.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=$
(f
ind $PACKAGE_DIR -name "${dep}-*
.rpm" -size +1k -pr
int -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字节文件
f
ind $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=$
(f
ind $PACKAGE_DIR -name 'kubeadm-*
.rpm' -size +1k
| head -1)
if [[ -z $kubeadm_rpm ]]; then
kubeadm_rpm=$
(f
ind $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 "conta
inerd
.io" "docker-ce-cli" "docker-ce"; do
rpm_file=$
(f
ind $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"
cont
inue
fi
echo "⬇️ 拉取镜像
: $image"
# 尝试官方源
if docker pull $image; then
docker save -o $IMAGES_DIR/$filename $image
cont
inue
fi
# 尝试阿里云镜像源
ali_image="registry
.aliyuncs
.com/google_conta
iners/$
(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 "🔒 生成校验文件
..."
f
ind $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 conta
inerd
.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'
#!/b
in/bash
set -e
echo "=== Docker 离线安装脚本 ==="
# 1
. 安装依赖
echo "🛠️ 安装系统依赖
..."
yum
install -y yum-utils device-mapper-persistent-data lvm2
# 2
. 安装Docker组件
components=
("conta
inerd
.io" "docker-ce-cli" "docker-ce")
for
comp
in "${
components[@]}"; do
rpm_file=$
(f
ind packages/ -name "${
comp}-*
.rpm" -size +1k -pr
int -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'
#!/b
in/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=$
(f
ind packages/ -name "${
comp}-*
.rpm" -size +1k -pr
int -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 '{pr
int $1}')
cat > kubeadm-config
.yaml <<EOC
apiVersion
: kubeadm
.k8s
.io/v1beta3
k
ind
: InitConfiguration
nodeRegistration
:
kubeletExtraArgs
:
node-ip
: $NODE_IP
---
apiVersion
: kubeadm
.k8s
.io/v1beta3
k
ind
: ClusterConfiguration
kubernetesVersion
: $K8S_VERSION
network
ing
:
podSubnet
: "10
.2
44.0
.0/16"
controlPlaneEndpo
int
: "$
(hostname -f)
:6
443"
imageRepository
: registry
.aliyuncs
.com/google_conta
iners
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/adm
in.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 --pr
int-jo
in-
command
echo ""
echo "🚨 注意
: 如果节点有多个IP地址，请确保使用正确的内部IP"
EOF
chmod +x $REPO_DIR/*
.sh
mark_state "scripts_generated"
echo "✅ 部署脚本生成完成"
fi
}
# ==================== 主执行流程 ====================
ma
in() {
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 "📦 组件列表
:"
f
ind $PACKAGE_DIR -name '*
.rpm' -size +1k -exec basename {} \;
| sort
echo ""
echo "🐳 镜像列表
:"
f
ind $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-offl
ine"
echo "
./
install_docker
.sh # 安装Docker"
echo "
./deploy_k8s
.sh # 部署Kubernetes集群"
echo "========================================"
}
# 执行主函数
ma
in
```
### 关键修复说明
#### 1
. 修复仓库配置问题
```bash
# 修复仓库名称配置
cat > /etc/yum
.repos
.d/kubernetes
.repo <<'EOF'
[kubernetes] # 使用正确的仓库名称
name=Kubernetes
baseurl=https
://mirrors
.aliyun
.com/kubernetes/yum/repos/kubernetes-el7-x86_6
4/
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=$
(f
ind packages/ -name "${
comp}-*
.rpm" -size +1k -pr
int -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-offl
ine-generator
.sh
./k8s-offl
ine-generator
.sh
```
2
. **选择版本**：
```
📋 可用 Kubernetes 版本
:
1) 1
.33
.3
2) 1
.33
.2
...
👉 请选择版本号 [1-365, 默认1]
: 11
```
3
. **在离线环境部署**：
```bash
cd /opt/k8s-offl
ine
./
install_docker
.sh
./deploy_k8s
.sh
```
### 验证集群状态
```bash
kubectl get nodes
kubectl get pods -A
```
### 错误处理指南
**问题：组件安装
失败**
```bash
# 手动安装缺失组件
rpm -ivh --force /opt/k8s-offl
ine/packages/<package-name>
.rpm
```
**问题：kubeadm 初始化
失败**
```bash
# 重置集群
kubeadm reset -f
# 清理网络配置
ip l
ink delete cni0
ip l
ink delete flannel
.1
rm -rf /var/lib/cni/
# 重新初始化
./deploy_k8s
.sh
```
**问题：Docker 无法启动**
```bash
# 检查存储驱动
grep overlay /proc/filesystems
# 检查内核模块
lsmod
| grep overlay
# 临时启用内核模块
modprobe overlay
```
此版本修复了仓库配置问题，增强了文件处理逻辑，并优化了错误处理机制。
本文介绍了解决Wget在下载SSL网址时遇到的证书错误的两种方法：一是通过添加--no-check-certificate参数忽略证书检查；二是安装ca-certificates或ssl-cert包来更新系统信任的证书。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
