1、
gitlab-ci.yml中构建阶段单独构建，上传到minio缓存服务，下次构建时，只需要重新拉取缓存服务器上的依赖包，增量打包构建。

.gitlab-ci.yml中配置如下：

  1. stages:
  2.   - validate
  3.   - unit-test
  4.   - build
  5.   - package
  6.   - deploy
  7.   - .post
  9. image: registry.cn-hangzhou.aliyuncs.com/123/maven:3-jdk-8-slim
  10. ......
  12. build:jar:
  13.   stage: build
  14.   script:
  15.     - mvn  $MAVEN_OPTS -Dmaven.test.skip=true -U package deploy
  16.   tags:
  17.     - maven
  18.   artifacts:
  19.     paths:
  20.       - manage-provider/target/manage-provider*.jar
  21.     expire_in: 1 week
  22.   only:
  23.     refs:
  24.       - tags
  25.       - master
  27. build:image:
  28.   stage: package
  29.   image: gcr.azk8s.cn/kaniko-project/executor:debug
  30.   dependencies:
  31.     - build:jar
  32.   script:
  33.     - |
  34.       docker build $CI_PROJECT_DIR \
  35.       -t $IMAGE:$IMAGE_TAG \
  36.       -t $IMAGE:latest
  37.     - docker push $IMAGE:$IMAGE_TAG
  38.     - docker push $IMAGE:latest
  39.   tags:
  40.     - docker-builder
  41.   when: manual
  42.   allow_failure: false
  43.   only:
  44.     refs:
  45.       - tags
  46.       - master
  47. .....

这种方式将maven项目的package和Dockerfile制作推送分成两步，好处是可以看到每次package时候的日志输出，缺点是每次打完包都要上传依赖包到缓存服务器，加长了部署时间。
2、
Dockerfile中使用多阶段构建，只取jar包，添加到镜像中，构建在服务器上。依赖存放服务器本地或者私有镜像仓库

使用多阶段构建Dockerfile
以Java Maven项目为例，在Java Maven项目中新建Dockerfile文件，并在Dockerfile文件添加以下内容。
说明 该Dockerfile文件使用了二阶段构建。
第一阶段：选择Maven基础镜像（Gradle类型也可以选择相应Gradle基础镜像）完成项目编译，拷贝源代码到基础镜像并运行RUN命令，从而构建Jar包。
第二阶段：拷贝第一阶段生成的Jar包到OpenJDK镜像中，设置CMD运行命令。

  1. # First stage: complete build environment
  2. FROM maven:3.5.0-jdk-8-alpine AS builder
  4. # add pom.xml and source code
  5. ADD ./pom.xml pom.xml
  6. ADD ./src src/
  8. # package jar
  9. RUN mvn clean package
  11. # Second stage: minimal runtime environment
  12. From openjdk:8-jre-alpine
  14. # copy jar from the first stage
  15. COPY --from=builder target/my-app-1.0-SNAPSHOT.jar my-app-1.0-SNAPSHOT.jar
  17. EXPOSE 8080
  19. CMD ["java", "-jar", "my-app-1.0-SNAPSHOT.jar"]

这种方式将package和制作镜像，推送镜像放到了一起，省去了推送依赖包到缓存服务的时间。