How do you create a Docker image for a Spring Boot application?

Table of Contents

Introduction

Creating a Docker image for a Spring Boot application is an essential step in containerizing your application for consistent and portable deployment. Docker provides an isolated environment where your application can run with all of its dependencies, ensuring it behaves the same regardless of where it's deployed. By Dockerizing your Spring Boot application, you can make it easier to scale, deploy in cloud environments, or run on different machines without worrying about dependencies.

In this guide, we will walk through the steps of creating a Docker image for a Spring Boot application.

Steps to Create a Docker Image for a Spring Boot Application

1. Build Your Spring Boot Application

Before you can Dockerize your Spring Boot application, ensure that it is packaged correctly as a JAR or WAR file. This can be done easily using Maven or Gradle.

Example: Using Maven to Build the Application

Navigate to the root directory of your Spring Boot project and run the following Maven command:

This will compile your code and package your Spring Boot application into a JAR file, typically located in the target directory.

Example: Using Gradle to Build the Application

If you are using Gradle, run the following command:

The output JAR file will be located in the build/libs directory.

2. Create a Dockerfile

A Dockerfile is a simple text file that contains a set of instructions for building a Docker image. To create a Docker image for your Spring Boot application, you need to create a Dockerfile in the root directory of your project (next to your pom.xml or build.gradle file).

Example Dockerfile for Spring Boot Application

Explanation of the Dockerfile:

  • FROM openjdk:17-jdk-alpine: Uses an official OpenJDK 17 image as the base. You can choose a different version of Java if needed.
  • WORKDIR /app: Sets the working directory inside the container to /app.
  • COPY target/myapp-0.0.1-SNAPSHOT.jar app.jar: Copies the Spring Boot JAR file from your local machine into the container. Make sure the JAR file name matches the one generated in the target folder.
  • EXPOSE 8080: Exposes port 8080 to allow external access to the Spring Boot application. Spring Boot's default port is 8080.
  • ENTRYPOINT ["java", "-jar", "app.jar"]: Runs the Spring Boot application inside the container.

3. Build the Docker Image

Once you've created the Dockerfile, the next step is to build the Docker image using the docker build command.

Navigate to the directory where the Dockerfile is located (this should be the root of your project). Then run the following command:

Explanation:

  • -t spring-boot-app: This option tags the image with the name spring-boot-app.
  • .: Refers to the current directory where the Dockerfile is located.

This command will build the Docker image and output the results of the build process. If successful, you will see the image built and tagged.

4. Verify the Docker Image

After the image is built, you can verify that it exists by running:

This command will list all the available Docker images. You should see your spring-boot-app image listed.

5. Run the Docker Container

Now that you have created the Docker image, you can run the Spring Boot application inside a Docker container. To do this, use the docker run command:

Explanation:

  • -p 8080:8080: Maps port 8080 of the container to port 8080 of your host machine, allowing you to access the application at http://localhost:8080.
  • spring-boot-app: This is the name of the Docker image you just built.

After running the command, the Spring Boot application will be running inside the container, and you can access it through http://localhost:8080.

6. Access the Application

Once the container is running, open a web browser or use a tool like Postman or curl to send a request to your Spring Boot application:

If everything is set up correctly, you should receive a response from your Spring Boot application.

7. Stop the Docker Container

To stop the Docker container, run the following command:

This will list the running containers. Find the CONTAINER ID of your Spring Boot container, and then stop it using:

Replace <container_id> with the actual ID of your container.

Optional: Using Docker Compose for Multi-Container Applications

If your Spring Boot application needs to connect to other services (e.g., a database like MySQL or PostgreSQL), you can use Docker Compose to manage multiple containers.

Example docker-compose.yml for Spring Boot and MySQL

To start the services using Docker Compose:

To stop the services:

Conclusion

By following these steps, you can easily create a Docker image for your Spring Boot application, making it portable and scalable. Docker allows you to package your application along with all its dependencies into a single container, which can run consistently across different environments. This approach simplifies the deployment process and ensures that your Spring Boot application behaves the same regardless of the host machine.

Docker also integrates well with tools like Docker Compose, allowing you to manage multi-container applications, making it easier to develop and deploy full-stack applications. Dockerizing your Spring Boot app can be a game-changer when it comes to scaling and deploying in production environments, especially in cloud or container orchestration systems like Kubernetes.

Share
Similar Questions