Detailed steps for using jib for docker deployment in Spring Cloud

Introduction to Jib

Jib is a library developed by Google that can directly build Docker and OCI images of Java applications. It is provided in the form of Maven and Gradle plug-ins.

With Jib, Java developers can use the Java tools they are familiar with to build containers. Jib is a fast and simple container image building tool that takes care of all the steps required to package your application into a container image. It doesn't require you to write a Dockerfile or install Docker, and it integrates directly into Maven and Gradle - just add the plugin to your build and you can containerize your Java application instantly.

Jib open source address: https://github.com/GoogleContainerTools/jib

Common Docker build process

alt img

Jib build process

alt img

Jib Integration

The project is Spring Cloud, version Hoxton.SR1.

alt img

To integrate jib, you only need to add the jib plugin to pom.

<plugin>
        <groupId>com.google.cloud.tools</groupId>
        <artifactId>jib-maven-plugin</artifactId>
        <version>${jib.version}</version>
      </plugin>

Jib related complete configuration

<properties>
    <!-- jib docker config-->
    <!-- jib version -->
    <jib.version>2.2.0</jib.version>
    <!-- Whether to skip jib packaging -->
    <jib.skip>true</jib.skip>
    <!-- Warehouse image name -->
    <jib.repository.name>akk-system</jib.repository.name>
    <!-- Startup Class -->
    <jib.main.class>com.akk.GatewayApplication</jib.main.class>
    <!-- Warehouse login username -->
    <REGISTRY_USERNAME>222222222222</REGISTRY_USERNAME>
    <!-- Warehouse login password -->
    <REGISTRY_PASSWORD>111111111111</REGISTRY_PASSWORD>
</properties>

 <plugins>
    <plugin>
      <groupId>com.google.cloud.tools</groupId>
      <artifactId>jib-maven-plugin</artifactId>
      <version>${jib.version}</version>
      <configuration>
        <skip>${jib.skip}</skip>
        <!-- Configure the base image -->
        <from>
          <image>openjdk:8-jre-alpine</image>
        </from>
        <!-- Configure push address, warehouse name, mirror name-->
        <to>
          <image>registry.cn-hangzhou.aliyuncs.com/akk_java/${jib.repository.name}</image>
          <tags>
            <!-- <tag>${jib.repository.name}</tag>-->
            <!-- <tag>${version}</tag>-->
          </tags>
          <auth>
            <username>${REGISTRY_USERNAME}</username>
            <password>${REGISTRY_PASSWORD}</password>
          </auth>
        </to>
        <!--Private servers are http instead of https. By default, jib does not push to non-https private servers. Private servers are added, but public servers are not added. -->
        <!-- <allowInsecureRegistries>true</allowInsecureRegistries>-->
        <container>
          <mainClass>${jib.main.class}</mainClass>
          <labels>
            <name>${artifactId}</name>
          </labels>
        </container>
      </configuration>
      <!--Bound to Maven lifecicle-->
      <!-- <executions>-->
      <!-- <execution>-->
      <!-- <phase>package</phase>-->
      <!-- <goals>-->
      <!-- <goal>build</goal>-->
      <!-- </goals>-->
      <!-- </execution>-->
      <!-- </executions>-->
    </plugin>
  </plugins>

Parameter Description:
${jib.version} jib version: choose as you like
${jib.skip} Whether to skip jib: The jib plug-in is placed in the pom under the root directory, so all modules of the project will perform jib operations. If the public dependency modules of the project do not need to be packaged, you can redefine this property and skip jib
${jib.repository.name} mirror push repository name: repository name
${version} Image version: the version of the pushed image
${REGISTRY_USERNAME} Mirror repository username: Login account for private repository
${REGISTRY_PASSWORD} Mirror repository password: login password for private repository
${jib.main.class} Project module startup class: Project module startup class, Spring boot startup class

form tag defines the base image, which is based on openjdk:8-jre-alpine here, but you can use others. to tag defines the compiled image push information, image defines the push image name information, and tags pushes the image tag. You can pull the specified image through the tag. auth defines the login information for a private repository. container defines the content information of the image, and mainClass starts the main class. labels application metadata key-value pairs, similar to Docker's labels. The following executions bind commands. Here, the jib build command is bound to the maven package command. When running mvn package, jib build will be automatically executed. (For more configuration tags, refer to https://github.com/GoogleContainerTools/jib/tree/master/jib-maven-plugin)

At this point, you can see the jib plugin related content in the Maven menu of idea:

alt img

For example: gateway module (need to package the image), the pom configuration is as follows

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <parent>
    <artifactId>akk-system</artifactId>
    <groupId>com.akk</groupId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <modelVersion>4.0.0</modelVersion>

  <artifactId>gateway</artifactId>

  <properties>
    <!-- jib docker config-->
    <jib.version>2.2.0</jib.version>
    <jib.skip>false</jib.skip>
    <jib.repository.name>akk-gateway</jib.repository.name>
    <jib.main.class>com.akk.GatewayApplication</jib.main.class>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    <dependency>
      <groupId>com.github.xiaoymin</groupId>
      <artifactId>knife4j-spring-boot-starter</artifactId>
    </dependency>
  </dependencies>

</project>

Common public dependency package pom (no need to package the image):

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <artifactId>akk-system</artifactId>
    <groupId>com.akk</groupId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>common</artifactId>
  <version>0.0.1-SNAPSHOT</version>

  <properties>
    <!-- jib docker config-->
    <jib.version>2.2.0</jib.version>
    <jib.skip>true</jib.skip>
    <jib.repository.name>akk-system</jib.repository.name>
    <jib.image.name>akk-system</jib.image.name>
  </properties>

  <dependencies>
    <!-- Dependency Information -->
  </dependencies>

</project>

Among them, properties covers the relevant parameter configuration of jib.

Packaging image

Run mvn package jib:dockerBuild to package.

alt img

After packaging is complete, check the local docker image (the jib:dockerBuild command will not upload the image, but the jib:build command will upload the image)

alt img

Pack and upload the image

Run mvn package jib:build to package and upload.
Log in to the docker private warehouse

docker login --username=username --password=password registry.cn-hangzhou.aliyuncs.com

Pull the image

docker pull registry.cn-hangzhou.aliyuncs.com/akk_java/akk-gateway:latest

alt img

Docker deployment project

Microservice project deployment has many modules and is generally a distributed cluster environment, so manual deployment is cumbersome. You can use automated deployment tools like Jenkins. After using Jenkins to package and upload the image, log in to the remote server and execute the script to start it. like:

#!/bin/bash
# Log in to the docker repositorydocker login --username=username --password=password registry.cn-hangzhou.aliyuncs.com
# Stop the running container docker ps | grep akk_java | awk '{print $1}' | xargs docker stop
# Delete the container docker ps -a -q | grep akk_java | awk '{print $1}' | xargs docker rm
# Query the image file and delete docker images | grep akk_java | awk '{print $3}' | xargs docker rmi
# Pull the image docker pull registry.cn-hangzhou.aliyuncs.com/akk_java/akk-user:latest
docker pull registry.cn-hangzhou.aliyuncs.com/akk_java/akk-gateway:latest
docker pull registry.cn-hangzhou.aliyuncs.com/akk_java/akk-task:latest
docker pull registry.cn-hangzhou.aliyuncs.com/akk_java/akk-store:latest
docker pull registry.cn-hangzhou.aliyuncs.com/akk_java/akk-pay:latest
docker pull registry.cn-hangzhou.aliyuncs.com/akk_java/akk-app-api:latest
docker pull registry.cn-hangzhou.aliyuncs.com/akk_java/akk-sso-auth:latest
docker pull registry.cn-hangzhou.aliyuncs.com/akk_java/akk-seata:latest

After re-pulling the image, execute the docker run command to start Docker.

This concludes this article about the detailed steps of using jib for docker deployment in Spring Cloud. For more relevant Spring Cloud docker deployment content, please search for previous articles on 123WORDPRESS.COM or continue to browse the following related articles. I hope everyone will support 123WORDPRESS.COM in the future!

You may also be interested in:

Using jib to package docker images
Detailed steps for building, running, publishing, and obtaining a Docker image for the first time
Analysis of two methods of building Docker images
Analysis of the Docker image construction principle (you can build an image without installing Docker)
Use GoogleContainerTools to containerize jib to build a docker image

<<: The whole process record of vue3 recursive component encapsulation

>>: Detailed explanation of the lock structure in MySQL

Detailed steps for using jib for docker deployment in Spring Cloud

Introduction and architecture of Apache Arrow, a high-performance data format library package on JVM (Gkatziouras)

How to implement Linux disk mounting, partitioning, and capacity expansion operations

Detailed explanation of TypeScript's basic types

React implements the principle analysis of the three stages of loading, loading, completion, loading failure

JavaScript selector functions querySelector and querySelectorAll

Introduction to the process of extending the boot partition in Kylin 4.0.2 (Ubuntu)

Methods and steps to access Baidu Maps API with JavaScript

Vue implements a scroll bar style

Explanation of the working principle and usage of redux

Several skills you must know when making web pages

Recommend

A Deep Dive into JavaScript Promises

Linux kernel device driver memory management notes

How to implement scheduled backup of CentOS MySQL database

How to process blob data in MySQL

jQuery realizes the picture following effect

MySQL query learning basic query operations

VM VirtualBox virtual machine mount shared folder

How to configure Nginx to support ipv6 under Linux system

Detailed steps for installing ros2 in docker

Implementation of Docker batch container orchestration

Using Nginx to implement grayscale release

How to hide rar files in pictures

JavaScript countdown to close ads

Some issues we should pay attention to when designing a web page

Implementation of vue-nuxt login authentication