How do you integrate Spring Boot with Docker?

Table of Contents

• Introduction
• Steps to Integrate Spring Boot with Docker
  • 1. Prepare Your Spring Boot Application
    • Example: Using Maven to Build the JAR File
  • 2. Create a Dockerfile
    • Example: Dockerfile for Spring Boot Application
  • 3. Build the Docker Image
  • 4. Run the Docker Container
  • 5. Verify the Application is Running
  • 6. Docker Compose for Multi-Container Environments (Optional)
    • Example: docker-compose.yml for Spring Boot and MySQL
• Conclusion

Introduction

Docker is a powerful platform for developing, shipping, and running applications inside containers. By packaging your Spring Boot application into a Docker container, you can ensure that it runs consistently across different environments. This approach enhances portability, scalability, and makes it easier to deploy your Spring Boot application in cloud or server environments. In this guide, we'll walk you through the steps to integrate Spring Boot with Docker and deploy your application inside a container.

Steps to Integrate Spring Boot with Docker

1. Prepare Your Spring Boot Application

Before you can Dockerize your Spring Boot application, make sure it's a runnable application (i.e., an executable JAR or WAR file). To generate the JAR file, you can use Maven or Gradle.

Example: Using Maven to Build the JAR File

In your Spring Boot project, navigate to the root directory and run:

This will generate an executable JAR file in the target directory (for example, myapp-0.0.1-SNAPSHOT.jar).

Alternatively, for Gradle users, you can use:

This will create the JAR file in the build/libs directory.

2. Create a Dockerfile

A Dockerfile is a text file that contains all the instructions to build a Docker image. You need to create a Dockerfile in the root directory of your Spring Boot project.

Example: Dockerfile for Spring Boot Application

Explanation:

• FROM openjdk:17-jdk-alpine: Uses the official Java 17 JDK image as the base image.
• WORKDIR /app: Sets the working directory inside the container.
• COPY target/myapp-0.0.1-SNAPSHOT.jar app.jar: Copies the Spring Boot JAR file from the target folder into the Docker container.
• EXPOSE 8080: Exposes port 8080 so that the container can accept requests on this port.
• ENTRYPOINT ["java", "-jar", "app.jar"]: Specifies the command to run the Spring Boot JAR file inside the container.

3. Build the Docker Image

Now that you have the Dockerfile in place, you can build the Docker image. Run the following command in the root directory of your project (where the Dockerfile is located):

This will create a Docker image named spring-boot-app. The . refers to the current directory where the Dockerfile is located.

4. Run the Docker Container

Once the Docker image is built, you can run the Spring Boot application inside a container using the following command:

Explanation:

• -p 8080:8080: Maps port 8080 of the container to port 8080 on your host machine.
• spring-boot-app: Specifies the Docker image name.

The application will be accessible on http://localhost:8080 in your browser.

5. Verify the Application is Running

After running the container, you can verify that your Spring Boot application is running by visiting http://localhost:8080 in your web browser. If the application is running correctly, you should see the application’s homepage or endpoint output.

You can also check the logs of your running container by using:

You can find the container_id by running:

6. Docker Compose for Multi-Container Environments (Optional)

If your application requires other services like a database or caching service (e.g., MySQL, Redis), you can use Docker Compose to manage multiple containers.

Example: docker-compose.yml for Spring Boot and MySQL

Explanation:

• This docker-compose.yml file defines two services: the Spring Boot application and a MySQL container.
• depends_on ensures that MySQL starts before the Spring Boot app.
• The MySQL service will be available at localhost:3306, and the Spring Boot app will be available at localhost:8080.

To start the services using Docker Compose, run:

To stop the services, run:

Conclusion

Integrating Spring Boot with Docker allows you to package your application and its dependencies into a single container, making it highly portable and scalable. By creating a Dockerfile, building the Docker image, and running it in a container, you can easily deploy your Spring Boot application in any environment that supports Docker. Additionally, Docker Compose helps manage multi-container applications, which is useful when your Spring Boot app requires services like a database or cache.

With Docker, you can ensure that your Spring Boot application runs consistently across different environments, making it ideal for continuous integration and deployment (CI/CD) pipelines.