[Docker] Utilice el complemento docker-maven-plugin para crear, publicar y enviar la imagen a un almacén privado.

Este artículo describe cómo enviar el proyecto a un almacén acoplable privado a través del complemento docker-maven-plugin en el proyecto Spring Boot, y luego extraer el proyecto en el almacén y ejecutarlo usando docker run. Construido por el propio autor, la calidad está garantizada.

1. Utilice el complemento docker-maven-plugin para enviar el proyecto a la ventana acoplable del servidor privado.

1.1. Crear imagen v1.0

1. Si desea utilizarlo docker-maven-plugin, debe pom.xmlagregar el complemento;

<build>
     <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
        <plugin>
            <groupId>io.fabric8</groupId>
            <artifactId>docker-maven-plugin</artifactId>
            <version>0.33.0</version>
            <configuration>
                <!-- Docker 推送镜像仓库地址(由于是推送到本地的docker镜像仓库) -->
                <pushRegistry>http://localhost:5000</pushRegistry>
                <images>
                    <image>
                        <!--由于推送到私有镜像仓库，镜像名需要添加仓库地址(相当于告诉去哪里拉取镜像)-->
                        <name>localhost:5000/fire-tiny/${project.name}:${project.version}</name>
                        <!--定义镜像构建行为-->
                        <build>
                            <!--定义基础镜像-->
                            <from>java:8</from>
                            <args>
                                <!-- jar的名称，一般配置为gav的av -->
                                <JAR_FILE>${project.build.finalName}.jar</JAR_FILE>
                            </args>
                            <!--定义哪些文件拷贝到容器中-->
                            <assembly>
                                <!--定义拷贝到容器的目录-->
                                <targetDir>/</targetDir>
                                <!--只拷贝生成的jar包-->
                                <descriptorRef>artifact</descriptorRef>
                            </assembly>
                            <!--定义容器启动命令-->
                            <entryPoint>["java", "-jar","/${project.build.finalName}.jar"]</entryPoint>
                            <!--定义维护者-->
                            <maintainer>firefish</maintainer>
                            <!--使用Dockerfile构建时打开-->
                            <!--<dockerFileDir>${project.basedir}</dockerFileDir>-->
                        </build>
                        <!--定义容器启动行为-->
                        <run>
                            <!--设置容器名，可采用通配符(一般配置为gav的a)-->
                            <containerNamePattern>${project.artifactId}</containerNamePattern>
                            <!--设置端口映射-->
                            <ports>
                                <port>8080:8080</port>
                            </ports>
                            <!--设置容器间连接(即容器需要连接mysql，需要外部环境提供mysql连接)-->
                            <links>
                                <link>mysql:db</link>
                            </links>
                        </run>
                    </image>
                </images>
            </configuration>
        </plugin>
    </plugins>
</build>

Nota: preste atención a db:3306

spring:
  datasource:
    url: jdbc:mysql://db:3306/fire?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
    username: root
    password: root

2. Antes de construir la imagen, primero debemos empaquetar el proyecto y luego compilarlo. De lo contrario, se producirá un error. Simplemente use el siguiente comando.

mvn package docker:build

3. Una vez completado el embalaje, podrá ver la imagen en nuestra máquina local;

# 本地运行
[root@linux-local work]# docker images
REPOSITORY                                             TAG              IMAGE ID       CREATED             SIZE
localhost:5000/fire-tiny/fire-tiny-fabric              0.0.1-SNAPSHOT   9b7cf9c38c5d   About an hour ago   680MB

4. Por supuesto, también podemos packageempaquetar la imagen directamente cuando usamos el comando, modificarla pom.xmly <plugin>agregar <executions>la configuración debajo del nodo;

Es una adición adicional; si no la crea, simplemente cree la imagen de la ventana acoplable cuando sea necesario.

<plugin>
    <groupId>io.fabric8</groupId>
    <artifactId>docker-maven-plugin</artifactId>
    <version>0.33.0</version>
    <executions>
        <!--如果想在项目打包时构建镜像添加-->
        <execution>
            <id>build-image</id>
            <phase>package</phase>
            <goals>
                <goal>build</goal>
            </goals>
        </execution>
    </executions>
</plugin>

1.2 Crear imagen v2.0

La creación de la imagen v2.0 es una actualización a la v1.0. La desventaja original es que los pasos para crear la imagen de la ventana acoplable están muy relacionados con el código pom del proyecto, lo que no favorece modificaciones posteriores y el proceso de compilación provoca que el archivo pom estar hinchado. Para abordar estas deficiencias, la versión 2.0 utiliza el método DockerFile para separar los pasos de construcción de la imagen de la ventana acoplable del archivo pom del proyecto Spring Boot. Los pasos específicos son los siguientes:

1. Crea un nuevo DockerFile

Cree un nuevo archivo DockerFile en el proyecto con contenido personalizado, el contenido de referencia es el siguiente:

# 该镜像需要依赖的基础镜像
FROM java:8
# 拷贝target下的文件到容器中
ARG JAR_FILE
ADD target/${JAR_FILE} /
# 声明服务运行在8080端口
EXPOSE 8080
# 指定docker容器启动时运行jar包
ENTRYPOINT ["java", "-jar","/fire-tiny-fabric-0.0.1-SNAPSHOT.jar"]
# 指定维护者的名字
MAINTAINER mike

2. Modifique el archivo pom

El proceso de creación de una imagen acoplable ahora solo tiene <dockerFileDir>${project.basedir}</dockerFileDir>esta línea, que es muy simple.

<build>
     <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
        <plugin>
            <groupId>io.fabric8</groupId>
            <artifactId>docker-maven-plugin</artifactId>
            <version>0.33.0</version>
            <configuration>
                <!-- Docker 推送镜像仓库地址(由于是推送到本地的docker镜像仓库) -->
                <pushRegistry>http://localhost:5000</pushRegistry>
                <images>
                    <image>
                        <!--由于推送到私有镜像仓库，镜像名需要添加仓库地址(这个相当于告诉别人拉取镜像的时候去哪里拉取)-->
                        <name>localhost:5000/fire-tiny/${project.name}:${project.version}</name>
                        <!--定义镜像构建行为-->
                        <build>
                            <!--使用Dockerfile构建时打开-->
                            <dockerFileDir>${project.basedir}</dockerFileDir>
                        </build>
                    </image>
                </images>
            </configuration>
        </plugin>
    </plugins>
</build>

3. Empaquetar, crear y ver la imagen.

Llévatelo en un solo set de 3 pasos, mucho más sencillo que el original y luce más cómodo.

# 打包构建
mvn clean package docker:build
# 查看本地镜像
docker images

1.3 Empujar al almacén de espejos

1. Especifique la compilación y envíe para enviar al almacén privado.

2. Inicie sesión en la dirección del almacén privado: http://localhost:8280/ y vea la imagen que acaba de enviar.

2. Extraiga la imagen de la ventana acoplable del servidor privado y ejecútela.

Después de enviar la imagen al almacén privado, debe llevar la imagen al local y usarla.

1. Lleva la imagen a local.

Debido a que creamos la imagen localmente y luego la enviamos al almacén privado, primero debemos eliminar la imagen creada original y luego ir al almacén privado para extraer la imagen.

docker rmi "localhost:5000/fire-tiny/fire-tiny-fabric:0.0.1-SNAPSHOT"
docker pull "localhost:5000/fire-tiny/fire-tiny-fabric:0.0.1-SNAPSHOT"

2. Ejecute el contenedor

docker run --rm -d --name fire-tiny-fabric -p 8080:8080 "localhost:5000/fire-tiny/fire-tiny-fabric:0.0.1-SNAPSHOT"

3. Acceda a una de las interfaces del contenedor.

curl -X GET --header 'Accept: application/json' 'http://localhost:8080/brand/list?pageNum=1&pageSize=3'

Pero desafortunadamente, verificar el registro de Docker mostrará errores relacionados con la base de datos sin accidente.

Esto se debe a que cuando creamos la imagen del proyecto fire-tiny-fabric en el paso anterior, especificamos que necesitamos confiar en la base de datos mysql, pero no especificamos la base de datos en la ejecución de Docker, por lo que habrá errores en conexión de base de datos.

4. Vuelva a ejecutar el contenedor

• Si hay una base de datos creada con Docker, especifique la base de datos mysql a través de –link:

  docker run --rm -d --name fire-tiny-fabric -p 8080:8080 \
  --link mysql:db \
  "localhost:5000/fire-tiny/fire-tiny-fabric:0.0.1-SNAPSHOT"
  

  Nota: mysql en mysql:db es el nombre del contenedor (–name), y la siguiente base de datos es la variable especificada al construir fire-tiny-fabric. El principio de –link es agregar un nombre de alias a /etc/hosts.

• Si es una base de datos construida localmente, especifique la dirección IP y el puerto.

  Usamos db como nombre de dominio para conectarnos a la base de datos en el proyecto, por lo que solo necesitamos agregar una asignación de nombre de dominio desde db a la dirección IP del host al contenedor.

  spring:
    datasource:
      url: jdbc:mysql://db:3306/fire?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
      username: root
      password: root
  

  # 域名db与主机ip的映射
  docker run --rm -d --name fire-tiny-fabric -p 8080:8080 \
  --add-host=db:192.168.1.6 \
  "localhost:5000/fire-tiny/fire-tiny-fabric:0.0.1-SNAPSHOT"
  

# 测试接口
curl -X GET --header 'Accept: application/json' 'http://localhost:8080/brand/list?pageNum=1&pageSize=3'

3. Referencias

Mi artículo: "Cómo comprobar qué versión tiene una imagen de Docker.md"

Mi artículo: "Docker establece la fuente de imagen nacional.md"

Mi artículo: "Tutorial práctico de inicio rápido de Docker.md"

Mi artículo: "Docker instala MySQL, Redis, RabbitMQ, Elasticsearch, Nacos y otros servicios comunes.md"

Mi artículo: "Docker instala Nacos service.md"

Mi artículo: "Cómo modificar el archivo .md en Docker"

Mi artículo: "Métodos de conexión o comunicación entre contenedores Docker.md"

Mi artículo: "Cómo MySQL instalado por Docker persiste en la base de datos data.md"

Mi artículo: "Hacer Docker Private Warehouse.md"

Mi artículo: "Uso del complemento docker-maven-plugin para crear, publicar y enviar imágenes a almacenes privados.md"

Mi artículo: "Resolver el error al acceder al puerto 9200 después de que Docker instaló Elasticsearch.md"

---

Portal: análisis del código fuente Spring5 al estilo Nanny

Bienvenido a intercambiar tecnología y vida laboral con el autor.

Contacta con el autor