Quick overview

So you built a Spring Boot microservice in Java and now you want to wrap it in a neat little container so the world can run it without drama. This guide walks through packaging a runnable jar into a Docker image and taking that image from local sanity checks to CI CD and then to production on Docker Compose or Kubernetes. Same facts as the boring manuals but with fewer lectures and more sarcasm.

Prepare the application

Make sure Maven or Gradle produces a single executable jar. Configure your server port and health endpoints so orchestrators can ping your service and decide if it is alive or faking it. Trim dev junk from the build to keep the image small and avoid shipping your IDE settings to production.

Create a Dockerfile

Use a multi stage Dockerfile so the build tools stay in the build stage and the final image contains only the runtime bits. That reduces image size and speeds up delivery which your CI will thank you for.

FROM maven AS builder
COPY pom.xml .
COPY src src
RUN mvn -DskipTests package

FROM openjdk
COPY --from=builder target/app.jar app.jar
ENTRYPOINT ["java", "-jar", "app.jar"]

This example uses Maven but Gradle works the same idea. Replace openjdk with a slim Java runtime for smaller images. Do not forget to expose the port you use in Spring Boot in the image metadata or simply map it at runtime.

Build the Docker image

Run the docker build command with a meaningful tag so you can push and reference the artifact later. Example command is

docker build -t myorg/myapp:1.0 .

Tags help your CI CD pipelines identify releases and forks. Use semantic versioning or commit based tags if you like living dangerously.

Run and test locally

Start the container locally to validate behavior. A quick run might look like this

docker run -p 8080:8080 --rm myorg/myapp:1.0

Check logs and hit your health endpoint. Use docker inspect to find dynamic port mappings when you use publish all ports. Quick smoke tests prevent very expensive surprises later.

Push to a registry and CI CD

Tag and push the image to your registry with docker tag and docker push. Use a private registry for internal services and a public one for shared components. Hook the build and push steps into your CI CD pipeline so images are produced automatically on merges or tags.

Deploy to production

For small deployments use Docker Compose to wire up a few services. For fleets of microservices use Kubernetes with health probes, resource limits and readiness checks so your cluster can behave like an adult under load. Always add liveness and readiness probes so Kubernetes can tell the truth about service health.

Quick checklist

• Produce a runnable jar with Maven or Gradle
• Use a multi stage Dockerfile to keep images lean
• Tag images clearly for CI CD and tracing
• Smoke test locally before pushing
• Use Docker Compose for small stacks and Kubernetes for scale

If you follow those steps you will have a Dockerized Spring Boot application that plays nicely with CI CD pipelines and modern deployment platforms including Kubernetes. Congratulations you are now officially containerized and marginally more cloud ready than you were five minutes ago.