A template project to create a Docker image for a Java application. The example application uses Quarkus to expose an HTTP endpoint.
Golang developer? Check out https://github.com/miguno/golang-docker-build-tutorial
Features:
- The Docker build uses a
multi-stage build setup
including a downsized JRE (built inside Docker via
jlink) to minimize the size of the generated Docker image, which is 131MB. - Supports Docker BuildKit
- Java 21 (Eclipse Temurin)
- JUnit 5 for testing
- Maven for build management, using Maven Wrapper
- Supports GraalVM to create native images (think: native binaries that do not require a JRE to be installed) for the example application. See Building a Native Exectuable in the Quarkus documentation. To keep things simple, the Docker setup of this project intentionally does not use these native app images because the majority of Java developers do not use GraalVM. If you do want to use native images, please modify Dockerfile accordingly.
- GitHub Actions workflows for Maven and Docker
- Optionally, uses
just
for running common commands conveniently, see justfile.
- Uses .env as central configuration to set variables used by justfile and other helper scripts in this project.
Docker must be installed on your local machine. That's it. You do not need a Java JDK or Maven installed.
Step 1: Create the Docker image according to Dockerfile.
This step uses Maven to build, test, and package the
Java application according to
pom.xml. The resulting image is 102MB in size, of which 44MB are
the underlying alpine image.
# ***Creating an image may take a few minutes!***
$ docker build --platform linux/x86_64/v8 -t miguno/java-docker-build-tutorial:latest .
# You can also build with the new BuildKit.
# https://docs.docker.com/build/
$ docker buildx build --platform linux/x86_64/v8 -t miguno/java-docker-build-tutorial:latest .Optionally, you can check the size of the generated Docker image:
$ docker images miguno/java-docker-build-tutorial
REPOSITORY TAG IMAGE ID CREATED SIZE
miguno/java-docker-build-tutorial latest 6eeb79c07157 4 minutes ago 102MBStep 2: Start a container for the Docker image.
$ docker run -p 8123:8123 miguno/java-docker-build-tutorial:latestStep 3: Open another terminal and access the example API endpoint of the running container.
$ curl http://localhost:8123/status
{"status":"idle"}If you have just installed, you can run the commands above more conveniently as per this project's justfile:
$ just
Available recipes:
build-native # build the native application locally (requires GraalVM)
clean # clean (remove) the build artifacts
default # print available targets
dev # run the application locally (in Quarkus development mode) with hot reload
docker-image-create # create a docker image (requires Docker)
docker-image-run # run the docker image (requires Docker)
docker-image-size # size of the docker image (requires Docker)
evaluate # evaluate and print all just variables
package # package the application to create an uber jar
run # run the application locally.
send-request-to-app # send request to the app's HTTP endpoint (requires running container)
system-info # print system information such as OS and architecture
test # run the test suiteExample:
$ just docker-image-createYou can also build, test, package, and run the Java application locally
(without Docker) if you have JDK 21+ installed. You do not need to have Maven
installed, because this repository contains the
Maven Wrapper mvnw (use mvnw.cmd
on Windows).
# Build, test, package the application locally.
$ ./mvnw clean package
# Run the application locally.
$ java -jar target/app-runner.jar
# Alternatively, you can run the application in development mode with hot reloading.
$ ./mvnw quarkus:dev