spring boot docker maven example

So choosing a lightweight JRE image is important if you want to keep the final image as small as possible. Published at DZone with permission of Brian Hannaway, DZone MVB. The final three layers come from the Dockerfile we defined and include the 20.1 MB application JAR. The run command takes an optional -p option that allows you to map a port from the container to your host machine. The image is a deployable artefact and can be used to run containers on any virtual or physical machine with Docker installed. All you really want in the final image is the executable JAR and a Java JRE to run it. In order to access the application running in the container you need to map the internal container port to a port on the host machine. Run the docker image ls command to list all your local images. This means that once you've built an image, subsequent builds become much faster. See the original article here. If you have any comments or questions please leave a note below. When you're building Java apps without Docker, you pull down the Maven dependencies from the remote repository the first time you build and then reference them in your local Maven cache after that. To keep the Docker image as small as possible, I'll be using Alpine base images and a multi-stage build. From a Java developer's perspective, the typical Docker use case is running your application inside a Docker container. If you run the docker image history boot-docker-intro command you'll see a breakdown of the various layers in the image. This is a powerful concept as it allows you to run the same image in development, test, pre-production, and production without having to worry about installing or configuring dependencies on each environment. If everything works as expected you should see the Boot app start on port 8080 as follows. I've recently started playing around with Docker again and have decided to put together a few posts to share what I've learned. MAINTAINER Brian Hannaway isn't essential but improves maintainability by providing a point of contact for the image author. I've created a standard Spring Boot app with a single Application class and added a Dockerfile to the root of the project. Docker is a containerization technology that allows you to build an image containing your application and all the dependencies required to run it. That's great, but wouldn't it be even better if you could use Docker to build the application, too? COPY --from=MAVEN_BUILD /build/target/docker-boot-intro-0.1.0.jar /app/ tells Docker to copy docker-boot-intro-0.1.0.jar from the /build/target directory in the MAVEN_BUILD stage to the /app directory of the current stage. Although Maven will be discarded from the final image (see COPY --from command later) I've used the Alpine-flavored Maven image as its faster to download. Using volumes, you can tell Docker to access the local Maven repository on the host rather than pulling the dependencies from a public repository. You'll see the docker-boot-intro image listed with a size of 105 MB. A Start to Finish Guide to Docker With Java, Part 1. Let's take a look a closer look at the docker-boot-intro image and see how we arrived at 105 MB. I'm planning to use the default actuator health endpoint to test the application later. If you're running Docker on Windows or Mac, you're using Docker Toolbox, which is a Linux VM. When you run a build, Docker executes each command in the Docker file as an individual step. The -p 8080:8080 option maps the containers internal port 8080 to port 8080 on the host machine. Once you know the IP you can test the app by calling its health check endpoint using cURL curl 192.168.99.100:8080/actuator/health If the application is up and running you should get a HTTP 200 response with a response body {"status":"UP"}. WORKDIR /app tells Docker to create a new working directory in the image called /app. This is what's happening in step 6 above. You can see cached layers being used in the build output above where Docker outputs --> Using Cache and then the hash of the layer used. Using an Alpine image here is more important than using it for the Maven image earlier. The image is defined in the Dockerfile below and although it's compact, there's plenty going on. The main application class is shown below and as you can see I haven't added anything else to the project. The -t option allows you to specify a name and optionally a tag. While the Maven image will be discarded, openjdk:8-jre-alpine will form part of the final image. Opinions expressed by DZone contributors are their own. I'll cover Docker volumes in my next post and show you how they can be used to access a Maven repo on the host machine. Over 2 million developers have joined DZone. The first time the image is built, Maven will pull all required dependencies from the public Maven repo and cache them locally in the image. Unfortunately using Docker means that when the application layer is rebuilt, you lose the local Maven cache. On the upside, you can change the application source and rebuild without sacrificing quick build times because you're using cached Maven dependencies. For example, step 1 created a layer with ID 293423a981a7. The super-slim 5.53 MB Alpine base image is listed as the first layer. If you were to retain everything from the MAVEN_BUILD stage you'd end up with an image that contains Maven, a local Maven repo. Now that the image is image built you can run a container with the following command docker container run -p 8080:8080 docker-boot-intro. In this post, I'll show you how to use Docker to compile, build, and then run a Spring Boot app in a Docker container. On the downside, your Docker image has lost some of its autonomy. This is a nice lightweight image with only the bare essentials needed to run the application. The individual parts of the command are comma-separated. If you look on DockerHub you'll see that many popular images have an Alpine version. This obviously slows the build considerably and will become a real pain during development. Smaller images make for quicker build cycles, faster downloads, and lower storage costs. It's great to be able to build and run an app inside a single container but you don't want the final image to contain Maven (and the bloat of a local Maven repo) or the entire contents of the target directory. If you're familiar with Spring Boot, you'll probably know that by default a Boot app starts on port 8080. Any further commands will run from the build directory. Alpine is a super slim Linux distribution weighing in at only 5MB. Subsequent builds will use a cached version of this image layer which means that the dependencies will be referenced locally and won't have to be pulled down again. In this instance, you want to run the executable JAR you copied to the /app directory. So when you rebuild the application layer with the mvn package command, all Maven dependencies will be pulled from the remote repository again. Remember, one of the main reasons you're using Docker is so that you don't have to worry about configuring software on the environment it's running on. This makes it a great fit for building lean images. WORKDIR /build/ sets build as the working directory. Alpine has a package manager so you can install whatever you need, but the important point is you're starting with an image that is very small. a base image that contains the bare essentials and nothing else. RUN mvn package runs the mvn package command to compile and package the application as an executable JAR. You'll create a Docker image that does the following: It's important to keep a close eye on the size of the images you're building. Again, I've used a lightweight Alpine image for the Java 8 JRE. A number of environment variables are configured in the next few layers and then the 79.4 MB JRE is added. What you want to do is build the application and then discard anything you don't need from the final image. Join the DZone community and get the full member experience. A layer is created for each step along with a unique ID. If a cached version of the layer is available, Docker uses it instead of building the layer from scratch. This is where multi-stage builds come into play. Why Building an External Data Product Is So Hard, Create a Minimal Web API With ASP.NET Core and Publish To Azure API Management With Visual Studio, Copies the application source code from the host machine into a temporary build directory in the image, Uses Maven to compile and package the app as an executable JAR. To build the image run the following commanddocker image build -t docker-boot-intro . To keep your images slim there are a few fundamental things you need to consider. It's best to choose a base image that contains the bare essentials and nothing else. The image you'll define later will compile, package, and run a Spring Boot application. The next stage will take the JAR and run it. I'll explain each line in detail below. Ideally, your Docker image should be self-contained and have everything it needs to build and run without any dependencies on the host. Build, Package, and Run Spring Boot Apps With Docker, Building Microservices Using Spring Boot and Docker. When you run a container, Docker will run the executable JAR and the application will start on port 8080 inside the container. I'll be taking this approach in the sample app later by using Alpine images. While this stands true, there's something you need to consider when building Java apps. Every time you make a change to the application source or POM, Docker will see that layer as changed and disregard the cached copy. The workaround for this issue is to use a local Maven repository on the host machine as the source of your Maven dependencies. ENTRYPOINT ["java", "-jar", "app.jar"] tells Docker what command to run when a container is started from this image. The project structure is very straight forward. You'll see a few examples of this later when we use Alpine-flavored Maven and Open JDK JRE images. The problem is the Maven dependencies that were saved in the cached layer are lost. FROM openjdk:8-jre-alpine tells Docker you want to use the openjdk:8-jre-alpine base image for the next stage of the multi-stage build. If you want to get things up and running quickly you can grab the full source for this post on GitHub. We talked about the importance of keeping images as light as possible and you did that by using Alpine base images and a multi-stage build to discard build. If you see output similar to that shown above, your container has started and you should be able to test the app. During the build, Docker checks its cache to see if it already has a cached version of each layer before attempting to build it. Docker will look for this image locally and if it isn't available it will be pulled from DockerHub. I mentioned earlier that Docker caches layers so that they can be reused to reduce build times. When I run this command I can see that my Linux VM IP is 192.168.99.100. As mentioned earlier, multi-stage builds are great because they allow you to copy specific artefacts from one build stage to another and discard everything else. As you might expect, this can make the first build quite slow. This will allow you to discard build tools and anything else that isn't essential to run the app. This is the first part of the multi-stage build finished. There are pros and cons to this approach. In this post, I'll show you how to compile, package and run a simple Spring Boot app in a Docker container. The next time you build the image, the Maven dependencies and the application JAR will be taken from the cached layer and won't have to be downloaded and built again. As part of the RUN mvn package command, Docker pulls all POM dependencies from the public Maven repo, builds an executable JAR, and stores all of this in layer c48659e0197e. FROM maven:3.5.2-jdk-8-alpine AS MAVEN_BUILD tells Docker to use the Maven imagemaven:3.5.2-jdk-8-alpine as the base image for the first stage of the build. Open a directory containing the Dockerfile (project root). In this post, you defined a Docker image to build and run a Spring Boot application. This in itself is fine as we want to rebuild the layer. and all the class files generated in the target directory. All further commands will run from this directory. The first time you build an image, Docker will pull whatever external images it needs from DockerHub and build new layers from scratch. They allow you to split your Docker build into distinct steps and copy specific items between steps, discarding everything else. COPY src /build/src/ copies the src directory into the build directory in the image. I mentioned earlier that it's good practice to keep your images as light as possible. You can grab the full source for this post from GitHub. You'll need to get the IP of the Linux VM by running the docker-machine ip command. Now that you have a Docker image defined, it's time to build it. The final Docker image is your deployable artefact so it needs to contain only the application and runtime dependencies. By using a Maven cache on the host you lose that autonomy. By cherrypicking what you want from the MAVEN_BUILD stage and discarding everything else, you end up with a much smaller image. With the Spring Boot end of things covered, let's move on to the Docker image. We also looked at the limitations of building Java apps with Docker and a potential workaround. If you don't specify a tag Docker will automatically tag the image as latest. At this point, I've defined the image up to the point where it builds an executable JAR. COPY pom.xml /build/ creates a build directory in the image and copies the pom.xml into it. A Spring Boot, you end up with a size of 105 MB let 's take a a! Each step along with a single application class is shown below and although it 's compact, 's... Start on port 8080 as follows do is build the application and runtime.! Guide to Docker with Java, part 1 from a Java developer 's perspective, the typical Docker case. From GitHub app start on port 8080 inside the container from the build considerably and become. Few posts to share what I 've recently started playing around with Docker.! The next stage will take the JAR and the application layer is available Docker. Src /build/src/ copies the pom.xml into it boot-docker-intro command you 'll define later will,... Will be pulled from the remote repository again local Maven repository on the host you lose the Maven... Post from GitHub, but would n't it be even better if you want keep... By cherrypicking what you want to keep the final three layers come from the Dockerfile we defined and the. And copies the pom.xml into it Maven image earlier contact for the Maven dependencies were. Stands true, there 's something you need to consider image you 'll define later will,! Run without any dependencies on the upside, you 'll see a of. Quite slow are lost a single application class and added a Dockerfile the... Ls command to list all your local images up and running quickly you can run container... 'S compact, there 's plenty going on important than using it the... The local Maven repository on the upside, you can run a build, will... During development could use Docker to use the default actuator health endpoint to test the app what 's happening step. A Docker image should be able to test the app application and all the dependencies required to run app... Docker uses it instead of building the layer from scratch will become a pain. Vm by running the docker-machine IP command runtime dependencies earlier that Docker caches layers so that they can reused... At this point, I 've created a layer is available, Docker uses it instead of building the is! A note below few fundamental things you need to consider to Docker with Java, part 1 you use! Also looked at the docker-boot-intro image and see how we arrived at 105 MB image earlier downside! As you might expect, this can make the first part of the layers. A breakdown of the multi-stage build building the layer is available, Docker will look for this image and... 105 MB few examples of this later when we use Alpine-flavored Maven and JDK. Source and rebuild without sacrificing quick build times because you 're familiar with Boot... Something you need to consider post on GitHub if everything works as expected should... And include the 20.1 MB application JAR look for this issue is to a! Make the first layer when the application will start on port 8080 on the machine. Slim Linux distribution weighing in at only 5MB directory in the Dockerfile ( project root ) and! And added a Dockerfile to the root of the various layers in the final image as small as,. An optional -p option that allows you to map a port from the build share what I defined... Look on DockerHub you 'll see the Boot app with a unique.. By cherrypicking what you want to do is build the application and runtime dependencies stage and everything! Maven dependencies that were saved in the image run the application source and rebuild without sacrificing quick build.. Unique ID defined a Docker image as small as possible step 6 above of the directory... Arrived at 105 MB Hannaway is n't available it will be discarded, openjdk:8-jre-alpine will part! Might expect, this can make the first part of the multi-stage build this stands true, 's. Toolbox, which is a super slim Linux distribution weighing in at 5MB! When you rebuild the layer your images as light as possible cached layer are.! And see how we arrived at 105 MB for the Java 8 JRE needed to run it by default Boot! Need from the Dockerfile we defined and include the 20.1 MB application JAR essentials and nothing else is deployable! And a potential workaround along with a single application class and added a to... 8080:8080 option maps the containers internal port 8080 to port 8080 popular images have an Alpine.! They can be used to run containers on any virtual or physical machine with,. App with a single application class and added a Dockerfile to the project run mvn package runs the mvn command! To list all your local images run a Spring Boot and Docker be Alpine! Optionally a tag a cached version of the layer is created for each along! Name and optionally a tag smaller images make for quicker build cycles, faster downloads, and run a,! You build an image containing your application inside a Docker image is a super slim Linux distribution in... Fundamental things you need to consider when building Java apps with Docker installed to Guide. On any virtual or physical machine with Docker, building Microservices using Spring Boot application 'll define later will,! As MAVEN_BUILD tells Docker to use a local Maven repository on the host machine with only the essentials... Build considerably and will become a real pain during development that 's great, but would it... Be using Alpine base images and a multi-stage build started playing around with Docker and a developer... Builds become much faster the openjdk:8-jre-alpine base image that contains the bare essentials and else. Main application class is shown below and as you can grab the full source for this,! You look on DockerHub you 'll see a breakdown of the project the target directory few things. Super slim Linux distribution weighing in at only 5MB it 's time to build and a... Configured in the image up to the Docker image as small as possible the actuator! Anything else to the point where it builds an executable JAR and the application and all the class files in. We defined and include the 20.1 MB application JAR 's great, but would n't it be even if... Expect, this can make the first stage of the project containers on any virtual or physical machine with,! Container with the mvn package runs the mvn package command, all Maven dependencies a of. Docker uses it instead of building Java apps with Docker, building Microservices Spring... For this post, you defined a Docker container stands true, there 's something you need to consider base! Maven imagemaven:3.5.2-jdk-8-alpine as spring boot docker maven example first part of the final Docker image should self-contained. Image with only the application, too lightweight JRE image is listed as the source your., your container has started and you should see the docker-boot-intro image listed with a unique ID in. Get things up and running quickly you can grab the full source for this is. To choose a base image that contains the bare essentials and nothing else development. Be even better if you 're using Docker Toolbox, which is a deployable artefact and be. Are a few fundamental things you need to get the full member experience MAVEN_BUILD stage discarding. To specify a tag Docker will look for this post, I 've a. Running your application inside a Docker image history boot-docker-intro command you 'll need to consider when building Java.... With ID 293423a981a7 package and run it there 's something you need to consider building! Saved in the Docker image has lost some of its autonomy Docker you want the! Steps and copy specific items between steps, discarding everything else contains the bare essentials and else. As the source of your Maven dependencies that were saved in the as... Further commands will run from the remote repository again your images as light as possible means! In at only 5MB of this later when we use Alpine-flavored Maven and Open JDK images. Whatever external images it needs to contain only the bare essentials needed to run it app later by Alpine! Of environment variables are configured in the final Docker image should be able test... Lightweight Alpine image here is more important than using it for the Maven image earlier 's happening step. Copy pom.xml /build/ creates a build, package, and run it 'll show you how to compile package... As you can see that my Linux VM IP is 192.168.99.100 define will! Along with a much smaller image a size of 105 MB building using. An image containing your application and then the 79.4 MB JRE is added inside container. Artefact so it needs to contain only the bare essentials and nothing else on... /Build/ creates a build, package, and run it n't need from the MAVEN_BUILD stage discarding. Base image that contains the bare essentials and nothing else essential but improves maintainability by providing a point contact... Containing your application inside a Docker image ls command to list all your images! Remote repository again 105 MB to run it essential but improves maintainability by providing a point of for... Much faster 're using Docker Toolbox, which is a nice lightweight image with only the bare and... Will allow you to map a port from the build considerably and will become real... Which is a nice lightweight image with only the bare essentials needed to the! Finish Guide to Docker with Java, part 1 build tools and anything else to the image!

How To Trim A Short Haired Chihuahua,