springboot零停机发布方案#

1
deployment:
2
  admin:
3
    admin_key_required: true            # 建议开发后期再打开
4
    admin_key:
5
      - name: admin
6
        role: admin
7
        key: CKjcGDoqxcJfpIXWigyqjdUSACvwzEJy
8
    allow_admin:
9
      - 127.0.0.0/24
10
      - 172.17.0.0/16                   # Docker 默认桥接
11
      - 0.0.0.0/0                    # 仅本地演示可全开

1
#!/bin/bash
2

3
# APISIX 80端口管理脚本
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.12.0-debian"
9

10
# 停止APISIX
11
stop() {
12
    echo "停止所有APISIX相关容器..."
13

14
    # 停止所有可能的APISIX容器名称
15
    for name in apisix-main apisix-no-auth apisix-quickstart apisix-quickstart-80; do
16
        if docker ps -a --format "{{.Names}}" | grep -q "^${name}$"; then
17
            echo "停止容器: $name"
18
            docker stop $name 2>/dev/null
19
            docker rm $name 2>/dev/null
20
        fi
21
    done
22

23
    echo "所有APISIX容器已停止"
24
}
25

26
# 启动APISIX (80端口)
27
start() {
28
    echo "启动APISIX容器 (80端口)..."
29

30
    # 先检查容器是否已存在
31
    if docker ps -a --format "{{.Names}}" | grep -q "^${CONTAINER_NAME}$"; then
32
        echo "容器 $CONTAINER_NAME 已存在，先删除..."
33
        docker stop $CONTAINER_NAME 2>/dev/null
34
        docker rm $CONTAINER_NAME 2>/dev/null
35
    fi
36

37
    # 启动新容器
38
      CONTAINER_ID=$(docker run -d --name $CONTAINER_NAME \
39
      --network $NETWORK_NAME \
40
      -v $(pwd)/config.yaml:/usr/local/apisix/conf/config.yaml:ro \
41
      -p 80:9080 \
42
      -p 443:9443 \
43
      -p 9180:9180 \
44
      -e APISIX_DEPLOYMENT_ETCD_HOST="[\"$ETCD_HOST\"]" \
45
      $APISIX_IMAGE 2>&1)
46

47

48
    if [ $? -eq 0 ]; then
49
        echo "容器启动成功，ID: ${CONTAINER_ID:0:12}"
50
        echo "等待服务启动..."
51
        sleep 5
52

53
        # 检查容器是否真正运行
54
        if docker ps --format "{{.Names}}" | grep -q "^${CONTAINER_NAME}$"; then
55
            echo "APISIX已成功启动在80端口"
56
        else
57
            echo "容器启动失败，查看日志:"
58
            docker logs $CONTAINER_NAME 2>/dev/null | tail -10
59
        fi
60
    else
61
        echo "容器启动失败: $CONTAINER_ID"
62
    fi
63
}
64

65
# 重启
66
restart() {
67
    stop
68
    sleep 2
69
    start
70
}
71

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

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

1
#!/bin/bash
2

3
# APISIX Dashboard Docker 管理脚本
4
# 支持安装、启动、停止、卸载功能
5

6
# 颜色定义
7
RED='\033[0;31m'
8
GREEN='\033[0;32m'
9
YELLOW='\033[1;33m'
10
BLUE='\033[0;34m'
11
NC='\033[0m' # No Color
12

13
# 配置变量
14
DOCKER_IMAGE="apache/apisix-dashboard"
15
CONTAINER_NAME="apisix-dashboard"
16
DASHBOARD_PORT="9000"
17
CONFIG_DIR="/tmp/apisix-dashboard-config"
18
CONFIG_FILE="$CONFIG_DIR/conf.yaml"
19

20
# 日志函数
21
log_info() {
22
    echo -e "${BLUE}[INFO]${NC} $1"
23
}
24

25
log_success() {
26
    echo -e "${GREEN}[SUCCESS]${NC} $1"
27
}
28

29
log_warning() {
30
    echo -e "${YELLOW}[WARNING]${NC} $1"
31
}
32

33
log_error() {
34
    echo -e "${RED}[ERROR]${NC} $1"
35
}
36

37
# 检查Docker是否安装
38
check_docker() {
39
    if ! command -v docker &> /dev/null; then
40
        log_error "Docker 未安装，请先安装 Docker"
41
        exit 1
42
    fi
43

44
    if ! docker info &> /dev/null; then
45
        log_error "Docker 服务未运行，请启动 Docker 服务"
46
        exit 1
47
    fi
48
}
49

50
# 检查etcd是否运行
51
check_etcd() {
52
    log_info "检查 etcd 服务状态..."
53

54
    # 检查APISIX快速安装的etcd容器
55
    if docker ps --format "{{.Names}}" | grep -q "etcd-quickstart"; then
56
        log_success "发现 APISIX 快速安装的 etcd 容器正在运行"
57
        return 0
58
    fi
59

60
    # 检查本地etcd服务
61
    if curl -s http://127.0.0.1:2379/health &> /dev/null; then
62
        log_success "etcd 服务运行正常"
63
        return 0
64
    fi
65

66
    log_warning "未发现运行中的 etcd 服务"
67
    log_warning "请确保以下任一条件满足："
68
    log_warning "1. APISIX 快速安装脚本已运行（etcd-quickstart 容器存在）"
69
    log_warning "2. 本地 etcd 服务正在 127.0.0.1:2379 运行"
70

71
    read -p "是否继续安装？(y/N): " -n 1 -r
72
    echo
73
    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
74
        exit 1
75
    fi
76
}
77

78
# 生成配置文件
79
generate_config() {
80
    log_info "生成配置文件..."
81
    mkdir -p "$CONFIG_DIR"
82

83
    # 检测etcd连接地址
84
    local etcd_endpoint="http://127.0.0.1:2379"
85
    local admin_api_endpoint="http://127.0.0.1:9180"
86

87
    # 如果发现APISIX快速安装的etcd容器，使用容器网络连接
88
    if docker ps --format "{{.Names}}" | grep -q "etcd-quickstart"; then
89
        log_info "检测到 APISIX 快速安装环境，配置容器网络连接"
90
        etcd_endpoint="http://etcd-quickstart:2379"
91
        admin_api_endpoint="http://apisix-quickstart:9180"
92
    fi
93

94
    cat > "$CONFIG_FILE" << EOF
95
conf:
96
  listen:
97
    host: 0.0.0.0
98
    port: 9000
99
  etcd:
100
    endpoints:
101
      - $etcd_endpoint
102
  log:
103
    error_log:
104
      level: warn
105
      file_path: logs/error.log
106
    access_log:
107
      file_path: logs/access.log
108
authentication:
109
  secret: secret
110
  expire_time: 3600
111
  users:
112
    - username: admin
113
      password: admin
114
plugins:
115
  - api-breaker
116
  - authz-keycloak
117
  - basic-auth
118
  - batch-requests
119
  - consumer-restriction
120
  - cors
121
  - echo
122
  - fault-injection
123
  - grpc-transcode
124
  - hmac-auth
125
  - http-logger
126
  - ip-restriction
127
  - jwt-auth
128
  - kafka-logger
129
  - key-auth
130
  - limit-conn
131
  - limit-count
132
  - limit-req
133
  - node-status
134
  - openid-connect
135
  - prometheus
136
  - proxy-cache
137
  - proxy-mirror
138
  - proxy-rewrite
139
  - redirect
140
  - referer-restriction
141
  - request-id
142
  - request-validation
143
  - response-rewrite
144
  - serverless-post-function
145
  - serverless-pre-function
146
  - sls-logger
147
  - syslog
148
  - tcp-logger
149
  - udp-logger
150
  - uri-blocker
151
  - wolf-rbac
152
  - zipkin
153
  - server-info
154
  - traffic-split
155
apisix:
156
  base_url: $admin_api_endpoint
157
  api_key: ""
158
EOF
159

160
    log_success "配置文件已生成: $CONFIG_FILE"
161
    log_info "etcd 连接地址: $etcd_endpoint"
162
    log_info "Admin API 地址: $admin_api_endpoint"
163
}
164

165
# 检查容器状态
166
check_container_status() {
167
    if docker ps -q -f name="$CONTAINER_NAME" | grep -q .; then
168
        echo "running"
169
    elif docker ps -aq -f name="$CONTAINER_NAME" | grep -q .; then
170
        echo "stopped"
171
    else
172
        echo "not_exists"
173
    fi
174
}
175

176
# 安装Dashboard
177
install_dashboard() {
178
    log_info "开始安装 APISIX Dashboard..."
179

180
    # 检查是否已经安装
181
    status=$(check_container_status)
182
    if [ "$status" != "not_exists" ]; then
183
        log_warning "Dashboard 容器已存在"
184
        read -p "是否重新安装？这将删除现有容器 (y/N): " -n 1 -r
185
        echo
186
        if [[ $REPLY =~ ^[Yy]$ ]]; then
187
            uninstall_dashboard
188
        else
189
            return 0
190
        fi
191
    fi
192

193
    # 检查依赖
194
    check_docker
195
    check_etcd
196

197
    # 生成配置文件
198
    generate_config
199

200
    # 拉取镜像
201
    log_info "拉取 Docker 镜像..."
202
    if ! docker pull "$DOCKER_IMAGE"; then
203
        log_error "拉取镜像失败"
204
        exit 1
205
    fi
206

207
    # 创建并启动容器
208
    log_info "创建并启动容器..."
209

210
    # 检测是否需要连接到APISIX网络
211
    local network_option=""
212
    if docker ps --format "{{.Names}}" | grep -q "etcd-quickstart"; then
213
        # 检查apisix-quickstart-net网络是否存在
214
        if docker network ls --format "{{.Name}}" | grep -q "apisix-quickstart-net"; then
215
            log_info "连接到 APISIX 快速安装网络"
216
            network_option="--network apisix-quickstart-net"
217
        fi
218
    fi
219

220
    if docker run -d \
221
        --name "$CONTAINER_NAME" \
222
        $network_option \
223
        -p "$DASHBOARD_PORT:9000" \
224
        -v "$CONFIG_FILE:/usr/local/apisix-dashboard/conf/conf.yaml" \
225
        "$DOCKER_IMAGE"; then
226

227
        log_success "APISIX Dashboard 安装成功！"
228
        log_info "访问地址: http://127.0.0.1:$DASHBOARD_PORT"
229
        log_info "默认用户名: admin"
230
        log_info "默认密码: admin"
231
    else
232
        log_error "容器启动失败"
233
        exit 1
234
    fi
235
}
236

237
# 启动Dashboard
238
start_dashboard() {
239
    log_info "启动 APISIX Dashboard..."
240

241
    status=$(check_container_status)
242
    case $status in
243
        "running")
244
            log_warning "Dashboard 已经在运行中"
245
            ;;
246
        "stopped")
247
            if docker start "$CONTAINER_NAME"; then
248
                log_success "Dashboard 启动成功"
249
                log_info "访问地址: http://127.0.0.1:$DASHBOARD_PORT"
250
            else
251
                log_error "Dashboard 启动失败"
252
                exit 1
253
            fi
254
            ;;
255
        "not_exists")
256
            log_error "Dashboard 容器不存在，请先安装"
257
            exit 1
258
            ;;
259
    esac
260
}
261

262
# 停止Dashboard
263
stop_dashboard() {
264
    log_info "停止 APISIX Dashboard..."
265

266
    status=$(check_container_status)
267
    case $status in
268
        "running")
269
            if docker stop "$CONTAINER_NAME"; then
270
                log_success "Dashboard 已停止"
271
            else
272
                log_error "停止 Dashboard 失败"
273
                exit 1
274
            fi
275
            ;;
276
        "stopped")
277
            log_warning "Dashboard 已经停止"
278
            ;;
279
        "not_exists")
280
            log_error "Dashboard 容器不存在"
281
            exit 1
282
            ;;
283
    esac
284
}
285

286
# 查看状态
287
show_status() {
288
    log_info "检查 APISIX Dashboard 状态..."
289

290
    status=$(check_container_status)
291
    case $status in
292
        "running")
293
            log_success "Dashboard 正在运行"
294
            echo
295
            echo "容器信息:"
296
            docker ps --filter name="$CONTAINER_NAME" --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
297
            echo
298
            log_info "访问地址: http://127.0.0.1:$DASHBOARD_PORT"
299
            ;;
300
        "stopped")
301
            log_warning "Dashboard 已停止"
302
            ;;
303
        "not_exists")
304
            log_error "Dashboard 容器不存在，请先安装"
305
            ;;
306
    esac
307
}
308

309
# 查看日志
310
show_logs() {
311
    log_info "显示 APISIX Dashboard 日志..."
312

313
    status=$(check_container_status)
314
    if [ "$status" = "not_exists" ]; then
315
        log_error "Dashboard 容器不存在"
316
        exit 1
317
    fi
318

319
    echo "最近50行日志:"
320
    docker logs --tail 50 "$CONTAINER_NAME"
321
    echo
322
    read -p "按回车键继续..."
323
}
324

325
# 卸载Dashboard
326
uninstall_dashboard() {
327
    log_info "卸载 APISIX Dashboard..."
328

329
    status=$(check_container_status)
330
    if [ "$status" = "not_exists" ]; then
331
        log_warning "Dashboard 容器不存在"
332
        return 0
333
    fi
334

335
    read -p "确认卸载 APISIX Dashboard？这将删除容器和配置文件 (y/N): " -n 1 -r
336
    echo
337
    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
338
        log_info "取消卸载"
339
        return 0
340
    fi
341

342
    # 停止并删除容器
343
    if [ "$status" = "running" ]; then
344
        docker stop "$CONTAINER_NAME"
345
    fi
346

347
    docker rm "$CONTAINER_NAME"
348

349
    # 删除配置文件
350
    if [ -d "$CONFIG_DIR" ]; then
351
        rm -rf "$CONFIG_DIR"
352
    fi
353

354
    log_success "APISIX Dashboard 已卸载"
355
}
356

357
# 显示主菜单
358
show_menu() {
359
    clear
360
    echo -e "${BLUE}================================${NC}"
361
    echo -e "${BLUE}   APISIX Dashboard 管理工具${NC}"
362
    echo -e "${BLUE}================================${NC}"
363
    echo
364
    echo "1. 安装 Dashboard"
365
    echo "2. 启动 Dashboard"
366
    echo "3. 停止 Dashboard"
367
    echo "4. 查看状态"
368
    echo "5. 查看日志"
369
    echo "6. 卸载 Dashboard"
370
    echo "7. 退出"
371
    echo
372
}
373

374
# 主函数
375
main() {
376
    while true; do
377
        show_menu
378
        read -p "请选择操作 [1-7]: " choice
379
        echo
380

381
        case $choice in
382
            1)
383
                install_dashboard
384
                ;;
385
            2)
386
                start_dashboard
387
                ;;
388
            3)
389
                stop_dashboard
390
                ;;
391
            4)
392
                show_status
393
                ;;
394
            5)
395
                show_logs
396
                ;;
397
            6)
398
                uninstall_dashboard
399
                ;;
400
            7)
401
                log_info "退出程序"
402
                exit 0
403
                ;;
404
            *)
405
                log_error "无效选择，请输入 1-7"
406
                ;;
407
        esac
408

409
        echo
410
        read -p "按回车键继续..."
411
    done
412
}
413

414
# 检查是否以root权限运行
415
if [ "$EUID" -eq 0 ]; then
416
    log_warning "建议不要以 root 权限运行此脚本"
417
fi
418

419
# 启动主程序
420
main

1
#!/bin/bash
2

3
# APISIX 配置管理脚本
4
# 支持一键导出和导入所有配置
5
# 作者: Manus AI
6
# 版本: 1.0
7

8
# 颜色定义
9
RED='\033[0;31m'
10
GREEN='\033[0;32m'
11
YELLOW='\033[1;33m'
12
BLUE='\033[0;34m'
13
NC='\033[0m' # No Color
14

15
# 默认配置
16
DEFAULT_APISIX_HOST="1.2.3.4"
17
DEFAULT_APISIX_PORT="9180"
18
DEFAULT_API_KEY="CKjcGDoqxcJfpIXWigyqjdUSACvwzEJy"
19

20
# 配置文件列表
21
CONFIG_TYPES=(
22
    "routes"
23
    "upstreams"
24
    "services"
25
    "consumers"
26
    "ssls"
27
    "global_rules"
28
    "plugin_configs"
29
    "stream_routes"
30
    "plugins/list"
31
)
32

33
# 配置文件名映射
34
declare -A CONFIG_FILES=(
35
    ["routes"]="apisix_routes.json"
36
    ["upstreams"]="apisix_upstreams.json"
37
    ["services"]="apisix_services.json"
38
    ["consumers"]="apisix_consumers.json"
39
    ["ssls"]="apisix_ssls.json"
40
    ["global_rules"]="apisix_global_rules.json"
41
    ["plugin_configs"]="apisix_plugin_configs.json"
42
    ["stream_routes"]="apisix_stream_routes.json"
43
    ["plugins/list"]="apisix_plugins.json"
44
)
45

46
# 显示标题
47
show_header() {
48
    echo -e "${BLUE}================================================${NC}"
49
    echo -e "${BLUE}           APISIX 配置管理工具${NC}"
50
    echo -e "${BLUE}================================================${NC}"
51
    echo ""
52
}
53

54
# 显示菜单
55
show_menu() {
56
    echo -e "${YELLOW}请选择操作:${NC}"
57
    echo -e "${GREEN}1.${NC} 一键导出所有配置"
58
    echo -e "${GREEN}2.${NC} 一键导入所有配置"
59
    echo -e "${GREEN}3.${NC} 退出"
60
    echo ""
61
}
62

63
# 去除字符串两边的空格
64
trim_spaces() {
65
    local var="$1"
66
    # 去除前导空格
67
    var="${var#"${var%%[![:space:]]*}"}"
68
    # 去除尾随空格
69
    var="${var%"${var##*[![:space:]]}"}"
70
    echo "$var"
71
}
72

73
# 检查 APISIX 连接
74
check_apisix_connection() {
75
    local host="$1"
76
    local port="$2"
77
    local api_key="$3"
78

79
    echo -e "${YELLOW}正在检查 APISIX 连接...${NC}"
80

81
    local response=$(curl -s -w "%{http_code}" -H "X-API-KEY: $api_key" \
82
        "http://$host:$port/apisix/admin/routes" -o /dev/null)
83

84
    if [ "$response" = "200" ]; then
85
        echo -e "${GREEN}✓ APISIX 连接成功${NC}"
86
        return 0
87
    else
88
        echo -e "${RED}✗ APISIX 连接失败 (HTTP状态码: $response)${NC}"
89
        echo -e "${RED}请检查服务器地址、端口和API密钥${NC}"
90
        return 1
91
    fi
92
}
93

94
# 获取用户输入的配置信息
95
get_apisix_config() {
96
    echo -e "${YELLOW}请输入 APISIX 配置信息:${NC}"
97

98
    read -p "APISIX 服务器地址 [默认: $DEFAULT_APISIX_HOST]: " APISIX_HOST
99
    APISIX_HOST=$(trim_spaces "${APISIX_HOST:-$DEFAULT_APISIX_HOST}")
100

101
    read -p "APISIX 端口 [默认: $DEFAULT_APISIX_PORT]: " APISIX_PORT
102
    APISIX_PORT=$(trim_spaces "${APISIX_PORT:-$DEFAULT_APISIX_PORT}")
103

104
    read -p "API 密钥 [默认: $DEFAULT_API_KEY]: " API_KEY
105
    API_KEY=$(trim_spaces "${API_KEY:-$DEFAULT_API_KEY}")
106

107
    echo ""
108
}
109

110
# 导出配置
111
export_configs() {
112
    echo -e "${BLUE}开始导出 APISIX 配置...${NC}"
113
    echo ""
114

115
    # 获取配置信息
116
    get_apisix_config
117

118
    # 检查连接
119
    if ! check_apisix_connection "$APISIX_HOST" "$APISIX_PORT" "$API_KEY"; then
120
        return 1
121
    fi
122

123
    # 获取导出目录
124
    read -p "请输入导出目录路径 [默认: ./apisix_export]: " EXPORT_DIR
125
    EXPORT_DIR=$(trim_spaces "${EXPORT_DIR:-./apisix_export}")
126

127
    # 创建导出目录
128
    if [ ! -d "$EXPORT_DIR" ]; then
129
        mkdir -p "$EXPORT_DIR"
130
        echo -e "${GREEN}✓ 创建导出目录: $EXPORT_DIR${NC}"
131
    fi
132

133
    echo ""
134
    echo -e "${YELLOW}正在导出配置文件...${NC}"
135

136
    # 导出各类配置
137
    local success_count=0
138
    local total_count=${#CONFIG_TYPES[@]}
139

140
    for config_type in "${CONFIG_TYPES[@]}"; do
141
        local file_name="${CONFIG_FILES[$config_type]}"
142
        local output_file="$EXPORT_DIR/$file_name"
143

144
        echo -n "导出 $config_type ... "
145

146
        local response=$(curl -s -H "X-API-KEY: $API_KEY" \
147
            "http://$APISIX_HOST:$APISIX_PORT/apisix/admin/$config_type")
148

149
        if [ $? -eq 0 ] && [ -n "$response" ]; then
150
            echo "$response" | python3 -m json.tool > "$output_file" 2>/dev/null
151
            if [ $? -eq 0 ]; then
152
                echo -e "${GREEN}✓${NC}"
153
                ((success_count++))
154
            else
155
                echo -e "${RED}✗ (JSON格式化失败)${NC}"
156
            fi
157
        else
158
            echo -e "${RED}✗ (请求失败)${NC}"
159
        fi
160
    done
161

162
    echo ""
163

164
    # 创建配置汇总报告
165
    create_export_summary "$EXPORT_DIR"
166

167
    # 创建压缩包
168
    local timestamp=$(date +%Y%m%d_%H%M%S)
169
    local archive_name="apisix_config_export_$timestamp.tar.gz"
170

171
    echo -e "${YELLOW}正在创建压缩包...${NC}"
172
    cd "$(dirname "$EXPORT_DIR")"
173
    tar -czf "$archive_name" "$(basename "$EXPORT_DIR")" 2>/dev/null
174

175
    if [ $? -eq 0 ]; then
176
        echo -e "${GREEN}✓ 压缩包已创建: $archive_name${NC}"
177
    fi
178

179
    echo ""
180
    echo -e "${GREEN}导出完成! ($success_count/$total_count 个配置文件导出成功)${NC}"
181
    echo -e "${BLUE}导出目录: $EXPORT_DIR${NC}"
182
    echo ""
183
}
184

185
# 创建导出汇总报告
186
create_export_summary() {
187
    local export_dir="$1"
188
    local summary_file="$export_dir/export_summary.md"
189

190
    cat > "$summary_file" << EOF
191
# APISIX 配置导出报告
192

193
## 导出信息
194
- **导出时间**: $(date '+%Y年%m月%d日 %H:%M:%S')
195
- **服务器地址**: $APISIX_HOST:$APISIX_PORT
196
- **导出目录**: $export_dir
197

198
## 配置文件列表
199
EOF
200

201
    for config_type in "${CONFIG_TYPES[@]}"; do
202
        local file_name="${CONFIG_FILES[$config_type]}"
203
        local file_path="$export_dir/$file_name"
204

205
        if [ -f "$file_path" ]; then
206
            local file_size=$(du -h "$file_path" | cut -f1)
207
            echo "- ✓ $file_name ($file_size)" >> "$summary_file"
208
        else
209
            echo "- ✗ $file_name (导出失败)" >> "$summary_file"
210
        fi
211
    done
212

213
    cat >> "$summary_file" << EOF
214

215
## 使用说明
216
1. 所有配置文件均为 JSON 格式
217
2. 可使用本脚本的导入功能恢复配置
218
3. 建议定期备份配置文件
219

220
---
221
*由 APISIX 配置管理工具自动生成*
222
EOF
223

224
    echo -e "${GREEN}✓ 导出汇总报告已创建: export_summary.md${NC}"
225
}
226

227
# 导入配置
228
import_configs() {
229
    echo -e "${BLUE}开始导入 APISIX 配置...${NC}"
230
    echo ""
231

232
    # 获取配置信息
233
    get_apisix_config
234

235
    # 检查连接
236
    if ! check_apisix_connection "$APISIX_HOST" "$APISIX_PORT" "$API_KEY"; then
237
        return 1
238
    fi
239

240
    # 获取导入目录
241
    read -p "请输入配置文件目录路径: " IMPORT_DIR
242
    IMPORT_DIR=$(trim_spaces "$IMPORT_DIR")
243

244
    if [ -z "$IMPORT_DIR" ]; then
245
        echo -e "${RED}✗ 目录路径不能为空${NC}"
246
        return 1
247
    fi
248

249
    if [ ! -d "$IMPORT_DIR" ]; then
250
        echo -e "${RED}✗ 目录不存在: $IMPORT_DIR${NC}"
251
        return 1
252
    fi
253

254
    echo ""
255
    echo -e "${YELLOW}正在检查配置文件...${NC}"
256

257
    # 检查配置文件是否存在
258
    local missing_files=()
259
    local existing_files=()
260

261
    for config_type in "${CONFIG_TYPES[@]}"; do
262
        # 跳过插件列表，因为它是只读的
263
        if [ "$config_type" = "plugins/list" ]; then
264
            continue
265
        fi
266

267
        local file_name="${CONFIG_FILES[$config_type]}"
268
        local file_path="$IMPORT_DIR/$file_name"
269

270
        if [ -f "$file_path" ]; then
271
            existing_files+=("$config_type:$file_path")
272
            echo -e "${GREEN}✓${NC} $file_name"
273
        else
274
            missing_files+=("$file_name")
275
            echo -e "${YELLOW}!${NC} $file_name (文件不存在，将跳过)"
276
        fi
277
    done
278

279
    if [ ${#existing_files[@]} -eq 0 ]; then
280
        echo -e "${RED}✗ 没有找到任何可导入的配置文件${NC}"
281
        return 1
282
    fi
283

284
    echo ""
285
    echo -e "${YELLOW}警告: 导入操作将覆盖现有配置!${NC}"
286
    read -p "确认继续导入? (y/N): " confirm
287

288
    if [[ ! "$confirm" =~ ^[Yy]$ ]]; then
289
        echo -e "${YELLOW}导入操作已取消${NC}"
290
        return 0
291
    fi
292

293
    echo ""
294
    echo -e "${YELLOW}正在导入配置...${NC}"
295

296
    local success_count=0
297
    local error_count=0
298

299
    # 导入配置的顺序很重要：先导入upstreams，再导入routes
300
    local import_order=("upstreams" "services" "consumers" "routes" "ssls" "global_rules" "plugin_configs" "stream_routes")
301

302
    for config_type in "${import_order[@]}"; do
303
        local file_name="${CONFIG_FILES[$config_type]}"
304
        local file_path="$IMPORT_DIR/$file_name"
305

306
        # 检查文件是否存在
307
        local found=false
308
        for item in "${existing_files[@]}"; do
309
            if [[ "$item" == "$config_type:"* ]]; then
310
                found=true
311
                break
312
            fi
313
        done
314

315
        if [ "$found" = false ]; then
316
            continue
317
        fi
318

319
        echo -n "导入 $config_type ... "
320

321
        # 读取配置文件
322
        local config_data=$(cat "$file_path")
323

324
        if [ -z "$config_data" ]; then
325
            echo -e "${RED}✗ (文件为空)${NC}"
326
            ((error_count++))
327
            continue
328
        fi
329

330
        # 解析JSON并导入每个配置项
331
        local items=$(echo "$config_data" | python3 -c "
332
import json, sys
333
try:
334
    data = json.load(sys.stdin)
335
    if 'list' in data:
336
        for item in data['list']:
337
            if 'value' in item and 'key' in item:
338
                # 提取ID
339
                key_parts = item['key'].split('/')
340
                if len(key_parts) > 0:
341
                    item_id = key_parts[-1]
342
                    print(f\"{item_id}|||{json.dumps(item['value'])}\")
343
except:
344
    pass
345
")
346

347
        if [ -z "$items" ]; then
348
            echo -e "${YELLOW}! (无配置项)${NC}"
349
            continue
350
        fi
351

352
        local item_success=0
353
        local item_total=0
354

355
        while IFS='|||' read -r item_id item_value; do
356
            if [ -n "$item_id" ] && [ -n "$item_value" ]; then
357
                ((item_total++))
358

359
                # 发送PUT请求导入配置
360
                local response=$(curl -s -w "%{http_code}" -X PUT \
361
                    -H "X-API-KEY: $API_KEY" \
362
                    -H "Content-Type: application/json" \
363
                    -d "$item_value" \
364
                    "http://$APISIX_HOST:$APISIX_PORT/apisix/admin/$config_type/$item_id" \
365
                    -o /dev/null)
366

367
                if [[ "$response" =~ ^20[0-9]$ ]]; then
368
                    ((item_success++))
369
                fi
370
            fi
371
        done <<< "$items"
372

373
        if [ $item_total -eq 0 ]; then
374
            echo -e "${YELLOW}! (无配置项)${NC}"
375
        elif [ $item_success -eq $item_total ]; then
376
            echo -e "${GREEN}✓ ($item_success/$item_total)${NC}"
377
            ((success_count++))
378
        else
379
            echo -e "${YELLOW}! ($item_success/$item_total)${NC}"
380
            ((error_count++))
381
        fi
382
    done
383

384
    echo ""
385

386
    if [ $success_count -gt 0 ]; then
387
        echo -e "${GREEN}导入完成! ($success_count 个配置类型导入成功)${NC}"
388
    fi
389

390
    if [ $error_count -gt 0 ]; then
391
        echo -e "${YELLOW}注意: $error_count 个配置类型导入时出现问题${NC}"
392
    fi
393

394
    echo ""
395
}
396

397
# 主函数
398
main() {
399
    show_header
400

401
    while true; do
402
        show_menu
403
        read -p "请输入选项 (1-3): " choice
404

405
        case $choice in
406
            1)
407
                echo ""
408
                export_configs
409
                ;;
410
            2)
411
                echo ""
412
                import_configs
413
                ;;
414
            3)
415
                echo -e "${GREEN}感谢使用 APISIX 配置管理工具!${NC}"
416
                exit 0
417
                ;;
418
            *)
419
                echo -e "${RED}无效选项，请重新选择${NC}"
420
                echo ""
421
                ;;
422
        esac
423

424
        echo ""
425
        read -p "按回车键继续..."
426
        echo ""
427
    done
428
}
429

430
# 检查依赖
431
check_dependencies() {
432
    local missing_deps=()
433

434
    if ! command -v curl &> /dev/null; then
435
        missing_deps+=("curl")
436
    fi
437

438
    if ! command -v python3 &> /dev/null; then
439
        missing_deps+=("python3")
440
    fi
441

442
    if ! command -v tar &> /dev/null; then
443
        missing_deps+=("tar")
444
    fi
445

446
    if [ ${#missing_deps[@]} -gt 0 ]; then
447
        echo -e "${RED}错误: 缺少必要的依赖程序:${NC}"
448
        for dep in "${missing_deps[@]}"; do
449
            echo -e "${RED}  - $dep${NC}"
450
        done
451
        echo ""
452
        echo -e "${YELLOW}请安装缺少的程序后重新运行脚本${NC}"
453
        exit 1
454
    fi
455
}
456

457
# 脚本入口
458
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
459
    check_dependencies
460
    main "$@"
461
fi