If you want to get a Spring Boot app running in Docker fast and stop pretending manual deployment is a rite of passage, you are in the right place. This guide walks you from build artifact to running container with the minimum amount of ceremony and the maximum amount of practical commands.

What you will end up with

A runnable jar produced by Maven or Gradle, a tiny Dockerfile that actually does the job, a local image you can run for testing, and optional steps to push the image to a registry for real world deployment. Think of this as containerization for people who like short checklists and bad coffee.

Step 1 Build the runnable jar

Use your project build tool to produce an executable jar. If you use Maven run

mvn clean package

If you use Gradle run

./gradlew bootJar

The jar will usually appear in target for Maven or build/libs for Gradle. That jar is your app wrapped and ready for a tiny VM we call a container.

Step 2 Create a minimal Dockerfile

Keep it small and boring. Pick a compact Java runtime image, copy the jar in, and set the launch command. No multi stage drama required for a quick test.

FROM eclipse-temurin:17-jdk-slim
COPY target/myapp.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

Notes and swaps

• If you used Gradle change the jar path to build/libs.
• Choose a smaller JRE if you want less image size in production and know how to trim runtime modules.
• EXPOSE is optional but useful for documentation and some tooling that reads the Dockerfile.

Step 3 Build the Docker image

From the project root run a straightforward build and tag it for local testing.

docker build -t myapp .

Tip If you plan to push to a registry later add a meaningful tag and consider using your registry naming convention in the tag.

Step 4 Run the container for testing

Start the container in the background and publish a port so you can hit the app from your machine.

docker run -d --name myapp_container -p 8080:8080 myapp

Check logs with docker logs -f myapp_container or hit the endpoint with curl or a browser at http://localhost:8080. If the app does not start check the jar path and Java version.

Step 5 Test and deliver

Run your smoke tests locally. Use curl or an API client to validate the endpoints. When you are happy push the image to a registry using your preferred workflow and tag style. Common registry commands look like logging in and pushing an appropriately named image.

CI and pipeline friendly notes

• Make the Docker build part of your CI job after the artifact step. Artifacts can be produced by Maven or Gradle and then used by the container build step.
• Use consistent tags and immutable tags for deployed images in your CD pipeline.
• Scan images for vulnerabilities as part of your DevOps checks before pushing to production.

Quick troubleshooting guide

• App does not start Look at the logs and confirm the jar runs locally with java -jar.
• Port not reachable Confirm the container port matches your app port and that you used -p hostPort:containerPort.
• Image too large Consider switching to a smaller base runtime or using a build stage to trim artifacts.

That is it. From a successful jar build to a local Docker container in a few commands. This process gives you repeatable local testing and a solid foundation for CI pipelines and production containerization without unnecessary drama.