完整部署手册

第一部分：Docker 环境安装与验证

适用于两台服务器：
应用服务器：ecs-fouhsdc3pql2gu（前后端应用）
中间件服务器：ecs-zqxrr7gla5agfr（IP: 20.160.250.107）

1.1 创建文件存放目录

bash

编辑

# 创建 ai_files 目录用于存放所有 tar 包
mkdir -p /ai_files

# 确认目录创建成功
ls -ld /ai_files

1.2 上传 Docker 离线安装包

将 Docker 离线包上传到 /tmp，再移动到 /ai_files：

bash

编辑

# 假设通过 scp 上传到 /tmp
scp docker-27.5.1.tgz root@<服务器IP>:/tmp/

# 移动到 ai_files 目录
mv /tmp/docker-27.5.1.tgz /ai_files/

# 确认文件存在
ls -lh /ai_files/docker-27.5.1.tgz

1.3 卸载旧版 Docker（如有）

bash

编辑

# 停止旧版 Docker 服务
systemctl stop docker 2>/dev/null
systemctl stop docker.socket 2>/dev/null
systemctl stop containerd 2>/dev/null

# 卸载旧版
yum remove -y docker docker-client docker-client-latest docker-common \
    docker-latest docker-latest-logrotate docker-logrotate docker-engine \
    containerd runc 2>/dev/null

# 清理残留
rm -rf /var/lib/docker
rm -rf /var/lib/containerd
rm -rf /etc/docker

1.4 安装 Docker（离线方式）

bash

编辑

# 解压 Docker 二进制包
cd /ai_files
tar -xzf docker-27.5.1.tgz

# 将二进制文件复制到系统路径
cp docker/* /usr/bin/

# 验证二进制文件已就位
ls -lh /usr/bin/docker*
ls -lh /usr/bin/containerd*
ls -lh /usr/bin/runc

1.5 配置 Docker 为 Systemd 服务

bash

编辑

cat > /etc/systemd/system/docker.service << 'EOF'
[Unit]
Description=Docker Application Container Engine
Documentation=https://docs.docker.com
After=network-online.target firewalld.service containerd.service
Wants=network-online.target

[Service]
Type=notify
ExecStart=/usr/bin/dockerd
ExecReload=/bin/kill -s HUP $MAINPID
TimeoutSec=0
RestartSec=2
Restart=always
StartLimitBurst=3
StartLimitInterval=60s
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
TasksMax=infinity
Delegate=yes
KillMode=process
OOMScoreAdjust=-500

[Install]
WantedBy=multi-user.target
EOF

1.6 配置 Docker Daemon（16核32G 优化）

bash

编辑

mkdir -p /etc/docker

cat > /etc/docker/daemon.json << 'EOF'
{
  "storage-driver": "overlay2",
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m",
    "max-file": "3"
  },
  "default-ulimits": {
    "nofile": {
      "Name": "nofile",
      "Hard": 65536,
      "Soft": 65536
    },
    "nproc": {
      "Name": "nproc",
      "Hard": 65536,
      "Soft": 65536
    }
  },
  "live-restore": true,
  "max-concurrent-downloads": 10,
  "max-concurrent-uploads": 10,
  "default-address-pools": [
    {
      "base": "172.17.0.0/16",
      "size": 24
    }
  ],
  "exec-opts": ["native.cgroupdriver=systemd"],
  "registry-mirrors": [],
  "insecure-registries": [],
  "features": {
    "containerd-snapshotter": true
  }
}
EOF

1.7 系统内核参数优化（16核32G）

bash

编辑

cat >> /etc/sysctl.conf << 'EOF'

# ===== Docker & 中间件优化（16核32G） =====
# 网络优化
net.core.somaxconn = 65535
net.core.netdev_max_backlog = 65535
net.ipv4.tcp_max_syn_backlog = 65535
net.ipv4.tcp_fin_timeout = 10
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_keepalive_time = 60
net.ipv4.tcp_keepalive_intvl = 10
net.ipv4.tcp_keepalive_probes = 6
net.ipv4.ip_local_port_range = 1024 65535

# 内存优化
vm.max_map_count = 262144
vm.swappiness = 10
vm.overcommit_memory = 1

# 文件描述符
fs.file-max = 6553560
fs.nr_open = 6553560

# 网络连接跟踪
net.netfilter.nf_conntrack_max = 1048576
EOF

# 立即生效
sysctl -p

1.8 文件描述符限制优化

bash

编辑

cat >> /etc/security/limits.conf << 'EOF'

# ===== Docker & 中间件优化 =====
*    soft    nofile    655360
*    hard    nofile    655360
*    soft    nproc     655360
*    hard    nproc     655360
*    soft    memlock   unlimited
*    hard    memlock   unlimited
root soft    nofile    655360
root hard    nofile    655360
EOF

1.9 启动 Docker 并设置开机自启

bash

编辑

# 重新加载 systemd 配置
systemctl daemon-reload

# 启动 Docker
systemctl start docker

# 设置开机自启
systemctl enable docker

# 查看运行状态
systemctl status docker

1.10 验证 Docker 安装

bash

编辑

# 查看 Docker 版本
docker version

# 查看 Docker 系统信息
docker info

# 运行测试容器（如有网络）
docker run --rm hello-world

# 确认 Docker 进程运行
ps aux | grep dockerd

# 确认 socket 文件存在
ls -la /var/run/docker.sock

期望输出（docker version）：

文本

编辑

Client:
 Version:           27.5.1
 API version:       1.47
 ...

Server: Docker Engine - Community
 Engine:
  Version:          27.5.1
  ...

1.11 创建 Docker 网络（两台服务器都执行）

bash

编辑

# 创建自定义桥接网络（用于中间件容器间通信）
docker network create --driver bridge --subnet=172.18.0.0/16 --gateway=172.18.0.1 app-network

# 验证网络创建
docker network ls
docker network inspect app-network

1.12 关闭防火墙（避免端口拦截）

bash

编辑

# 停止并禁用 firewalld
systemctl stop firewalld
systemctl disable firewalld

# 确认状态
systemctl status firewalld
# 应显示：inactive (dead)

第二部分：中间件服务部署（服务器：20.160.250.107）

服务器：ecs-zqxrr7gla5agfr（16核32G）
所有 tar 包统一存放在 /ai_files/ 目录

2.1 上传所有中间件镜像包

bash

编辑

# 将各中间件 tar 包上传到 /tmp，再移动到 /ai_files
scp redis-7.4.tar    root@20.160.250.107:/tmp/
scp mysql-8.0.tar    root@20.160.250.107:/tmp/
scp elasticsearch-9.4.2-arm64.tar  root@20.160.250.107:/tmp/
scp minio.tar        root@20.160.250.107:/tmp/
scp kafka-3.9.tar    root@20.160.250.107:/tmp/

# 移动到 ai_files
mv /tmp/redis-7.4.tar /ai_files/
mv /tmp/mysql-8.0.tar /ai_files/
mv /tmp/elasticsearch-9.4.2-arm64.tar /ai_files/
mv /tmp/minio.tar /ai_files/
mv /tmp/kafka-3.9.tar /ai_files/

# 确认所有文件
ls -lh /ai_files/

2.2 加载所有 Docker 镜像

bash

编辑

# 逐个加载镜像
docker load -i /ai_files/redis-7.4.tar
docker load -i /ai_files/mysql-8.0.tar
docker load -i /ai_files/elasticsearch-9.4.2-arm64.tar
docker load -i /ai_files/minio.tar
docker load -i /ai_files/kafka-3.9.tar

# 确认所有镜像已加载
docker images

2.3 创建数据持久化目录

bash

编辑

# 创建所有中间件的数据目录
mkdir -p /data/redis/data
mkdir -p /data/redis/conf
mkdir -p /data/mysql/data
mkdir -p /data/mysql/conf
mkdir -p /data/mysql/logs
mkdir -p /data/elasticsearch/data
mkdir -p /data/elasticsearch/logs
mkdir -p /data/elasticsearch/config
mkdir -p /data/minio/data
mkdir -p /data/minio/config
mkdir -p /data/kafka/data
mkdir -p /data/kafka/config

# 设置目录权限
chmod -R 777 /data/elasticsearch
chmod -R 777 /data/kafka
chmod -R 777 /data/redis
chmod -R 777 /data/mysql
chmod -R 777 /data/minio

2.4 部署 Redis 7.4

bash

编辑

# 创建 Redis 配置文件
cat > /data/redis/conf/redis.conf << 'EOF'
# 绑定所有网卡
bind 0.0.0.0

# 端口
port 6379

# 后台运行（Docker中不需要）
daemonize no

# 持久化
appendonly yes
appendfsync everysec

# 最大内存（16核32G 分配 4GB 给 Redis）
maxmemory 4gb
maxmemory-policy allkeys-lru

# 连接数
maxclients 10000

# 日志
loglevel notice

# 密码（按需设置）
# requirepass your_redis_password

# 慢查询日志
slowlog-log-slower-than 10000
slowlog-max-len 128

# TCP 优化
tcp-keepalive 60
tcp-backlog 511
EOF

# 启动 Redis 容器
docker run -d \
  --name redis \
  --network app-network \
  --restart always \
  -p 6379:6379 \
  -v /data/redis/data:/data \
  -v /data/redis/conf/redis.conf:/etc/redis/redis.conf \
  --memory 4g \
  --cpus 2 \
  redis:7.4 \
  redis-server /etc/redis/redis.conf

# 验证
docker ps --filter name=redis
docker logs redis --tail 10

2.5 部署 MySQL 8.0

bash

编辑

# 创建 MySQL 配置文件
cat > /data/mysql/conf/my.cnf << 'EOF'
[mysqld]
# 基础配置
port = 3306
bind-address = 0.0.0.0
default-storage-engine = InnoDB
character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci

# 性能优化（16核32G 分配 8GB 给 MySQL）
innodb_buffer_pool_size = 8G
innodb_buffer_pool_instances = 8
innodb_log_file_size = 1G
innodb_log_buffer_size = 64M
innodb_flush_log_at_trx_commit = 1
innodb_flush_method = O_DIRECT
innodb_io_capacity = 4000
innodb_io_capacity_max = 8000
innodb_read_io_threads = 8
innodb_write_io_threads = 8

# 连接数
max_connections = 2000
max_connect_errors = 100000
wait_timeout = 600
interactive_timeout = 600

# 缓存
table_open_cache = 4096
table_definition_cache = 2048
tmp_table_size = 256M
max_heap_table_size = 256M
sort_buffer_size = 4M
join_buffer_size = 4M
read_buffer_size = 2M
read_rnd_buffer_size = 4M

# 慢查询日志
slow_query_log = 1
slow_query_log_file = /var/log/mysql/slow.log
long_query_time = 2

# 二进制日志
log-bin = mysql-bin
binlog_format = ROW
expire_logs_days = 7
max_binlog_size = 256M

# 其他
skip-name-resolve
lower_case_table_names = 1
sql_mode = STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION

[client]
default-character-set = utf8mb4
port = 3306

[mysql]
default-character-set = utf8mb4
EOF

# 启动 MySQL 容器
docker run -d \
  --name mysql \
  --network app-network \
  --restart always \
  -p 3306:3306 \
  -v /data/mysql/data:/var/lib/mysql \
  -v /data/mysql/conf/my.cnf:/etc/mysql/conf.d/my.cnf \
  -v /data/mysql/logs:/var/log/mysql \
  -e MYSQL_ROOT_PASSWORD=YourMySQLPassword123 \
  -e TZ=Asia/Shanghai \
  --memory 10g \
  --cpus 4 \
  mysql:8.0

# 验证
docker ps --filter name=mysql
docker logs mysql --tail 20

# 等待 MySQL 完全启动（约30秒），然后测试连接
sleep 30
docker exec -it mysql mysql -uroot -pYourMySQLPassword123 -e "SELECT VERSION();"

2.6 部署 Elasticsearch 9.4.2（ARM64）

bash

编辑

# 创建 ES 配置目录和文件
mkdir -p /data/elasticsearch/config/certs

# 设置 vm.max_map_count（ES 必需）
echo "vm.max_map_count=262144" >> /etc/sysctl.conf
sysctl -p

# 启动 ES 容器
docker run -d \
  --name elasticsearch \
  --network app-network \
  --restart always \
  -p 9200:9200 \
  -p 9300:9300 \
  -v /data/elasticsearch/data:/usr/share/elasticsearch/data \
  -v /data/elasticsearch/logs:/usr/share/elasticsearch/logs \
  -e "discovery.type=single-node" \
  -e "cluster.name=es-cluster" \
  -e "node.name=es-node-1" \
  -e "xpack.security.enabled=true" \
  -e "xpack.security.http.ssl.enabled=false" \
  -e "ELASTIC_PASSWORD=cQcSSKmkVQLMp6Ju" \
  -e "ES_JAVA_OPTS=-Xms4g -Xmx4g" \
  -e "bootstrap.memory_lock=false" \
  --memory 6g \
  --cpus 4 \
  --ulimit nofile=65536:65536 \
  --ulimit memlock=-1:-1 \
  docker.elastic.co/elasticsearch/elasticsearch:9.4.2-arm64

# 验证（等待约30-60秒启动）
sleep 30
docker ps --filter name=elasticsearch
docker logs elasticsearch --tail 30

# 测试 ES 是否正常响应
curl -s -o /dev/null -w "%{http_code}" -u elastic:cQcSSKmkVQLMp6Ju http://127.0.0.1:9200
echo ""
# 期望返回：200

2.7 部署 MinIO

bash

编辑

# 启动 MinIO 容器
docker run -d \
  --name minio \
  --network app-network \
  --restart always \
  -p 9000:9000 \
  -p 9001:9001 \
  -v /data/minio/data:/data \
  -v /data/minio/config:/root/.minio \
  -e "MINIO_ROOT_USER=admin" \
  -e "MINIO_ROOT_PASSWORD=YourMinIOPassword123" \
  -e "MINIO_PROMETHEUS_AUTH_TYPE=public" \
  --memory 4g \
  --cpus 2 \
  minio/minio:latest \
  server /data --console-address ":9001"

# 验证
docker ps --filter name=minio
docker logs minio --tail 10

# 测试健康检查
curl -s -o /dev/null -w "%{http_code}" http://127.0.0.1:9000/minio/health/live
echo ""
# 期望返回：200

2.8 部署 Kafka 3.9（KRaft 模式）

bash

编辑

# 启动 Kafka 容器（KRaft 单节点模式）
docker run -d \
  --name kafka \
  --network app-network \
  --restart always \
  -p 9092:9092 \
  -v /data/kafka/data:/var/lib/kafka/data \
  -e "KAFKA_NODE_ID=1" \
  -e "KAFKA_PROCESS_ROLES=broker,controller" \
  -e "KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092,CONTROLLER://0.0.0.0:9093" \
  -e "KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://20.160.250.107:9092" \
  -e "KAFKA_CONTROLLER_LISTENER_NAMES=CONTROLLER" \
  -e "KAFKA_LISTENER_SECURITY_PROTOCOL_MAP=CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT" \
  -e "KAFKA_CONTROLLER_QUORUM_VOTERS=1@localhost:9093" \
  -e "KAFKA_LOG_DIRS=/var/lib/kafka/data" \
  -e "KAFKA_NUM_PARTITIONS=6" \
  -e "KAFKA_DEFAULT_REPLICATION_FACTOR=1" \
  -e "KAFKA_LOG_RETENTION_HOURS=168" \
  -e "KAFKA_LOG_SEGMENT_BYTES=1073741824" \
  -e "KAFKA_HEAP_OPTS=-Xms2g -Xmx2g" \
  --memory 4g \
  --cpus 2 \
  apache/kafka:3.9.0

# 验证
docker ps --filter name=kafka
docker logs kafka --tail 20

# 测试端口连通性
timeout 1 bash -c "echo > /dev/tcp/127.0.0.1/9092" && echo "✅ Kafka 端口连通" || echo "❌ Kafka 端口不通"

2.9 中间件资源分配总览（16核32G）

表格

服务	CPU	内存	端口	说明
Redis	2核	4 GB	6379	缓存
MySQL	4核	10 GB	3306	数据库
Elasticsearch	4核	6 GB	9200, 9300	搜索引擎
MinIO	2核	4 GB	9000, 9001	对象存储
Kafka	2核	4 GB	9092	消息队列
系统预留	2核	4 GB	—	OS + Docker
合计	16核	32 GB	—	—

2.10 阿里云安全组配置（必须！）

登录阿里云控制台 → ECS → 实例 20.160.250.107 → 安全组 → 配置规则 → 入方向，添加以下规则：

表格

协议	端口范围	授权对象	说明
TCP	6379/6379	0.0.0.0/0（或应用服务器IP）	Redis
TCP	3306/3306	0.0.0.0/0（或应用服务器IP）	MySQL
TCP	9200/9200	0.0.0.0/0（或应用服务器IP）	Elasticsearch HTTP
TCP	9300/9300	0.0.0.0/0（或应用服务器IP）	Elasticsearch Transport
TCP	9000/9000	0.0.0.0/0（或应用服务器IP）	MinIO API
TCP	9001/9001	0.0.0.0/0（或应用服务器IP）	MinIO Console
TCP	9092/9092	0.0.0.0/0（或应用服务器IP）	Kafka

⚠️ 生产环境建议：将授权对象限制为应用服务器的固定 IP，而非 0.0.0.0/0。

第三部分：应用前后端部署（服务器：应用服务器）

服务器：ecs-fouhsdc3pql2gu（16核32G）

3.1 上传应用镜像包

bash

编辑

# 上传到 /tmp 再移动到 /ai_files
scp backend-app.tar   root@<应用服务器IP>:/tmp/
scp frontend-app.tar  root@<应用服务器IP>:/tmp/

mv /tmp/backend-app.tar /ai_files/
mv /tmp/frontend-app.tar /ai_files/

# 加载镜像
docker load -i /ai_files/backend-app.tar
docker load -i /ai_files/frontend-app.tar

# 确认
docker images

3.2 部署后端应用

bash

编辑

# 创建应用配置目录
mkdir -p /data/app/backend/config
mkdir -p /data/app/backend/logs
mkdir -p /data/app/backend/upload

# 启动后端容器
docker run -d \
  --name backend \
  --restart always \
  -p 8080:8080 \
  -v /data/app/backend/config:/app/config \
  -v /data/app/backend/logs:/app/logs \
  -v /data/app/backend/upload:/app/upload \
  -e "SPRING_PROFILES_ACTIVE=prod" \
  -e "REDIS_HOST=20.160.250.107" \
  -e "REDIS_PORT=6379" \
  -e "MYSQL_HOST=20.160.250.107" \
  -e "MYSQL_PORT=3306" \
  -e "ES_HOST=20.160.250.107" \
  -e "ES_PORT=9200" \
  -e "MINIO_ENDPOINT=http://20.160.250.107:9000" \
  -e "KAFKA_BOOTSTRAP_SERVERS=20.160.250.107:9092" \
  -e "JAVA_OPTS=-Xms2g -Xmx2g -XX:+UseG1GC -XX:MaxGCPauseMillis=200" \
  --memory 4g \
  --cpus 4 \
  backend-app:latest

# 验证
docker ps --filter name=backend
docker logs backend --tail 30

3.3 部署前端应用（Nginx）

bash

编辑

# 创建前端配置目录
mkdir -p /data/app/frontend/html
mkdir -p /data/app/frontend/conf

# Nginx 配置文件
cat > /data/app/frontend/conf/nginx.conf << 'EOF'
worker_processes auto;
worker_rlimit_nofile 65535;

events {
    worker_connections 10240;
    use epoll;
    multi_accept on;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    # 日志格式
    log_format main '$remote_addr - $remote_user [$time_local] "$request" '
                    '$status $body_bytes_sent "$http_referer" '
                    '"$http_user_agent" "$http_x_forwarded_for" '
                    'rt=$request_time';

    access_log /var/log/nginx/access.log main;
    error_log  /var/log/nginx/error.log warn;

    # 性能优化
    sendfile        on;
    tcp_nopush      on;
    tcp_nodelay     on;
    keepalive_timeout 65;
    types_hash_max_size 2048;
    client_max_body_size 100m;

    # Gzip 压缩
    gzip on;
    gzip_min_length 1k;
    gzip_comp_level 6;
    gzip_types text/plain text/css application/json application/javascript
               text/xml application/xml application/xml+rss text/javascript;
    gzip_vary on;

    # 后端上游
    upstream backend {
        server 127.0.0.1:8080;
        keepalive 32;
    }

    server {
        listen 80;
        server_name _;

        # 前端静态文件
        location / {
            root /usr/share/nginx/html;
            index index.html;
            try_files $uri $uri/ /index.html;

            # 静态资源缓存
            location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$ {
                expires 7d;
                add_header Cache-Control "public, immutable";
            }
        }

        # 后端 API 代理
        location /api/ {
            proxy_pass http://backend/;
            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_connect_timeout 30s;
            proxy_read_timeout 60s;
            proxy_send_timeout 60s;
            proxy_http_version 1.1;
            proxy_set_header Connection "";
        }

        # 健康检查
        location /health {
            access_log off;
            return 200 "OK";
            add_header Content-Type text/plain;
        }
    }
}
EOF

# 将前端构建产物放入 html 目录
# cp -r /path/to/dist/* /data/app/frontend/html/

# 启动 Nginx 容器
docker run -d \
  --name frontend \
  --restart always \
  -p 80:80 \
  -v /data/app/frontend/html:/usr/share/nginx/html \
  -v /data/app/frontend/conf/nginx.conf:/etc/nginx/nginx.conf \
  -v /data/app/frontend/logs:/var/log/nginx \
  --memory 1g \
  --cpus 2 \
  nginx:latest

# 验证
docker ps --filter name=frontend
curl -s -o /dev/null -w "%{http_code}" http://127.0.0.1/health
echo ""
# 期望返回：200

3.4 应用服务器资源分配总览（16核32G）

表格

服务	CPU	内存	端口	说明
后端应用	4核	4 GB	8080	Java/Spring Boot
前端 Nginx	2核	1 GB	80	静态资源 + 反向代理
系统预留	10核	27 GB	—	OS + Docker + 扩展
合计	16核	32 GB	—	—

第四部分：全链路连通性验证

在应用服务器上执行，验证到中间件服务器所有端口的连通性。

bash

编辑

echo "========== 全链路连通性验证 =========="
echo ""

# 1. Redis
echo "--- Redis (6379) ---"
timeout 1 bash -c "echo > /dev/tcp/20.160.250.107/6379" && echo "✅ Redis 端口连通" || echo "❌ Redis 端口不通"

# 2. MySQL
echo "--- MySQL (3306) ---"
timeout 1 bash -c "echo > /dev/tcp/20.160.250.107/3306" && echo "✅ MySQL 端口连通" || echo "❌ MySQL 端口不通"

# 3. Elasticsearch
echo "--- Elasticsearch (9200) ---"
ES_CODE=$(curl -s -o /dev/null -w "%{http_code}" --connect-timeout 3 -u elastic:cQcSSKmkVQLMp6Ju http://20.160.250.107:9200)
if [ "$ES_CODE" = "200" ]; then
    echo "✅ Elasticsearch 连通 (HTTP $ES_CODE)"
else
    echo "❌ Elasticsearch 不通 (HTTP $ES_CODE)"
fi

# 4. MinIO
echo "--- MinIO (9000) ---"
MINIO_CODE=$(curl -s -o /dev/null -w "%{http_code}" --connect-timeout 3 http://20.160.250.107:9000/minio/health/live)
if [ "$MINIO_CODE" = "200" ]; then
    echo "✅ MinIO 连通 (HTTP $MINIO_CODE)"
else
    echo "❌ MinIO 不通 (HTTP $MINIO_CODE)"
fi

# 5. Kafka
echo "--- Kafka (9092) ---"
timeout 1 bash -c "echo > /dev/tcp/20.160.250.107/9092" && echo "✅ Kafka 端口连通" || echo "❌ Kafka 端口不通"

echo ""
echo "========== 验证完成 =========="

期望输出：

文本

编辑

========== 全链路连通性验证 ==========

--- Redis (6379) ---
✅ Redis 端口连通
--- MySQL (3306) ---
✅ MySQL 端口连通
--- Elasticsearch (9200) ---
✅ Elasticsearch 连通 (HTTP 200)
--- MinIO (9000) ---
✅ MinIO 连通 (HTTP 200)
--- Kafka (9092) ---
✅ Kafka 端口连通

========== 验证完成 ==========

第五部分：运维常用命令速查

bash

编辑

# ===== 容器管理 =====
docker ps -a                          # 查看所有容器
docker logs -f <容器名> --tail 100    # 查看实时日志
docker restart <容器名>               # 重启容器
docker stop <容器名>                  # 停止容器
docker start <容器名>                 # 启动容器
docker stats                          # 查看资源占用

# ===== 数据备份 =====
# MySQL 备份
docker exec mysql mysqldump -uroot -pYourMySQLPassword123 --all-databases > /ai_files/backup/mysql_$(date +%Y%m%d).sql

# Redis 备份
docker exec redis redis-cli BGSAVE

# ===== 日志清理 =====
docker system prune -f                # 清理无用镜像/容器
du -sh /data/*/logs                   # 查看日志大小

# ===== 服务器资源监控 =====
top -bn1 | head -20                   # CPU/内存概览
free -h                               # 内存详情
df -h                                 # 磁盘使用
docker stats --no-stream              # 容器资源一览

附录：目录结构总览

文本

编辑

/
├── ai_files/                          # 所有 tar 包存放
│   ├── docker-27.5.1.tgz
│   ├── redis-7.4.tar
│   ├── mysql-8.0.tar
│   ├── elasticsearch-9.4.2-arm64.tar
│   ├── minio.tar
│   ├── kafka-3.9.tar
│   ├── backend-app.tar
│   └── frontend-app.tar
│
├── data/                              # 数据持久化根目录
│   ├── redis/
│   │   ├── data/
│   │   └── conf/redis.conf
│   ├── mysql/
│   │   ├── data/
│   │   ├── conf/my.cnf
│   │   └── logs/
│   ├── elasticsearch/
│   │   ├── data/
│   │   ├── logs/
│   │   └── config/
│   ├── minio/
│   │   ├── data/
│   │   └── config/
│   ├── kafka/
│   │   ├── data/
│   │   └── config/
│   └── app/                           # 应用服务器
│       ├── backend/
│       │   ├── config/
│       │   ├── logs/
│       │   └── upload/
│       └── frontend/
│           ├── html/
│           ├── conf/nginx.conf
│           └── logs/
│
└── etc/
    ├── docker/daemon.json             # Docker 配置
    ├── sysctl.conf                    # 内核参数
    └── security/limits.conf           # 文件描述符限制

完整部署手册

第一部分：Docker 环境安装与验证

1.1 创建文件存放目录

1.2 上传 Docker 离线安装包

1.3 卸载旧版 Docker（如有）

1.4 安装 Docker（离线方式）

1.5 配置 Docker 为 Systemd 服务

1.6 配置 Docker Daemon（16核32G 优化）

1.7 系统内核参数优化（16核32G）

1.8 文件描述符限制优化

1.9 启动 Docker 并设置开机自启

1.10 验证 Docker 安装

1.11 创建 Docker 网络（两台服务器都执行）

1.12 关闭防火墙（避免端口拦截）

第二部分：中间件服务部署（服务器：20.160.250.107）

2.1 上传所有中间件镜像包

2.2 加载所有 Docker 镜像

2.3 创建数据持久化目录

2.4 部署 Redis 7.4

2.5 部署 MySQL 8.0

2.6 部署 Elasticsearch 9.4.2（ARM64）

2.7 部署 MinIO

2.8 部署 Kafka 3.9（KRaft 模式）

2.9 中间件资源分配总览（16核32G）

2.10 阿里云安全组配置（必须！）

第三部分：应用前后端部署（服务器：应用服务器）

3.1 上传应用镜像包

3.2 部署后端应用

3.3 部署前端应用（Nginx）

3.4 应用服务器资源分配总览（16核32G）

第四部分：全链路连通性验证

第五部分：运维常用命令速查

附录：目录结构总览

评论区

完整部署手册