Rancher集群动态伸缩：Node节点的自动化添加与清理

1. 为什么我们需要自动化管理Rancher节点？

如果你和我一样，管理过几个Rancher集群，肯定经历过这样的场景：业务高峰期突然来了，监控面板一片飘红，CPU和内存告警响个不停。这时候你手忙脚乱地打开云平台控制台，申请新机器，然后登录上去，一遍又一遍地执行那些重复的命令：改主机名、关防火墙、装Docker、再到Rancher UI里复制注册命令……一套流程下来，十几二十分钟过去了，业务那边可能已经受到了影响。更头疼的是，当流量低谷期来临，你又得手动登录到那些闲置的节点上，小心翼翼地清理容器、删除数据卷、移除Rancher目录，生怕删错了东西把集群搞崩。

这种手动操作，一次两次还行，但架不住业务弹性伸缩的需求越来越频繁。今天搞个促销，明天做个活动，集群规模像弹簧一样来回伸缩。纯靠人工，不仅效率低下，容易出错，而且对运维同学来说，简直就是一种精神折磨。我踩过几次坑之后，痛定思痛，决定把这一切都交给脚本和自动化流程。

所以，我们今天要聊的，就是如何用最接地气的Shell脚本，实现Rancher集群Node节点的自动化添加与清理。这不仅仅是把命令串起来那么简单，而是要构建一个可靠、高效、可重复的自动化流程。它能让你在几分钟内完成节点的扩容，也能在节点下线时，确保数据被彻底、安全地清理，不留任何“尾巴”。这对于需要频繁调整集群规模的DevOps场景，比如电商大促、在线教育高峰、游戏开服等，价值巨大。接下来，我就把自己实战中打磨出来的这套方法，掰开揉碎了讲给你听。

2. 自动化基石：环境准备与脚本设计思路

在动手写脚本之前，我们得先把地基打牢。自动化不是乱来，每一步都要有清晰的逻辑和兜底方案。我的经验是，把整个过程拆解成两个核心阶段：扩容和缩容，并为每个阶段设计独立的、健壮的脚本。

2.1 扩容阶段的核心任务拆解

扩容，就是把一台全新的、裸的Linux服务器（可能是云上的虚拟机，也可能是物理机），变成Rancher集群中一个合格的Worker节点。这个过程必须标准化，我把它分解为四个不可颠倒的步骤：

1. 系统初始化：这是第一步，也是确保环境一致性的关键。主要包括设置一个符合规范的主机名（比如 node-prod-01），以及关闭或配置防火墙（生产环境通常有更外层的安全组，这里为了简化，我们先关闭系统防火墙，但你要根据自身安全策略调整）。
2. Docker引擎部署：Rancher管理的容器跑在Docker（或其他容器运行时）之上。我们需要一个稳定、快速的方法来安装指定版本的Docker。二进制安装虽然步骤稍多，但避免了因系统包管理器版本差异带来的问题，可控性更强。
3. Rancher Agent注册：这是让节点“认祖归宗”的一步。我们需要从Rancher Server的UI界面上，为特定集群生成一条唯一的注册命令，然后在目标节点上执行它。这一步实现了节点与集群控制平面的连接。
4. 健康检查与就绪确认：命令执行完不代表万事大吉。我们需要一个检查机制，确认节点上的Rancher Agent容器是否成功启动，并且节点状态在Rancher UI中是否变为“Active”。

2.2 缩容阶段的安全清理逻辑

缩容，恰恰是更容易出问题的地方。粗暴地直接关掉虚拟机，会导致Rancher Server认为节点失联，但上面运行的容器可能还“残留”着，数据卷也没清理，久而久之会造成资源泄露和状态混乱。安全的缩容流程应该是：

1. 驱逐或迁移工作负载：在Rancher UI或通过kubectl命令，将该节点标记为不可调度（Cordon），并排空（Drain）其上运行的Pod，让它们迁移到其他节点。这是第一步，也是保护业务连续性的关键。
2. 从Rancher集群中移除：在Rancher UI中，将该节点从集群中删除。这会触发Rancher Server清理该节点的元数据。
3. 节点本地彻底清理：这是脚本发挥主要作用的地方。我们需要登录到该节点，执行清理“三部曲”：停止并删除所有容器、删除所有本地数据卷、删除Rancher Agent留下的目录和配置文件。确保这台机器下次能作为一张“白纸”被重新利用。
4. 可选：归还基础设施：如果节点是云主机，最后可以调用云厂商API将其关机或销毁。

基于以上分析，我们的脚本设计思路就很清晰了：编写两个主脚本，add_node.sh 负责扩容，remove_node.sh 负责缩容。它们都应该具备参数化输入（比如节点IP、集群令牌）、完善的日志记录、每一步的错误检查以及失败重试或回退的机制。下面，我们就进入实战环节。

3. 实战：编写智能节点扩容脚本（add_node.sh）

这个脚本的目标是：你只需要提供新节点的IP地址（或主机名）和必要的集群信息，它就能自动完成从系统初始化到加入集群的全过程。我们一步步来构建它。

3.1 脚本开头：参数定义与安全校验

一个好的脚本应该易于使用和调试。我们首先定义必要的参数，并做一些基础检查。

#!/bin/bash

# 文件名：add_node.sh
# 描述：自动化将新服务器添加为Rancher集群节点
# 用法：./add_node.sh <NODE_IP> <RANCHER_REGISTRATION_COMMAND>

set -e  # 遇到任何命令执行失败就退出，避免错误累积

NODE_IP=$1
RANCHER_CMD=$2

# 颜色定义，让输出更友好
GREEN='\033[0;32m'
RED='\033[0;31m'
NC='\033[0m' # No Color

# 简单的参数检查
if [ -z "$NODE_IP" ] || [ -z "$RANCHER_CMD" ]; then
    echo -e "${RED}错误：参数缺失。${NC}"
    echo "用法: $0 <新节点IP地址> <从Rancher UI复制的完整注册命令>"
    echo "示例: $0 192.168.1.100 'sudo docker run -d --privileged --restart=unless-stopped --net=host -v /etc/kubernetes:/etc/kubernetes -v /var/run:/var/run rancher/rancher-agent:v2.3.8 --server https://rancher.example.com --token xyz --ca-checksum abc'"
    exit 1
fi

echo -e "${GREEN}[INFO] 开始准备节点: $NODE_IP ${NC}"
LOG_FILE="/tmp/add_node_${NODE_IP}_$(date +%Y%m%d%H%M%S).log"
exec > >(tee -a "$LOG_FILE") 2>&1  # 同时输出到屏幕和日志文件
echo "任务开始时间: $(date)"

这里的关键是 set -e 和参数检查。set -e 能确保脚本中任何一步出错，整个脚本就停止，防止在错误的环境上继续执行更危险的操作。将Rancher UI生成的整条注册命令作为第二个参数传入，是最灵活的方式，因为它包含了服务器地址、令牌等所有信息。

3.2 核心函数一：远程系统初始化

我们将通过SSH在目标节点上执行命令。为了代码清晰，我们把主要操作封装成函数。

# 函数：初始化目标节点系统
init_node() {
    local ip=$1
    echo -e "${GREEN}[STEP 1] 正在初始化节点系统...${NC}"

    # 1. 设置主机名（假设我们根据IP生成主机名）
    local hostname="node-$(echo $ip | tr '.' '-')"
    ssh root@$ip "hostnamectl set-hostname $hostname"
    echo "  主机名已设置为: $hostname"

    # 2. 关闭防火墙（生产环境请根据实际情况调整，可能只需放行特定端口）
    if ssh root@$ip "systemctl is-active firewalld >/dev/null 2>&1"; then
        ssh root@$ip "systemctl stop firewalld && systemctl disable firewalld"
        echo "  防火墙已停止并禁用。"
    else
        echo "  防火墙未运行或未安装，跳过。"
    fi

    # 3. 关闭Swap（Kubernetes通常要求）
    ssh root@$ip "swapoff -a"
    sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab 2>/dev/null || true
    echo "  Swap已临时关闭并在fstab中注释。"
}

这个函数完成了最基础的系统配置。注意，关闭防火墙和Swap是通用做法，但你必须评估自己的安全需求。在公有云上，主要依赖安全组，关闭实例防火墙是可以接受的。

3.3 核心函数二：使用二进制包安装Docker

为什么用二进制安装？因为它不依赖于特定Linux发行版的包管理器，版本控制更精准，适合自动化。我们安装一个较新的稳定版，比如20.10。

# 函数：安装Docker（二进制方式）
install_docker() {
    local ip=$1
    echo -e "${GREEN}[STEP 2] 正在安装Docker...${NC}"

    # 定义要安装的Docker版本
    local DOCKER_VERSION="20.10.23"
    local DOCKER_URL="https://download.docker.com/linux/static/stable/x86_64/docker-${DOCKER_VERSION}.tgz"

    # 通过SSH在目标节点上执行安装脚本
    ssh root@$ip "bash -s" << EOF
        set -e
        echo "  检查是否已安装Docker..."
        if command -v docker &> /dev/null; then
            echo "  Docker已存在，跳过安装。"
            exit 0
        fi

        echo "  开始下载Docker二进制包..."
        curl -fsSL $DOCKER_URL -o /tmp/docker.tgz

        echo "  解压到 /usr/bin..."
        tar -xz -C /usr/bin -f /tmp/docker.tgz --strip-components=1

        echo "  创建docker用户组..."
        groupadd docker 2>/dev/null || true

        echo "  启动Docker服务..."
        cat > /etc/systemd/system/docker.service << 'SVC_EOF'
[Unit]
Description=Docker Application Container Engine
Documentation=https://docs.docker.com
After=network-online.target firewalld.service
Wants=network-online.target

[Service]
Type=notify
ExecStart=/usr/bin/dockerd
ExecReload=/bin/kill -s HUP \$MAINPID
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
TimeoutStartSec=0
Delegate=yes
KillMode=process
Restart=on-failure
StartLimitBurst=3
StartLimitInterval=60s

[Install]
WantedBy=multi-user.target
SVC_EOF

        systemctl daemon-reload
        systemctl enable docker
        systemctl start docker

        echo "  验证Docker安装..."
        docker --version
        echo "  Docker安装完成。"
EOF
    echo -e "${GREEN}  Docker安装成功。${NC}"
}

这个函数内容较多，它通过 ssh ... “bash -s” << EOF 的方式，将一整个脚本块传递到远程节点执行。里面包含了下载、解压、配置systemd服务、启动等完整步骤。安装前会检查是否已存在，避免重复安装。

3.4 核心函数三：执行Rancher注册命令

这是最关键的一步，我们将用户传入的注册命令在目标节点上执行。

# 函数：加入Rancher集群
join_rancher_cluster() {
    local ip=$1
    local cmd="$2"
    echo -e "${GREEN}[STEP 3] 正在将节点加入Rancher集群...${NC}"

    # 注意：这里直接执行传入的完整命令。该命令通常已经包含了sudo docker run...
    echo "  执行的命令: $cmd"
    ssh root@$ip "$cmd"

    if [ $? -eq 0 ]; then
        echo -e "${GREEN}  Rancher Agent启动命令已发送。${NC}"
    else
        echo -e "${RED}  错误：执行Rancher注册命令失败！${NC}"
        exit 1
    fi
}

这里有一个小细节：从Rancher UI复制的命令通常以 sudo docker run... 开头。因为我们脚本全程使用root用户SSH登录，所以这个 sudo 其实是多余的，甚至可能导致命令失败（如果没配置sudo）。更严谨的做法是，在脚本中或传入前，将命令中的 sudo 去掉。我们可以简单处理一下：cmd=\${cmd//sudo /}。为了保持灵活性，脚本中暂时不做处理，但你在实际使用时需要注意。

3.5 核心函数四：等待并确认节点就绪

执行完注册命令不等于节点就可用。我们需要等待一段时间，并检查节点状态。

# 函数：检查节点状态
check_node_status() {
    local ip=$1
    echo -e "${GREEN}[STEP 4] 等待并检查节点状态...${NC}"
    local max_retries=30
    local retry_interval=10 # 秒

    echo "  等待Rancher Agent启动（最多等待 ${max_retries} 次，每次 ${retry_interval} 秒）..."
    for i in $(seq 1 $max_retries); do
        # 检查节点上rancher-agent容器是否在运行
        if ssh root@$ip "docker ps --filter 'name=rancher-agent' --format 'table {{.Names}}\t{{.Status}}' | grep -q Up"; then
            echo -e "${GREEN}  节点 $ip 上的Rancher Agent容器已正常运行。${NC}"
            echo "  请注意：节点在Rancher UI中显示为'Active'可能需要额外1-2分钟。"
            return 0
        else
            echo "  第 $i 次检查，Agent尚未就绪，等待 ${retry_interval} 秒后重试..."
            sleep $retry_interval
        fi
    done

    echo -e "${RED}  错误：在预定时间内未检测到节点 $ip 上的Rancher Agent运行。${NC}"
    echo "  请登录Rancher UI或检查节点日志进行排查。"
    return 1
}

这个函数会循环检查远程节点上是否有名为 rancher-agent 且状态为 Up 的容器。这是节点加入集群的第一步信号。至于在Rancher UI里变成“Active”，还取决于节点与控制平面的网络通信、节点检查任务完成等情况，所以脚本里给出了提示。

3.6 脚本主流程与执行示例

最后，我们把所有函数串联起来，形成主流程。

# 主执行流程
main() {
    local node_ip=$NODE_IP
    local rancher_cmd=$RANCHER_CMD

    echo -e "${GREEN}========== 开始自动化添加节点流程 ==========${NC}"
    init_node $node_ip
    install_docker $node_ip
    join_rancher_cluster $node_ip "$rancher_cmd"
    check_node_status $node_ip

    echo -e "${GREEN}========== 流程结束 ==========${NC}"
    echo -e "${GREEN}[SUCCESS] 节点 $node_ip 已成功加入流程执行完毕。${NC}"
    echo "请稍后登录Rancher UI确认节点状态为 'Active'。"
    echo "操作日志已保存至: $LOG_FILE"
}

# 执行主函数
main

使用这个脚本非常简单：

1. 首先，在Rancher UI中，进入你的集群，点击“编辑集群”，滚动到“节点选项”部分，复制那行长长的 docker run... 命令。
2. 在你的运维机器（跳板机）上运行：./add_node.sh 192.168.1.100 ‘你复制的命令’。

脚本就会自动完成所有工作，并将日志输出到屏幕和文件。这样一来，扩容一台新节点，从手动操作的十几二十分钟，缩短到了脚本执行的几分钟，而且完全标准化，避免了人为失误。

4. 实战：编写安全节点清理脚本（remove_node.sh）

节点下线比上线更需要小心谨慎。我们的清理脚本必须确保在移除节点前，尽可能安全地迁移工作负载，并彻底清理节点本地环境。

4.1 清理前的关键准备：驱逐工作负载

这是最重要且容易被脚本忽略的一步！ 直接在节点上清理容器，会导致正在运行的服务突然中断。正确的做法是，先在Rancher或Kubernetes层面将节点标记为不可调度并排空。

由于这通常需要在拥有kubeconfig的运维机上操作，我们可以把这一步作为脚本的“前置条件”或一个可选阶段。这里给出通过kubectl实现的示例：

#!/bin/bash
# 文件名：remove_node.sh
# 描述：安全地从Rancher集群移除节点并清理环境
# 用法：./remove_node.sh <NODE_IP> <NODE_NAME_IN_RANCHER>

set -e

NODE_IP=$1
NODE_NAME=$2 # 节点在Kubernetes/Rancher中的名称

GREEN='\033[0;32m'
YELLOW='\033[1;33m'
RED='\033[0;31m'
NC='\033[0m'

if [ -z "$NODE_IP" ] || [ -z "$NODE_NAME" ]; then
    echo -e "${RED}错误：需要提供节点IP和节点名。${NC}"
    echo "用法: $0 <节点IP> <节点在Rancher中的名称>"
    echo "提示：节点名可通过 'kubectl get nodes' 获取"
    exit 1
fi

LOG_FILE="/tmp/remove_node_${NODE_NAME}_$(date +%Y%m%d%H%M%S).log"
exec > >(tee -a "$LOG_FILE") 2>&1

echo -e "${YELLOW}[WARNING] 这是一个破坏性操作，请确保已备份必要数据！${NC}"
read -p "是否确认清理节点 $NODE_NAME ($NODE_IP)? (输入 yes 继续): " confirm
if [ "$confirm" != "yes" ]; then
    echo "操作已取消。"
    exit 0
fi

# 步骤0（建议）：在拥有kubectl的环境先执行驱逐
echo -e "${GREEN}[STEP 0] 建议：在控制平面执行节点驱逐...${NC}"
echo "请在能访问Kubernetes集群的机器上手动执行以下命令（或集成到你的流程中）："
echo "  kubectl cordon $NODE_NAME        # 标记为不可调度"
echo "  kubectl drain $NODE_NAME --ignore-daemonsets --delete-emptydir-data   # 驱逐Pod"
echo ""
echo "等待Pod迁移完成后，再在此脚本窗口按回车继续本地清理..."
read -p "按回车键继续 > "

脚本一开始就进行了强烈的风险提示和确认。它给出了手动执行 kubectl cordon 和 kubectl drain 的命令示例。在实际的自动化流水线中，你可以将这一步与你的CI/CD工具（如Jenkins）或配置管理工具（如Ansible）结合，实现完全自动化。但为了安全起见，保留一个手动确认环节是明智的。

4.2 核心清理函数：停止容器、删除数据、移除配置

确认工作负载已迁移后，我们就可以登录到节点进行“大扫除”了。

# 函数：清理节点上的Docker和Rancher残留
cleanup_node() {
    local ip=$1
    local node_name=$2
    echo -e "${GREEN}[STEP 1] 正在清理节点 $node_name ($ip) ...${NC}"

    # 1. 停止并删除所有容器
    echo "  停止并删除所有容器..."
    ssh root@$ip "docker stop \$(docker ps -aq) 2>/dev/null || true"
    ssh root@$ip "docker rm -f \$(docker ps -aq) 2>/dev/null || true"
    echo "  所有容器已停止并删除。"

    # 2. 删除所有数据卷（谨慎操作！）
    echo "  删除所有本地数据卷..."
    ssh root@$ip "docker volume rm \$(docker volume ls -q) 2>/dev/null || true"
    echo "  数据卷已清理。"

    # 3. 删除Rancher相关目录和配置
    echo "  删除Rancher Agent目录和配置..."
    ssh root@$ip "rm -rf /var/lib/rancher /etc/rancher /opt/rancher"
    echo "  Rancher相关目录已删除。"

    # 4. 清理Docker相关资源（网络、镜像可选）
    echo "  清理Docker网络和残留镜像（可选）..."
    ssh root@$ip "docker network prune -f 2>/dev/null || true"
    # 注意：删除所有镜像通常不需要，但如果你需要完全重置，可以取消下一行注释
    # ssh root@$ip "docker rmi -f \$(docker images -aq) 2>/dev/null || true"

    # 5. 停止并禁用Docker服务（如果打算彻底重装或不再使用）
    echo "  停止Docker服务..."
    ssh root@$ip "systemctl stop docker 2>/dev/null || true"
    ssh root@$ip "systemctl disable docker 2>/dev/null || true"
    echo "  Docker服务已停止并禁用。"

    echo -e "${GREEN}  节点本地清理完成。${NC}"
}

这个函数是清理脚本的核心。它按照依赖关系，从外到内进行清理：

1. 先停再删容器：避免直接删除运行中的容器导致问题。
2. 删除数据卷：这是释放存储空间的关键。请务必确认这些卷上的数据没有其他用途或已备份。
3. 删除Rancher目录：/var/lib/rancher 包含了agent的证书、缓存等，必须删除，否则未来用相同主机名和IP加入集群可能会冲突。
4. 可选清理：清理Docker网络和镜像。对于要彻底回收的机器，可以做。
5. 停止Docker：如果这台机器后续要移作他用或重新初始化，停止服务是好的做法。

4.3 主流程与最终确认

# 主执行流程
main() {
    local node_ip=$NODE_IP
    local node_name=$NODE_NAME

    echo -e "${GREEN}========== 开始安全清理节点流程 ==========${NC}"
    echo -e "${YELLOW}目标节点: $node_name ($node_ip)${NC}"
    echo -e "${YELLOW}请确保该节点上的工作负载已迁移完毕！${NC}"

    cleanup_node $node_ip $node_name

    echo -e "${GREEN}========== 本地清理流程结束 ==========${NC}"
    echo -e "${GREEN}[SUCCESS] 节点 $node_name ($node_ip) 本地环境已清理。${NC}"
    echo ""
    echo -e "${YELLOW}[重要后续步骤]${NC}"
    echo "1. 登录Rancher UI，在集群的'节点'页面，手动删除节点 '$node_name'。"
    echo "2. （如果使用云主机）现在可以在云平台安全地关闭或删除此虚拟机实例。"
    echo "操作日志已保存至: $LOG_FILE"
}

main

脚本运行结束后，它清晰地指出了后续必须手动完成的两步：在Rancher UI中删除节点元数据，以及在云平台操作虚拟机。这是因为这些操作通常涉及更高的权限和不同的系统，不适合放在一个面向所有节点的通用脚本里。

5. 进阶：将脚本集成到自动化流程与避坑指南

有了这两个脚本，我们已经实现了单次操作的自动化。但要真正应对弹性伸缩，我们需要把它融入更大的自动化流程中，并了解可能遇到的“坑”。

5.1 与CI/CD或云平台事件集成

单纯的脚本需要人工触发。我们可以把它变得“智能”：

• 基于监控告警的自动扩容：当Prometheus监控到集群资源不足时，可以通过Webhook触发Jenkins Pipeline或直接调用一个编排系统（如Ansible Tower）。该流程首先调用云厂商API创建新虚拟机，然后通过SSH在这台新机器上执行我们的 add_node.sh 脚本。
• 与Terraform等IaC工具结合：在Terraform定义虚拟机资源时，可以使用 remote-exec provisioner，在资源创建后立即执行 add_node.sh 的核心逻辑（需要将脚本内容嵌入或提前上传）。
• 定时缩容：在业务低峰期（例如凌晨2点），通过一个定时任务，调用 remove_node.sh 来清理标记为“可回收”的节点。节点的标记可以通过打标签（Label）来实现，例如 recycle=true。

这里给出一个简化的Jenkins Pipeline阶段示例，展示思路：

pipeline {
    agent any
    parameters {
        string(name: ‘NODE_IP‘, description: ‘新节点IP地址‘)
        string(name: ‘RANCHER_CMD‘, description: ‘Rancher注册命令‘)
    }
    stages {
        stage(‘添加Rancher节点‘) {
            steps {
                script {
                    // 假设脚本已在工作空间
                    sh “chmod +x ./scripts/add_node.sh“
                    sh “./scripts/add_node.sh ${params.NODE_IP} ‘${params.RANCHER_CMD}‘“
                }
            }
        }
    }
}

5.2 实战中踩过的坑与解决方案

1. 坑一：注册命令中的sudo问题

   • 现象：从Rancher UI复制的命令包含 sudo，但脚本用root SSH执行，导致 sudo: command not found 或权限错误。
   • 解决：在脚本中处理命令时，移除 sudo 关键字。可以在 join_rancher_cluster 函数里加一行：local clean_cmd=\${cmd//sudo /}，然后用 $clean_cmd 去执行。

2. 坑二：节点一直处于“Pending”或“Provisioning”状态

   • 现象：脚本执行成功，但Rancher UI中节点一直不变成“Active”。
   • 排查：
     • 检查节点与Rancher Server的网络连通性（端口443, 6443等）。
     • 登录到节点，查看 docker logs rancher-agent 容器的日志，通常会有明确的错误信息，比如证书错误、token无效、服务器地址无法解析等。
     • 确认Rancher Server的版本与Agent的版本是否兼容。
   • 解决：根据日志修复网络、DNS或配置问题。确保注册命令是从正确的集群页面复制的。

3. 坑三：清理脚本误删其他节点数据

   • 风险：如果脚本通过IP或主机名识别节点有误，可能会登录到错误的机器上执行清理，造成灾难。
   • 预防：
     • 在脚本中增加双重确认，不仅要IP，还要验证主机名或某个特定标签文件。
     • 先执行一个“模拟”命令，例如 ssh root@$ip ‘hostname‘ 来确认目标机器。
     • 将清理操作分为“检查”和“执行”两个阶段，检查阶段只列出将要删除的内容，由人工确认后再执行。

4. 坑四：Docker镜像拉取缓慢导致Agent启动超时

   • 现象：在 check_node_status 阶段等待超时，因为 rancher/rancher-agent 镜像从Docker Hub拉取太慢。
   • 解决：
     • 在初始化节点后，先为Docker配置国内镜像加速器。
     • 或者，在私有环境中，先将必要的镜像推送到内网镜像仓库，并修改注册命令中的镜像地址。

5. 安全提醒：脚本中使用了root SSH免密登录，这要求运维机与节点之间有SSH密钥信任关系。务必妥善保管私钥，并限制运维机的访问来源。在生产环境中，考虑使用像Vault这样的秘密管理工具来动态管理SSH证书，而不是使用固定的密钥对。

把这些脚本和注意事项融入到你的运维体系中，你就能构建一个响应迅速、安全可靠的Rancher集群弹性伸缩能力。从手动到自动，改变的不仅是效率，更是运维的确定性和可靠性。