=======================================
1、制作HZERO PaaS 平台 1.12版本的Demo环境的Mysql镜像日志
备注：本文是个人自建Demo系统学习研究过程中的日志，仅供培训学习参考
环境：WSL：Ubuntu-22.04-hzero 系统
说明：该环境独立安装了docker 和docker compose, 没有跟windows dockerDesktop 做集成。
由于制作Docker镜像的过程中需要通过Docker Hub库拉镜像，这个环境无法直接访问Docker Hub库（要梯子，但wsl 子系统无法直接用Windows Host机的代理），所以这个镜像制作多了些麻烦。
后续的其他Docker镜像制作, 放到Ubuntu-22.04 里面制作，Ubuntu-22.04 跟Docker Desktop做了集成，因为DockerDesktop是Windows的应用，可以用梯子，所以就很方便了。
一、启动 MySQL
$ systemctl start mysql
二、导出所有数据库
$ cd /
$ mkdir d03
$ cd /d03
$ mysqldump -u root -p –all-databases > init.sql
$ mkdir mysql-custom && cd mysql-custom
$ cp /d03/init.sql .
三、制作Dockerfile
$ vi my_custom.cnf
写入如下内容：
my_custom.cnf
[mysqld]
max_connections=2000
max_allowed_packet=32M
lower_case_table_names=1
character_set_server=utf8mb4
collation_server=utf8mb4_bin
$ vi Dockerfile
写入如下内容：
基于官方 MySQL 8 镜像
FROM mysql:8.0
设置 MySQL root 密码（可选，也可启动时通过环境变量指定）
ENV MYSQL_ALLOW_EMPTY_PASSWORD=yes
将导出的 SQL 文件复制到 MySQL 自动执行目录
容器启动时，会自动执行 /docker-entrypoint-initdb.d 下的 .sql 文件
COPY init.sql /docker-entrypoint-initdb.d/
复制自定义配置文件到 MySQL 配置目录
COPY my_custom.cnf /etc/mysql/conf.d/
四、构建mysql镜像
$ docker build -t mysql-hzero-jk-demo:1.12 .
报错：拉不到mysql 8.0的镜像，增加国内镜像地址：
$ vi /etc/docker/daemon.json
写入内容：
{
“registry-mirrors”: [
“https://qfebddkjdu.mirror.aliyuncs.com”,
“https://registry.docker-cn.com”,
“https://docker.mirrors.ustc.edu.cn”,
“http://hub-mirror.c.163.com”
]
}
$ sudo systemctl daemon-reload
$ sudo systemctl restart docker
$ sudo docker info 看到镜像已经加进去了
$ docker pull mysql:8.0 还是不行
$ curl -I https://registry.docker-cn.com 无法访问，其他几个镜像也是无法访问，阿里云的只允许通过阿里云ECS服务器访问。
这些镜像都不靠谱；
去掉这些不靠谱的镜像
$ rm -f /etc/docker/daemon.json
直接从华为云拉mysql:8.0镜像：
$ docker pull swr.cn-east-2.myhuaweicloud.com/library/mysql:8.0
成功拉取
再次构建：
$ docker build -t mysql-hzero-jk-demo:1.12 .
还是报错：ERROR: failed to build: failed to solve: mysql:8.0: failed to resolve source metadata for docker.io/library/mysql:8.0: failed to do request: Head “https://registry-1.docker.io/v2/library/mysql/manifests/8.0”: read tcp 172.18.14.48:40900->98.90.233.146:443: read: connection reset by peer
怎么没有从本地库获取mysql:8.0呢？
解决方案有两种：
一种是更改 Dockfile，把来源更改掉：
FROM swr.cn-east-2.myhuaweicloud.com/library/mysql:8.0
另一种是把刚才从华为云拉下来的镜像打标签：
docker tag swr.cn-east-2.myhuaweicloud.com/library/mysql:8.0 mysql:8.0
推荐使用方法二，因为这样不需要修改Dockerfile，而且以后如果Dockerfile中其他镜像也有类似问题，可以同样处理。
打完标签后再次构建：
$ docker build -t mysql-hzero-jk-demo:1.12 .
这次成功了，验证：
$ docker images | grep mysql
mysql-hzero-jk-demo 1.12 38408f313597 2 minutes ago 824MB
mysql 8.0 2dd01afbe8df 7 years ago 485MB
swr.cn-east-2.myhuaweicloud.com/library/mysql 8.0 2dd01afbe8df 7 years ago 485MB
测试：停掉mysql
$ systemctl stop mysql
启动mysql 的docker 容器
$ docker run -d –name mysql-hzero-demo -p 3306:3306 mysql-hzero-jk-demo:1.12
启动没成功，
mysql-hzero-demo
4d5fa07458006f585c791adf763bfac46de28ef4b995e935f28c36cc4e9af420
$ docker ps -a 显示启动一会儿就退出了，看日志：
$ docker logs 4d5fa07458006f585c791adf763bfac46de28ef4b995e935f28c36cc4e9af420
错误发生在：
/usr/local/bin/docker-entrypoint.sh: running /docker-entrypoint-initdb.d/init.sql
ERROR 3723 (HY000) at line 516: The table ‘replication_asynchronous_connection_failover’ may not be created in the reserved tablespace ‘mysql’.
元宝分析可能是版本兼容问题，原来数据库版本是8.4.5，拉取的镜像8.0太低了。
解决方案：拉取8.4.5的镜像，试了阿里云、腾讯云、华为云的镜像站点，要么拒绝访问，要么需要用户名密码，用注册的云账户密码也不行。
问豆包有无网页版的下载，提供了Oracle的网站下载页，这个下载页会自动调用docker desktop来拉取，注册docker desktop的用户，打开clash party,在docker desktop的docker Hub里面找 mysql, 发现没有直接8.4.5的镜像，最近的只有8.4 和8.4.7
在dockerdesktop的docker hub里面搜mysql, 拉了8.4.7 版本；
在docker Desktop 的设置/Resources/WSL intergration 中把ubuntu-22.04的集成开关打开，这样在ubuntu-22.04中可以操作docker desktop
打开Ubnuntu-22.04
$ docker images | grep mysql
mysql 8.4.7 b306273d4d36 4 weeks ago 1.08GB
$ cd /d01/dockerimagesbak
格式：docker save -o 导出文件名 镜像名:标签
$ docker save -o mysql-8.4.7.tar mysql:8.4.7
拷贝 这个mysql-8.4.7.tar 到ubuntu-22.04-hzero/d03/mysql-custom 目录下
进入ubuntu-22.04-hzero/d03/mysql-custom，导入镜像
格式：docker load -i 镜像文件.tar
$ docker load -i mysql-8.4.7.tar
导入成功：Loaded image: mysql:8.4.7
验证：
$ docker images | grep mysql
mysql-hzero-jk-demo 1.12 35d024e4c936 13 hours ago 824MB
mysql 8.4.7 67471052edd5 4 weeks ago 788MB
mysql 8.0 2dd01afbe8df 7 years ago 485MB
mysql 8.4.5 2dd01afbe8df 7 years ago 485MB
swr.cn-east-2.myhuaweicloud.com/library/mysql 8.0 2dd01afbe8df 7 years ago 485MB
更改Dockfile ,
$ vi Dockerfile
基于官方 MySQL 8 镜像
FROM mysql:8.4.7
保存退出
再次构建：
$ docker build -t mysql-hzero-jk-demo:1.12 .
构建成功
$ docker images | grep mysql
mysql-hzero-jk-demo 1.12 8c6c4b989154 20 seconds ago 1.13GB
停掉Mysql服务
$ systemctl stop mysql
删除旧容器：
$ docker rm -f mysql-hzero-demo
启动mysql 的docker 容器
$ docker run -d –name mysql-hzero-demo -p 3306:3306 mysql-hzero-jk-demo:1.12
be9ae14a5562c8b28ca6ebeb6cbd25d470d4980045c1c47e8b15a3896d5353d7
root@desktop-jacksen:/d03/mysql-custom#
查看日志：
$ docker logs be9ae14a5562c8b28ca6ebeb6cbd25d470d4980045c1c47e8b15a3896d5353d7
出现错误：
2025-11-19 03:13:26+00:00 [Note] [Entrypoint]: /usr/local/bin/docker-entrypoint.sh: running /docker-entrypoint-initdb.d/init.sql
ERROR 1153 (08S01) at line 3076: Got a packet bigger than ‘max_allowed_packet’ bytes
错误日志给元宝分析后建议修改my_custom.cnf，重建镜像：
[mysqld]
max_connections=2000
max_allowed_packet=512M
lower_case_table_names=1
character_set_server=utf8mb4
collation_server=utf8mb4_bin
再次构建：
$ docker build -t mysql-hzero-jk-demo:1.12 .
删除旧容器：
$ docker rm -f mysql-hzero-demo
启动mysql 的docker 容器
docker run -d –name mysql-hzero-demo -p 3306:3306 mysql-hzero-jk-demo:1.12
3e49dc0282495402dab8fa41f49be132c9d135483a5867aa58aa1b2f2ed7c4bb
root@desktop-jacksen:/d03/mysql-custom#docker logs 3e49dc0282495402dab8fa41f49be132c9d135483a5867aa58aa1b2f2ed7c4bb
这次没有error了
root@desktop-jacksen:/d03/mysql-custom# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
3e49dc028249 mysql-hzero-jk-demo:1.12 “docker-entrypoint.s…” About a minute ago Up About a minute 0.0.0.0:3306->3306/tcp, [::]:3306->3306/tcp, 33060/tcp mysql-hzero-demo
验证：检查 max_allowed_packet 设置
$ docker exec mysql-hzero-demo mysql -u root -e “SHOW GLOBAL VARIABLES LIKE ‘max_allowed_packet’;”
Variable_name Value
max_allowed_packet 536870912
root@desktop-jacksen:/d03/mysql-custom#
进入容器内部测试连接
$ docker exec -it mysql-hzero-demo mysql -u root -e “SELECT 1;”
+—+
| 1 |
+—+
| 1 |
+—+
root@desktop-jacksen:/d03/mysql-custom#
查看所有数据库
$ docker exec -it mysql-hzero-demo mysql -u root -e “SHOW DATABASES;”
$ docker exec -it mysql-hzero-demo mysql -u root -e “SHOW DATABASES;”
+———————+
| Database |
+———————+
| hzero_admin |
| hzero_aip |
| hzero_alert |
| hzero_file |
| hzero_frontal |
| hzero_import |
| hzero_interface |
| hzero_lowcode |
| hzero_lowcodedata |
| hzero_message |
| hzero_modeler |
| hzero_orchestration |
| hzero_platform |
| hzero_report |
| hzero_scheduler |
| hzero_workflow |
| information_schema |
| mysql |
| performance_schema |
| sys |
+———————+
查看数据库大小和数量
$ docker exec -it mysql-hzero-demo mysql -u root -e “
SELECT
table_schema AS ‘数据库’,
COUNT(*) AS ‘表数量’,
ROUND(SUM(data_length + index_length) / 1024 / 1024, 2) AS ‘总大小(MB)’
FROM information_schema.tables
GROUP BY table_schema
ORDER BY SUM(data_length + index_length) DESC;”
+———————+———–+—————+
| 数据库 | 表数量 | 总大小(MB) |
+———————+———–+—————+
| hzero_platform | 344 | 11.42 |
| hzero_modeler | 345 | 10.56 |
| hzero_lowcode | 227 | 9.66 |
| hzero_aip | 250 | 7.88 |
| hzero_interface | 169 | 5.33 |
| mysql | 38 | 5.27 |
| hzero_workflow | 145 | 5.14 |
| hzero_admin | 69 | 2.09 |
| hzero_lowcodedata | 26 | 1.67 |
| hzero_orchestration | 47 | 1.58 |
| hzero_message | 50 | 1.50 |
| hzero_report | 40 | 1.23 |
| hzero_scheduler | 29 | 1.06 |
| hzero_frontal | 30 | 1.00 |
| hzero_alert | 19 | 0.58 |
| hzero_file | 10 | 0.36 |
| hzero_import | 12 | 0.31 |
| sys | 101 | 0.02 |
| performance_schema | 113 | 0.00 |
| information_schema | 78 | 0.00 |
+———————+———–+—————+
验证关键配置参数
$ docker exec -it mysql-hzero-demo mysql -u root -e “
SHOW VARIABLES WHERE
Variable_name IN (‘max_connections’, ‘max_allowed_packet’, ‘lower_case_table_names’,
‘character_set_server’, ‘collation_server’);”
+————————+————-+
| Variable_name | Value |
+————————+————-+
| character_set_server | utf8mb4 |
| collation_server | utf8mb4_bin |
| lower_case_table_names | 1 |
| max_allowed_packet | 536870912 |
| max_connections | 2000 |
+————————+————-+
测试端口
$ nc -z 127.0.0.1 3306 && echo “端口可访问” || echo “端口不可访问”
端口可访问
从宿主机连接测试（确保端口映射正确）
$ mysql -h 127.0.0.1 -P 3306 -u root -e “SELECT 1;” 2>/dev/null && echo “连接成功” || echo “连接失败”
连接失败
查看log
$ docker logs mysql-hzero-demo
2025-11-19T03:39:47.424515Z 16 [Warning] [MY-013360] [Server] Plugin sha256_password reported: ”sha256_password’ is deprecated and will be removed in a future release. Please use caching_sha2_password instead’
外部DBeaver 链接测试：正常
非root用户本地链接测试：正常
$ mysql -h 127.0.0.1 -P 3306 -u hzero -phzero -e “SELECT 1;”
mysql: [Warning] Using a password on the command line interface can be insecure.
+—+
| 1 |
+—+
| 1 |
+—+
#
检查用户权限
$ docker exec -it mysql-hzero-demo mysql -u root -e “
SELECT user, host, authentication_string, plugin FROM mysql.user;”
+——————+———–+————————————————————————+———————–+
| user | host | authentication_string | plugin |
+——————+———–+————————————————————————+———————–+
| hzero | % | $A$005$->l~V[~X[fU)>ja/x.oWsjWwIgUVt5/2iE55KHa.l5royRU1ukIw0EMn0 | caching_sha2_password |
| root | localhost | | caching_sha2_password |
+——————+———–+————————————————————————+———————–+
现在情况已经很清楚了。MySQL 容器运行正常，非 root 用户（hzero）可以正常连接，这证明 MySQL 服务本身是健康且可访问的。
root只能从容器内访问，这没问题，正常我们用不到root用户。
到这里 制作HZERO PaaS 平台 1.12版本的Demo环境的Mysql镜像 完成了；
但这个镜像的里面MySQL的数据无法持久化，要数据持久化，正确的做法是：
目标环境：
环境：WSL：Ubuntu-22.04系统
1、先建立容器外的mysql数据持久化目录，并修正目录权限（重要）
$ cd /d01/hzero-dockers/volumes
$ mkdir mysql
$ sudo chown -R 999:999 /d01/hzero-dockers/volumes/mysql
2、如果容器还没起，先起容器
$ cd /d01/hzero-dockers/mysql-docker
$ docker compose up -d
等2分钟，完成初始化 ，可以在docker日志中看到：
2025-11-24 02:46:05+00:00 [Note] [Entrypoint]: MySQL init process done. Ready for start up.
2025-11-24T02:46:05.189268Z 0 [System] [MY-015015] [Server] MySQL Server – start.
2025-11-24T02:46:06.688842Z 0 [System] [MY-010931] [Server] /usr/sbin/mysqld: ready for connections.
3、# 将容器内的数据拷贝出来
$ docker cp mysql-hzero:/var/lib/mysql /d01/hzero-dockers/volumes/mysql
Successfully copied 1.58GB to /d01/hzero-dockers/volumes/mysql
4、# 关闭mysql容器，重建镜像
$ docker compose down
4.1
$ vi my_custom.cnf
写入如下内容：
my_custom.cnf
[mysqld]
max_connections=2000
max_allowed_packet=512M
lower_case_table_names=1
character_set_server=utf8mb4
collation_server=utf8mb4_bin
4.2
$ vi Dockerfile
#写入如下内容：
基于官方 MySQL 8 镜像
FROM mysql:8.4.7
设置 MySQL root 密码（可选，也可启动时通过环境变量指定）
ENV MYSQL_ALLOW_EMPTY_PASSWORD=yes
复制自定义配置文件到 MySQL 配置目录
COPY my_custom.cnf /etc/mysql/conf.d/
4.3、再次构建：
$ docker build -t mysql-hzero-jk-demo:8.4.7 .
构建成功
5、编辑 docker-compose.yml, 挂载数据目录
要求Docker/Docker CE >= 19.x
services:
mysql-hzero:
image: mysql-hzero-jk-demo:8.4.7
container_name: mysql-hzero
user: “999:999” # 添加这一行，指定 mysql 用户
ports:
– “3306:3306”
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 1000m # 容器最大内存
volumes:
– ${DOCKER_VOLUME_DIRECTORY:-../volumes}/mysql:/var/lib/mysql
networks:
default:
name: hzero-demo
external: true
6、再次启动容器
$ cd /d01/hzero-dockers/mysql-docker
$ docker compose up -d
查看日志：
$ docker logs mysql-hzero
2025-11-24T03:23:45.211550Z 0 [System] [MY-010931] [Server] /usr/sbin/mysqld: ready for connections. Version: ‘8.4.7’ socket: ‘/var/run/mysqld/mysqld.sock’ port: 3306 MySQL Community Server – GPL.
成功启动，DBeaver 访问数据库，数据正常。
备注：这数据库镜像一般使用其原来版本作为标签（如果原来用的标签是1.12，要改成8.47）
将旧镜像名改为新镜像名
$ docker tag mysql-hzero-jk-demo:1.12 mysql-hzero-jk-demo:8.4.7
$ docker rmi mysql-hzero-jk-demo:1.12
改了镜像名之后，docker-compose.yml中的镜像名也要通步更改。
==================================================
2、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-注册服务中心 hzero-register镜像
环境：WSL：Ubuntu-22.04系统
$ cd /d01
$ mkdir hzero-register-docker
$ cd /d01/hzero-register-docker
$ vi Dockerfile
输入内容：
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-register.jar /ps-register.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $SKYWALKING_OPTS -jar /ps-register.jar
保存退出：
重新打包ps-register.jar
为适应Docker，bootstrap.yml 和 appication.yml要改造
来源系统先备份：
在Ubuntu-22.04-hzero系统中，进入
$ cd /d02/hzero/project/ps-register/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
更改 bootstrap.yml
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
更改 application.yml
defaultZone: ${EUREKA_DEFAULT_ZONE:http://dev.hzero.com.cn:8000/eureka}
改成：
defaultZone: ${EUREKA_DEFAULT_ZONE:http://localhost:8000/eureka}
来源系统备份jar
$ cd /d02/hzero/project/ps-register/target
$ cp ps-register.jar ps-register.wsl.ok.jar
来源系统构建 jar
$ cd /d02/hzero/project/ps-register
$ vi build.sh
!/bin/bash
SERVICE_NAME=${PWD##*/}
JAR=$SERVICE_NAME.jar
构建项目
echo “>>> mvn clean package -Dmaven.javadoc.skip=true”
mvn clean package -Dmaven.javadoc.skip=true -Dmaven.test.skip=true || { echo “>>> 构建失败”; exit 1; }
echo “>>> cd target”
cd target || { echo “>>> 找不到target目录”; exit 1; }
重命名JAR文件
if [ -f “app.jar” ]; then
mv app.jar $JAR
echo “>>> 重命名 app.jar 为 $JAR”
else
echo “>>> 警告：app.jar 文件不存在，可能使用其他名称”
JAR=$(ls *.jar 2>/dev/null | head -n1)
if [ -z “$JAR” ]; then
echo “>>> 错误：找不到JAR文件！”
exit 1
fi
echo “>>> 使用找到的JAR文件：$JAR”
fi
$ bash build.sh
构建完成，拷贝ps-register.jar 到Ubuntu-22.04/d01/hzero-dockers/hzero-register-docker
进入Ubuntu-22.04/d01/hzero-dockers/hzero-register-docker
$ cd /d01/hzero-dockers/hzero-register-docker
构建镜像
$ docker build -t hzero-register-jk-demo:1.12 .
构建成功
编辑docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-register:
image: hzero-register-jk-demo:1.12
container_name: hzero-register
ports:
– “8000:8000”
– “8001:8001”
environment:
– JAVA_OPTS=” -Xms300m -Xmx300m -Dspring.profiles.active=dev”
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 600m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
启动容器
$ docker compose up -d
[+] Running 2/2
✔ Network hzero-demo Created 0.1s
✔ Container hzero-register Started 0.7s
检查：
$ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
容器启动没成功
$ docker logs hzero-register
Picked up JAVA_TOOL_OPTIONS: -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
Error: Could not find or load main class “
Caused by: java.lang.ClassNotFoundException: “
豆包分析：
你遇到的核心问题是启动命令中的引号导致 JVM 解析错误，” -Xms300m -Xmx300m -Dspring.profiles.active=dev” 里的双引号被当成了类名的一部分，所以报Could not find or load main class “。
直接解决方案
修改docker-compose.yml中的环境变量配置，去掉 JAVA_OPTS 值的双引号：
$ docker compose down && docker compose up -d
检查容器状态
$ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
b25d8a3a5f4e hzero-register-jk-demo:1.12 “/bin/sh -c ‘exec ja…” 11 seconds ago Up 9 seconds 0.0.0.0:8000-8001->8000-8001/tcp, [::]:8000-8001->8000-8001/tcp hzero-register
查看日志确认启动成功
$ docker logs hzero-register
日志看起来成功了
访问测试：
http://localhost:8000 访问正常；
到这里 制作HZERO PaaS 平台 1.12版本的Demo环境的register 注册中心服务docker镜像 完成了；
==================================================
4、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-平台治理 hzero-admin 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero/project/ps-admin/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero/project/ps-admin/target
$ cp ps-admin.jar ps-admin.wsl.ok.jar
2、更改yml配置文件
application.yml中 mysql数据库的主机域名改成Docker compose容器名 :mysql-hzero
url: ${SPRING_DATASOURCE_URL:jdbc:mysql://mysql-hzero:3306/hzero_platform?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true}
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
datasource:
hzero:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成localhost
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://localhost:8060/hadm/config}
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero/project/ps-admin/
4、构建适合Docker的Jar包
$ cd /d02/hzero/project/ps-admin/
$ bash build.sh
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-admin-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-admin-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-admin\target\ps-admin.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-admin-docker\
7、编辑Dockerfile
$ cd /d01/hzero-dockers/hzero-admin-docker
$ vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-admin.jar /ps-admin.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-admin.jar
8、编辑docker-compose.yml
vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-admin:
image: hzero-admin-jk-demo:1.12
container_name: hzero-admin
ports:
– “8060:8060”
– “8061:8061”
environment:
– JAVA_OPTS= -Xms300m -Xmx300m -Dspring.profiles.active=dev
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 600m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
8、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-admin-docker
$ docker build -t hzero-admin-jk-demo:1.12 .
构建成功：
docker images | grep admin
hzero-admin-jk-demo 1.12 b392466e7162 13 seconds ago 1.09GB
9、测试Docker镜像
测试之前先确保 redis-docker 和 mysql-docker，hzero-register 容器已经启动：
$ docker ps
如果没启动可以执行
cd /d01/hzero-dockers/mysql-docker
docker compose up -d
cd /d01/hzero-dockers/redis-docker
docker compose up -d
cd /d01/hzero-dockers/hzero-register-docker
docker compose up -d
启动hzero-admin容器
$ cd /d01/hzero-dockers/hzero-admin-docker
$ docker compose up -d
测试容器中能否连通redis-hzero容器中的redis数据库：
$ docker exec -it hzero-admin /bin/bash
jshell << EOF
import java.net.Socket;
try {
Socket socket = new Socket(“redis-hzero”, 6379);
System.out.println(“Connected successfully!”);
socket.close();
} catch (Exception e) {
System.out.println(“Connection failed: ” + e.getMessage());
}
EOF
结果：
jshell> Connected successfully!
测试容器中能否链通mysql-hzero容器中的mysql数据库：
进入你的Java容器
$ docker exec -it hzero-platform /bin/bash
在你的Java容器中执行
jshell << EOF
try {
new java.net.Socket(“mysql-hzero”, 3306).close();
System.out.println(“端口3306可达”);
} catch (Exception e) {
System.out.println(“端口不可达: ” + e.getMessage());
}
EOF
结果：
jshell> 端口3306可达
测试web服务：（可以访问）
http://localhost:8061/
true
error.error
There is a mistake in the program. Please contact the administrator
warn
No static resource .
==================================================
4、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-平台基础管理 hzero-platform 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero/project/ps-platform/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero/project/ps-platform/target
$ cp ps-platform.jar ps-platform.wsl.ok.jar
2、更改yml配置文件
application.yml中 数据库的主机域名改成Docker compose容器名 :mysql-hzero
url: ${SPRING_DATASOURCE_URL:jdbc:mysql://mysql-hzero:3306/hzero_platform?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true}
application.yml中 数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成docker compose容器名：hzero-admin
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://hzero-admin:8060/hadm/config}
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero/project/ps-platform/
4、构建适合Docker的Jar包
$ cd /d02/hzero/project/ps-platform/
$ bash build.sh
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-platform-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-platform-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-platform\target\ps-platform.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-platform-docker\
7、编辑Dockerfile
$ vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-platform.jar /ps-platform.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-platform.jar
8、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-platform:
image: hzero-platform-jk-demo:1.12
container_name: hzero-platform
ports:
– “8100:8100”
– “8101:8101”
environment:
– JAVA_OPTS= -Xms500m -Xmx500m -Dspring.profiles.active=dev
– REFLEC_OPTS=–add-opens java.base/java.lang=ALL-UNNAMED –add-opens java.base/java.util=ALL-UNNAMED –add-opens java.base/java.util.concurrent=ALL-UNNAMED –add-opens java.base/jdk.internal.loader=ALL-UNNAMED –add-opens java.base/java.net=ALL-UNNAMED –add-opens java.base/java.nio=ALL-UNNAMED –add-opens java.base/java.lang.reflect=ALL-UNNAMED
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 1000m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
8、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-platform-docker
$ docker build -t hzero-platform-jk-demo:1.12 .
构建成功：
root@desktop-jacksen:/d01/hzero-dockers/hzero-platform-docker# docker images | grep platform
hzero-platform-jk-demo 1.12 ea4f8909ae5e 58 seconds ago 1.31GB
9、测试Docker镜像
测试之前先确保 redis-docker 和 mysql-docker，hzero-register , hzero-admin容器已经启动：
$ cd /d01/hzero-dockers/hzero-platform-docker
$ docker compose up -d
$ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
375a4973b082 hzero-platform-jk-demo:1.12 “/bin/sh -c ‘exec ja…” 6 minutes ago Up 6 minutes 0.0.0.0:8100-8101->8100-8101/tcp, [::]:8100-8101->8100-8101/tcp hzero-platform
72cf93b6a594 hzero-admin-jk-demo:1.12 “/bin/sh -c ‘exec ja…” 50 minutes ago Up 50 minutes 0.0.0.0:8060-8061->8060-8061/tcp, [::]:8060-8061->8060-8061/tcp hzero-admin
094e45f23cb4 redis:6-alpine “docker-entrypoint.s…” About an hour ago Up About an hour 0.0.0.0:6379->6379/tcp, [::]:6379->6379/tcp redis-hzero
30200cc3a81c mysql-hzero-jk-demo:1.12 “docker-entrypoint.s…” About an hour ago Up About an hour 0.0.0.0:3306->3306/tcp, [::]:3306->3306/tcp mysql-hzero
b25d8a3a5f4e hzero-register-jk-demo:1.12 “/bin/sh -c ‘exec ja…” 2 days ago Up About an hour 0.0.0.0:8000-8001->8000-8001/tcp, [::]:8000-8001->8000-8001/tcp hzero-register
看日志：docker logs hzero-platform
看起来是正常启动了，访问数据库也都正常
测试web服务：(可以正常访问）
http://localhost:8100
true
error.error
An error occurred in the program. Please contact the administrator
warn
No static resource .
==================================================
5、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-License授权管理 hzero-license 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero/project/ps-license/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero/project/ps-license/target
$ cp ps-license.jar ps-license.wsl.ok.jar
2、更改yml配置文件
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成docker compose容器名：hzero-admin
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://hzero-admin:8060/hadm/config}
inetutils 网卡设置段:去掉：preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero/project/ps-license/
4、构建适合Docker的Jar包
$ cd /d02/hzero/project/ps-license/
$ bash build.sh
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-platform-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-license-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-license\target\ps-license.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-license-docker\
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-license\licenseAgent\license-agent112a.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-license-docker\
7、编辑Dockerfile
$ cd /d01/hzero-dockers/hzero-license-docker
$ vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-license.jar /ps-license.jar
COPY license-agent112a.jar /license-agent112a.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-license.jar
8、编辑docker-compose.yml
vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-license:
image: hzero-license-jk-demo:1.12
container_name: hzero-license
ports:
– “8105:8105”
– “8106:8106”
environment:
– JAVA_OPTS=-Xms200m -Xmx200m -Dspring.profiles.active=dev
– AGENT=-javaagent:/license-agent112a.jar
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 400m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
8、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-license-docker
$ docker build -t hzero-license-jk-demo:1.12 .
构建成功：
docker images | grep license
hzero-license-jk-demo 1.12 a1e6db72ccea 30 seconds ago 1.02GB
如果需要重建，重建后清空悬空镜像：
$ docker image prune
9、测试Docker镜像
测试之前先确保 redis-docker 和 hzero-register 容器已经启动：
$ cd /d01/hzero-dockers/hzero-license-docker
$ docker compose up -d
看日志：
$ docker logs hzero-license
成功启动
测试网络访问：
http://localhost:8105
可以正常访问，镜像构建成功。
==================================================
6、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-身份认证管理 ps-iam-saas 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero/project/ps-iam-saas/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero/project/ps-iam-saas/target
$ cp ps-iam-saas.jar ps-iam-saas.wsl.ok.jar
2、更改yml配置文件
application.yml中 数据库的主机域名改成Docker compose容器名 :mysql-hzero
url: ${SPRING_DATASOURCE_URL:jdbc:mysql://mysql-hzero:3306/hzero_platform?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true}
application.yml中 数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成docker compose容器名：hzero-admin
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://hzero-admin:8060/hadm/config}
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero/project/ps-iam-saas/
4、构建适合Docker的Jar包
$ cd /d02/hzero/project/ps-iam-saas/
$ bash build.sh
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-iam-saas-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-iam-saas-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-iam-saas\target\ps-iam-saas.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-iam-saas-docker\
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-license\licenseAgent\license-agent112a.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-iam-saas-docker\
7、编辑Dockerfile
$ cd /d01/hzero-dockers/hzero-iam-saas-docker
$ vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-iam-saas.jar /ps-iam-saas.jar
COPY license-agent112a.jar /license-agent112a.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-iam-saas.jar
8、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-platform:
image: hzero-iam-saas-jk-demo:1.12
container_name: hzero-iam-saas
ports:
– “8030:8030”
– “8031:8031”
environment:
– JAVA_OPTS=-Xms400m -Xmx400m -Dspring.profiles.active=dev
– AGENT=-javaagent:/license-agent112a.jar
– REFLEC_OPTS=–add-opens java.base/java.lang=ALL-UNNAMED –add-opens java.base/java.util=ALL-UNNAMED –add-opens java.base/java.util.concurrent=ALL-UNNAMED –add-opens java.base/jdk.internal.loader=ALL-UNNAMED –add-opens java.base/java.net=ALL-UNNAMED –add-opens java.base/java.nio=ALL-UNNAMED –add-opens java.base/java.lang.reflect=ALL-UNNAMED
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 800m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
8、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-iam-saas-docker
$ docker build -t hzero-iam-saas-jk-demo:1.12 .
构建成功：
$ docker images | grep iam-saas
9、测试Docker镜像
测试之前先确保 redis-docker 和 mysql-docker，hzero-register , hzero-admin容器已经启动：
$ cd /d01/hzero-dockers/hzero-iam-saas-docker
$ docker compose up -d
看日志：docker logs hzero-iam-saas
看起来是正常启动了，访问数据库也都正常
测试web服务：(可以正常访问）
http://localhost:8030
关闭docker容器：
cd /d01/hzero-dockers/hzero-admin-docker/
docker compose down
cd /d01/hzero-dockers/hzero-iam-saas-docker/
docker compose down
cd /d01/hzero-dockers/hzero-license-docker/
docker compose down
cd /d01/hzero-dockers/hzero-platform-docker/
docker compose down
cd /d01/hzero-dockers/hzero-register-docker/
docker compose down
cd /d01/hzero-dockers/mysql-docker/
docker compose down
cd /d01/hzero-dockers/redis-docker/
docker compose down
==================================================
7、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-OAUTH认证 ps-oauth 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero/project/ps-oauth/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero/project/ps-oauth/target
$ cp ps-oauth.jar ps-oauth.wsl.ok.jar
2、更改yml配置文件
application.yml中 mysql数据库的主机域名改成Docker compose容器名 :mysql-hzero
url: ${SPRING_DATASOURCE_URL:jdbc:mysql://mysql-hzero:3306/hzero_platform?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true}
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
application.yml中 数据库的主机域名 改成Docker composer容器名 :redis-hzero
application.yml中 网关主机域名 改成Docker composer容器名 :hzero-gateway
# oauth 服务基础地址
base-url: ${HZERO_OAUTH_BASE_URL:http://hzero-gateway:8080/oauth}
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成docker compose容器名：hzero-admin
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://hzero-admin:8060/hadm/config}
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero/project/ps-oauth/
4、构建适合Docker的Jar包
$ cd /d02/hzero/project/ps-oauth/
$ bash build.sh
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-oauth-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-oauth-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-oauth\target\ps-oauth.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-oauth-docker\
7、编辑Dockerfile
$ cd /d01/hzero-dockers/hzero-oauth-docker
$ vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-oauth.jar /ps-oauth.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-oauth.jar
8、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-oauth:
image: hzero-oauth-jk-demo:1.12
container_name: hzero-oauth
ports:
– “8020:8020”
– “8021:8021”
environment:
– JAVA_OPTS=-Xms200m -Xmx200m -Dspring.profiles.active=dev
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 500m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
9、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-oauth-docker
$ docker build -t hzero-oauth-jk-demo:1.12 .
构建成功：
$ docker images | grep oauth
hzero-oauth-jk-demo 1.12 f8d746ca59db 20 seconds ago 1.04GB
10、测试Docker镜像
测试之前先确保 redis-docker 和 mysql-docker，hzero-register , hzero-admin容器已经启动：
cd /d01/hzero-dockers/redis-docker/
docker compose up -d
cd /d01/hzero-dockers/mysql-docker/
docker compose up -d
延时120秒
sleep 120
$ cd /d01/hzero-dockers/hzero-register-docker/
docker compose up -d
cd /d01/hzero-dockers/hzero-admin-docker/
docker compose up -d
cd /d01/hzero-dockers/hzero-oauth-docker
docker compose up -d
看日志：
$ docker logs hzero-oauth
看起来是正常启动了，访问数据库也都正常
==================================================
8、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-网关服务 ps-gateway 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero/project/ps-gateway/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero/project/ps-gateway/target
cp ps-gateway.jar ps-gateway.wsl.ok.jar
2、更改yml配置文件
application.yml中 mysql数据库的主机域名改成Docker compose容器名 :mysql-hzero
url: ${SPRING_DATASOURCE_URL:jdbc:mysql://mysql-hzero:3306/hzero_platform?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true}
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
application.yml中 数据库的主机域名 改成Docker composer容器名 :redis-hzero
application.yml中 网关主机域名 改成Docker composer容器名 :hzero-gateway
# oauth 服务基础地址
base-url: ${HZERO_OAUTH_BASE_URL:http://hzero-gateway:8080/oauth}
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成docker compose容器名：hzero-admin
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://hzero-admin:8060/hadm/config}
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero/project/ps-gateway/
4、构建适合Docker的Jar包
$ cd /d02/hzero/project/ps-gateway/
$ bash build.sh
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-oauth-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-gateway-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-gateway\target\ps-gateway.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-gateway-docker\
7、编辑Dockerfile
$ cd /d01/hzero-dockers/hzero-gateway-docker
$ vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-gateway.jar /ps-gateway.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-gateway.jar
8、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-gateway:
image: hzero-gateway-jk-demo:1.12
container_name: hzero-gateway
ports:
– “8080:8080”
– “8081:8081”
environment:
– JAVA_OPTS=-Xms200m -Xmx200m -Dspring.profiles.active=dev
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 500m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
9、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-gateway-docker
$ docker build -t hzero-gateway-jk-demo:1.12 .
构建成功：
$ docker images | grep gateway
10、测试Docker镜像
测试之前先确保 redis-docker 和 mysql-docker，hzero-register , hzero-admin容器已经启动：
$ cd /d01/hzero-dockers/hzero-gateway-docker
$ docker compose up -d
看日志：docker logs hzero-gateway
看起来是正常启动了，访问数据库也都正常
测试web服务：(不可正常访问）
http://localhost:8080
返回：
{“failed”:true,”code”:”error.permission.routeNotFound”,”message”:”This request mismatch any routes, uri: %2F”,”type”:”PERMISSION_SERVICE_ROUTE”,”detailsMessage”:”The route you visited does not exist or the related service is not installed”}
表示已经在服务了，成功。
==================================================
9、启动docker compose 容器 mongo-hzero
二、目标环境：
环境：WSL：Ubuntu-22.04系统
1、建立mongo-docker目录
$ cd /d01/hzero-dockers
$ mkdir mongo-docker
$ cd /d01/hzero-dockers/volumes
$ mkdir mongo
$ cd /d01/hzero-dockers/mongo-docker
$ sudo chown -R 1000:1000 ../volumes/mongo
$ sudo chmod -R 755 ../volumes/mongo
$ vi mongo-init.js
db.createUser({
user: “hzero”,
pwd: “hzero”,
roles: [
{ role: “readWrite”, db: “test” }
]
});
2、编辑docker-compose.yml
$ vi docker-compose.yml
services:
mongo-hzero:
image: registry.hand-china.com/hzero-public/mongo:5.0.25
container_name: mongo-hzero
user: “1000:1000” # 添加这一行，指定 mongo 用户
ports:
– “27017:27017”
environment:
– MONGO_INITDB_ROOT_USERNAME=hzero
– MONGO_INITDB_ROOT_PASSWORD=hzero
– MONGO_INITDB_DATABASE=test
volumes:
– ${DOCKER_VOLUME_DIRECTORY:-../volumes}/mongo:/data/db
– ./mongo-init.js:/docker-entrypoint-initdb.d/mongo-init.js:ro
networks:
default:
name: hzero-demo
external: true
3、测试Docker 容器
$ cd /d01/hzero-dockers/mongo-docker
$ docker compose up -d
看日志：docker logs mongo-hzero
启动成功
==================================================
10、启动docker compose 容器 elasticsearch-hzero
二、目标环境：
环境：WSL：Ubuntu-22.04系统
1、建立elasticsearch-docker目录
$ cd /d01/hzero-dockers
$ mkdir elasticsearch-docker
$ mkdir volumes
$ cd /d01/hzero-dockers/elasticsearch-docker
windows powershell 中 执行：原有demo数据迁移(包括AI平台的向量数据和关键字索引)：
$ cp -r \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero-aipaas\hzero-aigc-docker-compose\elastic\volumes\elastic \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\volumes\
设置 Elasticsearch 数据目录的所有者为 UID=1000 的用户
$ cd /d01/hzero-dockers/elasticsearch-docker
$ sudo chown -R 1000:1000 ../volumes/elastic
$ sudo chmod -R 755 ../volumes/elastic
2、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
elasticsearch-hzero:
image: registry.hand-china.com/hzero-public/elasticsearch:8.12.2
container_name: elasticsearch-hzero
user: “1000:1000” # 添加这一行，指定 Elasticsearch 用户
ports:
– “9200:9200”
– “9300:9300”
environment:
– ELASTIC_PASSWORD=elastic
– discovery.type=single-node
– xpack.security.enrollment.enabled=true
– xpack.security.enabled=true
– ES_JAVA_OPTS=-Xms1g -Xmx1g # 设置 JVM 堆内存为 500M
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 2g # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
volumes:
– ${DOCKER_VOLUME_DIRECTORY:-../volumes}/elastic/data:/usr/share/elasticsearch/data
– ${DOCKER_VOLUME_DIRECTORY:-../volumes}/elastic/plugins:/usr/share/elasticsearch/plugins
networks:
default:
name: hzero-demo
external: true
3、测试Docker 容器
$ cd /d01/hzero-dockers/elasticsearch-docker
$ docker compose up -d
看日志：docker logs elasticsearch-docker
启动成功
==================================================
11、启动docker compose 容器 minio-hzero
二、目标环境：
环境：WSL：Ubuntu-22.04系统
1、建立minio-docker目录
$ cd /d01/hzero-dockers
$ mkdir minio-docker
$ cd volumes
$ mkdir minio
$ cd /d01/hzero-dockers/minio-docker
windows powershell 中执行：原有Demo数据迁移（包括AI平台中的文档）
$ cp -r \wsl.localhost\Ubuntu-22.04-hzero\data\minio \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\volumes\
设置 minio 数据目录的所有者为 UID=1000 的用户
$ cd /d01/hzero-dockers/minio-docker
$ sudo chown -R 1000:1000 ../volumes/minio
$ sudo chmod -R 755 ../volumes/minio
2、编辑docker-compose.yml
$ vi docker-compose.yml
services:
minio-hzero:
image: minio/minio:latest
container_name: minio-hzero
user: “1000:1000” # 添加这一行，指定minio 用户
ports:
– “9000:9000” # MinIO API 端口
– “9001:9001” # MinIO 控制台端口
environment:
– MINIO_ROOT_USER=hzero.admin
– MINIO_ROOT_PASSWORD=hzero.hand.2020.
– MINIO_ACCESS_KEY=hzero.admin # 兼容旧版配置
– MINIO_SECRET_KEY=hzero.hand.2020. # 兼容旧版配置
volumes:
– ${DOCKER_VOLUME_DIRECTORY:-../volumes}/minio:/data # 挂载原有数据目录
command: server /data –address “:9000” –console-address “:9001”
restart: always
networks:
default:
name: hzero-demo
external: true
3、测试Docker 容器
$ cd /d01/hzero-dockers/minio-docker
$ docker compose up -d
看日志：docker logs minio-hzero
启动成功
==================================================
12、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-接口平台 ps-interface 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero-ipaas/project/ps-jipaas-interface/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero-ipaas/project/ps-jipaas-interface/target
$ cp ps-jipaas-interface.jar ps-jipaas-interface.wsl.ok.jar
2、更改yml配置文件
application.yml中 数据库的主机域名改成Docker compose容器名 :mysql-hzero
url: ${SPRING_DATASOURCE_URL:jdbc:mysql://mysql-hzero:3306/hzero_platform?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true}
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
application.yml中 mongo数据库主机域名改成Docker composer容器名 :mongo-hzero
mongodb:
uri: ${SPRING_MONGODB_URI:mongodb://hzero:hzero@mongo-hzero:27017/test}
elasticsearch:
application.yml中 elasticsearch数据库主机域名
# 地址，支持多地址，逗号分隔
host: ${ELASTICSEARCH_HOST:elasticsearch-hzero}
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成docker compose容器名：hzero-admin
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://hzero-admin:8060/hadm/config}
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero-ipaas/project/ps-jipaas-interface/
4、构建适合Docker的Jar包
$ cd /d02/hzero-ipaas/project/ps-jipaas-interface/
$ bash build.sh
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-interface-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-interface-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero-ipaas\project\ps-jipaas-interface\target\ps-jipaas-interface.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-interface-docker\
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-license\licenseAgent\license-agent110.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-interface-docker\
7、编辑Dockerfile
$ cd /d01/hzero-dockers/hzero-interface-docker
$ vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-jipaas-interface.jar /ps-jipaas-interface.jar
COPY license-agent110.jar /license-agent110.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-jipaas-interface.jar
8、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-interface:
image: hzero-jipaas-interface-jk-demo:1.12
container_name: hzero-interface
ports:
– “8150:8150”
– “8151:8151”
environment:
– JAVA_OPTS=-Xms800m -Xmx800m -Dspring.profiles.active=dev
– AGENT=-javaagent:/license-agent110.jar
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 1500m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
9、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-interface-docker
$ docker build -t hzero-jipaas-interface-jk-demo:1.12 .
构建成功：
$ docker images | grep interface
10、测试Docker镜像
测试之前先确保 redis-docker 和 mysql-docker，hzero-register , hzero-admin,mongo-hzero, elasticsearch-hzero 容器已经启动：
$ cd /d01/hzero-dockers/hzero-interface-docker
$ docker compose up -d
看日志：docker logs hzero-interface
有错误：
For ‘hzero-license’ URL not provided. Will try picking an instance via load-balancing.
For ‘hzero-iam’ URL not provided. Will try picking an instance via load-balancing.
Caused by: java.sql.SQLSyntaxErrorException: Table ‘hzero_interface.iam_role’ doesn’t exist
服务启动没成功，在注册中心未能注册成功。
分析：
iam_role 这张表是在hzero_platform数据库中的，为啥会去hzero_interface数据库中找？奇怪！
可能是license、iam、platform三个服务没有提前启动的原因？
解决方案：
把hzero-license服务 hzero-iam服务 和 hzero-platform 也启动后再启
先停interface服务
$ cd /d01/hzero-dockers/hzero-interface-docker
$ docker compose down
起hzero-license、 hzero-iam、hzero-platform服务
$ cd /d01/hzero-dockers/hzero-license-docker
$ docker compose up -d
$ cd /d01/hzero-dockers/hzero-iam-saas-docker
$ docker compose up -d
$ cd /d01/hzero-dockers/hzero-platform-docker
$ docker compose up -d
再重启interface服务
$ cd /d01/hzero-dockers/hzero-interface-docker
$ docker compose up -d
这次看起来是正常启动了，在注册中心http://localhost:8000中可以看到了，看起来他能找到hzero-iam路由的话，就不会去访问hzero_interface.iam_role，反之就会去访问hzero_interface.iam_role，是实际上hzero_interface数据库中没有iam_role表就出错了。
测试web服务：(可以正常访问）
http://localhost:8150，可以正常转到license服务的Web界面。
==================================================
13、启动docker compose 容器 kkfileview-hzero
二、目标环境：
环境：WSL：Ubuntu-22.04系统
1、建立elasticsearch-docker目录
$ cd /d01/hzero-dockers
$ mkdir kkfileview-docker
2、编辑docker-compose.yml
$ cd /d01/hzero-dockers/kkfileview-docker
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
kkfileview-hzero:
image: keking/kkfileview
container_name: kkfileview-hzero
ports:
– “8012:8012”
networks:
default:
name: hzero-demo
external: true
3、测试Docker 容器
$ cd /d01/hzero-dockers/kkfileview-docker
$ docker compose up -d
看日志：docker logs kkfileview-docker
启动成功
http://localhost:8012 上传一个中文PPT测试预览，正常。
==================================================
14、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-定时任务服务 ps-scheduler 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero/project/ps-scheduler/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero/project/ps-scheduler/target
$ cp ps-scheduler.jar ps-scheduler.wsl.ok.jar
2、更改yml配置文件
application.yml中 mysql数据库的主机域名改成Docker compose容器名 :mysql-hzero
url: ${SPRING_DATASOURCE_URL:jdbc:mysql://mysql-hzero:3306/hzero_platform?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true}
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
application.yml中 数据库的主机域名 改成Docker composer容器名 :redis-hzero
application.yml中 网关主机域名 改成Docker composer容器名 :hzero-gateway
# oauth 服务基础地址
base-url: ${HZERO_OAUTH_BASE_URL:http://hzero-gateway:8080/oauth}
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成docker compose容器名：hzero-admin
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://hzero-admin:8060/hadm/config}
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：4、构建适合Docker的Jar包
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero/project/ps-scheduler/
$ cd /d02/hzero/project/ps-scheduler/
$ bash build.sh
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-scheduler-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-scheduler-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-scheduler\target\ps-scheduler.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-scheduler-docker\
7、编辑Dockerfile
$ cd /d01/hzero-dockers/hzero-scheduler-docker
$ vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-scheduler.jar /ps-scheduler.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-scheduler.jar
8、编辑docker-compose.yml
vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-scheduler:
image: hzero-scheduler-jk-demo:1.12
container_name: hzero-scheduler
ports:
– “8130:8130”
– “8131:8131”
environment:
– JAVA_OPTS=-Xms200m -Xmx200m -Dspring.profiles.active=dev
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 500m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
9、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-scheduler-docker
$ docker build -t hzero-scheduler-jk-demo:1.12 .
构建成功：
$ docker images | grep scheduler
10、测试Docker镜像（测试之前先确保 redis-docker 和 mysql-docker，hzero-register , hzero-admin容器已经启动）：
$ cd /d01/hzero-dockers/hzero-scheduler-docker
$ docker compose up -d
看日志：docker logs hzero-scheduler
看起来是正常启动了
http://localhost:8000注册中心中可见hzero-scheduler服务
==================================================
15、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-文件服务 ps-file 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero/project/ps-file/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero/project/ps-file/target
$ cp ps-file.jar ps-file.wsl.ok.jar
2、更改yml配置文件
application.yml中 mysql数据库的主机域名改成Docker compose容器名 :mysql-hzero
url: ${SPRING_DATASOURCE_URL:jdbc:mysql://mysql-hzero:3306/hzero_platform?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true}
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
application.yml中 数据库的主机域名 改成Docker composer容器名 :redis-hzero
application.yml中 网关主机域名 改成Docker composer容器名 :hzero-gateway
# oauth 服务基础地址
base-url: ${HZERO_OAUTH_BASE_URL:http://hzero-gateway:8080/oauth}
application.yml中 KKV主机域名 改成Docker composer容器名 :kkfileview-hzero
preview-type: kkFileView
kk-file-view-url: http://kkfileview-hzero:8012/onlinePreview # kkFileView的文件预览地址
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成docker compose容器名：hzero-admin
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://hzero-admin:8060/hadm/config}
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero/project/ps-file/
4、构建适合Docker的Jar包
$ cd /d02/hzero/project/ps-file/
$ bash build.sh
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-file-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-file-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-file\target\ps-file.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-file-docker\
7、编辑Dockerfile
$ cd /d01/hzero-dockers/hzero-file-docker
$ vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-file.jar /ps-file.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-file.jar
8、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-file:
image: hzero-file-jk-demo:1.12
container_name: hzero-file
ports:
– “8110:8110”
– “8111:8111”
environment:
– JAVA_OPTS=-Xms220m -Xmx220m -Dspring.profiles.active=dev
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 500m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
9、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-file-docker
$ docker build -t hzero-file-jk-demo:1.12 .
构建成功：
$ docker images | grep file
10、测试Docker镜像（测试之前先确保 redis-docker 和 mysql-docker，hzero-register , hzero-admin容器已经启动）：
$ cd /d01/hzero-dockers/hzero-file-docker
$ docker compose up -d
看日志：docker logs hzero-file
看起来是正常启动了
http://localhost:8000注册中心中可见hzero-file服务
==================================================
16、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-预警服务 ps-alert 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero/project/ps-alert/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero/project/ps-alert/target
$ cp ps-alert.jar ps-alert.wsl.ok.jar
2、更改yml配置文件
application.yml中 mysql数据库的主机域名改成Docker compose容器名 :mysql-hzero
url: ${SPRING_DATASOURCE_URL:jdbc:mysql://mysql-hzero:3306/hzero_platform?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true}
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
application.yml中 数据库的主机域名 改成Docker composer容器名 :redis-hzero
application.yml中 网关主机域名 改成Docker composer容器名 :hzero-gateway
# oauth 服务基础地址
base-url: ${HZERO_OAUTH_BASE_URL:http://hzero-gateway:8080/oauth}
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成docker compose容器名：hzero-admin
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://hzero-admin:8060/hadm/config}
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero/project/ps-alert/
4、构建适合Docker的Jar包
$ cd /d02/hzero/project/ps-alert/
$ bash build.sh
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-file-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-alert-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-alert\target\ps-alert.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-alert-docker\
7、编辑Dockerfile
$ cd /d01/hzero-dockers/hzero-alert-docker
$ vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-alert.jar /ps-alert.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-alert.jar
8、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-alert:
image: hzero-alert-jk-demo:1.12
container_name: hzero-alert
ports:
– “8115:8115”
– “8116:8116”
environment:
– JAVA_OPTS=-Xms250m -Xmx250m -Dspring.profiles.active=dev
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 500m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
9、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-alert-docker
$ docker build -t hzero-alert-jk-demo:1.12 .
构建成功：
$ docker images | grep alert
10、测试Docker镜像（测试之前先确保 redis-docker 和 mysql-docker，hzero-register , hzero-admin容器已经启动）：
$ cd /d01/hzero-dockers/hzero-alert-docker
$ docker compose up -d
看日志：docker logs hzero-alert
看起来是正常启动了
http://localhost:8000注册中心中可见hzero-alert服务
==================================================
17、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-导入服务 ps-import 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero/project/ps-import/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero/project/ps-import/target
$ cp ps-import.jar ps-import.wsl.ok.jar
2、更改yml配置文件
application.yml中 mysql数据库的主机域名改成Docker compose容器名 :mysql-hzero
url: ${SPRING_DATASOURCE_URL:jdbc:mysql://mysql-hzero:3306/hzero_platform?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true}
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
application.yml中 数据库的主机域名 改成Docker composer容器名 :redis-hzero
application.yml中 网关主机域名 改成Docker composer容器名 :hzero-gateway
# oauth 服务基础地址
base-url: ${HZERO_OAUTH_BASE_URL:http://hzero-gateway:8080/oauth}
application.yml中 文件网关域名 改成Docker composer容器名 :hzero-gateway
file:
gateway-path: ${FILE_GATEWAY_URL:http://hzero-gateway:8080/himp}
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成docker compose容器名：hzero-admin
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://hzero-admin:8060/hadm/config}
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：4、构建适合Docker的Jar包
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero/project/ps-import/
$ cd /d02/hzero/project/ps-import/
$ bash build.sh
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-import-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-import-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-import\target\ps-import.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-import-docker\
7、编辑Dockerfile
$ cd /d01/hzero-dockers/hzero-import-docker
$ vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-import.jar /ps-import.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-import.jar
8、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-import:
image: hzero-import-jk-demo:1.12
container_name: hzero-import
ports:
– “8140:8140”
– “8141:8141”
environment:
– JAVA_OPTS=-Xms220m -Xmx220m -Dspring.profiles.active=dev
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 500m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
9、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-import-docker
$ docker build -t hzero-import-jk-demo:1.12 .
构建成功：
$ docker images | grep import
10、测试Docker镜像（测试之前先确保 redis-docker 和 mysql-docker，hzero-register , hzero-admin容器已经启动）：
$ cd /d01/hzero-dockers/hzero-import-docker
$ docker compose up -d
看日志：docker logs hzero-import
看起来是正常启动了
http://localhost:8000注册中心中可见hzero-import服务
==================================================
18、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-消息服务 ps-message 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero/project/ps-message/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero/project/ps-message/target
$ cp ps-message.jar ps-message.wsl.ok.jar
2、更改yml配置文件
application.yml中 mysql数据库的主机域名改成Docker compose容器名 :mysql-hzero
url: ${SPRING_DATASOURCE_URL:jdbc:mysql://mysql-hzero:3306/hzero_platform?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true}
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
application.yml中 数据库的主机域名 改成Docker composer容器名 :redis-hzero
application.yml中 网关主机域名 改成Docker composer容器名 :hzero-gateway
# oauth 服务基础地址
base-url: ${HZERO_OAUTH_BASE_URL:http://hzero-gateway:8080/oauth}
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成docker compose容器名：hzero-admin
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://hzero-admin:8060/hadm/config}
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：4、构建适合Docker的Jar包
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero/project/ps-message/
$ cd /d02/hzero/project/ps-message/
$ bash build.sh
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-message-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-message-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-message\target\ps-message.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-message-docker\
7、编辑Dockerfile
$ cd /d01/hzero-dockers/hzero-message-docker
$ vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-message.jar /ps-message.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-message.jar
8、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-message:
image: hzero-message-jk-demo:1.12
container_name: hzero-message
ports:
– “8120:8120”
– “8121:8121”
environment:
– JAVA_OPTS=-Xms250m -Xmx250m -Dspring.profiles.active=dev
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 500m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
9、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-message-docker
$ docker build -t hzero-message-jk-demo:1.12 .
构建成功：
$ docker images | grep message
10、测试Docker镜像（测试之前先确保 redis-docker 和 mysql-docker，hzero-register , hzero-admin容器已经启动）：
$ cd /d01/hzero-dockers/hzero-message-docker
$ docker compose up -d
看日志：docker logs hzero-message
看起来是正常启动了
http://localhost:8000注册中心中可见hzero-import服务
==================================================
19、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-消息服务 ps-report 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero/project/ps-report/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero/project/ps-report/target
$ cp ps-report.jar ps-report.wsl.ok.jar
2、更改yml配置文件
application.yml中 mysql数据库的主机域名改成Docker compose容器名 :mysql-hzero
url: ${SPRING_DATASOURCE_URL:jdbc:mysql://mysql-hzero:3306/hzero_platform?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true}
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
application.yml中 数据库的主机域名 改成Docker composer容器名 :redis-hzero
application.yml中 网关主机域名 改成Docker composer容器名 :hzero-gateway
# oauth 服务基础地址
base-url: ${HZERO_OAUTH_BASE_URL:http://hzero-gateway:8080/oauth}
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成docker compose容器名：hzero-admin
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://hzero-admin:8060/hadm/config}
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：4、构建适合Docker的Jar包
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero/project/ps-report/
$ cd /d02/hzero/project/ps-report/
$ bash build.sh
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-report-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-report-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-report\target\ps-report.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-report-docker\
7、编辑Dockerfile
$ cd /d01/hzero-dockers/hzero-report-docker
$ vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-report.jar /ps-report.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-report.jar
8、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-report:
image: hzero-report-jk-demo:1.12
container_name: hzero-report
ports:
– “8210:8210”
– “8211:8211”
environment:
– JAVA_OPTS=-Xms200m -Xmx800m -Dspring.profiles.active=dev
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 1500m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
9、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-report-docker
$ docker build -t hzero-report-jk-demo:1.12 .
构建成功：
$ docker images | grep report
10、测试Docker镜像（测试之前先确保 redis-docker 和 mysql-docker，hzero-register , hzero-admin容器已经启动）：
$ cd /d01/hzero-dockers/hzero-report-docker
$ docker compose up -d
看日志：docker logs hzero-report
看起来是正常启动了
http://localhost:8000注册中心中可见hzero-report服务
==================================================
20、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-API文档服务 ps-swagger 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero/project/ps-swagger/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero/project/ps-swagger/target
$ cp ps-swagger.jar ps-swagger.wsl.ok.jar
2、更改yml配置文件
application.yml中 mysql数据库的主机域名改成Docker compose容器名 :mysql-hzero
url: ${SPRING_DATASOURCE_URL:jdbc:mysql://mysql-hzero:3306/hzero_platform?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true}
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
application.yml中 数据库的主机域名 改成Docker composer容器名 :redis-hzero
application.yml中 网关主机域名 改成Docker composer容器名 :hzero-gateway
base-url: ${HZERO_SWAGGER_BASE_URL:http://hzero-gateway:8080}
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成docker compose容器名：hzero-admin
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://hzero-admin:8060/hadm/config}
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：4、构建适合Docker的Jar包
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero/project/ps-swagger/
$ cd /d02/hzero/project/ps-swagger/
$ bash build.sh
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-swagger-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-swagger-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-swagger\target\ps-swagger.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-swagger-docker\
7、编辑Dockerfile
$ cd /d01/hzero-dockers/hzero-swagger-docker
$ vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-swagger.jar /ps-swagger.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-swagger.jar
8、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-swagger:
image: hzero-swagger-jk-demo:1.12
container_name: hzero-swagger
ports:
– “8050:8050”
– “8051:8051”
environment:
– JAVA_OPTS=-Xms200m -Xmx800m -Dspring.profiles.active=dev
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 1500m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
9、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-swagger-docker
$ docker build -t hzero-swagger-jk-demo:1.12 .
构建成功：
$ docker images | grep swagger
10、测试Docker镜像（测试之前先确保 redis-docker 和 mysql-docker，hzero-register , hzero-admin容器已经启动）：
$ cd /d01/hzero-dockers/hzero-swagger-docker
$ docker compose up -d
看日志：docker logs hzero-swagger
看起来是正常启动了
http://localhost:8000注册中心中可见hzero-swagger服务
==================================================
21、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-低代码模型服务 ps-modeler 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero-apaas/project/ps-modeler/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero-apaas/project/ps-modeler/target
$ cp ps-modeler.jar ps-modeler.wsl.ok.jar
2、更改yml配置文件
application.yml中 数据库的主机域名改成Docker compose容器名 :mysql-hzero
url: ${SPRING_DATASOURCE_URL:jdbc:mysql://mysql-hzero:3306/hzero_platform?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true}
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
application.yml中 seta注册主机域名改成Docker composer容器名 :hzero-register
service-url: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成docker compose容器名：hzero-admin
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://hzero-admin:8060/hadm/config}
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：4、构建适合Docker的Jar包
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero-apaas/project/ps-modeler/
$ cd /d02/hzero-apaas/project/ps-modeler/
$ bash build.sh
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-modeler-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-modeler-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero-apaas\project\ps-modeler\target\ps-modeler.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-modeler-docker\
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-license\licenseAgent\license-agent112a.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-modeler-docker\
7、编辑Dockerfile
$ cd /d01/hzero-dockers/hzero-modeler-docker
$ vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-modeler.jar /ps-modeler.jar
COPY license-agent112a.jar /license-agent112a.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-modeler.jar
8、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-modeler:
image: hzero-modeler-jk-demo:1.12
container_name: hzero-modeler
ports:
– “8085:8085”
– “8086:8086”
environment:
– JAVA_OPTS=-Xms500m -Xmx800m -Dspring.profiles.active=dev
– AGENT=-javaagent:/license-agent112a.jar
– REFLEC_OPTS=–add-opens java.base/java.lang=ALL-UNNAMED –add-opens java.base/java.util=ALL-UNNAMED –add-opens java.base/java.util.concurrent=ALL-UNNAMED –add-opens java.base/jdk.internal.loader=ALL-UNNAMED –add-opens java.base/java.net=ALL-UNNAMED –add-opens java.base/java.nio=ALL-UNNAMED –add-opens java.base/java.lang.reflect=ALL-UNNAMED
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 1500m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
9、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-modeler-docker
$ docker build -t hzero-modeler-jk-demo:1.12 .
构建成功：
$ docker images | grep modeler
10、测试Docker镜像
测试之前先确保 redis-docker 和 mysql-docker，hzero-register , hzero-admin 容器已经启动：
$ cd /d01/hzero-dockers/hzero-modeler-docker
$ docker compose up -d
看日志：docker logs hzero-modeler
测试web服务：(可以正常访问）
http://localhost:8000，可以看到hzero-modeler已经成功注册。
==================================================
22、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-低代码应用服务 ps-lowcode 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero-apaas/project/ps-lowcode/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero-apaas/project/ps-lowcode/target
$ cp ps-lowcode.jar ps-lowcode.wsl.ok.jar
2、更改yml配置文件
application.yml中 数据库的主机域名改成Docker compose容器名 :mysql-hzero
url: ${SPRING_DATASOURCE_URL:jdbc:mysql://mysql-hzero:3306/hzero_platform?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true}
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
application.yml中 seta注册主机域名改成Docker composer容器名 :hzero-register
service-url: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成docker compose容器名：hzero-admin
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://hzero-admin:8060/hadm/config}
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：4、构建适合Docker的Jar包
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero-apaas/project/ps-lowcode/
$ cd /d02/hzero-apaas/project/ps-lowcode/
$ bash build.sh
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-lowcode-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-lowcode-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero-apaas\project\ps-lowcode\target\ps-lowcode.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-lowcode-docker\
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-license\licenseAgent\license-agent112a.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-lowcode-docker\
7、编辑Dockerfile
$ cd /d01/hzero-dockers/hzero-lowcode-docker
$ vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-lowcode.jar /ps-lowcode.jar
COPY license-agent112a.jar /license-agent112a.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-lowcode.jar
8、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-lowcode:
image: hzero-lowcode-jk-demo:1.12
container_name: hzero-lowcode
ports:
– “8095:8095”
– “8096:8096”
environment:
– JAVA_OPTS=-Xms500m -Xmx800m -Dspring.profiles.active=dev
– AGENT=-javaagent:/license-agent112a.jar
– REFLEC_OPTS=–add-opens java.base/java.lang=ALL-UNNAMED –add-opens java.base/java.util=ALL-UNNAMED –add-opens java.base/java.util.concurrent=ALL-UNNAMED –add-opens java.base/jdk.internal.loader=ALL-UNNAMED –add-opens java.base/java.net=ALL-UNNAMED –add-opens java.base/java.nio=ALL-UNNAMED –add-opens java.base/java.lang.reflect=ALL-UNNAMED
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 1500m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
9、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-lowcode-docker
$ docker build -t hzero-lowcode-jk-demo:1.12 .
构建成功：
$ docker images | grep lowcode
10、测试Docker镜像
测试之前先确保 redis-docker 和 mysql-docker，hzero-register , hzero-admin 容器已经启动：
$ cd /d01/hzero-dockers/hzero-lowcode-docker
$ docker compose up -d
看日志：docker logs hzero-lowcode
测试web服务：(可以正常访问）
http://localhost:8000，可以看到hzero-lowcode已经成功注册。
==================================================
23、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-低代码空数据服务 ps-lowcodedata 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero-apaas/project/ps-lowcodedata/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero-apaas/project/ps-lowcodedata/target
$ cp ps-lowcodedata.jar ps-lowcodedata.wsl.ok.jar
2、更改yml配置文件
application.yml中 数据库的主机域名改成Docker compose容器名 :mysql-hzero
url: ${SPRING_DATASOURCE_URL:jdbc:mysql://mysql-hzero:3306/hzero_platform?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true}
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
application.yml中 seta注册主机域名改成Docker composer容器名 :hzero-register
service-url: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成docker compose容器名：hzero-admin
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://hzero-admin:8060/hadm/config}
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：4、构建适合Docker的Jar包
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero-apaas/project/ps-lowcodedata/
$ cd /d02/hzero-apaas/project/ps-lowcodedata/
$ bash build.sh
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-lowcodedata-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-lowcodedata-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero-apaas\project\ps-lowcodedata\target\ps-lowcodedata.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-lowcodedata-docker\
7、编辑Dockerfile
$ cd /d01/hzero-dockers/hzero-lowcodedata-docker
$ vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-lowcodedata.jar /ps-lowcodedata.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-lowcodedata.jar
8、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-lowcodedata:
image: hzero-lowcodedata-jk-demo:1.12
container_name: hzero-lowcodedata
ports:
– “8555:8555”
– “8556:8556”
environment:
– JAVA_OPTS=-Xms200m -Xmx300m -Dspring.profiles.active=dev
– REFLEC_OPTS=–add-opens java.base/java.lang=ALL-UNNAMED –add-opens java.base/java.util=ALL-UNNAMED –add-opens java.base/java.util.concurrent=ALL-UNNAMED –add-opens java.base/jdk.internal.loader=ALL-UNNAMED –add-opens java.base/java.net=ALL-UNNAMED –add-opens java.base/java.nio=ALL-UNNAMED –add-opens java.base/java.lang.reflect=ALL-UNNAMED
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 600m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
9、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-lowcodedata-docker
$ docker build -t hzero-lowcodedata-jk-demo:1.12 .
构建成功：
$ docker images | grep lowcodedata
10、测试Docker镜像
测试之前先确保 redis-docker 和 mysql-docker，hzero-register , hzero-admin 容器已经启动：
$ cd /d01/hzero-dockers/hzero-lowcodedata-docker
$ docker compose up -d
看日志：docker logs hzero-lowcodedata
测试web服务：(可以正常访问）
http://localhost:8000，可以看到hzero-lowcodedata已经成功注册。
==================================================
24、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-集成平台前置机 ps-frontal 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero-ipaas/project/ps-frontal/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero-ipaas/project/ps-frontal/target
$ cp ps-frontal.jar ps-frontal.wsl.ok.jar
2、更改yml配置文件
application.yml中 数据库的主机域名改成Docker compose容器名 :mysql-hzero
url: ${SPRING_DATASOURCE_URL:jdbc:mysql://mysql-hzero:3306/hzero_platform?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true}
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成docker compose容器名：hzero-admin
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://hzero-admin:8060/hadm/config}
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：4、构建适合Docker的Jar包
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero-ipaas/project/ps-frontal/
$ cd /d02/hzero-ipaas/project/ps-frontal/
$ bash build.sh
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-frontal-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-frontal-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero-ipaas\project\ps-frontal\target\ps-frontal.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-frontal-docker\
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-license\licenseAgent\license-agent110.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-frontal-docker\
7、编辑Dockerfile
$ cd /d01/hzero-dockers/hzero-frontal-docker
$ vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-frontal.jar /ps-frontal.jar
COPY license-agent110.jar /license-agent110.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-frontal.jar
8、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-frontal:
image: hzero-frontal-jk-demo:1.12
container_name: hzero-frontal
ports:
– “8155:8155”
– “8156:8156”
environment:
– JAVA_OPTS=-Xms200m -Xmx350m -Dspring.profiles.active=dev
– AGENT=-javaagent:/license-agent110.jar
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 700m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
9、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-frontal-docker
$ docker build -t hzero-frontal-jk-demo:1.12 .
构建成功：
$ docker images | grep frontal
10、测试Docker镜像
测试之前先确保 redis-docker 和 mysql-docker，hzero-register , hzero-admin 容器已经启动：
$ cd /d01/hzero-dockers/hzero-frontal-docker
$ docker compose up -d
看日志：docker logs hzero-frontal
看注册中心：
http://localhost:8000，可以看到frontal服务的已经正常注册。
==================================================
25、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-集成平台编排服务 ps-orchestration-all 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero-ipaas/project/ps-orchestration-all/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero-ipaas/project/ps-orchestration-all/target
$ cp ps-orchestration-all.jar ps-orchestration-all.wsl.ok.jar
2、更改yml配置文件
application.yml中 数据库的主机域名改成Docker compose容器名 :mysql-hzero
url: ${SPRING_DATASOURCE_URL:jdbc:mysql://mysql-hzero:3306/hzero_platform?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true}
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
application.yml中 mongo数据库主机域名改成Docker composer容器名 :mongo-hzero
mongodb:
uri: ${SPRING_MONGODB_URI:mongodb://hzero:hzero@mongo-hzero:27017/test}
elasticsearch:
application.yml中 elasticsearch数据库主机域名
# 地址，支持多地址，逗号分隔
host: ${ELASTICSEARCH_HOST:elasticsearch-hzero}
application.yml中 #seta 注册中心 hzero-register
application.yml中 #orchestration网关：
orchestration:
server-uri: ${HZERO_ORCHESTRATION_SERVER_URI:http://hzero-gateway}
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成docker compose容器名：hzero-admin
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://hzero-admin:8060/hadm/config}
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：4、构建适合Docker的Jar包
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero-ipaas/project/ps-orchestration-all/
$ cd /d02/hzero-ipaas/project/ps-orchestration-all/
$ bash build.sh
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-orchestration-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-orchestration-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero-ipaas\project\ps-orchestration-all\target\ps-orchestration-all.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-orchestration-docker\
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-license\licenseAgent\license-agent110.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-orchestration-docker\
7、编辑Dockerfile
cd /d01/hzero-dockers/hzero-orchestration-docker
vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-orchestration-all.jar /ps-orchestration-all.jar
COPY license-agent110.jar /license-agent110.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-orchestration-all.jar
8、编辑docker-compose.yml
vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-orchestration:
image: hzero-orchestration-all-jk-demo:1.12
container_name: hzero-orchestration
ports:
– “8185:8185”
– “8186:8186”
environment:
– JAVA_OPTS=-Xms200m -Xmx350m -Dspring.profiles.active=dev
– AGENT=-javaagent:/license-agent110.jar
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 700m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
9、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-orchestration-docker
$ docker build -t hzero-orchestration-all-jk-demo:1.12 .
构建成功：
$ docker images | grep orchestration
10、测试Docker镜像
测试之前先确保 redis-docker 和 mysql-docker，hzero-register , hzero-admin 容器已经启动：
$ cd /d01/hzero-dockers/hzero-orchestration-docker
$ docker compose up -d
看日志：docker logs hzero-orchestration
看注册中心：
http://localhost:8000，可以看到orchestration服务的已经正常注册。
==================================================
26、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-流程平台工作流服务 ps-workflow 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero-bpaas/project/ps-workflow/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero-bpaas/project/ps-workflow/target
$ cp ps-workflow.jar ps-workflow.wsl.ok.jar
2、更改yml配置文件
application.yml中 数据库的主机域名改成Docker compose容器名 :mysql-hzero
url: ${SPRING_DATASOURCE_URL:jdbc:mysql://mysql-hzero:3306/hzero_platform?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true}
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
application.yml中 hzero的lock 用的redis数据库改成：容器名：redis-hzero
hzero:
import:
transaction-control: false
lock:
pattern: single
single-server:
address: ${SPRING_REDIS_HOST:redis-hzero}
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成docker compose容器名：hzero-admin
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://hzero-admin:8060/hadm/config}
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：4、构建适合Docker的Jar包
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero-bpaas/project/ps-workflow/
$ cd /d02/hzero-bpaas/project/ps-workflow/
$ bash build.sh
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-workflow-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-workflow-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero-bpaas\project\ps-workflow\target\ps-workflow.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-workflow-docker\
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-license\licenseAgent\license-agent112a.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-workflow-docker\
7、编辑Dockerfile
$ cd /d01/hzero-dockers/hzero-workflow-docker
$ vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-workflow.jar /ps-workflow.jar
COPY license-agent112a.jar /license-agent112a.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-workflow.jar
8、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-workflow:
image: hzero-workflow-jk-demo:1.12
container_name: hzero-workflow
ports:
– “8165:8165”
– “8166:8166”
environment:
– JAVA_OPTS=-Xms500m -Xmx800m -Dspring.profiles.active=dev
– AGENT=-javaagent:/license-agent112a.jar
– REFLEC_OPTS=–add-opens java.base/java.lang=ALL-UNNAMED –add-opens java.base/java.util=ALL-UNNAMED –add-opens java.base/java.util.concurrent=ALL-UNNAMED –add-opens java.base/jdk.internal.loader=ALL-UNNAMED –add-opens java.base/java.net=ALL-UNNAMED –add-opens java.base/java.nio=ALL-UNNAMED –add-opens java.base/java.lang.reflect=ALL-UNNAMED
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 1500m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
9、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-workflow-docker
$ docker build -t hzero-workflow-jk-demo:1.12 .
构建成功：
$ docker images | grep workflow
10、测试Docker镜像
测试之前先确保 redis-docker 和 mysql-docker，hzero-register , hzero-admin 容器已经启动：
$ cd /d01/hzero-dockers/hzero-workflow-docker
$ docker compose up -d
看日志：docker logs hzero-workflow
启动失败：原因是依赖不满足，这个workflow服务之前构建的jar是可以用的，可以成功启动并注册到注册中心，后来本地maven库更改过，看起来是更改后再次打包的jar有问题了。
org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name ‘flowExecuteServiceImpl’ defined in URL [jar:nested:/ps-workflow.jar/!BOOT-INF/lib/hzero-boot-modeler-event-driver-2.10.0-1.12.RELEASE.jar!/org/hzero/boot/modeler/event/domain/service/impl/FlowExecuteServiceImpl.class]: Unsatisfied dependency expressed through constructor parameter 4: Error creating bean with name ‘eventEncryptHelper’: Lookup method resolution failed
解决方案：把POM中的这一段去掉，重新构建jar 和docker镜像（不需要其作为低代码领域的业务微服务）
org.hzero.boot
hzero-boot-modeler-driver
2.10.0-1.12.RELEASE
org.hzero.boot
hzero-boot-modeler-client
2.10.0-1.12.RELEASE
操作：
环境：Ubuntu-22.04-hzero
$ cd /d02/hzero-bpaas/project/ps-workflow
$ cp pom.xml pom.xml.bak20251124-OK
$ cd /d02/hzero-bpaas/project/ps-workflow/
$ bash build.sh
windows 环境 PowShell 执行：
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero-bpaas\project\ps-workflow\target\ps-workflow.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-workflow-docker\
9、构建Docker镜像
环境：Ubuntu-22.04
$ cd /d01/hzero-dockers/hzero-workflow-docker
$ docker compose down
$ docker build -t hzero-workflow-jk-demo:1.12 .
$ docker compose up -d
看日志，这次成功了，在注册中心可以看到workflow已成功注册。
==================================================
27、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-AI平台APP服务 ps-aip-app 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero-aipaas/project/ps-aip-app/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero-aipaas/project/ps-aip-app/target
$ cp ps-aip-app.jar ps-aip-app.wsl.ok.jar
2、更改yml配置文件
application.yml中 数据库的主机域名改成Docker compose容器名 :mysql-hzero
url: ${SPRING_DATASOURCE_URL:jdbc:mysql://mysql-hzero:3306/hzero_platform?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true}
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :elasticsearch-hzero
elasticsearch:
hosts: ${ELASTICSEARCH_HOSTS:https://elasticsearch-hzero:9200}
application.yml中 python执行器的主机域名 改成Docker composer容器名 :hzero-hype
python:
# python脚本执行地址
gateway-path: ${HZERO_AIP_AGENT_PYTHON_GATEWAY_PATH:http://hype-hzero:10088}
application.yml中 HKMS切片执行器的主机域名 改成Docker composer容器名 :hzero-hkms
llama:
gateway-path: ${HZERO_KNOWLEDGE_LLAMA_GATEWAY_PATH:http://hzero-hkms:18080}
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成docker compose容器名：hzero-admin
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://hzero-admin:8060/hadm/config}
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：4、构建适合Docker的Jar包
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero-aipaas/project/ps-aip-app/
$ cd /d02/hzero-aipaas/project/ps-aip-app/
$ bash build.sh
构建失败，错误信息：
[ERROR] Failed to execute goal on project ps-aip-app-snapshot: Could not resolve dependencies for project org.hzero:ps-aip-app-snapshot:jar:1.6.1.ALPHA.1.3: Could not find artifact com.volcengine:volc-sdk-java:jar:2.0.5-SNAPSHOT in Hzero (https://nexus.saas.hand-china.com/repository/hzero/) -> [Help 1]
分析：
这个之前是构建成功的，POM文件内容没有变化，失败原因是 volc-sdk-java:jar:2.0.5-SNAPSHOT找不到了，这个好像是火山引擎的SDK吧。
跟产研沟通了下，给的建议是
1、这个依赖在库里确实没有了。
2、建议升级到最新版：
hzero-aip-server 1.6.1.ALPHA.4
hzero-aip-app 1.6.1.ALPHA.4
hzero-front-haip 1.6.1-alpha.4
执行：按建议升级，具体升级过程参考 Unbntu-22.04-hzero /d02/更新日志.txt
升级完成后，构建成功，继续执行后续步骤。
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-aipapp-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-aipapp-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero-aipaas\project\ps-aip-app\target\ps-aip-app.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-aipapp-docker\
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-license\licenseAgent\license-agent112a.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-aipapp-docker\
7、编辑Dockerfile
$ cd /d01/hzero-dockers/hzero-aipapp-docker
$ vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-aip-app.jar /ps-aip-app.jar
COPY license-agent112a.jar /license-agent112a.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-aip-app.jar
8、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-aip-app:
image: hzero-aip-app-jk-demo:1.12
container_name: hzero-aip-app
ports:
– “8088:8088”
– “8089:8089”
environment:
– JAVA_OPTS=-Xms500m -Xmx1500m -Dspring.profiles.active=dev
– AGENT=-javaagent:/license-agent112a.jar
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 2500m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
9、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-aipapp-docker
$ docker build -t hzero-aip-app-jk-demo:1.12 .
构建成功：
$ docker images | grep aip-app
10、测试Docker镜像
测试之前先确保 redis-docker 和 mysql-docker，hzero-register , hzero-admin 容器已经启动：
$ cd /d01/hzero-dockers/hzero-aipapp-docker
$ docker compose up -d
看日志：docker logs hzero-aip-app，OK的
看注册中心，在注册中心可以看到workflow已成功注册。
==================================================
28、制作HZERO PaaS 平台 1.12版本的Demo环境的HZERO 微服务-AI平台Server服务 ps-aip-server 镜像
一、来源环境：
环境：WSL：Ubuntu-22.04-hzero系统
1、来源环境先备份
$ cd /d02/hzero-aipaas/project/ps-aip-server/src/main/resources
$ cp application.yml application.wsl.ok.yml
$ cp bootstrap.yml bootstrap.wsl.ok.yml
$ cd /d02/hzero-aipaas/project/ps-aip-server/target
$ cp ps-aip-server.jar ps-aip-server.wsl.ok.jar
2、更改yml配置文件
application.yml中 数据库的主机域名改成Docker compose容器名 :mysql-hzero
url: ${SPRING_DATASOURCE_URL:jdbc:mysql://mysql-hzero:3306/hzero_platform?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true}
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :redis-hzero
redis:
host: ${SPRING_DATA_REDIS_HOST:redis-hzero}
application.yml中 mongo数据库的主机域名 改成Docker composer容器名 :mongo-hzero
mongodb:
uri: ${SPRING_DATA_MONGODB_URI:mongodb://hzero:hzero@mongo-hzero:27017/haip?authSource=admin}
application.yml中 redis数据库的主机域名 改成Docker composer容器名 :elasticsearch-hzero
elasticsearch:
hosts: ${ELASTICSEARCH_HOSTS:https://elasticsearch-hzero:9200}
application.yml中 python执行器的主机域名 改成Docker composer容器名 :hzero-hype
python:
# python脚本执行地址
gateway-path: ${HZERO_AIP_AGENT_PYTHON_GATEWAY_PATH:http://hype-hzero:10088}
application.yml中 HKMS切片执行器的主机域名 改成Docker composer容器名 :hzero-hkms
llama:
gateway-path: ${HZERO_KNOWLEDGE_LLAMA_GATEWAY_PATH:http://hzero-hkms:18080}
bootstrap.yml 中 注册中心的主机域名地址改成docker compose容器名 ：hzero-register
# 注册中心地址
defaultZone: ${EUREKA_DEFAULT_ZONE:http://hzero-register:8000/eureka}
bootstrap.yml中 配置中心的主机域名地址改成docker compose容器名：hzero-admin
# 配置中心地址
uri: ${SPRING_CLOUD_CONFIG_URI:http://hzero-admin:8060/hadm/config}
去掉：
preferred-networks[0]: ${PREFERRED_IP}
增加
ignored-interfaces:
– lo
– docker0
– veth.*
3、复制Jar包构建脚本：4、构建适合Docker的Jar包
$ cp /d02/hzero/project/ps-register/build.sh /d02/hzero-aipaas/project/ps-aip-server/
$ cd /d02/hzero-aipaas/project/ps-aip-server/
$ bash build.sh
二、目标环境：
环境：WSL：Ubuntu-22.04系统
5、建立hzero-aipserver-docker目录
$ cd /d01/hzero-dockers
$ mkdir hzero-aipserver-docker
6、拷贝Jar包到目标环境
在windows powershell 中执行
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero-aipaas\project\ps-aip-server\target\ps-aip-server.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-aipserver-docker\
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\project\ps-license\licenseAgent\license-agent112a.jar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-aipserver-docker\
7、编辑Dockerfile
$ cd /d01/hzero-dockers/hzero-aipserver-docker
$ vi Dockerfile
FROM registry.cn-shanghai.aliyuncs.com/c7n/javabase:17
COPY ps-aip-server.jar /ps-aip-server.jar
COPY license-agent112a.jar /license-agent112a.jar
ENV JAVA_TOOL_OPTIONS -Dfile.encoding=UTF8 -Duser.language=zh -Duser.region=zh_CN -Duser.country=zh_CN
ENTRYPOINT exec java -XX:+UnlockExperimentalVMOptions $JAVA_OPTS $REFLEC_OPTS $AGENT $SKYWALKING_OPTS -jar /ps-aip-server.jar
8、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-aip-server:
image: hzero-aip-server-jk-demo:1.12
container_name: hzero-aip-server
ports:
– “8270:8270”
– “8271:8271”
environment:
– JAVA_OPTS=-Xms500m -Xmx2000m -Dspring.profiles.active=dev
– AGENT=-javaagent:/license-agent112a.jar
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 3000m # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
networks:
default:
name: hzero-demo
external: true
9、构建Docker镜像
$ cd /d01/hzero-dockers/hzero-aipserver-docker
$ docker build -t hzero-aip-server-jk-demo:1.12 .
构建成功：
$ docker images | grep aip-server
10、测试Docker镜像
测试之前先确保 redis-docker 和 mysql-docker，hzero-register , hzero-admin 容器已经启动：
$ cd /d01/hzero-dockers/hzero-aipserver-docker
$ docker compose up -d
看日志：docker logs hzero-aip-server，OK的
看注册中心，在注册中心可以看到aip已成功注册。
==================================================
29、启动docker compose 容器 Python沙箱 hzero-hype
二、目标环境：
环境：WSL：Ubuntu-22.04系统
1、建立hzero-hype目录
$ cd /d01/hzero-dockers
$ mkdir hzero-hype-docker
$ cd /d01/hzero-dockers/hzero-hype-docker
2、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-hype:
container_name: hzero-hype
image: registry.hand-china.com/hzero-public/haip-python-executor:0.2
privileged: true
environment:
WORKERNUM: 8
TIMEOUT: 800
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 500m # 容器最大内存（python应用直接限制内存大小）
ports:
– “10080:80”
networks:
default:
name: hzero-demo
external: true
3、测试Docker 容器
$ cd /d01/hzero-dockers/hzero-hype-docker
$ docker compose up -d
出错了：
[+] Running 1/1
✘ hzero-hype Error failed to resolve reference “registry.hand-china.com/hzero-public/haip-python-executor:0.2”: failed to do reques… 5.1s
Error response from daemon: failed to resolve reference “registry.hand-china.com/hzero-public/haip-python-executor:0.2”: failed to do request: Head “https://registry.hand-china.com/v2/hzero-public/haip-python-executor/manifests/0.2”: EOF
看起来是无法从库里面拉取了。
不过我之前拉取过，可以从ubuntu-22.04-hzero的docker镜像库中导出来，在到这边导进来。
在ubuntu-22.04-hzero环境：
$ cd /d03/dockerimagesbak
$ docker images 看下镜像列表
格式：docker save -o 导出文件名 镜像名:标签
$ docker save -o haip-python-executor-0.2.tar registry.hand-china.com/hzero-public/haip-python-executor:0.2
拷贝 这个haip-python-executor-0.2.tar 到ubuntu-22.04 /d01/hzero-dockers/hzero-hype目录下
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d03\dockerimagesbak\haip-python-executor-0.2.tar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-hype-docker\
进入Ubuntu-22.04\d01\hzero-dockers\hzero-hype-docker\ ，导入镜像
格式：docker load -i 镜像文件.tar
$ docker load -i haip-python-executor-0.2.tar
导入成功：Loaded image: registry.hand-china.com/hzero-public/haip-python-executor:0.2
再次启动：docker compose up -d
看日志：docker logs hzero-hype
启动成功
==================================================
30、启动docker compose 容器 文档切片服务 hzero-hkms
二、目标环境：
环境：WSL：Ubuntu-22.04系统
1、建立hzero-hkms目录
$ cd /d01/hzero-dockers
$ mkdir hzero-hkms-docker
$ cd /d01/hzero-dockers/volumes
$ mkdir hkms
windows powershell 中执行：原有数据迁移
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero-aipaas\hzero-aigc-docker-compose\hkms\nginx.conf \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\volumes\hkms\
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero-aipaas\hzero-aigc-docker-compose\hkms\app.log \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\volumes\hkms\
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero-aipaas\hzero-aigc-docker-compose\hkms\logs \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\volumes\hkms\
设置 hkms 数据目录的所有者为 UID=1000 的用户
$ cd /d01/hzero-dockers/hzero-hkms-docker
$ sudo chown -R 33:33 ../volumes/hkms
$ sudo chmod -R 755 ../volumes/hkms
$ cd /d01/hzero-dockers/hzero-hkms-docker
2、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
hzero-hkms:
container_name: hzero-hkms
image: registry.hand-china.com/hzero-public/hkms-python:1.6.1
# command: sh -c “apt-get update && apt-get install -y iputils-ping
environment:
# HKMS服务进程数量
WORKERNUM: 16
OPENAI_PROXY: “”
# MongoDB地址
MONGO_CONN: mongodb://hzer:hzero@mongo-hzero:27017/hgpt?authSource=admin&authMechanism=SCRAM-SHA-1
# APP URL
HAIP_HOST: http://hzero-aip-app:8088
# 网关地址
FILE_SERVICE_HOST: http://hzero-gateway:8080
# 调用soffice转换文件类型（doc、ppt）时的超时时间，单位：秒。
EMBED_CONVERT_TIME: “120”
# 同步文档向量时，如果文档总长度超过该值（按token计）会中止，不进行向量计算。单位：万token
EMBED_MAX_TEXT_LENGTH: “300”
# 当普通文本中包含源代码块（Markdown格式）时，源代码不参与文本切片时的切片大小计算。但是当源代码块长度超过这个参数设定的值（字符数）时，会进行片段分割（在源代码块前或后，会保持源代码块的完整）。单位：字符。
SRC_BLK_THRESHOLD: “4000”
# 当单个代码块的长度超过此上限时，截断超过部分。单位：字符。
SRC_BLK_THRESHOLD_UPPER: “50000”
# 从向量库、ElasticSearch检索时返回的最大结果数。
EMBED_QUERY_LIMIT_CHUNK: “30”
# 开启debug日志
LOG_CONFIG_FILE: ./bin/log_debug.conf
# 代码插件配置
#ENABLE_CODE_SYNC: “no”
#ASYNC_RDB_URL: “mysql+aiomysql://${MYSQL_USERNAME}:${MYSQL_PASSWORD}@${MYSQL_URL}/hzero_aip”
#RDB_URL: “mysql+pymysql://${MYSQL_USERNAME}:${MYSQL_PASSWORD}@${MYSQL_URL}/hzero_aip”
#CODESYNC_ASYNC_MODE: “no”
# 异步处理配置
#ENABLE_CELERY: “no”
#CELERY_BROKER: “redis://:${REDIS_PASSWORD}@${REDIS_HOST}:${REDIS_PORT}/14”
#CELERY_BACKEND: “redis://:${REDIS_PASSWORD}@${REDIS_HOST}:${REDIS_PORT}/14”
#CELERY_LOG_LEVEL: “DEBUG”
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 3.5g # 容器最大内存（python应用直接限制内存）
volumes:
– ${DOCKER_VOLUME_DIRECTORY:-../volumes}/hkms/nginx.conf:/etc/nginx/sites-available/default
– ${DOCKER_VOLUME_DIRECTORY:-../volumes}/hkms/app.log:/root/hkms/bin/app.log
– ${DOCKER_VOLUME_DIRECTORY:-../volumes}/hkms/logs:/root/hkms/logs
ports:
– “18080:80”
networks:
default:
name: hzero-demo
external: true
3、测试Docker 容器
$ cd /d01/hzero-dockers/hzero-hkms-docker
$ docker compose up -d
出错了：
[+] Running 1/1
✘ hzero-hkms Error failed to resolve reference “registry.hand-china.com/hzero-public/hkms-python:1.6.1”: failed to do request: Head… 5.5s
Error response from daemon: failed to resolve reference “registry.hand-china.com/hzero-public/hkms-python:1.6.1”: failed to do request: Head “https://registry.hand-china.com/v2/hzero-public/hkms-python/manifests/1.6.1”: EOF
分析：
看起来是无法从库里面拉取了。
不过我之前拉取过，可以从ubuntu-22.04-hzero的docker镜像库中导出来，在到这边导进来。
执行：
在ubuntu-22.04-hzero环境：
$ cd /d03/dockerimagesbak
$ docker images 看下镜像列表
格式：docker save -o 导出文件名 镜像名:标签
$ docker save -o hkms-python-1.6.1.tar registry.hand-china.com/hzero-public/hkms-python:1.6.1
拷贝 这个hkms-python-1.6.1.tar 到ubuntu-22.04 /d01/hzero-dockers/hzero-hkms-docker目录下
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d03\dockerimagesbak\hkms-python-1.6.1.tar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\hzero-hkms-docker\
进入Ubuntu-22.04\d01\hzero-dockers\hzero-hkms-docker\ ，导入镜像
格式：docker load -i 镜像文件.tar
$ docker load -i hkms-python-1.6.1.tar
导入成功：Loaded image: registry.hand-china.com/hzero-public/hkms-python:1.6.1
再次启动：docker compose up -d
看日志：docker logs hzero-hkms
正常启动了
==================================================
31、启动docker compose 容器 图数据库 neo4j
二、目标环境：
环境：WSL：Ubuntu-22.04系统
1、建立neo4j-docker目录
$ cd /d01/hzero-dockers
$ mkdir neo4j-docker
windows powershell 中执行：原有数据迁移
$ cp -r \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero-aipaas\hzero-aigc-docker-compose\neo4j\volumes\neo4j \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\volumes\
$ cd /d01/hzero-dockers/neo4j-docker
2、编辑docker-compose.yml
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
neo4j-hzero:
image: registry.hand-china.com/hzero-public/neo4j:5.16.0
container_name: neo4j-hzero
ports:
– “7474:7474”
– “7687:7687”
environment:
– NEO4J_apoc_export_file_enabled=true
– NEO4J_apoc_import_file_enabled=true
– NEO4J_apoc_import_file_use__neo4j__config=true
– NEO4J_PLUGINS=[“apoc”]
– NEO4J_AUTH=neo4j/password
– ES_JAVA_OPTS=-Xms500m -Xmx500m # 设置 JVM 堆内存为 500M
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 1g # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
volumes:
– ${DOCKER_VOLUME_DIRECTORY:-../volumes}/neo4j/data:/data
– ${DOCKER_VOLUME_DIRECTORY:-../volumes}/neo4j/plugins:/plugins
networks:
default:
name: hzero-demo
external: true
3、测试Docker 容器
$ cd /d01/hzero-dockers/neo4j-docker
$ docker compose up -d
出错了：
[+] Running 1/1
✘ neo4j-hzero Error failed to resolve reference “registry.hand-china.com/hzero-public/neo4j:5.16.0”: failed to do request: Head “h… 5.2s
Error response from daemon: failed to resolve reference “registry.hand-china.com/hzero-public/neo4j:5.16.0”: failed to do request: Head “https://registry.hand-china.com/v2/hzero-public/neo4j/manifests/5.16.0”: EOF
分析：
看起来是无法从库里面拉取了。
不过我之前拉取过，可以从ubuntu-22.04-hzero的docker镜像库中导出来，在到这边导进来。
执行：
在ubuntu-22.04-hzero环境：
$ cd /d03/dockerimagesbak
$ docker images 看下镜像列表
格式：docker save -o 导出文件名 镜像名:标签
$ docker save -o neo4j-5.16.0.tar registry.hand-china.com/hzero-public/neo4j:5.16.0
拷贝 这个neo4j-5.16.0.tar 到ubuntu-22.04 /d01/hzero-dockers/neo4j-docker目录下
$ cp \wsl.localhost\Ubuntu-22.04-hzero\d03\dockerimagesbak\neo4j-5.16.0.tar \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\neo4j-docker\
进入Ubuntu-22.04\d01\hzero-dockers\neo4j-docker\ ，导入镜像
格式：docker load -i 镜像文件.tar
$ docker load -i neo4j-5.16.0.tar
导入成功：Loaded image: registry.hand-china.com/hzero-public/neo4j:5.16.0
再次启动：docker compose up -d
看日志：docker logs neo4j-hzero
正常启动了
==================================================
32、启动docker 容器 web服务器 nginx
二、目标环境：
环境：WSL：Ubuntu-22.04系统
1、建立nginx-docker目录
$ cd /d01/hzero-dockers
$ mkdir nginx-docker
$ cd /d01/hzero-dockers/volumes
$ mkdir nginx
$ cd /d01/hzero-dockers/volumes/nginx
windows powershell:复制前端文件 和nginx配置文件
$ cp -r \wsl.localhost\Ubuntu-22.04-hzero\d02\hzero\front\dist \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\volumes\nginx\
$ cp \wsl.localhost\Ubuntu-22.04-hzero\etc\nginx\sites-available\default \wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\volumes\nginx\nginx.conf
编辑\wsl.localhost\Ubuntu-22.04\d01\hzero-dockers\volumes\nginx\nginx.conf
把root目录改成指向 /usr/share/nginx/html
root /usr/share/nginx/html;
location ^~ /mobile-provider {
root /usr/share/nginx/html/packages;
aigc.hzero.com.cn 专用服务器
# 改为后端服务实际IP:端口
proxy_pass http://hzero-aip-app:8088; # 示例：假设后端在本机8088
把433端口的服务Serve配置全部去掉
2、编辑docker-compose.yml
$ cd /d01/hzero-dockers/nginx-docker
$ vi docker-compose.yml
services:
nginx-hzero:
image: nginx:latest
container_name: nginx-hzero
restart: always
ports:
– “80:80”
volumes:
– ${DOCKER_VOLUME_DIRECTORY:-../volumes}/nginx/dist:/usr/share/nginx/html
– ${DOCKER_VOLUME_DIRECTORY:-../volumes}/nginx/nginx.conf:/etc/nginx/conf.d/default.conf
networks:
default:
name: hzero-demo
external: true
3、测试Docker 容器
$ cd /d01/hzero-dockers/nginx-docker
$ docker compose up -d
$ docker logs nginx-hzero
成功启动
4、测试页面
输入 http://dev.hzero.com.cn
出来首页，但马上报错
http://hzero-gateway:8080/oauth/login
分析：因为容器中 网关地址用了容器名，但现在是在外面，所以解析不到；
解决方案：
在hosts文件中把hzero-gateway 的解析加上
172.18.14.48 hzero-gateway # API网关地址
加上之后可以正常访问 admin/Admin@123!
==================================================
33、启动docker compose 容器 onlyoffice
二、目标环境：
环境：WSL：Ubuntu-22.04系统
1、建立onlyoffice-docker目录
$ cd /d01/hzero-dockers
$ mkdir onlyoffice-docker
建立onlyoffce的volumes目录
$ cd /d01/hzero-dockers/volumes
$ mkdir -p onlyoffice/DocumentServer/{logs,data,lib,db}
$ sudo chown -R 998:998 onlyoffice/DocumentServer
$ sudo chmod -R 755 onlyoffice/DocumentServer
$ sudo chown -R 999:999 onlyoffice/DocumentServer/db
$ sudo chmod -R 755 onlyoffice/DocumentServer/db
2、编辑docker-compose.yml
$cd /d01/hzero-dockers/ onlyoffice-docker
$ vi docker-compose.yml
要求Docker/Docker CE >= 19.x
services:
onlyoffice-hzero:
image: onlyoffice/documentserver
container_name: onlyoffice-hzero
ports:
– “8800:80”
environment:
– JWT_SECRET=your-secret-key # 建议添加JWT密钥（可选但推荐）
– TZ=Asia/Shanghai # 设置时区
deploy: # 限制容器总内存（Docker Compose v2.3+）
resources:
limits:
memory: 2g # 容器最大内存（建议为 JVM 内存的 1.5~2 倍）
volumes:
– ${DOCKER_VOLUME_DIRECTORY:-../volumes}/onlyoffice/DocumentServer/logs:/var/log/onlyoffice
– ${DOCKER_VOLUME_DIRECTORY:-../volumes}/onlyoffice/DocumentServer/data:/var/www/onlyoffice/Data
– ${DOCKER_VOLUME_DIRECTORY:-../volumes}/onlyoffice/DocumentServer/lib:/var/lib/onlyoffice
– ${DOCKER_VOLUME_DIRECTORY:-../volumes}/onlyoffice/DocumentServer/db:/var/lib/postgresql
networks:
default:
name: hzero-demo
external: true
3、测试Docker 容器
$ cd /d01/hzero-dockers/onlyoffice-docker
$ docker compose up -d
看日志：docker logs onlyoffice-hzero
正常启动了
