【信创】外网纯国产化aarch64(arm64)终端安装deepseek Ragflow 迁移至内网银河麒麟V10服务器

真实环境实验

• 外网：飞腾 D2000/4核16G，UOS1070 aarch64（64K 页），全程 root 执行 sudo su
• 内网：FT2000+ 128G，银河麒麟 V10 矛系统，物理断网
• 核心原则：外网只构建镜像、导入模型、打包离线资源，不启动完整 RAG 对话业务（16G 内存不足以跑 14B 推理）

【信创】外网aarch64终端安装deepseek Ragflow 迁移至内网银河麒麟服务器

文章目录

• 【信创】外网aarch64终端安装deepseek Ragflow 迁移至内网银河麒麟服务器
• 第一阶段：外网 D2000 UOS 1070 操作（联网）
• • 操作前：手动进入ROOT（必须先做）
  • 步骤1：创建第一个脚本 01env_build.sh
  • 步骤2：创建 02build_ragflow.sh（构建镜像）
  • 步骤3：创建 03install_ollama_build.sh（安装Ollama+下载模型）
  • 步骤4：创建 04inputDeepseek.sh（导入模型）
• 第二阶段：打包全部离线包（联网终端）
• • 步骤1：创建 10backup_check_space.sh（检查存储空间）
  • 步骤2：创建 11backup_ollama_only.sh（打包ollama）
  • 步骤3：创建 12export_docker_image.sh（导出docker）
• ✅【外网所有工作到此结束】
• 第三阶段：内网 FT2000+ 128G 麒麟断网部署（最终运行）
• • 1. 内网终端先切root
  • 2. 挂载移动介质
  • 3. 内网安装Docker脚本 21env_prod.sh
  • 4. 内网部署全套业务脚本 22deploy_prod.sh
  • 5. 修改内网.env配置
  • 6. 修改内网nginx/nginx.conf配置
  • 7. 修改内网docker-compose.yml配置
  • 8. 启动项目
• 最终成功！！！
• 总结核心真相
• 致谢：
• 整套离线还原原理（外网导出 → 内网恢复）
• • 一、
• 关键要点总结（还原核心逻辑）

第一阶段：外网 D2000 UOS 1070 操作（联网）

需要下载的几个大文件：

wget https://mirrors.ustc.edu.cn/docker-ce/linux/static/stable/aarch64/docker-26.0.2.tgz

wget https://github.com/docker/buildx/releases/download/v0.37.0/buildx-v0.37.0.linux-arm64

wget https://github.com/docker/compose/releases/download/v2.27.1/docker-compose-linux-aarch64

git clone https://github.com/infiniflow/ragflow.git

# Q4_K_M 推荐
wget https://hf-mirror.com/bartowski/DeepSeek-R1-Distill-Qwen-14B-GGUF/resolve/main/DeepSeek-R1-Distill-Qwen-14B-Q4_K_M.gguf

ollama pull qllama/bge-small-zh-v0.5:q4_k_m

操作前：手动进入ROOT（必须先做）

打开终端，输入：

sudo su

输入密码 现在你是#最高权限。

步骤1：创建第一个脚本 01env_build.sh

新建文件：

nano 01env_build.sh

粘贴下面完整修复好的代码（无任何sudo错误）

#!/bin/bash
set -e

apt update
apt install -y git wget curl ca-certificates python3-pip

# Docker静态包（中科大可用）
# wget https://mirrors.ustc.edu.cn/docker-ce/linux/static/stable/aarch64/docker-26.0.2.tgz
if [ "$(id -u)" -ne 0 ];then
echo "请使用root权限运行此脚本"
exit 1
fi

# 停止残留服务与进程
systemctl stop docker || true
systemctl stop docker.socket || true
systemctl stop containerd || true
pkill -9 dockerd || true
pkill -9 containerd || true
pkill -9 runc || true
sleep 1

# 校验离线静态包
if [ ! -f "./docker-26.0.2.tgz" ];then
echo "[ERROR] 缺失文件 docker-26.0.2.tgz"
exit 1
fi

# 解压并部署二进制
rm -rf docker
tar -zxf docker-26.0.2.tgz
rm -f /usr/local/bin/{docker,dockerd,containerd,runc,docker-init,docker-proxy}
cp docker/* /usr/local/bin/
chmod +x /usr/local/bin/{docker,dockerd,containerd,runc,docker-init,docker-proxy}

# 写入systemd服务单元
cat > /etc/systemd/system/docker.service <<'SERVICE'
[Unit]
Description=Docker Application Container Engine
After=network-online.target
[Service]
Type=notify
ExecStart=/usr/local/bin/dockerd
ExecReload=/bin/kill -s HUP $MAINPID
TimeoutSec=0
RestartSec=2
Restart=always
[Install]
WantedBy=multi-user.target
SERVICE

# 部署 docker‑compose
cp docker-compose-linux-aarch64 /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
ln -sf /usr/local/bin/docker-compose /usr/bin/docker-compose

# 重载systemd，启动docker
systemctl daemon-reload
systemctl start docker
systemctl enable docker

# 永久修复PATH（统信UOS默认不含/usr/local/bin）
echo 'export PATH="/usr/local/bin:$PATH"' > /etc/profile.d/99-docker-path.sh
chmod 644 /etc/profile.d/99-docker-path.sh
export PATH="/usr/local/bin:$PATH"
hash -r

# Docker CLI 插件（推荐全局目录）
# 下载二进制
wget https://github.com/docker/buildx/releases/download/v0.37.0/buildx-v0.37.0.linux-arm64
# 创建插件目录
mkdir -p /usr/local/lib/docker/cli-plugins
# 复制并重命名为 docker-buildx
cp buildx-v0.37.0.linux-arm64 /usr/local/lib/docker/cli-plugins/docker-buildx
# 添加执行权限
chmod +x /usr/local/lib/docker/cli-plugins/docker-buildx

# 验证安装
docker buildx version
# 成功输出类似：github.com/docker/buildx v0.37.0

# 最终校验
docker -v
docker-compose -v
echo "====== Docker 26.0.2 aarch64 离线安装完成 ======"

保存：Ctrl+O 回车 退出：Ctrl+X

小提示：以后不要完整重跑整个脚本，Docker程序正在运行时不能覆盖。 现在只要两条命令输出版本号，01这一步就彻底完成，直接进入构建镜像的阶段。

赋予权限并运行

chmod +x 01env_build.sh
./01env_build.sh

✅ Docker 安装完成

步骤2：创建 02build_ragflow.sh（构建镜像）

nano 02build_ragflow.sh

粘贴：

#!/bin/bash
set -e

if [ ! -d "./ragflow" ];then
echo "[ERROR] 当前目录不存在 ragflow 源码文件夹！"
exit 1
fi

cd ragflow

# 创建 / 修改 daemon.json 镜像配置及开启 BuildKit
mkdir -p /etc/docker
cat > /etc/docker/daemon.json <<EOF
{
"registry-mirrors": [
"https://docker.1ms.run",
"https://docker.ketches.cn"
],
"features": {
"buildkit": true
}
}
EOF

# 设置安全权限
chmod 644 /etc/docker/daemon.json

# 重启 docker 服务生效
systemctl daemon-reload
systemctl restart docker

# 验证镜像源是否生效
docker info | grep -A 10 "Registry Mirrors"

echo "===== 开始构建 ragflow:arm64 镜像 ====="

# 临时开启 BuildKit（当前终端生效）
export DOCKER_BUILDKIT=1

docker build –build-arg NEED_MIRROR=1 -t ragflow:arm64 .

echo "===== 拉取中间件镜像 ====="
docker pull postgres:15-alpine
docker pull redis:7-alpine
docker pull nginx:alpine

echo "【OK】RAGFlow镜像构建完成"
docker images

运行：

chmod +x 02build_ragflow.sh
./02build_ragflow.sh

步骤3：创建 03install_ollama_build.sh（安装Ollama+下载模型）

nano 03install_ollama_build.sh

粘贴：

#!/bin/bash
set -e

# 安装ollama
# 解压.tar.zst → .tar → 解包文件
apt update
apt install zstd -y
# 保留原zst文件-不加 – k 会自动删除原.zst 包；加上 -k 保留原压缩文件
zstd -d -k ollama-linux-arm64.tar.zst
tar -xvf ollama-linux-arm64.tar

cp -R ollama-linux-arm64 /usr/local/bin/ollama
chmod +x /usr/local/bin/ollama/bin/ollama

# 写入系统服务
cat > /etc/systemd/system/ollama.service <<'EOF'
[Unit]
Description=Ollama Service
After=network.target

[Service]
Environment="OLLAMA_HOST=0.0.0.0"
ExecStart=/usr/local/bin/ollama/bin/ollama serve
Restart=always

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl start ollama
systemctl enable ollama

# 创建全局软链接，任意目录直接执行 ollama
ln -sf /usr/local/bin/ollama/bin/ollama /usr/bin/ollama

ollama –version

echo "【OK】ollama构建完成"

运行：

chmod +x 03install_ollama_build.sh
./03install_ollama_build.sh

步骤4：创建 04inputDeepseek.sh（导入模型）

nano 04inputDeepseek.sh

粘贴：

#!/bin/bash
set -e

# 切换到模型GGUF存放目录

# 1. 构建 DeepSeek‑R1‑14B Ollama 模型
cat > Modelfile-14b <<'MF'
FROM ./DeepSeek-R1-Distill-Qwen-14B-Q4_K_M.gguf
PARAMETER temperature 0.6
PARAMETER num_ctx 8192
MF

ollama create deepseek-r1-14b -f Modelfile-14b
echo "✅ deepseek-r1-14b 创建成功"
# 构建成功后可以直接删除临时Modelfile
rm -f Modelfile-14b

# 导入向量模型
# 2. 直接拉取向量模型（不用手动下载GGUF，规避404）
ollama pull qllama/bge-small-zh-v1.5:q4_k_m

# 查看全部模型
ollama list
curl 127.0.0.1:11434/api/tags
echo "两个模型全部就绪，准备离线打包迁移"
echo "【OK】模型导入完成（禁止对话测试！！！16G内存会崩）"

运行：

chmod +x 04inputDeepseek.sh
./04inputDeepseek.sh

第二阶段：打包全部离线包（联网终端）

外网导出阶段（12export_docker_image.sh）做了什么

步骤1：创建 10backup_check_space.sh（检查存储空间）

nano 10backup_check_space.sh

粘贴：

#!/bin/bash
OLLAMA_PATH="/root/.ollama"
# 获取模型大小(KB)
SIZE_KB=$(du -s "${OLLAMA_PATH}" | awk '{print $1}')
SIZE_GB=$(echo "$SIZE_KB / 1024 /1024" | bc -l)
# 当前分区可用空间(KB)
AVAIL_KB=$(df -Pk . | tail -1 | awk '{print $4}')
AVAIL_GB=$(echo "$AVAIL_KB /1024 /1024" | bc -l)

echo "================空间评估=================="
printf "模型源文件大小: %.2f GB\\n" ${SIZE_GB}
printf "当前磁盘剩余: %.2f GB\\n" ${AVAIL_GB}
echo "——————————————"
printf "【复制再打包】最少需要: %.2f GB空闲\\n" $(echo "2 * $SIZE_GB" | bc -l)
printf "【直接tar打包】最少需要: %.2f GB空闲\\n" ${SIZE_GB}
echo "=========================================="
if (( $(echo "$AVAIL_GB < $SIZE_GB" | bc –l) ));then
echo "⚠️警告：空间不足！本机无法备份，请使用外接U盘/移动硬盘"
elif (( $(echo "$AVAIL_GB < 2 * $SIZE_GB" | bc –l) ));then
echo "✅只能使用【直接tar打包】，禁止cp复制方案"
else
echo "✅空间充足，两种备份方式都可以"
fi

步骤2：创建 11backup_ollama_only.sh（打包ollama）

nano 11backup_ollama_only.sh

粘贴：

#!/bin/bash

#!/bin/bash
set -e

SCRIPT_FILE=$(readlink -f "$0")
WORKDIR=$(dirname "${SCRIPT_FILE}")
cd "${WORKDIR}" || { echo "目录异常：${WORKDIR}"; exit 1; }

BUNDLE_DIR="${WORKDIR}/offline_bundle"
DEPLOY_TMP="${WORKDIR}/deploy_pack"

# 真实部署目录（来自systemd service）
OLLAMA_INSTALL_ROOT="/usr/local/bin/ollama"
OLLAMA_CLI="/usr/bin/ollama"
OLLAMA_DATA_SRC="/root/.ollama"
OLLAMA_SERVICE_FILE="/etc/systemd/system/ollama.service"
RAGFLOW_HOST_DIR="${WORKDIR}/ragflow/docker"

echo "=================================================="
echo "【Ollama完整离线备份（发布包+模型+服务配置）】"
echo "基准目录: ${WORKDIR}"
echo "程序根目录: ${OLLAMA_INSTALL_ROOT}"
echo "模型目录: ${OLLAMA_DATA_SRC}"
echo "=================================================="

# 前置校验
if [ ! -d "${OLLAMA_INSTALL_ROOT}" ];then
echo "[ERROR] 主程序目录不存在：${OLLAMA_INSTALL_ROOT}"
exit 1
fi
if [ ! -d "${OLLAMA_DATA_SRC}/models" ];then
echo "[ERROR] Ollama模型目录缺失"
exit 1
fi
if [ ! -d "${RAGFLOW_HOST_DIR}" ];then
echo "[ERROR] ragflow/docker不存在"
exit 1
fi

# 停止服务防止文件占用
systemctl stop ollama 2>/dev/null || true

rm -rf "${BUNDLE_DIR}" "${DEPLOY_TMP}"
mkdir -p "${BUNDLE_DIR}"
mkdir -p "${DEPLOY_TMP}/ollama_install"
mkdir -p "${DEPLOY_TMP}/cli_link"
mkdir -p "${DEPLOY_TMP}/systemd"

echo "[1] 备份完整ollama发布包 /usr/local/bin/ollama"
cp -r "${OLLAMA_INSTALL_ROOT}" "${DEPLOY_TMP}/ollama_install/"

echo "[2] 备份CLI快捷命令 /usr/bin/ollama"
if [ -e "${OLLAMA_CLI}" ];then
cp "${OLLAMA_CLI}" "${DEPLOY_TMP}/cli_link/"
fi

echo "[3] 备份systemd服务文件"
if [ -f "${OLLAMA_SERVICE_FILE}" ];then
cp "${OLLAMA_SERVICE_FILE}" "${DEPLOY_TMP}/systemd/"
fi

echo "[4] 备份完整模型（GGUF14B + pull向量模型）"
cp -r "${OLLAMA_DATA_SRC}" "${DEPLOY_TMP}/ollama_data"

echo "[5] 复制Ragflow配置文件"
cp "${RAGFLOW_HOST_DIR}/.env" "${DEPLOY_TMP}/"
cp "${RAGFLOW_HOST_DIR}/docker-compose.yml" "${DEPLOY_TMP}/"

echo "[6] 打包 deploy_pack.tar.gz"
tar -zcvf "${BUNDLE_DIR}/deploy_pack.tar.gz" -C "${DEPLOY_TMP}" .

# 重启服务
systemctl start ollama 2>/dev/null || true

echo -e "\\n✅ Ollama全套备份完成！"
echo "输出文件：${BUNDLE_DIR}/deploy_pack.tar.gz"
ls -lh "${BUNDLE_DIR}"

运行：

chmod +x 11backup_ollama_only.sh
./11backup_ollama_only.sh

目录结构：

deploy_pack/
├── cli_link/ # ollama软链接备份目录
├── ollama_data/ # ollama模型数据（blobs/manifests）
├── ollama_install/ # ollama整套二进制+依赖so库
├── systemd/ # systemd服务单元
│ └── ollama.service
├── .env # ragflow compose环境变量
└── docker-compose.yml # ragflow编排文件

步骤3：创建 12export_docker_image.sh（导出docker）

nano 12export_docker_image.sh

粘贴：

#!/bin/bash
set -e

# 定义路径
WORKDIR=$(cd "$(dirname "$0")";pwd)
BUNDLE_DIR="${WORKDIR}/offline_bundle"
mkdir -p "${BUNDLE_DIR}"

# ==========新增开始：自动复制docker静态包==========
DOCKER_STATIC="./docker-26.0.2.tgz"
if [ ! -f "${DOCKER_STATIC}" ];then
echo "[ERROR] 缺失文件 docker-26.0.2.tgz，请放在脚本同级目录！"
exit 1
fi
cp "${DOCKER_STATIC}" "${BUNDLE_DIR}/"
# ==========新增结束==========

# ==========新增开始==========
# 复制compose二进制到离线包
COMPOSE_BIN="./docker-compose-linux-aarch64"
if [ ! -f "${COMPOSE_BIN}" ];then
echo "[ERROR] 缺失文件 docker-compose-linux-aarch64，请放在脚本同级目录！"
exit 1
fi
cp "${COMPOSE_BIN}" "${BUNDLE_DIR}/"
# ==========新增结束==========

IMG_LIST=(
ragflow:arm64
postgres:15-alpine
redis:7-alpine
nginx:alpine
)

echo "校验服务连通性……"
docker info >/dev/null
echo "✅守护进程正常"

# 循环校验每一个镜像
for img in "${IMG_LIST[@]}";do
if ! docker inspect "${img}" >/dev/null 2>&1;then
echo "[ERROR] 镜像不存在：${img}"
exit 1
fi
done
echo "全部镜像校验通过，开始导出镜像"

docker save \\
-o "${BUNDLE_DIR}/ragflow_bundle.tar" \\
"${IMG_LIST[@]}"

cd "${BUNDLE_DIR}"
md5sum ragflow_bundle.tar docker-compose-linux-aarch64 docker-26.0.2.tgz > file_md5.txt
echo "✅镜像导出完成"
ls -lh "${BUNDLE_DIR}"

运行：

chmod +x 12export_docker_image.sh
./12export_docker_image.sh

✅【外网所有工作到此结束】

你得到./offline_bundle目录下5个重要文件：

重点：外网绝对不做问答测试！！16G必崩！！

第三阶段：内网 FT2000+ 128G 麒麟断网部署（最终运行）

1. 内网终端先切root

sudo su

2. 挂载移动介质

整套离线还原原理（外网导出 → 内网恢复）

整套方案本质：外网把运行环境所有必要二进制、配置、镜像、模型全部打包成静态文件；内网不联网、不 apt/yum 安装软件，直接复制文件 + 写入 systemd 配置，重建运行环境。

没有安装程序，全部是文件级还原，不跑软件包管理器。

整体分两大块： 21env_prod.sh（底层环境还原：docker）、 22deploy_prod.sh（应用层还原：镜像、ollama、业务）

3. 内网安装Docker脚本 21env_prod.sh

作用：内网机器原本没有docker，纯文件方式部署docker

原理拆解：

⚠️注意：此时镜像还没有导入，只是docker环境装好了。

nano 21env_prod.sh

粘贴：

#!/bin/bash
set -e

mkdir -p /data
cp -r /mnt/usb/offline_bundle /data/

# 部署 docker
cd /data/offline_bundle
tar -zxf docker-26.0.2.tgz
cp docker/* /usr/bin

# 部署 docker‑compose
cp docker-compose-linux-aarch64 /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
ln -sf /usr/local/bin/docker-compose /usr/bin/docker-compose

cat > /etc/systemd/system/docker.service <<'SERVICE'
[Unit]
Description=Docker Application Container Engine
After=network-online.target

[Service]
Type=notify
ExecStart=/usr/bin/dockerd
ExecReload=/bin/kill -s HUP $MAINPID
TimeoutSec=0
RestartSec=2
Restart=always

[Install]
WantedBy=multi-user.target
SERVICE

# 永久修复PATH（统信UOS默认不含/usr/local/bin）
echo 'export PATH="/usr/local/bin:$PATH"' > /etc/profile.d/99-docker-path.sh
chmod 644 /etc/profile.d/99-docker-path.sh
export PATH="/usr/local/bin:$PATH"
hash -r

# 重载systemd，启动docker
systemctl daemon-reload
systemctl start docker
systemctl enable docker

# 创建插件目录
mkdir -p /usr/local/lib/docker/cli-plugins
# 复制并重命名为 docker-buildx
cp buildx-v0.37.0.linux-arm64 /usr/local/lib/docker/cli-plugins/docker-buildx
# 添加执行权限
chmod +x /usr/local/lib/docker/cli-plugins/docker-buildx

# 最终校验
docker -v
docker-compose -v
echo "====== 【OK】内网Docker安装完成 ======"

运行：

chmod +x 21env_prod.sh
./21env_prod.sh

4. 内网部署全套业务脚本 22deploy_prod.sh

还原镜像、Ollama、业务应用

• 外网docker save把内存里的镜像打包成tar文件；
• 内网docker load读取tar，把镜像解压写入/data/docker（4T盘）；

此时镜像已经存在本地，但容器还没有创建启动。

① cp -r "${BUNDLE_DIR}/ollama_install/ollama" /usr/local/ollama – ollama不是单文件，附带很多arm64的so依赖库；完整复制整套运行目录到系统/usr/local/ollama。 ②创建软链接：/usr/local/bin/ollama指向真实二进制，让全局可以执行ollama命令。 ③拷贝外网原版ollama.service到/etc/systemd/system/，这是systemd控制ollama服务的配置文件。 ④sed修改service，追加环境变量OLLAMA_MODELS=/data/ollama：模型存储路径指向大盘，不再写root家目录。 ⑤cp -r "${BUNDLE_DIR}/ollama_data" /data/ollama > ✅这就是模型还原核心：外网已经下载好的模型blob文件完整拷贝到内网/data/ollama；内网不需要重新pull下载模型。 ⑥daemon‑reload加载服务配置，enable设置开机自启，start启动ollama服务；ollama list验证模型识别正常。

nano 22deploy_prod.sh

粘贴：

#!/bin/bash
set -e
SCRIPT_DIR=$(cd "$(dirname "$0")"; pwd)
BUNDLE_DIR="${SCRIPT_DIR}/offline_bundle"
# data数据大盘：4T机械盘挂载点，物理路径固定为 /data
DATA_DISK="/data"
DEPLOY_PACK_ROOT="${DATA_DISK}"

# 校验离线介质
if [ ! -d "${BUNDLE_DIR}" ];then
echo "[ERROR] 找不到离线包目录: ${BUNDLE_DIR}"
echo "请把 offline_bundle 放置到脚本同级目录"
exit 1
fi

# MD5完整性校验
cd "${BUNDLE_DIR}"
md5sum -c file_md5.txt

# 导入RAGFlow docker镜像
docker load -i ragflow_bundle.tar

# 解压业务包直接释放到【data数据大盘】
cd "${DATA_DISK}"
tar -zxvf "${BUNDLE_DIR}/deploy_pack.tar.gz"

# 部署Ollama二进制到系统SSD
rm -rf /usr/local/ollama
cp -r "${DEPLOY_PACK_ROOT}/ollama_install/ollama" /usr/local/ollama
ln -sf /usr/local/ollama/bin/ollama /usr/bin/ollama
chmod +x /usr/local/ollama/bin/ollama
hash -r
ollama –version

# 加载ollama systemd服务
cp "${DEPLOY_PACK_ROOT}/systemd/ollama.service" /etc/systemd/system/ollama.service

# 追加模型路径环境变量，模型存放至【data数据大盘】
grep -q "OLLAMA_MODELS" /etc/systemd/system/ollama.service || \\
sed -i '/^\\[Service\\]/a Environment="OLLAMA_MODELS=/data/ollama"' /etc/systemd/system/ollama.service

# 复制模型数据到data数据大盘运行目录
rm -rf "${DATA_DISK}/ollama"
cp -r "${DEPLOY_PACK_ROOT}/ollama_data" "${DATA_DISK}/ollama"

# 另外银河麒麟还有点问题，调试时需要注意Environment="HOME=/root"，Environment="OLLAMA_MODELS=/data/ollama_data/models"多一级models，执行下面命令修复
cat > /etc/systemd/system/ollama.service <<'EOF'
[Unit]
Description=Ollama Service
After=network.target
[Service]
Environment="HOME=/root"
Environment="OLLAMA_HOST=0.0.0.0"
Environment="OLLAMA_MODELS=/data/ollama_data/models"
ExecStart=/usr/local/ollama/bin/ollama serve
Restart=always
[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl restart ollama
sleep 3
ollama list

# 启动ollama服务
systemctl daemon-reload
systemctl enable ollama
systemctl start ollama
ollama list

# 自动生成nginx反向代理配置，对外80端口访问RAGFlow
NGINX_DIR="${DEPLOY_PACK_ROOT}/nginx"
mkdir -p "${NGINX_DIR}"
cat > "${NGINX_DIR}/nginx.conf" <<'NGINX_CONF'
server {
listen 80;
server_name _;
location / {
proxy_pass http://ragflow-cpu:8000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
}
}
NGINX_CONF

# 启动整套RAGFlow容器
cd "${DEPLOY_PACK_ROOT}"
if [ -f "docker-compose.yml" ];then
echo "===== 启动RAGFlow业务容器（Nginx 80端口反向代理，数据存放于data数据大盘） ====="
docker-compose up -d
fi

# 防火墙放行端口(麒麟V10 firewalld)
firewall-cmd –permanent –add-port=80/tcp
firewall-cmd –permanent –add-port=11434/tcp
firewall-cmd –reload

# 自检输出
echo "— Docker根目录检查 —"
docker info | grep "Docker Root Dir"
echo "— Ollama模型目录（data数据大盘）检查 —"
ls "${DATA_DISK}/ollama"
echo "— 磁盘分区状态 —"
df -h
echo "— Ollama接口测试 —"
curl -s http://127.0.0.1:11434/api/tags

echo "【✅全部部署完成】data数据大盘路径：${DATA_DISK}"
echo "请修改 ${DATA_DISK}/.env 的OLLAMA_BASE_URL为本机内网IP，再重启容器"

运行：

chmod +x 22deploy_prod.sh
./22deploy_prod.sh

5. 修改内网.env配置

vim /data/.env

改内网IP、数据库参数

POSTGRES_USER=ragflow
POSTGRES_PASSWORD=RagFlow@2026
POSTGRES_DB=ragflow
POSTGRES_HOST=postgres
POSTGRES_PORT=5432

REDIS_HOST=redis
REDIS_PORT=6379

# 内网部署修改为本机IP
OLLAMA_BASE_URL=http://127.0.0.1:11434

6. 修改内网nginx/nginx.conf配置

vim /data/nginx/nginx.conf

server {
listen 80;
server_name _;
location / {
proxy_pass http://ragflow-cpu:8000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
}
}

7. 修改内网docker-compose.yml配置

vim /data/docker-compose.yml

精简版 docker-compose.yml

services:
postgres:
image: postgres:15-alpine
restart: always
volumes:
– postgres_data:/var/lib/postgresql/data
env_file: .env
healthcheck:
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
interval: 10s
timeout: 5s
retries: 20

redis:
image: redis:7-alpine
restart: always
volumes:
– redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 10s
timeout: 5s
retries: 20

ragflow-cpu:
image: ragflow:arm64
restart: always
env_file: .env
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
extra_hosts:
– "host.docker.internal:host-gateway"
volumes:
– ./ragflow-logs:/ragflow/logs

nginx:
image: nginx:alpine
restart: always
ports:
– "80:80"
volumes:
– ./nginx/nginx.conf:/etc/nginx/conf.d/default.conf
depends_on:
– ragflow-cpu

volumes:
postgres_data:
redis_data:

8. 启动项目

# 一定要确保data目录下存在精简版的 docker-compose.yml
cd /data
docker-compose up -d

最终成功！！！

浏览器打开：内网IP 全套RAGFlow+14B大模型离线运行

总结核心真相

致谢：

最后由衷感谢闲鱼这位大哥，25年国产化刚兴起，买一台崭新的arm64主机用来学习，没想到这次派上了用场。

物料大集合：

整套离线还原原理（外网导出 → 内网恢复）

整套方案本质：外网把运行环境所有必要二进制、配置、镜像、模型全部打包成静态文件；内网不联网、不apt/yum安装软件，直接复制文件+写入systemd配置，重建运行环境。

没有安装程序，全部是文件级还原，不跑软件包管理器。

整体分两大块：21env_prod.sh（底层环境还原：docker）、22deploy_prod.sh（应用层还原：镜像、ollama、业务）

一、

外网产出物全部放在offline_bundle，这就是完整的“备份介质”。

关键要点总结（还原核心逻辑）