docker swarm 中间件安装

docker swarm 模式可以于管理 Docker 守护进程集群。

节点准备

小型的部署，准备三台机器即可，三台机器都是 manager 也是 worker。

TIP

如果机器资源充足，manager 节点仅做管理工作，不运行容器，保证集群的稳定性，运行容器交给 worker 节点，此时 manager 的配置需求较低。

公网 IP：123.123.123.123，此处仅为举例假设，根据实际情况调整。

假设设置完成我们三台机器的信息如下：

序号	swarm 角色	IP	主机名（hostname）
1	manager	192.168.3.6	docker1
2	manager	192.168.3.7	docker2
3	manager	192.168.3.8	docker3

以上三台机器都分别进行以下操作：

设置 hostname

设置 hostname 可以更方便后续的使用

执行命令：

shell

$ hostnamectl set-hostname docker1 # 其中 `docker1` 为主机名，请根据实际情况修改

设置静态 IP

机器需要设置静态 IP，且机器间需要能互相访问

执行命令：

shell

$ vi /etc/sysconfig/network-scripts/ifcfg-eth0 # 如果网卡名称不同，请替换掉 eth0

修改或添加以下内容：

ini

BOOTPROTO=static
ONBOOT=yes
IPADDR=192.168.3.6 # 机器的静态 IP，请根据实际情况修改
NETMASK=255.255.255.0 # 子网掩码，请根据实际情况修改
GATEWAY=192.168.3.1 # 网关，请根据实际情况修改

关闭防火墙

docker swarm 集群需要开放 2377 7946 4789 三个端口，后期部署的服务也可能需要其他端口的开放，所以此处为了方便直接关闭防火墙，对于有安全需求的环境，可以保留防火墙进行更细粒度的端口控制。

执行命令：

shell

$ systemctl disable --now firewalld

时钟同步

一些情况下，docker swarm 集群的节点之间时间不同步会导致服务无法正常工作，所以需要保证集群内的时间一致。执行命令：

shell

$ yum install -y chrony
$ vi /etc/chrony.conf

修改或添加以下内容：

#server 0.centos.pool.ntp.org iburst
#server 1.centos.pool.ntp.org iburst
#server 2.centos.pool.ntp.org iburst
#server 3.centos.pool.ntp.org iburst
server ntp.aliyun.com iburst
server ntp.tencent.com iburst
server ntp.ntsc.ac.cn iburst

修改完成执行命令：

shell

$ systemctl enable --now chronyd 
$ chronyc -a makestep

创建 swarm

首先在每台机器上安装 docker 引擎，可参考安装教程。Docker Swarm 模式已经内置在 Docker 引擎中，不用再安装。

初始化 manager

在 docker1 机器执行命令：

shell

$ docker swarm init --advertise-addr 192.168.3.6 # 机器的静态 IP，请根据实际情况修改
Swarm initialized: current node (i0ud4009ucaha7r32sak9icyf) is now a manager.

To add a worker to this swarm, run the following command:

    docker swarm join --token SWMTKN-1-42nk13lzku6fkhvi4952sjj91lm9cbap9ckpoiiif96kakcst5-bse19v1hszy4lww8bnk89aacm 192.168.3.6:2377

To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.

根据以上命令执行返回的提示，可以进一步知道其他节点以 worker 或者 manager 角色加入集群的命令：

在 docker1 机器执行命令获取以 worker 角色加入集群的命令

shell


$ docker swarm join-token worker
To add a worker to this swarm, run the following command:

    docker swarm join --token SWMTKN-1-42nk13lzku6fkhvi4952sjj91lm9cbap9ckpoiiif96kakcst5-bse19v1hszy4lww8bnk89aacm 192.168.3.6:2377

在 docker1 机器执行命令获取以 manager 角色加入集群的命令

shell

$ docker swarm join-token manager
To add a manager to this swarm, run the following command:

    docker swarm join --token SWMTKN-1-42nk13lzku6fkhvi4952sjj91lm9cbap9ckpoiiif96kakcst5-4mpd7orqaoakm46qrcl2jb00y 192.168.3.6:2377

加入其他节点

由于 docker2 和 docker3 也是设为 manager 节点，所以在这两台上也执行命令：

shell

$ docker swarm join --token SWMTKN-1-42nk13lzku6fkhvi4952sjj91lm9cbap9ckpoiiif96kakcst5-4mpd7orqaoakm46qrcl2jb00y 192.168.3.6:2377

通过以上操作，三台机器就组成了一个 docker swarm 集群。在任一 manager 节点上可查看所有成员信息，执行命令：

shell

$ docker node ls
ID                            HOSTNAME   STATUS    AVAILABILITY   MANAGER STATUS   ENGINE VERSION
i0ud4009ucaha7r32sak9icyf     docker1    Ready     Active         Leader           26.1.4
r0meycxxrwtxga9a7ag39byfi *   docker2    Ready     Active         Reachable        26.1.4
k9kfdd78xf3tdttvfqo9n8661     docker3    Ready     Active         Reachable        26.1.4

创建 docker network

为了后续安装的各个服务之间能通过服务名解析到对应的 IP 互相连通，创建一个 docker 网络，各个服务都加入到这个网络中。

shell

$ docker network create --driver overlay y9-share-net

中间件安装

TIP

在 docker swarm 模式集群中，部署的应用会随机分配到一个节点上，对于有状态（有数据持久化）的应用，下次重启容器可能会被分配到另一节点导致“数据丢失”，所以需要将有状态的应用绑定到固定的机器并挂载本地目录，或者使用分布式存储。

但是分布式存储较为复杂，对于小型部署运维较为困难，所以我们可以将有状态应用绑定到固定的机器上，挂载目录到容器中进行数据持久化。io 密集型中间件可以分散到多台机器减轻 io 压力。

下面是安装的部分中间件的分布情况：

主机	有状态服务
docker1	portainer、mysql、nginx
docker2	redis、ftp、kafka
docker3	elasticsearch、traefik、mongodb

部署架构图

上图为 docker swarm 集群的部署架构图，接下来介绍各个中间件的安装和配置。

Portainer

Portainer 是容器可视化管理平台，支持 docker swarm 模式。

创建 docker-portainer.yml 文件，内容如下：

yaml

services:
    agent: # 服务名，同一个网络中的其他服务可以直接用名称代替 IP 访问
        image: docker.youshengyun.com/portainer/agent:2.27.3
        volumes:
            - /var/run/docker.sock:/var/run/docker.sock
            - /var/lib/docker/volumes:/var/lib/docker/volumes
        networks:
            - agent_network
        deploy:
            mode: global
    portainer: # 服务名，同一个网络中的其他服务可以直接用名称代替 IP 访问
        image: docker.youshengyun.com/portainer/portainer-ce:2.27.3
        command: -H tcp://tasks.agent:9001 --tlsskipverify
        ports:
            - "9443:9443" # https 访问端口
            - "9000:9000" # http 访问端口
        volumes:
            - portainer_data:/data
        networks:
            - agent_network
            - y9-share-net
        deploy:
            mode: replicated
            replicas: 1
            placement:
                constraints:
                    - node.hostname == docker1 # 这里绑定到 docker1 节点，此处必须是 manager 节点，根据实际情况修改
networks:
    agent_network:
        driver: overlay
        attachable: true
    y9-share-net:
        external: true
volumes:
    portainer_data:

执行以下命令部署 portainer：

shell

$ docker stack deploy -c docker-portainer.yml portainer

部署完成后可以通过访问 https://192.168.3.6:9443 访问 portainer，首次登录需要设置用户名密码。

MySQL

MySQL 用于关系型数据的存储。

创建 docker-mysql.yml 文件，内容如下：

yaml

services:
    mysql: # 服务名，同一个网络中的其他服务可以直接用名称代替 IP 访问
        image: docker.youshengyun.com/mysql:8.0.41
        command: --default-authentication-plugin=caching_sha2_password
        environment:
            MYSQL_ROOT_PASSWORD: 111111 # root 密码，按需调整
        deploy:
            placement:
                constraints:
                    - node.hostname == docker1 # 绑定到 docker1 节点，根据实际情况修改
        volumes:
            - "/docker-data/mysql/data:/var/lib/mysql"
            - "/docker-data/mysql/config/my.cnf:/etc/mysql/conf.d/my.cnf"
        ports:
            - "3306:3306"
        networks:
            - y9-share-net
        restart: always
networks:
    y9-share-net:
        external: true

根据上面的 yml，MySQL 部署在 docker1 这台机器，所以我们需要先在该机器上建对应的目录和配置文件

shell

$ mkdir -p /docker-data/mysql/{data,config}

其中， /docker-data/mysql/config/my.cnf 文件的内容如下，配置项可以根据服务器的配置及自己的需求调整：

[mysqld]
symbolic-links=0
wait_timeout=1814400
lower_case_table_names=1
max_allowed_packet=1024M
max_connections=3000
character_set_server=utf8mb4
sql_mode=STRICT_TRANS_TABLES,NO_ENGINE_SUBSTITUTION

innodb_buffer_pool_dump_at_shutdown=1
innodb_buffer_pool_load_at_startup=1
innodb_buffer_pool_size=2147483648
innodb_lock_wait_timeout=100

sync_binlog=1000
innodb_flush_log_at_trx_commit=2
expire_logs_days=7

执行以下命令部署 mysql：

shell

$ docker stack deploy -c docker-mysql.yml mysql

Redis

Redis 用于缓存及登录票据的存储。

创建 docker-redis.yml 文件，内容如下：

yaml

services:
    redis: # 服务名，同一个网络中的其他服务可以直接用名称代替 IP 访问
        image: docker.youshengyun.com/redis:7.2.7
        ports:
            - "6379:6379"
        restart: always
        networks:
            - y9-share-net
        command: redis-server --requirepass "111111" # redis 密码，按需调整
        volumes:
            - /docker-data/redis:/data
        deploy:
            placement:
                constraints:
                    - node.hostname == docker2 # 绑定到 docker2 节点，根据实际情况修改
networks:
    y9-share-net:
        external: true

根据上面的 yml，Redis 部署在 docker2 这台机器，所以我们需要先在该机器上建对应的目录：

shell

$ mkdir -p /docker-data/redis

执行以下命令部署 redis：

shell

$ docker stack deploy -c docker-redis.yml redis

Elasticsearch

Elasticsearch 用于日志的存储和检索。

创建 docker-elasticsearch.yml 文件，内容如下：

yaml

services:
    elasticsearch: # 服务名，同一个网络中的其他服务可以直接用名称代替 IP 访问
        image: docker.youshengyun.com/elasticsearch:7.17.28
        environment:
            - node.name=elasticsearch-node1
            - cluster.name=y9elasticsearch
            #- discovery.seed_hosts=elasticsearch-node1
            - discovery.type=single-node
            #- cluster.initial_master_nodes=elasticsearch-node1
            - bootstrap.memory_lock=true
            - "ES_JAVA_OPTS=-Xms1024m -Xmx4024m"
            - xpack.security.enabled=true
            - xpack.license.self_generated.type=basic
            - ELASTIC_PASSWORD=111111 # elasticsearch 密码，按需调整
            - http.cors.enabled=true
            - http.cors.allow-origin=*
            - http.cors.allow-headers=Authorization
            - ingest.geoip.downloader.enabled=false
        restart: always
        ulimits:
            memlock:
                soft: -1
                hard: -1
        volumes:
            - /docker-data/elasticsearch/data:/usr/share/elasticsearch/data
            - /docker-data/elasticsearch/plugins:/usr/share/elasticsearch/plugins
        deploy:
            placement:
                constraints:
                    - node.hostname == docker3 # 绑定到 docker3 节点，根据实际情况修改
        ports:
            - "9200:9200"
            - "9300:9300"
        networks:
            - y9-share-net
networks:
    y9-share-net:
        external: true

根据上面的 yml，Elasticsearch 部署在 docker3 这台机器，所以我们需要先在该机器上建对应的目录：

shell

$ mkdir -p /docker-data/elasticsearch/{data,plugins}
$ chown -R 1000:1000 /docker-data/elasticsearch # 容器内的用户 uid 为 1000，不设置会导致权限问题

执行以下命令部署 elasticsearch：

shell

$ docker stack deploy -c docker-elasticsearch.yml elasticsearch

FTP

FTP 用于文件的上传和下载。

创建 docker-ftp.yml 文件，内容如下：

yaml

services:
    ftp: # 服务名，同一个网络中的其他服务可以直接用名称代替 IP 访问
        image: docker.youshengyun.com/fauria/vsftpd
        restart: always
        deploy:
            mode: replicated
            replicas: 1
            placement:
                constraints:
                    - node.hostname == docker2 # 绑定到 docker2 节点，根据实际情况修改
        environment:
            - FTP_USER=y9admin
            - FTP_PASS=111111 # ftp 用户名和密码，按需调整
            - PASV_ADDRESS=192.168.3.31 # 服务器内网 IP
            - PASV_MIN_PORT=21100 # 被动模式端口范围
            - PASV_MAX_PORT=21110
        ports:
            - "20:20"
            - "21:21"
            - "21100-21110:21100-21110"
        volumes:
            - /docker-data/ftp:/home/vsftpd
        networks:
            - y9-share-net
networks:
    y9-share-net:
        external: true

根据上面的 yml，FTP 部署在 docker2 这台机器，所以我们需要先在该机器上建对应的目录：

shell

$ mkdir -p /docker-data/ftp

执行以下命令部署 FTP：

shell

$ docker stack deploy -c docker-ftp.yml ftp

Kafka

Kafka 用于消息的发布和订阅。

创建 docker-kafka.yml 文件，内容如下：

yaml

services:
    kafka: # 服务名，同一个网络中的其他服务可以直接用名称代替 IP 访问
        image: docker.youshengyun.com/bitnami/kafka:3.7.0
        restart: always
        networks:
            - y9-share-net
        ports:
            - "9092:9092"
            - "9094:9094"
        environment:
            - KAFKA_CFG_NODE_ID=0
            - KAFKA_CFG_PROCESS_ROLES=controller,broker
            - KAFKA_CFG_LISTENERS=PLAINTEXT://:9092,CONTROLLER://:9093,EXTERNAL://0.0.0.0:9094
            - KAFKA_CFG_ADVERTISED_LISTENERS=PLAINTEXT://kafka:9092,EXTERNAL://192.168.3.7:9094 # 内网连接 IP，根据实际情况调整
            - KAFKA_CFG_LISTENER_SECURITY_PROTOCOL_MAP=CONTROLLER:PLAINTEXT,EXTERNAL:PLAINTEXT,PLAINTEXT:PLAINTEXT
            - KAFKA_CFG_CONTROLLER_LISTENER_NAMES=CONTROLLER
            - KAFKA_CFG_CONTROLLER_QUORUM_VOTERS=0@kafka:9093
            - KAFKA_CFG_MESSAGE_MAX_BYTES=1000000
        volumes:
            - /docker-data/kafka:/bitnami/kafka
        deploy:
            placement:
                constraints:
                    - node.hostname == docker2 # 绑定到 docker2 节点，根据实际情况修改
networks:
    y9-share-net:
        external: true

根据上面的 yml，Kafka 部署在 docker2 这台机器，所以我们需要先在该机器上建对应的目录：

shell

$ mkdir -p /docker-data/kafka
$ chown -R 1001:1001 /docker-data/kafka # 容器内的用户 uid 为 1001，不设置会导致权限问题

执行以下命令部署 Kafka：

shell

$ docker stack deploy -c docker-kafka.yml kafka

Traefik

Traefik 用于反向代理和负载均衡，通过 docker、docker swarm 自动发现服务，实现动态路由配置。

创建 docker-traefik.yml 文件，内容如下：

yaml

services:
    traefik: # 服务名，同一个网络中的其他服务可以直接用名称代替 IP 访问
        image: docker.youshengyun.com/traefik:2.11.22
        hostname: traefik
        restart: unless-stopped
        networks:
            - y9-share-net
        deploy:
            placement:
                constraints:
                    - node.role == manager
                    - node.hostname == docker3 # 这里绑定到 docker3 节点，此处必须是 manager 节点，根据实际情况修改
        ports:
            - "8888:8888" # 前端访问端口，按需调整
            - "9999:9999" # 后端访问端口，按需调整
            - "8080:8080" # The Web UI (enabled by --api.insecure=true)
        volumes:
            - "/var/run/docker.sock:/var/run/docker.sock"
            - "/docker-data/traefik:/etc/traefik/dynamic" # 挂载 traefik 的配置文件目录
        command:
            - "--global.sendanonymoususage=false"
            - "--global.checknewversion=false"
            - "--api=true"
            - "--api.dashboard=true"
            - "--api.insecure=true"
            - "--api.debug=false"
            - "--ping=true"
            - "--log.level=DEBUG" # 日志级别，根据实际情况调整
            - "--log.format=common"
            - "--accesslog=true" # 启用访问日志，根据实际情况调整
            - "--entrypoints.web.address=:8888" # 定义前端的端口，类似于 nginx 中 http.server.listen 的端口
            - "--entrypoints.web.forwardedHeaders.insecure"
            - "--entrypoints.api.address=:9999" # 定义后端的端口，类似于 nginx 中 http.server.listen 的端口
            - "--entrypoints.api.forwardedHeaders.insecure"
            - "--entrypoints.traefik.address=:8080"
            - "--providers.docker=true"
            - "--providers.docker.swarmMode=true"
            - "--providers.docker.watch=true"
            - "--providers.docker.exposedbydefault=false"
            - "--providers.docker.endpoint=unix:///var/run/docker.sock"
            - "--providers.docker.useBindPortIP=false"
            - "--providers.docker.network=y9-share-net"
            - "--providers.file=true"
            - "--providers.file.watch=true"
            - "--providers.file.directory=/etc/traefik/dynamic"
            - "--providers.file.debugloggeneratedtemplate=true"
        healthcheck:
            test: [ "CMD-SHELL", "wget -q --spider --proxy off localhost:8080/ping || exit 1" ]
            interval: 5s
            retries: 10
        logging:
            driver: "json-file"
            options:
                max-size: "1m"
networks:
    y9-share-net:
        external: true

根据上面的 yml，traefik 部署在 docker3 这台机器，所以我们需要先在该机器上建对应的目录：

shell

$ mkdir -p /docker-data/traefik

执行以下命令部署 traefik：

shell

$ docker stack deploy -c docker-traefik.yml traefik

Nginx

Nginx 用于静态资源的访问和反向代理。

创建 docker-nginx.yml 文件，内容如下：

yaml

services:
    frontend: # 服务名，同一个网络中的其他服务可以直接用名称代替 IP 访问
        image: docker.youshengyun.com/nginx:1.26.3
        hostname: frontend
        restart: unless-stopped
        # ports:
        # - "8888:80"
        volumes:
            - "/docker-data/nginx/html:/usr/share/nginx/html:ro"
            - "/docker-data/nginx/conf/nginx.conf:/etc/nginx/nginx.conf:ro"
        deploy:
            placement:
                constraints:
                    - node.hostname == docker1
            labels:
                - "traefik.enable=true"
                - "traefik.http.routers.frontend.entrypoints=web"
                - "traefik.http.routers.frontend.rule=Host(`123.123.123.123`)" # host 匹配，根据实际情况调整
                - "traefik.http.routers.frontend.service=frontend"
                - "traefik.http.routers.frontend.priority=1"
                - "traefik.http.services.frontend.loadbalancer.passHostHeader=true"
                - "traefik.http.services.frontend.loadbalancer.server.port=80"
        networks:
            - y9-share-net
networks:
    y9-share-net:
        external: true

根据上面的 yml，nginx 部署在 docker1 这台机器，所以我们需要先在该机器上执行命令创建 html 目录和配置文件 conf 目录：

shell

$ mkdir -p /docker-data/nginx/{html,conf}

编辑 nginx 配置文件 /docker-data/nginx/conf/nginx.conf，内容如下：

worker_processes auto;

error_log  /var/log/nginx/error.log notice;
pid        /var/run/nginx.pid;

events {
    worker_connections 4096;
    use epoll;
}

http {
    include mime.types;
    default_type application/octet-stream;
    sendfile off;
    server_names_hash_bucket_size 128;
    client_body_timeout 600;
    client_header_timeout 600;
    client_header_buffer_size 512k;
    large_client_header_buffers 4 512k;
    client_max_body_size 1024m;
    keepalive_timeout 600;
    send_timeout 600;
    keepalive_requests 60;
    fastcgi_connect_timeout 60m;
    fastcgi_read_timeout 60m;
    fastcgi_send_timeout 60m;
    proxy_read_timeout 60m;
    underscores_in_headers on;
    gzip  on;
    map $http_upgrade $connection_upgrade {
        default upgrade;
        '' close;
    }

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
    access_log  /var/log/nginx/access.log  main;

    server {
        listen       80;
        listen  [::]:80;

        root /usr/share/nginx/html;

        location = / {
                return 302 /home/;
        }

        location ~^/([a-zA-Z0-9\-]+)/(.*)$ {
            try_files $uri $uri/ /$1/index.html;
            add_header Cache-Control 'no-cache';
        }
    }

}

执行命令启动 Nginx：

shell

$ docker stack deploy -c docker-nginx.yml nginx

Nacos

Nacos 是一个开源的动态服务发现、配置和服务管理平台。

nacos 启动之前需要在 mysql 中创建 nacos 库，执行 SQL 文件：mysql-schema.sql。

创建 docker-nacos.yml 文件，内容如下：

yaml

services:
    nacos: # 服务名，同一个网络中的其他服务可以直接用名称代替 IP 访问
        image: docker.youshengyun.com/nacos/nacos-server:v2.2.1
        networks:
            - y9-share-net
        ports:
            - "8848:8848" # nacos 访问主端口
            - "9848:9848" # gRPC客户端请求 nacos 服务端端口
        environment:
            - PREFER_HOST_MODE=hostname
            - MODE=standalone
            - SPRING_DATASOURCE_PLATFORM=mysql
            - MYSQL_SERVICE_HOST=mysql # mysql 地址
            - MYSQL_SERVICE_DB_NAME=nacos # mysql 库名
            - MYSQL_SERVICE_PORT=3306 # mysql 端口
            - MYSQL_SERVICE_USER=root # mysql 用户名，按需调整
            - MYSQL_SERVICE_PASSWORD=111111 # mysql 密码，按需调整
            - MYSQL_SERVICE_DB_PARAM=characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useSSL=false&allowPublicKeyRetrieval=true
            - NACOS_AUTH_ENABLE=true
            - NACOS_AUTH_IDENTITY_KEY=nacos # Nacos 用户名，按需调整
            - NACOS_AUTH_IDENTITY_VALUE=111111 # Nacos 密码，按需调整
            - NACOS_AUTH_TOKEN=VGhpc0lzTXlDdXN0b21TZWNyZXRLZXkwMTIzNDU2Nzg=
networks:
    y9-share-net:
        external: true

执行以下命令部署 nacos：

shell

$ docker stack deploy -c docker-nacos.yml nacos

部署完成后可以通过访问 http://192.168.3.6:8848/nacos/ 访问 nacos

MongoDB

MongoDB 用于非关系型数据的存储。创建 docker-mongodb.yml 文件，内容如下：

yaml

services:
    mongodb: # 服务名，同一个网络中的其他服务可以直接用名称代替 IP 访问
        image: docker.youshengyun.com/mongodb/mongodb-community-server:5.0.31-ubuntu2004
        environment:
            - MONGODB_INITDB_ROOT_USERNAME=y9admin
            - MONGODB_INITDB_ROOT_PASSWORD=111111
        volumes:
            - /docker-data/mongodb:/data/db
        extra_hosts:
            - "host.docker.internal:host-gateway"
        ports:
            - "27017:27017"
        networks:
            - y9-share-net
        deploy:
            placement:
                constraints:
                    - node.hostname == docker3 # 绑定到 docker3 节点，根据实际情况修改
networks:
    y9-share-net:
        external: true

根据上面的 yml，mongodb 部署在 docker3 这台机器，所以我们需要先在该机器上建对应的目录：

shell

$ mkdir -p /docker-data/mongodb

执行以下命令部署 mongodb：

shell

$ docker stack deploy -c docker-mongodb.yml mongodb

应用部署

后端部署

我们大多数的后端应用没有直接的数据存储，所以不需要再固定再某台机器上。在后端部署中仅以 platform 和 sso 两个工程为例，其他工程类似。后端的部署我们在 portainer 中进行，简化操作。

为了进一步实现构建一次，到处运行的目标，后端项目中使用 spring profile 做多环境配置，镜像只打包一次，各个环境使用的时候设置相应的环境变量或者命令行参数来指定相应的 profile 使对应的配置文件生效，并结合 Spring Cloud Config 和 Nacos 来实现配置的动态化。具体可参考如何使用 SpringCloud 的远程配置？

platform

连接数据库新建数字底座公共库 y9_public。

新建 stack，输入 stack 名称为 app-platform，输入 docker compose 内容：

yaml

services:
    platform: # 服务名，同一个网络中的其他服务可以直接用名称代替 IP 访问
        image: docker-registry.youshengyun.com/risenet-y9boot-webapp-platform:v9.6.x
        restart: unless-stopped
        networks:
            - y9-share-net
        environment:
            - TZ=Asia/Shanghai
            - SPRING_PROFILES_ACTIVE=test # 激活的 profile
            - NACOS_PASSWORD=111111 # nacos 密码，按需调整
        deploy:
            replicas: 1 # 副本数量，如果需要负载均衡可以设置多个副本
            labels:
                - "traefik.enable=true"
                # 定义名为 platform 的 HTTP 路由器（router），它使用名为 api 的入口点，也就是对应端口 9999
                - "traefik.http.routers.platform.entrypoints=api"
                # 定义路由规则，匹配以 /platform 开头的请求
                - "traefik.http.routers.platform.rule=PathPrefix(`/platform`)"
                # 当 platform 路由器匹配到请求时，应该将请求转发给名为 platform 的服务
                - "traefik.http.routers.platform.service=platform"
                # 当 Traefik 把请求转发给后端服务时，会把原始的 Host 头部保留下来。
                - "traefik.http.services.platform.loadbalancer.passHostHeader=true"
                # 后端服务监听的端口为 8080。
                - "traefik.http.services.platform.loadbalancer.server.port=8080"
networks:
    y9-share-net:
        external: true

点击 Deploy the stack 按钮即可将对应的镜像拉取并启动容器。

sso

新建 stack，输入 stack 名称为 app-sso，输入 docker compose 内容：

yaml

services:
    sso: # 服务名，同一个网络中的其他服务可以直接用名称代替 IP 访问
        image: docker-registry.youshengyun.com/risenet-y9boot-webapp-sso-server:v9.6.x
        restart: unless-stopped
        networks:
            - y9-share-net
        environment:
            - TZ=Asia/Shanghai
            - SPRING_PROFILES_ACTIVE=test
            - NACOS_PASSWORD=111111
        deploy:
            replicas: 1
            labels:
                - "traefik.enable=true"
                # 由于 sso 非前后端分离，所以与上方 platform 不同，使用的是名为 web 的入口点，对应 8888 端口
                - "traefik.http.routers.sso.entrypoints=web"
                - "traefik.http.routers.sso.rule=PathPrefix(`/sso`)"
                - "traefik.http.routers.sso.service=sso"
                - "traefik.http.services.sso.loadbalancer.passHostHeader=true"
                - "traefik.http.services.sso.loadbalancer.server.port=8080"
networks:
    y9-share-net:
        external: true

点击 Deploy the stack 按钮即可将对应的镜像拉取并启动容器。

前端部署

前端应用修改配置文件后，将对应的打包目录放到上面 nginx 的 html 目录下，对应上方 nginx 容器所在的机器 docker1 映射的 /docker-data/nginx/html 目录

访问测试

经过以上操作，数字底座的中间件和应用就部署完成了，然后公网 IP 也开放了相应的端口，接下来就可以进行访问测试。

例如访问数字底座管理平台， http://123.123.123.123:8888/kernel-standard/

docker swarm 中间件安装 ​

节点准备 ​

设置 hostname ​

设置静态 IP ​

关闭防火墙 ​

时钟同步 ​

创建 swarm ​

初始化 manager ​

加入其他节点 ​

创建 docker network ​

中间件安装 ​

Portainer ​

MySQL ​

Redis ​

Elasticsearch ​

FTP ​

Kafka ​

Traefik ​

Nginx ​

Nacos ​

MongoDB ​

应用部署 ​

后端部署 ​

platform ​

sso ​

前端部署 ​

访问测试 ​

docker swarm 中间件安装

节点准备

设置 hostname

设置静态 IP

关闭防火墙

时钟同步

创建 swarm

初始化 manager

加入其他节点

创建 docker network

中间件安装

Portainer

MySQL

Redis

Elasticsearch

FTP

Kafka

Traefik

Nginx

Nacos

MongoDB

应用部署

后端部署

platform

sso

前端部署

访问测试