One last comment, for the content of this post, I am assuming that you have already installed Docker or can figure out how to do so yourself.<\/p>\n First up, the Spring Boot application.<\/p>\n This is the only part of the project that contains our code. The rest are just images downloaded from someone else\u2019s repository. To start moving this application towards running in a container, we need to create a This takes the base image of To build an image from the There is now an image named This will create and run a container built from the If we stopped this container and wanted to run it again, we should use the command:<\/p>\n Where Now the Spring application is successfully running in a container, but the logs are not looking very good. Let\u2019s have a quick look so we know what we need to do next.<\/p>\n MongoDB connection failing:<\/p>\n ActiveMQ also isn\u2019t there: We will sort these out in the next sections so the application can work in its entirety.<\/p>\n One last thing before we move onto looking at Mongo and ActiveMQ.<\/p>\n The This then allows us to replace a few of the lines in the Here one line has been added and one existing line is changed. The There is a MongoDB image ready and waiting for us to use. It is ideally named Adding Setting up ActiveMQ is just as simple as Mongo. Run the command below:<\/p>\n Here the If you have been running all these commands as you read through the post, you would have noticed that the By default, Docker creates a Bridge network when setting one up without any extra configuration. Below is how to do so:<\/p>\n Now that the network (named Once these are all run, the application as a whole will now work. Each container can see each other. Allowing the At this point, everything is working. It runs in the same way that I remember it working when I had everything set up on my own laptop. But, this time around, nothing is setup locally\u2026 Except for Docker!<\/p>\n We could have stopped there, but this next section will make running everything even easier. Docker Compose allows us to effectively bring all the commands that we ran earlier together and start all the containers and their network all in a single command. Obviously, there is some more setup but in the end, I think the amount of typing actually goes down.<\/p>\n To do this, we need to create a Use with this version of the This is pretty much everything that needs to be done.<\/p>\n The other two containers don\u2019t require much setup. As with the previous commands, the images they are built from are specified and The last piece of configuration happens in the background. A network is created and all the containers are added to it. This removes the need to create a network manually.<\/p>\n All that is left to do is run the This will build and run all the containers. The application code image is built if necessary. Running this exact command will output all the containers logs to the console, to do this in the background add the After doing so, we can have a look at the created containers and network. Running:<\/p>\n Shows us:<\/p>\n And the network:<\/p>\n Produces:<\/p>\n The names of the containers and network are prepended with the name of the project.<\/p>\n That is all there is to it\u2026 For a simple setup anyway, I\u2019m sure there is much more the Docker gods could do but I am not one of them\u2026 Yet.<\/p>\n In conclusion, we took an existing application that I wrote to work locally on a machine and shoved everything into a few containers. This meant we went from a machine that needed to have everything set up, with both MongoDB and ActiveMQ installed. To instead, a machine that could skip all of this by using containers and only requiring an installation of Docker. Docker then manages all of the dependencies for us.<\/p>\n We looked at how to move each part of the application into a container and then tied it all together with Docker Compose. Leaving us, at the end of all this, with a single command that can move us from absolutely nothing to everything needed to run the application.<\/p>\n The code used in this post can be found on my GitHub<\/a>.<\/p>\n If you found this post helpful, you can follow me on Twitter at @LankyDanDev <\/a>to keep up with my new posts.<\/p>\n![\"docker\"](\"http:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2018\/09\/docker-hong-kong.png\")
<\/a><\/p>\nConverting the Spring App<\/h3>\n
Dockerfile<\/code> that specifies the content of an image:<\/p>\nFROM openjdk:8-jdk-alpine\r\nLABEL maintainer=\"Dan Newton\"\r\nADD target\/spring-boot-jms-tutorial-1.0.0.jar app.jar\r\nEXPOSE 8080\r\nENTRYPOINT [\"java\", \"-jar\", \"\/app.jar\"]<\/pre>\n
openjdk:8-jdk-alpine<\/code> which is a good starting point for the application, adds the Jar built from the application code (naming it app.jar<\/code>) and exposes a port for communication between containers. The final line defines the command that executed when the image is run in a container. This is what starts the Spring application.<\/p>\nDockerfile<\/code> run the command below (assuming you have already built the application code):<\/p>\ndocker build -t spring-boot-jms-tutorial .<\/pre>\n
spring-boot-jms-tutorial<\/code> (-t<\/code> lets us define the name). This can now be used to create a container that executes the code that is packed into the image\u2019s Jar:<\/p>\ndocker run --name application -p 4000:8080 spring-boot-jms-tutorial<\/pre>\n
spring-boot-jms-tutorial<\/code> image. It names the container application<\/code> and the -p<\/code> property allows a port from a local machine to mapped to a port inside the container. To access port 8080<\/code> of the container we simply need to use port 4000<\/code> on our own machine.<\/p>\ndocker start application<\/pre>\n
application<\/code> is the name of the container we created before. If docker run<\/code> was used again it would create another new container rather than reusing the existing one. Actually, because we provided a name to the container, running the same run<\/code> command from earlier will lead to an error.<\/p>\nException in monitor thread while connecting to server mongocontainer:27017\r\n\r\ncom.mongodb.MongoSocketException: mongocontainer: Name does not resolve\r\n at com.mongodb.ServerAddress.getSocketAddress(ServerAddress.java:188) ~[mongodb-driver-core-3.6.4.jar!\/:na]\r\n at com.mongodb.connection.SocketStreamHelper.initialize(SocketStreamHelper.java:59) ~[mongodb-driver-core-3.6.4.jar!\/:na]\r\n at com.mongodb.connection.SocketStream.open(SocketStream.java:57) ~[mongodb-driver-core-3.6.4.jar!\/:na]\r\n at com.mongodb.connection.InternalStreamConnection.open(InternalStreamConnection.java:126) ~[mongodb-driver-core-3.6.4.jar!\/:na]\r\n at com.mongodb.connection.DefaultServerMonitor$ServerMonitorRunnable.run(DefaultServerMonitor.java:114) ~[mongodb-driver-core-3.6.4.jar!\/:na]\r\n at java.lang.Thread.run(Thread.java:748) [na:1.8.0_171]\r\nCaused by: java.net.UnknownHostException: mongocontainer: Name does not resolve\r\n at java.net.Inet4AddressImpl.lookupAllHostAddr(Native Method) ~[na:1.8.0_171]\r\n at java.net.InetAddress$2.lookupAllHostAddr(InetAddress.java:928) ~[na:1.8.0_171]\r\n at java.net.InetAddress.getAddressesFromNameService(InetAddress.java:1323) ~[na:1.8.0_171]\r\n at java.net.InetAddress.getAllByName0(InetAddress.java:1276) ~[na:1.8.0_171]\r\n at java.net.InetAddress.getAllByName(InetAddress.java:1192) ~[na:1.8.0_171]\r\n at java.net.InetAddress.getAllByName(InetAddress.java:1126) ~[na:1.8.0_171]\r\n at java.net.InetAddress.getByName(InetAddress.java:1076) ~[na:1.8.0_171]\r\n at com.mongodb.ServerAddress.getSocketAddress(ServerAddress.java:186) ~[mongodb-driver-core-3.6.4.jar!\/:na]\r\n ... 5 common frames omitted<\/pre>\n
Could not refresh JMS Connection for destination 'OrderTransactionQueue' - retrying using FixedBackOff{interval=5000, currentAttempts=1, maxAttempts=unlimited}. \r\nCause: Could not connect to broker URL: tcp:\/\/activemqcontainer:61616. \r\nReason: java.net.UnknownHostException: activemqcontainer<\/pre>\ndockerfile-maven-plugin<\/code> could also be used to help with the above which builds the container as part of running mvn install<\/code>. I chose not to use it since I couldn\u2019t get it to work properly with docker-compose<\/code>. Below is a quick example of using the plugin:<\/p>\n<build>\r\n <plugins>\r\n <plugin>\r\n <groupId>com.spotify<\/groupId>\r\n <artifactId>dockerfile-maven-plugin<\/artifactId>\r\n <version>1.4.4<\/version>\r\n <executions>\r\n <execution>\r\n <id>default<\/id>\r\n <goals>\r\n <goal>build<\/goal>\r\n <goal>push<\/goal>\r\n <\/goals>\r\n <\/execution>\r\n <\/executions>\r\n <configuration>\r\n <!-- Names the image: spring-boot-jms-tutorial -->\r\n <repository>${project.artifactId}<\/repository>\r\n <buildArgs>\r\n <JAR_FILE>${project.build.finalName}.jar<\/JAR_FILE>\r\n <\/buildArgs>\r\n <\/configuration>\r\n <\/plugin>\r\n <\/plugins>\r\n<\/build><\/pre>\nDockerfile<\/code>:<\/p>\nFROM openjdk:8-jdk-alpine\r\nLABEL maintainer=\"Dan Newton\"\r\nARG JAR_FILE \r\nADD target\/${JAR_FILE} app.jar\r\nEXPOSE 8080\r\nENTRYPOINT [\"java\", \"-jar\", \"\/app.jar\"]<\/pre>\nJAR_FILE<\/code> argument replaces the original name of the Jar which is injected in by the plugin from the pom.xml<\/code>. Make these changes and run mvn install<\/code> and bam, your container is built with all the required code.<\/p>\nUsing the MongoDB image<\/h3>\n
mongo<\/code>\u2026 What else did you expect? All we need to do is run<\/code> the image and give it\u2019s container a name:<\/p>\ndocker run -d --name mongocontainer mongo<\/pre>\n
-d<\/code> will run the container in the background. The name of the container is not just for convenience as the Spring application will need it later to connect to Mongo.<\/p>\nOnto the ActiveMQ image<\/h3>\n
docker run -d --name activemqcontainer -p 8161:8161 rmohr\/activemq<\/pre>\n
8161<\/code> ports are mapped from the container to the machine it\u2019s running on, allowing the admin console to be accessed from outside the container.<\/p>\nTying it all together<\/h3>\n
application<\/code> container hasn\u2019t actually been able to see the mongocontainer<\/code> and activemqcontainer<\/code>. This is because they are not running within the same network. Getting them to communicate is not difficult and takes only a few extra steps.<\/p>\ndocker network create network<\/pre>\n
network<\/code>) is created, the commands that were run previously need to be altered to create containers that will connect to the network instead. Below are the 3 commands used to create the containers in the previous sections, each altered to join the network.<\/p>\ndocker run -d --name mongocontainer --network=network mongo\r\ndocker run -d --name activemqcontainer -p 8161:8161 --network=network rmohr\/activemq\r\ndocker run --name application -p 4000:8080 --network=network spring-boot-jms-tutorial<\/pre>\n
application<\/code> container to connect to MongoDB and ActiveMQ in their respective containers.<\/p>\nDocker composing it up<\/h3>\n
docker-compose.yml<\/code> file:<\/p>\nversion: '3'\r\nservices:\r\n appcontainer:\r\n build:\r\n context: .\r\n args:\r\n JAR_FILE: \/spring-boot-jms-tutorial-1.0.0.jar\r\n ports:\r\n - \"4000:8080\"\r\n activemqcontainer:\r\n image: \"rmohr\/activemq\"\r\n ports:\r\n - \"8161:8161\"\r\n mongocontainer:\r\nimage: \"mongo\"<\/pre>\n
Dockerfile<\/code>:<\/p>\nFROM openjdk:8-jdk-alpine\r\nLABEL maintainer=\"Dan Newton\"\r\nARG JAR_FILE \r\nADD target\/${JAR_FILE} app.jar\r\nEXPOSE 8080\r\nENTRYPOINT [\"java\", \"-jar\", \"\/app.jar\"]<\/pre>\nappcontainer<\/code> is the Spring application container built from the project\u2019s code. The build<\/code> property of the container tells Docker to build the image based on the projects Dockerfile<\/code> found in the project\u2019s root directory. It passes in the JAR_FILE<\/code> argument to the Dockerfile<\/code> moving some of the configuration into this file instead.<\/p>\nactivemqcontainer<\/code> adds configuration around it\u2019s mapped ports.<\/p>\nup<\/code> command:<\/p>\ndocker-compose up<\/pre>\n
-d<\/code> flag:<\/p>\ndocker-compose up -d<\/pre>\n
docker ps -a --format \"table {{.Image}}\\t{{.Names}}\"<\/pre>\nIMAGE NAMES\r\nmongo spring-boot-jms_mongocontainer_1\r\nspring-boot-jms_appcontainer spring-boot-jms_appcontainer_1\r\nrmohr\/activemq spring-boot-jms_activemqcontainer_1<\/pre>\n
docker network ls<\/pre>\n
NETWORK ID NAME DRIVER SCOPE\r\n163edcfe5ada spring-boot-jms_default bridge local<\/pre>\n
Conclusion<\/h3>\n