idea uses docker plug-in to achieve one-click automated deployment

environment:

• ​ JDK 1.8 and above.
• Maven 3.2+
• Idea
• docker

1. Docker enables remote connection access

First we need to enable remote connection access to Docker. Ensure that Docker is not located on the server, and can also be accessed remotely.

Docker for Linux:

Modify the docker.service file and add the listening port -H tcp://0.0.0.0:2375

vi /usr/lib/systemd/system/docker.service

Find ExecStart and add -H tcp://0.0.0.0:2375 at the end, as shown in the figure below

Restart Docker

 systemctl daemon-reload
 systemctl start docker

If we have firewall, remember to add firewall policy or turn off the firewall.

Docker for Windows

Find the docker icon in the lower left corner of the computer, right-click and select settings. Check Expose daemon on tcp://localhost:2375 without TLS under the General menu. No reboot required.

Install and configure the idea docker plugin

In File --> Settings --> Plugins, search for Docker in the input box, select it and install it. After the installation is complete, restart Docker.

Configure Docker

Find Docker in File–> Settings–> Build, Execution, Deployment

Create a new docker instance, and then fill in the IP port number where docker is located in the Engine API URL. If Connection successful is displayed below, it proves that the connection to docker is successful. If it fails, it may be that we failed to open the remote connection with Docker in the previous step.

After we complete the settings, return to the idea main interface and you can see a docker window below the page. Click the green arrow to connect to Docker. After connecting, the displayed Containers and Images are the containers and images we already have in Docker.

Create a project and configure

1. Create a project

I will demonstrate with a simple Eureka project.

File–> New -->Project --> Spring Initializr

2. Configuration Project

Modify the pom.xml file and introduce the configuration of the docker-maven-plugin plug-in. Change the configuration in the <plugins> tag

 <!--Use the docker-maven-plugin plugin-->
    <plugin>
        <groupId>com.spotify</groupId>
        <artifactId>docker-maven-plugin</artifactId>
        <version>1.0.0</version>

        <!--Bind the plugin to a certain phase for execution-->
        <executions>
            <execution>
                <id>build-image</id>
                <!--Bind the plug-in to the package phase. That is to say,
                Users only need to execute mvn package, which will automatically execute mvn docker:build-->
                <phase>package</phase>
                <goals>
                    <goal>build</goal>
                </goals>
            </execution>
        </executions>

        <configuration>
            <!--Specify the generated image name, here is our project name-->
            <imageName>${project.artifactId}</imageName>
            <!--Specify the tag here to specify the version of the image, our default version is latest-->
            <imageTags>
                <imageTag>latest</imageTag>
            </imageTags>
            <!-- Specify the path of the Dockerfile file in our project-->
            <dockerDirectory>${project.basedir}/src/main/resources</dockerDirectory>

            <!--Specify the remote docker address-->
            <dockerHost>http://127.0.0.1:2375</dockerHost>

            <!-- Here is the configuration for copying the jar package to the specified directory of the docker container-->
            <resources>
                <resource>
                    <targetPath>/</targetPath>
                    <!--The path where the jar package is located is configured here to correspond to the target directory in the project-->
                    <directory>${project.build.directory}</directory>
                    <!-- The jar package that needs to be included, which corresponds to the file name added in Dockerfile-->
                    <include>${project.build.finalName}.jar</include>
                </resource>
            </resources>
        </configuration>
    </plugin>

Configure the basic configuration of the project. (This is not the point, just a quick aside)

①Modify application.properties and add project related information.

#The port number and IP address where the project is started server.port=9090
eureka.instance.hostname=127.0.0.1

# Whether to register it to the registration center, if it is not a cluster environment, false
eureka.client.register-with-eureka=false
# Whether to retrieve the service, false in single machine case
eureka.client.fetch-registry=false

eureka.client.service-url.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka/

② Find the project startup class and add the @EnableEurekaServer annotation

@EnableEurekaServer
@SpringBootApplication
public class EurekaServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(EurekaserverApplication.class, args);
    }

}

Add the Dockerfile file.

We add a file named Dockerfile in the EeurekaServer\src\main\resources directory.

If we do not have the java:8 image in docker, please use docker pull java:8 to pull the image down first.

FROM java:8
VOLUME /tmp
ADD *.jar app.jar
EXPOSE 9090
ENTRYPOINT [ "java", "-Djava.security.egd=file:/dev/./urandom", "-jar", "/app.jar" ]

We added a VOLUME pointing to the contents of "/tmp" because this is where Spring Boot applications create working directories for Tomcat by default. The effect is to create a temporary file on the host under "/var/lib/docker" and link it to the container under "/tmp". This step is optional for the simple application we write here, but may be necessary for other Spring Boot applications if you need to actually write in the file system.

To reduce Tomcat startup time, we added a system property pointing to "/dev/urandom" as entropy source. If you use a “standard” version of Tomcat (or any other web server), you don’t need a newer version of Spring Boot.

Maven packaging, generating images

Use Maven to package. We have configured it in pom.xml. If we use Maven package, the Dockerfile file will be automatically used for building.

We can see from the console that an image file with the same name as our project has been built for me.

We can see in the docker window that there is one more eurekaserver:latest image in our image library.

Create a container and deploy the project to docker

In the Docker window, find the image file we just created, right-click, and select Create container. We modify the configuration required to create the container.

In the Create Docker Configuration pop-up window, modify the Container name and Bind ports.

I add 127.0.0.1:8080:9090 here. Use the local port 8080 to access the container's port 9090.

After we click Run, the container will be automatically created and started.

We can see that in the docker plug-in, there is an additional eurekaServer container, and it is started successfully with port number 9090.

Accessing items in a container

We previously set up the project to use port 8080 to access container 9090.

We use 127.0.0.1:8080 to access the project, and the following page appears, proving that the project was successfully started.

Here we have basically completed all the configuration.

Modify the project and deploy it with one click

In the future, we can start the project as shown in the figure below. With one click, our project will run in the docker container.

If we modify the project and start the project in the docker plug-in, we will find that it is still the project before the modification when it is started, because we only start the container and do not repackage the modified project and generate docker images. If we want to run the package and start the project directly at startup, we can follow the steps below.

We modify the configuration of the Docker Images we created earlier.

2. Find Before launch: Activate tool window in the configuration startup item, where we add a Run Maven Gold.

We add a command package to the Command line here.

Save after configuration is complete. In the future, when we start the project, we will execute the Maven package command to automatically package us and generate a Docker image file for the project to start.

In the future, if we modify the project, we can start it as shown in the figure below. It will automatically package and create a docker image and start the project.

If we only need to start the project, go to the docker plug-in window and start the container of the corresponding project.

refer to

https://www.cnblogs.com/hsz-csy/p/9488469.html

https://spring.io/guides/gs/spring-boot-docker/

This is the end of this article about idea using docker plug-in to achieve one-click automated deployment. For more related idea docker one-click automated deployment content, please search 123WORDPRESS.COM's previous articles or continue to browse the following related articles. I hope everyone will support 123WORDPRESS.COM in the future!