阿里云ECS Spring Boot 双节点无感发布#

环境：Alibaba Cloud Linux 3 + Apache APISIX 3.14.1（Docker，内置 Dashboard）+ Spring Boot（双节点）

适用场景：单台 ECS（IP: 1.2.3.4）上，以 /home/backend/demo-node1 与 /home/backend/demo-node2 目录运行两个 Spring Boot 实例，通过 APISIX 网关做流量灰度与切换，并使用阿里云云效流水线实现一键无感发布 / 回滚。

1. 系统架构#

1
                      ┌───────────────┐
2
                      │  开发 / CI/CD │
3
                      └───────┬───────┘
4
                              │ (云效 Pipeline)
5
                      ┌───────▼───────┐
6
                      │   云效制品库   │
7
                      └───────┬───────┘
8
                              │
9
            ┌─────────────────▼──────────────────┐
10
            │ ECS 1.2.3.4 (Alibaba Cloud Linux 3) │
11
            │                                     │
12
            │  ┌──────────┐       ┌──────────┐    │
13
            │  │ demo-node1│       │ demo-node2│   │
14
            │  │ :8081    │       │ :8082    │    │
15
            │  └──────────┘       └──────────┘    │
16
            │         ▲                  ▲        │
17
            │         │ (health check)   │        │
18
            │  ┌──────┴──────────────────┴─────┐  │
19
            │  │   Apache APISIX 3.14.1 (9000) │  │
20
            │  │   Admin / Dashboard (9180)    │  │
21
            │  └───────────────────────────────┘  │
22
            └─────────────────────────────────────┘

2. 主机与端口#

角色	IP	端口	路径说明
APISIX 网关	1.2.3.4	9000（业务） / 9180（管理）	Docker 容器内 `/usr/local/apisix`
Spring Boot node1	1.2.3.4	8081	`/home/backend/demo-node1`
Spring Boot node2	1.2.3.4	8082	`/home/backend/demo-node2`

说明：APISIX 通过 Docker 启动，容器内默认监听 9080/9443/9180，通过端口映射对外暴露为 9000/9443/9180。

3. 部署流水线核心步骤（云效）#

流水线整体思路保持不变： 1）构建 Spring Boot 可执行 jar 并上传到制品库； 2）流水线依次在 demo-node1、demo-node2 上执行部署脚本； 3）部署脚本调用 APISIX Admin API 动态调整 upstream，保证只有健康节点接收流量，从而实现零停机。

构建配置#

阿里云云效构建配置

节点 1 部署配置#

阿里云云效节点1配置

节点 2 部署配置#

阿里云云效节点2配置

4. 环境准备（Alibaba Cloud Linux 3）#

4.1 操作系统与基础依赖#

操作系统：Alibaba Cloud Linux 3（基于 Anolis OS 8，兼容 CentOS 8 / RHEL 8 生态）
包管理器：dnf（兼容 yum 子命令）。
需要的系统工具（建议提前安装）：

1
sudo dnf -y install curl lsof jq tar

4.2 安装 Docker（Alibaba Cloud Linux 3）#

按照阿里云官方文档，在 Alibaba Cloud Linux 3 上安装 Docker CE：

1
#!/usr/bin/env bash
2
#
3
# 适用于 Alibaba Cloud Linux 3 的 Docker CE + Docker Compose 安装脚本
4

5
set -euo pipefail
6

7
echo ">>> 检查操作系统发行版信息..."
8
if [ -f /etc/os-release ]; then
9
  . /etc/os-release
10
  echo "NAME=${NAME:-}, VERSION_ID=${VERSION_ID:-}"
11
else
12
  echo "未找到 /etc/os-release，无法确认系统版本，仍将尝试安装。"
13
fi
14

15
echo ">>> 第 1 步：安装 dnf（如已存在可跳过）..."
16
sudo yum install -y dnf || true
17

18
echo ">>> 第 2 步：安装 Docker 存储驱动依赖..."
19
sudo dnf install -y device-mapper-persistent-data lvm2
20

21
echo ">>> 第 3 步：添加 Docker CE 软件源，并安装 Alibaba Cloud Linux 3 专用 dnf 兼容插件..."
22
sudo dnf config-manager --add-repo=https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
23
sudo dnf -y install dnf-plugin-releasever-adapter --repo alinux3-plus
24

25
echo ">>> 第 4 步：安装 Docker CE..."
26
sudo dnf -y install docker-ce --nobest
27

28
echo ">>> 第 5 步：启动并设置 Docker 开机自启..."
29
sudo systemctl start docker
30
sudo systemctl enable docker
31

32
echo ">>> 第 6 步：验证 Docker 安装..."
33
docker -v || { echo 'Docker 安装验证失败，请检查上方输出。'; exit 1; }
34

35
echo ">>>（可选）安装 Docker Compose 插件..."
36
if sudo dnf -y install docker-compose-plugin; then
37
  docker compose version || echo "Docker Compose 插件已安装，但版本检查失败，请手工排查。"
38
else
39
  echo "Docker Compose 插件安装失败，可稍后手动执行：sudo dnf -y install docker-compose-plugin"
40
fi
41

42
echo ">>> Docker CE 及（可选）Docker Compose 安装流程执行完成。"

5. 部署 Apache APISIX 3.14.1（内置 Dashboard）#

5.1 APISIX 配置文件 `config.yaml`#

在任意工作目录（例如 /home/backend/apisix）创建 config.yaml：

1
deployment:
2
  # Admin API 与内置 Dashboard 安全配置
3
  admin:
4
    admin_key_required: true            # 默认即为 true，明确打开以保证安全
5
    admin_key:
6
      - name: admin
7
        role: admin
8
        # 请在生产环境中改为安全随机值，例如 openssl rand -hex 16
9
        key: CKjcGDoqxcJfpIXWigyqjdUSACvwzEJy
10
    allow_admin:
11
      - 127.0.0.0/24                    # 本机
12
      - 172.17.0.0/16                   # Docker 默认 bridge 网段
13
      # - 0.0.0.0/0                     # 仅本地演示可放开，生产环境请严格收缩
14
    enable_admin_ui: true               # 启用 APISIX 内置 Dashboard
15

16
apisix:
17
  node_listen: 9080                     # 容器内监听端口，通过 -p 映射为 9000
18
  ssl:
19
    enable: true
20
    listen:
21
      - ip: 0.0.0.0
22
        port: 9443

如需自定义 etcd 地址，可在同一文件中补充 deployment.etcd 段落，或使用环境变量覆盖，参考官方文档。

5.2 APISIX 容器管理脚本 `apisix-manager.sh`#

以下脚本基于 Docker 运行 APISIX 3.14.1，并假定已经存在一个可用的 etcd 服务，容器名为 etcd-quickstart，位于 Docker 网络 apisix-quickstart-net 中（可通过官方 apisix-docker 示例或自建 etcd 部署）。

将脚本保存为 /home/backend/apisix/apisix-manager.sh，并赋予执行权限：

1
chmod +x /home/backend/apisix/apisix-manager.sh

脚本内容：

1
#!/bin/bash
2

3
# APISIX Docker 管理脚本（监听 9000 / 9443 / 9180）
4

5
CONTAINER_NAME="apisix-main"
6
NETWORK_NAME="apisix-quickstart-net"
7
ETCD_HOST="http://etcd-quickstart:2379"
8
APISIX_IMAGE="apache/apisix:3.14.1-debian"   # 对应 APISIX 3.14.1 Docker 镜像
9
CONFIG_FILE="$(cd "$(dirname "$0")" && pwd)/config.yaml"
10

11
stop_all() {
12
  echo "停止所有 APISIX 相关容器..."
13
  for name in apisix-main apisix-no-auth apisix-quickstart apisix-quickstart-80; do
14
    if docker ps -a --format "{{.Names}}" | grep -q "^${name}$"; then
15
      echo "停止容器: $name"
16
      docker stop "$name" >/dev/null 2>&1 || true
17
      docker rm "$name"   >/dev/null 2>&1 || true
18
    fi
19
  done
20
  echo "所有 APISIX 容器已停止"
21
}
22

23
start() {
24
  echo "启动 APISIX 容器（映射端口：9000->9080，9443->9443，9180->9180）..."
25

26
  if [ ! -f "$CONFIG_FILE" ]; then
27
    echo "未找到配置文件: $CONFIG_FILE"
28
    exit 1
29
  fi
30

31
  # 确认网络存在
32
  if ! docker network ls --format "{{.Name}}" | grep -q "^${NETWORK_NAME}$"; then
33
    echo "未找到 Docker 网络 ${NETWORK_NAME}，请先创建并将 etcd 加入该网络。"
34
    exit 1
35
  fi
36

37
  # 如容器存在则删除
38
  if docker ps -a --format "{{.Names}}" | grep -q "^${CONTAINER_NAME}$"; then
39
    echo "容器 $CONTAINER_NAME 已存在，先删除..."
40
    docker stop "$CONTAINER_NAME" >/dev/null 2>&1 || true
41
    docker rm "$CONTAINER_NAME"   >/dev/null 2>&1 || true
42
  fi
43

44
  CONTAINER_ID=$(
45
    docker run -d --name "$CONTAINER_NAME" \
46
      --network "$NETWORK_NAME" \
47
      -v "$CONFIG_FILE:/usr/local/apisix/conf/config.yaml:ro" \
48
      -p 9000:9080 \
49
      -p 9443:9443 \
50
      -p 9180:9180 \
51
      -e APISIX_DEPLOYMENT_ETCD_HOST="[\"$ETCD_HOST\"]" \
52
      "$APISIX_IMAGE" 2>&1
53
  )
54

55
  if [ $? -eq 0 ]; then
56
    echo "容器启动成功，ID: ${CONTAINER_ID:0:12}"
57
    echo "等待服务启动..."
58
    sleep 5
59
    if docker ps --format "{{.Names}}" | grep -q "^${CONTAINER_NAME}$"; then
60
      echo "APISIX 已成功启动："
61
      echo "  业务入口:    http://1.2.3.4:9000"
62
      echo "  管理 / UI:  http://1.2.3.4:9180"
63
    else
64
      echo "容器启动失败，查看日志："
65
      docker logs "$CONTAINER_NAME" 2>/dev/null | tail -20
66
    fi
67
  else
68
    echo "容器启动失败: $CONTAINER_ID"
69
  fi
70
}
71

72
status() {
73
  if docker ps --format "{{.Names}}" | grep -q "^${CONTAINER_NAME}$"; then
74
    echo "APISIX 运行中，端口映射："
75
    docker port "$CONTAINER_NAME"
76
  else
77
    echo "APISIX 未运行"
78
  fi
79
}
80

81
case "$1" in
82
  start)
83
    start
84
    ;;
85
  stop)
86
    stop_all
87
    ;;
88
  restart)
89
    stop_all
90
    sleep 2
91
    start
92
    ;;
93
  status)
94
    status
95
    ;;
96
  *)
97
    echo "用法: $0 {start|stop|restart|status}"
98
    exit 1
99
    ;;
100
esac

6. Spring Boot 双节点部署#

6.1 目录结构建议#

1
/home/backend/
2
  ├── demo-node1/
3
  │   ├── app.jar              # 节点 1 运行 jar（软链接）
4
  │   ├── logs/
5
  │   └── zero-deploy-node.sh  # 通用零停机脚本（本节后面给出）
6
  └── demo-node2/
7
      ├── app.jar
8
      ├── logs/
9
      └── zero-deploy-node.sh

云效在两个节点上的部署脚本仅负责解压制品并调用 zero-deploy-node.sh。

6.2 Spring Boot 运行约定#

节点 1：端口 8081，配置 spring.profiles.active=prod-node1
节点 2：端口 8082，配置 spring.profiles.active=prod-node2

示例启动命令（脚本中会自动执行）：

1
nohup java -jar app.jar \
2
  --server.port=8081 \
3
  --spring.profiles.active=prod-node1 \
4
  > logs/app.log 2>&1 &

7. 在 APISIX 中配置 Upstream 与 Route（使用内置 Dashboard）#

APISIX 3.14.1 默认在 Admin API 端口上提供管理 UI，通过 enable_admin_ui: true 打开后即可在浏览器中通过 9180 端口访问。

7.1 创建 Upstream（双节点）#

登录内置 Dashboard。
在 Upstream 页面中新建 upstream，ID 设置为 java-app-upstream（自定义字符串 ID 即可）。
类型选择 roundrobin，Nodes 配置为：
- 1.2.3.4:8081，weight = 1
- 1.2.3.4:8082，weight = 1
保存。

7.2 创建 Route#

在 Route 页面新建路由，例如：
- 请求路径：/api/*
- Host：按业务需要（如 api.example.com）
- 绑定 Upstream：选择 java-app-upstream
保存后，访问：

1
curl -i "http://1.2.3.4:9000/api/health"

确认可以命中两节点之一。

8. 零停机发布脚本#

本节脚本仅在需要做“无感发布”时使用，因此仍通过 Admin API（脚本调用）修改 Upstream 节点权重；平时的路由管理均使用 Dashboard 即可。

8.1 通用节点脚本：`zero-deploy-node.sh`#

分别拷贝到：

节点 1：/home/backend/demo-node1/zero-deploy-node.sh
节点 2：/home/backend/demo-node2/zero-deploy-node.sh

并执行：

1
chmod +x /home/backend/demo-node1/zero-deploy-node.sh
2
chmod +x /home/backend/demo-node2/zero-deploy-node.sh

脚本内容（两节点通用，通过Shell变量区分）：

1
#!/usr/bin/env bash
2
#
3
# zero-deploy-node.sh - Spring Boot 单节点零停机发布脚本（Alibaba Cloud Linux 3 适配）
4
# 变量通过脚本内 Shell 变量配置，无需依赖环境变量。
5

6
set -euo pipefail
7

8
###################### 配置区（按需修改） #########################
9

10
# 节点名称，仅用于日志标识
11
NODE_NAME="demo-node1"
12

13
# 应用目录
14
APP_HOME="/home/backend/demo-node1"
15

16
# 制品路径（例如云效下载到本机后的 tar 包）
17
PACKAGE_PATH="/home/flowapp/demo.tgz"
18

19
# 制品内的 JAR 文件名
20
JAR_NAME="demo-0.0.1-SNAPSHOT.jar"
21

22
# 当前节点端口和对端节点端口
23
NODE_PORT=8081
24
PEER_PORT=8082
25

26
# Spring Boot profile
27
SPRING_PROFILE="prod-node1"
28

29
# APISIX Admin API 配置
30
UPSTREAM_ID="java-app-upstream"
31
ADMIN_BASE="http://127.0.0.1:9180/apisix/admin"
32
ADMIN_KEY="CKjcGDoqxcJfpIXWigyqjdUSACvwzEJy"   # 与 APISIX config.yaml 中保持一致
33

34
# 健康检查及连接耗尽相关
35
HEALTH_PATH="/health"
36
HEALTH_TIMEOUT=60
37
KEEPALIVE_IDLE_TIMEOUT=30
38
IDLE_TIMEOUT_BUFFER=$((KEEPALIVE_IDLE_TIMEOUT * 2))
39

40
############################################################
41

42
# 基本校验，防止变量遗漏
43
check_config() {
44
  if [ -z "$NODE_NAME" ] || [ -z "$APP_HOME" ] || [ -z "$PACKAGE_PATH" ] || \
45
     [ -z "$JAR_NAME" ]  || [ -z "$SPRING_PROFILE" ]; then
46
    echo "配置错误：请在脚本顶部正确设置 NODE_NAME/APP_HOME/PACKAGE_PATH/JAR_NAME/SPRING_PROFILE 等变量"
47
    exit 1
48
  fi
49

50
  if [ -z "${NODE_PORT:-}" ] || [ -z "${PEER_PORT:-}" ]; then
51
    echo "配置错误：请在脚本顶部正确设置 NODE_PORT 和 PEER_PORT"
52
    exit 1
53
  fi
54
}
55

56
LOG_DIR="$APP_HOME/logs"
57
mkdir -p "$LOG_DIR"
58

59
AUTH_HEADER=(-H "X-API-KEY: $ADMIN_KEY")
60

61
log() {
62
  printf '[%s] [%s] %s\n' "$(date '+%F %T')" "$NODE_NAME" "$*" | tee -a "$LOG_DIR/deploy.log"
63
}
64

65
get_host_ip() {
66
  if command -v ip >/dev/null 2>&1; then
67
    ip route get 1.1.1.1 | awk '{print $7; exit}'
68
  else
69
    hostname -I | awk '{print $1; exit}'
70
  fi
71
}
72

73
HOST_IP="$(get_host_ip)"
74

75
stop_app() {
76
  local port=$1
77
  log "准备停止端口 $port 上的应用"
78

79
  local pid=""
80
  if command -v lsof >/dev/null 2>&1; then
81
    pid=$(lsof -t -i:"$port" -sTCP:LISTEN || true)
82
  elif command -v ss >/dev/null 2>&1; then
83
    pid=$(ss -lntp | awk -v p=":$port" '$4 ~ p {print $6}' | awk -F',' '{print $2}' | awk -F'=' '{print $2}' | head -n1)
84
  elif command -v netstat >/dev/null 2>&1; then
85
    pid=$(netstat -lntp 2>/dev/null | awk -v p=":$port" '$4 ~ p {print $7}' | cut -d'/' -f1 | head -n1)
86
  fi
87

88
  if [ -z "$pid" ]; then
89
    log "端口 $port 未发现运行中的进程，跳过停止"
90
    return 0
91
  fi
92

93
  log "发现进程 PID=$pid，发送 TERM 信号"
94
  kill -TERM "$pid" || true
95

96
  local wait_sec=0
97
  while kill -0 "$pid" 2>/dev/null; do
98
    if [ $wait_sec -ge 30 ]; then
99
      log "进程未在 30 秒内退出，发送 KILL"
100
      kill -KILL "$pid" || true
101
      break
102
    fi
103
    sleep 1
104
    wait_sec=$((wait_sec + 1))
105
  done
106

107
  log "端口 $port 已空闲"
108
}
109

110
start_app() {
111
  cd "$APP_HOME"
112
  ln -snf "$JAR_NAME" app.jar
113

114
  log "启动新版本应用: app.jar，端口 $NODE_PORT，profile=$SPRING_PROFILE"
115
  nohup java -jar app.jar \
116
    --server.port="$NODE_PORT" \
117
    --spring.profiles.active="$SPRING_PROFILE" \
118
    > "$LOG_DIR/app.log" 2>&1 &
119

120
  local start_time=0
121
  local url="http://127.0.0.1:${NODE_PORT}${HEALTH_PATH}"
122

123
  log "等待应用健康检查通过，超时时间 ${HEALTH_TIMEOUT}s，URL=$url"
124

125
  while true; do
126
    if curl -fsS "$url" >/dev/null 2>&1; then
127
      log "健康检查通过"
128
      break
129
    fi
130
    if [ $start_time -ge $HEALTH_TIMEOUT ]; then
131
      log "健康检查超时（${HEALTH_TIMEOUT}s），失败"
132
      exit 1
133
    fi
134
    sleep 2
135
    start_time=$((start_time + 2))
136
  done
137
}
138

139
update_upstream_only_peer() {
140
  local url="${ADMIN_BASE}/upstreams/${UPSTREAM_ID}"
141
  log "将当前节点下线：仅保留对端节点 ${HOST_IP}:${PEER_PORT}"
142

143
  local payload
144
  payload=$(cat <<EOF
145
{
146
  "type": "roundrobin",
147
  "nodes": {
148
    "${HOST_IP}:${PEER_PORT}": 1
149
  }
150
}
151
EOF
152
)
153

154
  local code
155
  code=$(curl -sS -w "%{http_code}" -o /tmp/zero-upstream-peer.json \
156
    "${AUTH_HEADER[@]}" \
157
    -H "Content-Type: application/json" \
158
    -X PUT "$url" \
159
    -d "$payload")
160

161
  if [[ "$code" != 2* ]]; then
162
    log "下线当前节点失败，HTTP 状态码: $code"
163
    cat /tmp/zero-upstream-peer.json || true
164
    exit 1
165
  fi
166

167
  log "当前节点权重置为 0，仅对端节点接收流量，等待连接耗尽 ${IDLE_TIMEOUT_BUFFER}s"
168
  sleep "$IDLE_TIMEOUT_BUFFER"
169
}
170

171
update_upstream_both_nodes() {
172
  local url="${ADMIN_BASE}/upstreams/${UPSTREAM_ID}"
173
  log "将当前节点重新加入 upstream：${HOST_IP}:${NODE_PORT} & ${HOST_IP}:${PEER_PORT}"
174

175
  local payload
176
  payload=$(cat <<EOF
177
{
178
  "type": "roundrobin",
179
  "nodes": {
180
    "${HOST_IP}:${NODE_PORT}": 1,
181
    "${HOST_IP}:${PEER_PORT}": 1
182
  }
183
}
184
EOF
185
)
186

187
  local code
188
  code=$(curl -sS -w "%{http_code}" -o /tmp/zero-upstream-both.json \
189
    "${AUTH_HEADER[@]}" \
190
    -H "Content-Type: application/json" \
191
    -X PUT "$url" \
192
    -d "$payload")
193

194
  if [[ "$code" != 2* ]]; then
195
    log "重新加入 upstream 失败，HTTP 状态码: $code"
196
    cat /tmp/zero-upstream-both.json || true
197
    exit 1
198
  fi
199

200
  log "upstream 已恢复为双节点轮询"
201
}
202

203
deploy_artifact() {
204
  log "检查制品文件: $PACKAGE_PATH"
205
  if [ ! -f "$PACKAGE_PATH" ]; then
206
    log "制品文件不存在: $PACKAGE_PATH"
207
    exit 1
208
  fi
209

210
  mkdir -p "$APP_HOME"
211
  cd "$APP_HOME"
212

213
  log "解压制品到 $APP_HOME"
214
  tar -zxf "$PACKAGE_PATH" -C "$APP_HOME"
215
  log "解压完成"
216
}
217

218
main() {
219
  check_config
220

221
  log "===== 零停机发布开始 ====="
222
  log "主机 IP: $HOST_IP, 本节点端口: $NODE_PORT, 对端端口: $PEER_PORT"
223

224
  # 1. 先将当前节点从 upstream 中“摘除”
225
  update_upstream_only_peer
226

227
  # 2. 停止当前节点
228
  stop_app "$NODE_PORT"
229

230
  # 3. 部署新制品
231
  deploy_artifact
232

233
  # 4. 启动新版本并通过健康检查
234
  start_app
235

236
  # 5. 将当前节点重新加入 upstream
237
  update_upstream_both_nodes
238

239
  log "===== 零停机发布完成 ====="
240
}
241

242
main "$@"

8.2 云效：节点 1 部署脚本#

云效节点 1 部署命令脚本示例，保存为（与原文一致）：

云效/节点1/部署脚本.txt：

1
set -e  # 遇到错误立即退出
2

3
# ==== 环境变量配置 ====
4
# 制品实际下载到的路径（云效制品默认下载目录，可按实际修改）
5
PACKAGE_PATH=/home/flowapp/demo.tgz
6

7
# 应用目录
8
APP_HOME=/home/backend/demo-node1
9

10
# jar 文件名（与制品内文件名一致）
11
JAR_NAME=demo-0.0.1-SNAPSHOT.jar
12

13
# 为通用脚本准备的参数
14
export NODE_NAME="demo-node1"
15
export APP_HOME
16
export PACKAGE_PATH
17
export JAR_NAME
18
export NODE_PORT=8081
19
export PEER_PORT=8082
20
export SPRING_PROFILE="prod-node1"
21

22
log() { echo "[$(date '+%F %T')] [node1] $*"; }
23

24
mkdir -p "$(dirname "$PACKAGE_PATH")"
25
mkdir -p "$APP_HOME"
26

27
deploy_package() {
28
  if [ ! -f "$PACKAGE_PATH" ]; then
29
    log "错误：制品文件不存在 $PACKAGE_PATH"
30
    exit 1
31
  fi
32
  log "解包 $PACKAGE_PATH 到 $APP_HOME"
33
  tar -zxf "$PACKAGE_PATH" -C "$APP_HOME"
34
  log "解包完成"
35
}
36

37
cd "$APP_HOME" || { echo "目录不存在: $APP_HOME"; exit 1; }
38

39
# 部署最新制品
40
deploy_package
41

42
# 调用通用零停机脚本
43
log "执行零停机发布（节点 1）"
44
bash "$APP_HOME/zero-deploy-node.sh"
45

46
log "节点 1 部署脚本执行完毕"

8.3 云效：节点 2 部署脚本#

云效/节点2/部署脚本.txt：

1
set -e  # 遇到错误立即退出
2

3
sleep 5   # 适当延迟，确保节点 1 已基本完成更新（可按需要调整）
4

5
# ==== 环境变量配置 ====
6
PACKAGE_PATH=/home/flowapp/demo.tgz
7
APP_HOME=/home/backend/demo-node2
8
JAR_NAME=demo-0.0.1-SNAPSHOT.jar
9

10
export NODE_NAME="demo-node2"
11
export APP_HOME
12
export PACKAGE_PATH
13
export JAR_NAME
14
export NODE_PORT=8082
15
export PEER_PORT=8081
16
export SPRING_PROFILE="prod-node2"
17

18
log() { echo "[$(date '+%F %T')] [node2] $*"; }
19

20
mkdir -p "$(dirname "$PACKAGE_PATH")"
21
mkdir -p "$APP_HOME"
22

23
deploy_package() {
24
  if [ ! -f "$PACKAGE_PATH" ]; then
25
    log "错误：制品文件不存在 $PACKAGE_PATH"
26
    exit 1
27
  fi
28
  log "解包 $PACKAGE_PATH 到 $APP_HOME"
29
  tar -zxf "$PACKAGE_PATH" -C "$APP_HOME"
30
  log "解包完成"
31
}
32

33
cd "$APP_HOME" || { echo "目录不存在: $APP_HOME"; exit 1; }
34

35
deploy_package
36

37
log "执行零停机发布（节点 2）"
38
bash "$APP_HOME/zero-deploy-node.sh"
39

40
log "节点 2 部署脚本执行完毕"