Master Spring Boot Deployment with Docker the Easy Way

Deploying a Spring Boot application can feel overwhelming, especially for beginners. However, with Docker, the process becomes simpler and more efficient. This guide walks you through mastering Spring Boot deployment with Docker in an easy, step-by-step way. Whether you’re a beginner or an intermediate developer, you’ll find practical tips, clear explanations, and real code examples to streamline your deployment process. Let’s dive in!

master springboot deployment docker easy

Why Use Docker for Spring Boot Deployment?

Docker simplifies application deployment by packaging your app and its dependencies into a single container. As a result, you avoid issues like “it works on my machine” syndrome. Moreover, Docker ensures consistency across development, testing, and production environments.

Here’s why Docker is a game-changer for Spring Boot:

Portability: Run your app anywhere Docker is installed.
Consistency: Ensure the same environment everywhere.
Scalability: Easily scale your app with container orchestration tools like Kubernetes.
Efficiency: Reduce setup time and dependency conflicts.

For more details on Docker’s benefits, check out the official Docker documentation.

Prerequisites for Spring Boot and Docker Deployment

Before we start, let’s ensure you have everything ready. Don’t worry—these are beginner-friendly tools and steps.

What You’ll Need

Java 17 or later: Spring Boot works best with modern Java versions.
Maven or Gradle: For building your Spring Boot app.
Docker Desktop: Install it from Docker’s official site.
A Spring Boot project: If you don’t have one, we’ll create a simple app.
Basic command-line knowledge: Familiarity with terminal commands helps.

If you’re new to Spring Boot, consider exploring our Introduction to Spring Boot for a quick start.

Step 1: Create a Simple Spring Boot Application

First, let’s build a basic Spring Boot app. This example uses Maven, but Gradle works similarly. If you already have a project, skip to the next section.

Setting Up the Project

Visit Spring Initializr.
Choose:
- Project: Maven
- Language: Java
- Spring Boot: Latest stable version
- Dependencies: Add “Spring Web”
Download and unzip the project.

Here’s a simple REST controller to test your app:

// src/main/java/com/example/demo/DemoApplication.java
package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, Docker!";
    }
}

This code creates a Spring Boot app with a /hello endpoint. Run it using ./mvnw spring-boot:run and visit http://localhost:8080/hello to see the output.

Step 2: Dockerize Your Spring Boot Application

Now, let’s package your app into a Docker container. This involves creating a Dockerfile, which tells Docker how to build your app’s image.

Writing the Dockerfile

Create a file named Dockerfile in your project’s root directory:

# Use an official OpenJDK image as the base
FROM openjdk:17-jdk-slim

# Set the working directory inside the container
WORKDIR /app

# Copy the compiled JAR file into the container
COPY target/demo-0.0.1-SNAPSHOT.jar app.jar

# Expose port 8080 for the Spring Boot app
EXPOSE 8080

# Run the Spring Boot app
ENTRYPOINT ["java", "-jar", "app.jar"]

Explanation of the Dockerfile

FROM: Uses a lightweight OpenJDK 17 image.
WORKDIR: Sets the container’s working directory.
COPY: Copies your app’s JAR file (built by Maven) into the container.
EXPOSE: Declares that the app runs on port 8080.
ENTRYPOINT: Specifies the command to run your app.

Building the Docker Image

Before building, compile your Spring Boot app:

./mvnw clean package

This generates a JAR file in the target directory. Next, build the Docker image:

docker build -t spring-boot-docker .

The -t flag names the image spring-boot-docker. The . tells Docker to use the Dockerfile in the current directory.

Step 3: Run Your Dockerized Spring Boot App

With the image built, let’s run it as a container:

docker run -p 8080:8080 spring-boot-docker

Here, -p 8080:8080 maps port 8080 on your machine to port 8080 in the container. Visit http://localhost:8080/hello to see “Hello, Docker!” in your browser.

If the port is already in use, try a different one, like -p 8081:8080.

Step 4: Optimize Your Docker Image

The current image works, but it’s not optimized. For instance, the image size might be larger than necessary. Let’s improve it using a multi-stage build.

Multi-Stage Dockerfile

Replace your Dockerfile with this optimized version:

# Stage 1: Build the application
FROM maven:3.8.5-openjdk-17 AS builder
WORKDIR /app
COPY . .
RUN mvn clean package -DskipTests

# Stage 2: Create the final image
FROM openjdk:17-jdk-slim
WORKDIR /app
COPY --from=builder /app/target/demo-0.0.1-SNAPSHOT.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

Why Multi-Stage Builds?

Smaller Image Size: The first stage builds the app, while the second stage only includes the JAR and runtime.
Faster Builds: Separates build and runtime environments.
Security: Reduces unnecessary tools in the final image.

Build and run the optimized image:

docker build -t spring-boot-docker .
docker run -p 8080:8080 spring-boot-docker

Step 5: Push Your Image to Docker Hub

To share or deploy your app, push the image to Docker Hub. First, create a Docker Hub account if you don’t have one.

Tagging and Pushing

Tag your image with your Docker Hub username:

docker tag spring-boot-docker yourusername/spring-boot-docker:latest

Push it to Docker Hub:

docker push yourusername/spring-boot-docker:latest

Now, anyone can pull and run your image using:

docker pull yourusername/spring-boot-docker:latest

Step 6: Deploy to a Cloud Platform

For production, you’ll likely deploy to a cloud platform like AWS, Azure, or Google Cloud. Let’s explore a simple deployment to Docker Swarm for local testing.

Setting Up Docker Swarm

Initialize Docker Swarm:

docker swarm init

Create a service:

docker service create --name spring-app --publish 8080:8080 spring-boot-docker

Check the service status:

docker service ls

Visit http://localhost:8080/hello to confirm it’s running. To scale the service:

docker service scale spring-app=3

This runs three instances of your app for load balancing.

For cloud deployment, explore our guide on Deploying Spring Boot to AWS.

Common Issues and Troubleshooting

Deploying with Docker can hit snags. Here are common issues and fixes:

Issue	Solution
Port already in use	Change the host port, e.g., `-p 8081:8080`.
Image too large	Use multi-stage builds or a slimmer base image.
App doesn’t start	Check logs with `docker logs <container_id>`.
Dependency errors	Ensure `pom.xml` includes all required dependencies.

Best Practices for Spring Boot and Docker

To master Spring Boot deployment with Docker, follow these tips:

Use .dockerignore: Exclude unnecessary files (e.g., .git, target) to speed up builds.
Monitor Logs: Use docker logs to debug issues.
Automate Builds: Integrate Docker builds into your CI/CD pipeline.
Secure Your App: Avoid running containers as root and use environment variables for sensitive data.

For more on CI/CD, read our CI/CD with Spring Boot guide.

Conclusion

Mastering Spring Boot deployment with Docker doesn’t have to be hard. By following this guide, you’ve learned how to create, dockerize, optimize, and deploy a Spring Boot app with ease. As a result, you can now deploy consistent, scalable applications anywhere Docker runs. Start experimenting with your own projects, and explore advanced topics like Kubernetes or cloud-native deployments to take your skills further.

Ready to dive deeper? Check out our Advanced Docker Tips or try deploying to Kubernetes.