使用shell、dockerfile、buildx、docker-compose整合构建多个jar包并实现一键发布项目

执行脚本

执行脚本时，构建了不同架构的镜像，需要注意的是docker版本需要支持buildx才可以，并且已经下载好不同架构的模拟器。我用的docker版本是 24.0.5；
执行脚本时，需要传一个值进去，例如：1.6.9（版本号）

执行构建jar的脚本

# build-giacpimages

#!/bin/bash

version=$1
echo "${version}"
#--platform 构建不同架构的镜像
function build_and_push_image() {
  local platform=$1
  local repo=$2
  local project_dir=$3

  docker build --platform ${platform} -f ${project_dir}/Dockerfile -t ${repo}:${version} ${project_dir}
  docker push ${repo}:${version}
}

#批次调用函数
build_and_push_image linux/amd64 192.168.6.30:8443/giacp-amd64/eureka ../giacp-eureka
build_and_push_image linux/arm64 192.168.6.30:8443/giacp-arm64/eureka ../giacp-eureka

build_and_push_image linux/amd64 192.168.6.30:8443/giacp-amd64/gateway ../giacp-gateway
build_and_push_image linux/arm64 192.168.6.30:8443/giacp-arm64/gateway ../giacp-gateway

build_and_push_image linux/amd64 192.168.6.30:8443/giacp-amd64/core ../giacp-core
build_and_push_image linux/arm64 192.168.6.30:8443/giacp-arm64/core ../giacp-core

build_and_push_image linux/amd64 192.168.6.30:8443/giacp-amd64/device ../giacp-device
build_and_push_image linux/arm64 192.168.6.30:8443/giacp-arm64/device ../giacp-device

build_and_push_image linux/amd64 192.168.6.30:8443/giacp-amd64/media ../giacp-media
build_and_push_image linux/arm64 192.168.6.30:8443/giacp-arm64/media ../giacp-media

build_and_push_image linux/amd64 192.168.6.30:8443/giacp-amd64/monitor ../giacp-system-monitor
build_and_push_image linux/arm64 192.168.6.30:8443/giacp-arm64/monitor ../giacp-system-monitor

构建web脚本

#构建giacp-web镜像
#!/bin/bash
version=$1
echo "${version}"
docker build --platform linux/amd64 -f ./Dockerfile -t 192.168.6.30:8443/giacp-amd64/giacp-web:${version} .
docker build --platform linux/arm64 -f ./Dockerfile -t 192.168.6.30:8443/giacp-arm64/giacp-web:${version} .
#推送镜像
docker push 192.168.6.30:8443/giacp-amd64/giacp-web:${version}
docker push 192.168.6.30:8443/giacp-arm64/giacp-web:${version}

构建sql脚本

#!/bin/bash

version=$1
echo "${version}"

#--build-arg 实现在构建的时候传递参数
docker build --platform linux/amd64 --build-arg variable="${version}" -f ../Dockerfile -t 192.168.6.30:8443/giacp-amd64/mysql:8.0.33-giacp-sql-${version} ../
docker build --platform linux/arm64 --build-arg variable="${version}" -f ../Dockerfile -t 192.168.6.30:8443/giacp-arm64/mysql:8.0.33-giacp-sql-${version} ../
# #推送amd架构镜像
docker push 192.168.6.30:8443/giacp-amd64/mysql:8.0.33-giacp-sql-${version}
# #推送arm架构镜像
docker push 192.168.6.30:8443/giacp-arm64/mysql:8.0.33-giacp-sql-${version}

推送到harbor镜像仓库

推送到harbor仓库的前提是要搭建好仓库，并创建好项目。

dockerfile文件

minio的dockerfile文件

# 基础镜像
FROM minio/minio:latest
# 设置环境变量
ENV MINIO_ROOT_USER="admin"
ENV MINIO_ROOT_PASSWORD="12345678"
# 暴露的端口
EXPOSE 9005
EXPOSE 9010
# 设置工作目录
WORKDIR /data
# 启动命令
CMD ["server", "/data", "--console-address", ":9005", "-address", ":9010"]

redis的dockerfile文件

# 基础镜像
FROM redis:6.2.4
# 复制配置文件到容器
COPY ./redis_docker/conf/redis.conf /etc/redis/redis.conf
# 暴露的端口
EXPOSE 6379
# 启动命令
CMD ["redis-server", "/etc/redis/redis.conf"]

redis配置文件

# Redis默认不是以守护进程的方式运行，可以通过该配置项修改，使用yes启用守护进程(此处必须是no，不然启动不了)
daemonize  no
# 你可以绑定单一接口，如果没有绑定，所有接口都会监听到来的连接
bind 0.0.0.0
# 因为redis本身同步数据文件是按上面save条件来同步的，所以有的数据会在一段时间内只存在于内存中。默认为no
appendonly no
# 设置Redis连接密码，如果配置了连接密码，客户端在连接Redis时需要通过
# auth <password>命令提供密码，默认关闭，当前密码为1111
requirepass redis123

mysql的dockerfile文件

# Dockerfile

# 基于指定的 MySQL 镜像开始构建
FROM mysql:8.0.33

# 设置容器的环境变量
ENV MYSQL_ROOT_PASSWORD=root123
ENV MYSQL_USER=user01
ENV MYSQL_PASSWORD=user01
ENV MYSQL_DATABASE=giacp

#定义了一个构建时变量,使用variable接受传进来的值
ARG variable 
#构建时变量赋值给一个运行时环境变量，把variable 设置成环境变量
ENV MY_VARIABLE=${variable}


# 将 SQL 文件复制到容器中
COPY GIACP-${MY_VARIABLE}/giacp-init-structure-1.6.7.sql /docker-entrypoint-initdb.d/giacp-init-structure-${MY_VARIABLE}.sql
COPY GIACP-${MY_VARIABLE}/giacp-init-data-${MY_VARIABLE}.sql /docker-entrypoint-initdb.d/giacp-init-data-${MY_VARIABLE}.sql

# 将配置文件复制到容器中
COPY conf/my.cnf /etc/mysql/conf.d/my.cnf

RUN echo '#!/bin/bash' > /docker-entrypoint-initdb.d/init.sh \
  && echo "mysql -u root -p\$MYSQL_ROOT_PASSWORD -D giacp < /docker-entrypoint-initdb.d/giacp-init-structure-\$MY_VARIABLE.sql" >> /docker-entrypoint-initdb.d/init.sh \
  && echo "mysql -u root -p\$MYSQL_ROOT_PASSWORD -D giacp < /docker-entrypoint-initdb.d/giacp-init-data-\$MY_VARIABLE.sql" >> /docker-entrypoint-initdb.d/init.sh \
  && chmod +x /docker-entrypoint-initdb.d/init.sh
# 将数据目录挂载到容器中
# VOLUME /var/lib/mysql

# 暴露 MySQL 服务的端口
EXPOSE 3306

# 执行初始化脚本
ENTRYPOINT ["bash", "-c", "docker-entrypoint.sh mysqld"]

mysql配置文件

mysql配置是更具项目需求配置，这里注意mysql的路径

[client]
port = 3306
socket = /tmp/mysql.sock

[mysqld]
init-connect='SET NAMES utf8'
basedir=/var/lib/mysql   #根据自己的安装目录填写
datadir=/var/lib/mysql/data #根据自己的mysql数据目录填写
socket=/tmp/mysql.sock
max_connections=200 # 允许最大连接数
character-set-server=utf8mb4 # 服务端使用的字符集默认为8比特编码的latin1字符集
default-storage-engine=INNODB # 创建新表时将使用的默认存储引擎

sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES
#sql_mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
#sql_mode='STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION'

log-error=/var/lib/mysql/data/error.log #输出告警日志
# 慢查询日志,慢查询设置为2秒，超过2秒的查询会被写入慢查询日志
slow_query_log = on
long_query_time = 2
slow-query-log-file = /var/lib/mysql/data/slow.log
expire_logs_days=5
lower_case_table_names=1 #1表示不区分大小写 0表示默认区分
#开启mysql的查询缓存
#query_cache_type = 1

performance_schema_accounts_size = 100
performance_schema_hosts_size = 100
performance_schema_max_cond_instances = 6900
performance_schema_max_file_classes = 50
performance_schema_max_mutex_instances = 21000
performance_schema_max_rwlock_instances = 10800
performance_schema_max_table_handles = 4000
performance_schema_max_thread_instances = 2100
performance_schema_setup_actors_size = 100
performance_schema_setup_objects_size = 100
performance_schema_users_size = 100
max_seeks_for_key = 4294967295
max_write_lock_count = 4294967295
myisam_max_sort_file_size = 2146435072
key_buffer_size = 16k
max_allowed_packet = 1M
thread_stack = 512k
sort_buffer_size = 64k
net_buffer_length = 2k
performance_schema_max_table_instances = 12500
table_open_cache_instances = 1
eq_range_index_dive_limit = 10

sync_binlog = 0
innodb_buffer_pool_size = 8M
innodb_log_buffer_size = 1M

performance_schema = off

eureka的dockerfile文件

FROM openjdk:8-jdk

COPY target/classes/application.yml /app.yml
COPY target/classes/application-jxd.yml /dev.yml
COPY target/*.jar /app.jar
ENTRYPOINT ["java", "-jar", "/app.jar", "--spring.config.location=/dev.yml","--spring.config.location=/app.yml"]

gateway的dockerfile文件

FROM openjdk:8-jdk

COPY target/classes/application.yml /app.yml
COPY target/classes/application-jxd.yml /dev.yml
COPY target/*.jar /app.jar

ENTRYPOINT ["java", "-jar", "/app.jar", "--spring.config.location=/dev.yml","--spring.config.location=/app.yml"]

core的dockerfile文件

FROM ubuntu:latest
RUN apt-get update && apt-get install -y net-tools libasound2 openjdk-8-jdk

RUN fdisk -l
RUN java -version
COPY core-service/target/classes/application.yml /app.yml
COPY core-service/target/classes/application-jxd.yml /dev.yml
COPY core-service/target/*.jar /app.jar

ENTRYPOINT ["java", "-jar", "/app.jar", "--spring.config.location=/dev.yml","--spring.config.location=/app.yml"]

device的dockerfile文件

FROM openjdk:8-jdk

COPY device-service/target/classes/application.yml /app.yml
COPY device-service/target/classes/application-jxd.yml /dev.yml
COPY device-service/target/*.jar /app.jar

ENTRYPOINT ["java", "-jar", "/app.jar", "--spring.config.location=/dev.yml","--spring.config.location=/app.yml"]

media的dockerfile文件

FROM ubuntu:latest

RUN apt-get update && apt-get install -y net-tools libasound2 openjdk-8-jdk
RUN fdisk -l
RUN java -version


COPY target/classes/application.yml /app.yml
COPY target/classes/application-jxd.yml /dev.yml
COPY target/*.jar /app.jar

ENTRYPOINT ["java", "-jar", "/app.jar", "--spring.config.location=/dev.yml", "--spring.config.location=/app.yml"]

monitor的dockerfile文件

FROM openjdk:8-jdk

COPY system-monitor-service/target/classes/application.yml /app.yml
COPY system-monitor-service/target/classes/application-jxd.yml /dev.yml
COPY system-monitor-service/target/*.jar /app.jar

ENTRYPOINT ["java", "-jar", "/app.jar", "--spring.config.location=/dev.yml", "--spring.config.location=/app.yml"]

docker-compose文件内容

需要注意的是，使用docker-compose的前提是镜像已经构建完整，然后再目标服务器中执行docker-compose up一键拉取镜像、运行容器并实现一键部署。

##################
#说明：
#1.“**”代表宿主机中的实际路径；
#2. redis.conf、nginx.cnf和目录的容器挂载需要自定义，没有则创建。
#———— 以136服务器为例
##################
version: '3.3'
services:

  redis:
    image: 192.168.6.30:8443/giacp-arm64/redis:6.2.4 #下载的redis镜像名称
    container_name: redis  #容器命名
    restart: always #跟随docker启动
    networks: #加入到自定义docker网络giacp中
      - giacp
    ports: #映射端口
      - "6379:6379" # 暴露的端口(可自定义)：容器内端口

  mysql:
    image: 192.168.6.30:8443/giacp-arm64/mysql:8.0.33-giacp-sql-1.6.7
    container_name: mysql
    restart: always
    networks:
      - giacp
    volumes:
      - ./mysql_docker/data:/var/lib/mysql #挂载目录
    ports:
      - "3306:3306"

  minio:
    image: 192.168.6.30:8443/giacp-arm64/minio:latest
    container_name: minio
    restart: always
    networks:
      - giacp
    volumes:
      - ./minio_docker/data:/data
    ports:
      - "9005:9005"
      - "9010:9010"


  eureka:
    image: 192.168.6.30:8443/giacp-arm64/eureka:1.6.9
    container_name: eureka
    restart: always
    volumes:
      - ./log/eureka-server:/log/eureka-server
    networks:
      - giacp
    ports:
      - "8761:8761"
  gateway:
    image: 192.168.6.30:8443/giacp-arm64/gateway:1.6.9
    container_name: gateway
    restart: always
    volumes:
      - ./log/gateway-service:/log/gateway-service
    networks:
      - giacp
    depends_on: #等eureka启动后
      - eureka
    ports:
      - "9000:9000"
  core:
    image: 192.168.6.30:8443/giacp-arm64/core:1.6.9
    container_name: core
    restart: always
    volumes:
      - ./log/core-service:/log/core-service
    networks:
      - giacp
    depends_on:
      - redis
      - mysql
      - eureka
      - gateway
    
    ports:
      - "10001:10001"
    privileged: true
    # devices:
    #   - /dev/mapper/openeuler_node10-root:/dev/mapper/openeuler_node10-root
    # volumes: #挂载
    #   - /**/core-service:/home/giacp/log/core-service  # 宿主机路径文件：容器内路径文件
  device:
    image: 192.168.6.30:8443/giacp-arm64/device:1.6.9
    container_name: device
    restart: always
    volumes:
      - ./log/device-service:/log/device-service
    networks:
      - giacp
    depends_on:
      - redis
      - mysql
      - eureka
      - core
      - gateway
    ports:
      - "20000:20000"
      - "10002:10002"
      - "8089:8089"


  monitor:
    # build:
    #   context: ../giacp-media
    image: 192.168.6.30:8443/giacp-arm64/monitor:1.6.9
    container_name: monitor
    restart: always
    volumes:
      - ./log/system-monitor-service:/log/system-monitor-service
    networks:
      - giacp
    depends_on:
      - redis
      - mysql
      - eureka
      - core
      - gateway
    ports:
      - "10005:10005"


  media:
    # build:
    #   context: ../giacp-media
    image: 192.168.6.30:8443/giacp-arm64/media:1.6.9
    container_name: media
    restart: always
    volumes:
      - ./log/media-service:/log/media-service
    network_mode: host  #共享宿主机网络ip，实现调用media时使用宿主机ip访问
    # ports: #必须注释掉端口映射，不然启动会报错，因为用了host共享主机ip，端口就不用了
    #   - "10003:10003"
    #   - "8888:8888"
    depends_on:
      - redis
      - mysql
      - eureka
      - core
      - gateway

  giacp_web:
    image: 192.168.6.30:8443/giacp-arm64/giacp-web:1.6.9
    restart: always
    container_name: giacp_web
    #  volumes:
    #      - /usr/local/docker/docker/nginx/conf/nginx.conf:/etc/nginx/nginx.conf:ro
    #      - /usr/local/docker/docker/nginx/web:/home/giacp/web
    ports:
        - "80:80"
    volumes:
        - ./log/giacp_web/nginx:/var/log/nginx
    depends_on:
        - eureka
        - gateway
    networks:
        - giacp



#创建docker网络
networks:
  giacp: #创建一个网络为giacp的
    driver: bridge
    ipam:
      driver: default
      config:
        - subnet: 172.21.0.0/24