Ultimate Guide to Deploying Spring Boot Applications with Docker

Docker and Its Growing Popularity

Docker has quickly become one of the most widely used technologies for DevOps and deployment. It has gained significant attention due to its versatility, compatibility across different devices, and its contribution to streamlining the development and deployment processes. Docker’s primary appeal lies in its ability to simplify the packaging of applications, making them more portable, consistent, and easier to deploy across different environments.

Why Docker Is So Popular?

Docker is often celebrated for its simplicity and efficiency in managing containerized applications. It allows developers to package their applications along with all the dependencies required to run them, including libraries, configurations, and environment variables. These application packages are known as containers, which can be easily deployed and run in any environment, regardless of the underlying system architecture or software configurations.

The growing interest in Docker in recent years can be attributed to its cloud-native capabilities. With Docker, organizations can run applications efficiently in cloud environments, eliminating the need for traditional virtual machines (VMs) or hardware-specific infrastructure. This has paved the way for scaling applications across large distributed systems, ensuring high availability, and improving the speed of development cycles.

One of the most significant benefits Docker brings is the ability to create immutable images. These images are pre-configured with everything needed for the application to run, ensuring that the application behaves the same way across all environments. Developers and operations teams no longer need to worry about discrepancies between development, staging, and production systems, as Docker ensures consistency by running containers in isolated environments.

Docker also provides a great level of flexibility when managing application deployment. The platform allows the creation of microservices, which enables each component of an application to be packaged as an independent container. These containers can then be deployed and scaled independently, optimizing the resources needed for running various parts of an application. This is especially beneficial for businesses adopting cloud-native architectures and striving for continuous delivery and integration practices.

Key Features of Docker

Docker’s appeal lies in a range of features that make it an excellent tool for development, testing, and deployment. Below are some of the primary features of Docker that have contributed to its widespread adoption:

1. Portability: Docker containers are portable and can be run on any machine that has Docker installed. This means that the application and its dependencies are packaged together in a container, ensuring consistent behavior across different environments, whether it’s a developer’s machine, a testing server, or a production system.
2. Lightweight: Docker containers are lightweight because they share the host system’s kernel, reducing the overhead compared to traditional virtual machines. This makes them faster to start and more resource-efficient.
3. Scalability: Docker supports scaling applications by running multiple containers across different nodes in a cluster. It also works seamlessly with orchestration tools like Kubernetes to handle dynamic scaling based on demand, which is crucial for cloud-native applications.
4. Isolation: Containers offer a level of isolation that prevents conflicts between applications. This is particularly useful when running multiple services or microservices on the same host. The container ensures that each application runs independently without affecting others, making them more secure and stable.
5. Version Control: Docker images can be versioned, allowing developers to track changes to their application images and easily roll back to previous versions if needed. This makes deployment and rollback processes straightforward.
6. Integration with DevOps Tools: Docker integrates well with a range of DevOps tools, including Jenkins, GitLab, and CircleCI, to enable continuous integration and continuous deployment (CI/CD) pipelines. This integration ensures that developers can automatically test, build, and deploy applications quickly and efficiently.
7. Community Support and Ecosystem: Docker benefits from a vast and active community, which contributes to a rich ecosystem of tools, plugins, and resources. This ecosystem makes it easier for developers to find solutions to problems and leverage pre-built Docker images from repositories like Docker Hub.

By using Docker, developers can focus more on writing code and less on managing the underlying infrastructure, significantly reducing the time and effort required to build, test, and deploy applications.

Introduction to Spring Boot with Docker

Spring Boot, a framework built on top of the popular Spring Framework, simplifies the development of Java-based applications. It provides production-ready configurations out of the box, minimizing the need for boilerplate code and configuration. Spring Boot also promotes microservice architecture, making it easier to create scalable and maintainable applications. When combined with Docker, Spring Boot allows developers to easily package and deploy their Java applications as containers, making them more portable and efficient.

What Is Spring Boot?

Spring Boot is a framework designed to simplify the development of Java applications by providing production-ready defaults and a set of pre-configured templates. It eliminates the need for complex XML configuration files and allows developers to focus on writing business logic rather than configuring application settings.

Spring Boot supports both monolithic applications and microservices architecture, enabling developers to build scalable, modular systems. One of the key features of Spring Boot is its embedded server capabilities, which means that developers can package their Spring Boot applications as standalone executable JAR or WAR files that include the server, thus removing the need for deploying the application on a separate web server.

The framework also includes features like automatic configuration, built-in security, and integrated testing, making it easier for developers to create robust and secure applications. The ability to run a Spring Boot application as a single self-contained unit is one of the reasons why it pairs well with Docker, as it simplifies the process of containerizing and deploying applications.

Why Combine Spring Boot with Docker?

When developers deploy applications using traditional methods, they often face issues with compatibility between different environments, such as development, testing, and production. These issues arise due to differences in system configurations, libraries, and runtime environments.

Docker solves this problem by encapsulating the application and its dependencies within containers. When combined with Spring Boot, Docker ensures that the Spring Boot application behaves consistently across all environments, whether it’s a local developer machine or a production server in the cloud. Docker containers package the application along with the required libraries, configuration files, and runtime environments, ensuring that the application runs smoothly and predictably anywhere.

In addition to solving compatibility issues, Docker enhances deployment efficiency by allowing developers to run multiple instances of the same Spring Boot application on the same machine. This improves resource utilization and reduces the overall cost of deployment.

Key Benefits of Using Docker with Spring Boot

There are several benefits to using Docker in combination with Spring Boot, especially for modern software development practices like continuous integration and continuous deployment (CI/CD). Here are some of the key advantages:

1. Consistent Environments: Docker containers ensure that Spring Boot applications run consistently across different environments, reducing the chances of bugs and errors due to environmental discrepancies.
2. Simplified Deployment: Docker simplifies the process of deploying Spring Boot applications by eliminating the need for complex configurations and setup. Developers can deploy the application with a single command and ensure it runs on any machine with Docker installed.
3. Faster Development Cycle: Docker accelerates the development cycle by allowing developers to quickly test and deploy changes in a containerized environment. This leads to faster iteration and more frequent releases.
4. Microservices Architecture: Spring Boot is designed to work seamlessly with microservices architecture, and Docker is an ideal platform for deploying and managing microservices. Each microservice can be packaged as a separate container, making it easy to scale and manage them independently.
5. Portability: Docker containers can run on any machine with Docker installed, making Spring Boot applications highly portable. This is particularly useful when deploying applications to the cloud or across different development, testing, and production environments.
6. Resource Efficiency: Docker containers are lightweight and resource-efficient compared to traditional virtual machines, enabling developers to run multiple instances of a Spring Boot application on the same machine without consuming too many resources.
7. Improved Security: Docker containers provide a level of isolation between applications, making it harder for vulnerabilities in one container to affect other containers. This enhances the security of Spring Boot applications.

Overall, combining Docker with Spring Boot creates a powerful solution for developing, testing, and deploying applications. It offers developers a streamlined, efficient, and consistent workflow, making it an ideal choice for modern software development practices.

Docker and Cloud-Native Applications

One of the most significant reasons Docker has gained popularity is its compatibility with cloud-native applications. Cloud-native applications are designed to take full advantage of the cloud’s flexibility, scalability, and resource management. Docker, along with tools like Kubernetes for orchestration, is a key enabler of cloud-native applications.

When building cloud-native applications, developers aim to break down applications into smaller, independent components (often referred to as microservices). Each of these components can be developed, tested, and deployed independently, which makes them easier to scale and maintain.

Docker simplifies the deployment of these microservices by providing a standardized environment where each service can be packaged into a container. These containers can be easily deployed and managed on cloud platforms, ensuring that the applications are highly available, scalable, and resilient to failures.

Bootstrap a Secure Spring Boot Application

Now that we understand the basics of Docker and Spring Boot, let’s dive into how you can bootstrap a secure Spring Boot application and prepare it for containerization. Spring Boot makes it easy to develop production-ready applications quickly. When you integrate security features into a Spring Boot application, it enhances the overall security of the application by providing built-in tools for authentication, authorization, and data protection.

Getting Started with Spring Boot

The first step in creating a Spring Boot application is to initialize your project. Spring Boot provides an easy-to-use tool called Spring Initializr, which allows you to generate a project with the required dependencies in just a few clicks. You can access the Spring Initializr web interface or use the command line to bootstrap your project.

To begin, open your preferred IDE and use Spring Initializr to create a new Spring Boot application. You can customize the project setup by selecting the language (Java, Kotlin, etc.), build system (Maven or Gradle), and other configurations such as the version of Spring Boot you wish to use. Additionally, you will select the dependencies your application requires. Common dependencies for a Spring Boot application include Spring Web, Spring Security, Spring Data JPA, and others, depending on the functionality you want to build into your application.

Once you’ve generated the project, you can download the ZIP file and extract it to a directory. For example, you could place the extracted project in a folder called springboot-docker-demo. This project directory will contain all the necessary files for your Spring Boot application.

Setting Up Your Application Class

In Spring Boot, the main application class is the entry point for your application. This class should be annotated with @SpringBootApplication, which is a convenience annotation that includes other annotations like @Configuration, @EnableAutoConfiguration, and @ComponentScan.

You can create your main application class in the following way:

java

Copy

@SpringBootApplication

public class SpringBootDockerDemoApplication {

    public static void main(String[] args) {

        SpringApplication.run(SpringBootDockerDemoApplication.class, args);

    }

}

 

Once you have this in place, you can start building your application’s functionality. For instance, you can add a simple controller to welcome users to your application. This is where you can define the greeting message for the user.

Adding a Simple Controller

You can add a controller class that handles HTTP requests and returns responses. In this example, we will create a simple controller that welcomes the user with a message like “Welcome, guest!”. The controller will be responsible for handling HTTP GET requests to the root URL (/), and it will return a message.

java

Copy

@RestController

public class WelcomeController {

    @GetMapping(“/”)

    public String welcome() {

        return “Welcome, guest!”;

    }

}

 

Now, your Spring Boot application should be functional. You can test it by running the application and accessing it through your web browser. This will confirm that everything is working as expected before you move to the next steps of security integration and Dockerization.

Configuring Spring Security

While Spring Boot simplifies the creation of secure applications, you still need to configure authentication and authorization. By default, Spring Boot uses basic authentication, which can be overridden with custom security settings.

To enable Spring Security, add the necessary dependency to your pom.xml (if you’re using Maven):

xml

Copy

<dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-security</artifactId>

</dependency>

 

Spring Security is highly customizable, allowing you to configure security mechanisms such as login forms, role-based access control, and more. In this case, let’s configure basic security settings and ensure that users can access the application.

Here’s an example of how you can configure Spring Security to secure your application:

java

Copy

@Configuration

@EnableWebSecurity

public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override

    protected void configure(HttpSecurity http) throws Exception {

        http

            .authorizeRequests()

                .antMatchers(“/”, “/welcome”).permitAll()  // Allow public access to home page

                .anyRequest().authenticated()  // Secure other pages

            .and()

            .formLogin()

                .loginPage(“/login”)

                .permitAll()

            .and()

            .logout()

                .permitAll();

    }

}

 

This configuration ensures that the home page (/) is publicly accessible, while other pages are protected and require authentication. You can adjust this configuration to suit the specific security needs of your application.

Integrating Okta for Authentication

For advanced authentication features like Single Sign-On (SSO), social logins, and OAuth 2.0, you can integrate Okta with your Spring Boot application. Okta is a popular identity provider that simplifies user authentication and authorization.

To integrate Okta, you first need to sign up for a free developer account with Okta. Once you have an account, you can create an Okta application for your Spring Boot application. Okta will provide the necessary credentials, including the client_id and client_secret, that you will use to authenticate your users.

Next, you need to configure your Spring Boot application to use Okta for authentication. You can achieve this by adding the Okta Spring Boot starter to your pom.xml file:

xml

Copy

<dependency>

    <groupId>com.okta.spring</groupId>

    <artifactId>okta-spring-boot-starter</artifactId>

</dependency>

 

Once the dependency is added, you can configure the Okta authentication in your application.properties file. Here’s an example of the required configuration:

properties

Copy

okta.oauth2.client-id=your-client-id

okta.oauth2.client-secret=your-client-secret

okta.oauth2.issuer=https://{yourOktaDomain}/oauth2/default

 

After completing these steps, your Spring Boot application will be integrated with Okta and will support advanced authentication features such as OAuth 2.0 and social logins.

Running the Spring Boot Application Locally

Once you’ve set up your Spring Boot application and added necessary security configurations, you can easily run your application locally to test its functionality. Spring Boot provides a convenient command for running the application directly from the terminal. Navigate to the project directory and run the following command:

bash

Copy

mvn spring-boot: run

 

Alternatively, if you’re using Gradle, you can run the application with:

bash

Copy

./gradlew bootRun

 

After running the application, open your web browser and navigate to http://localhost:8080. You should see the “Welcome, guest!” message, indicating that your Spring Boot application is up and running.

To test the security features, try to access any page other than the root URL (/). You should be prompted to log in, and once authenticated, you should be able to access the protected resources.

Summary of Spring Boot Security Configuration

• Spring Security: By default, Spring Boot integrates Spring Security, providing essential authentication and authorization features for your application.
• Okta Integration: For enhanced security and user management, Okta can be integrated with your Spring Boot application to enable Single Sign-On (SSO), OAuth 2.0, and social login options.
• Securing Endpoints: You can customize which endpoints in your application are publicly accessible and which require authentication, based on your needs.

With these steps, you’ve successfully bootstrapped a secure Spring Boot application that is ready for deployment in Docker. The next step is to create a Docker image of the application and deploy it using Docker. Dockerization will ensure that your application can be run consistently across different environments.

How to Build a Spring Boot Docker Image

Now that we have developed and secured a Spring Boot application, the next step is to containerize it using Docker. Dockerization allows us to package the application and all its dependencies into a container, making it easier to deploy, scale, and manage across different environments.

In this section, we will walk through the process of building a Docker image for a Spring Boot application and running it as a container.

Understanding Docker Images and Containers

Before we begin the process, it’s important to understand the concepts of Docker images and containers.

• Docker Image: An image is a lightweight, standalone, and executable package that contains everything needed to run a software application: code, libraries, environment variables, and configurations. It is a snapshot of the application, and once created, it can be reused and distributed across multiple systems.
• Docker Container: A container is a runtime instance of an image. When you run a Docker image, it becomes a container, which can be executed and managed. Containers are isolated from each other and the host system, ensuring that each application runs in a consistent environment.

Step 1: Create a Dockerfile

The first step in Dockerizing a Spring Boot application is to create a Dockerfile. This file contains a set of instructions that define how the Docker image should be built. A Dockerfile can be considered a blueprint for the container, providing the necessary configurations to create the application image.

Here’s an example of a Dockerfile for a Spring Boot application:

Dockerfile

Copy

# Use the official OpenJDK image as the base image

FROM openjdk:17-jdk-slim

 

# Set the working directory inside the container

WORKDIR /app

 

# Copy the JAR file from the local machine into the container

COPY target/myapp.jar /app/myapp.jar

 

# Expose the application port (default Spring Boot port is 8080)

EXPOSE 8080

 

# Define the command to run the application when the container starts

ENTRYPOINT [“java”, “-jar”, “myapp.jar”]

 

Let’s break down what each part of the Dockerfile does:

1. FROM openjdk:17-jdk-slim: This line specifies the base image for our application. In this case, we are using the OpenJDK 17 image, which includes the necessary Java runtime environment (JRE) to run a Spring Boot application.
2. WORKDIR /app: This sets the working directory inside the container to /app. All subsequent commands will be executed in this directory.
3. COPY target/myapp.jar /app/myapp.jar: This command copies the JAR file of your Spring Boot application into the container. Ensure that you’ve built your Spring Boot application and the JAR file is located in the target directory.
4. EXPOSE 8080: This exposes port 8080 on the container, which is the default port for a Spring Boot application. Exposing this port allows us to access the application once the container is running.
5. ENTRYPOINT [“java”, “-jar”, “myapp.jar”]: This defines the command to run when the container starts. In this case, it uses the java-jar command to run the Spring Boot JAR file.

Step 2: Build the Spring Boot Application JAR

Before building the Docker image, we need to package the Spring Boot application into a JAR file. You can do this using Maven or Gradle.

For Maven:

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

bash

Copy

mvn clean package

 

This will generate a JAR file inside the target directory (for example, myapp.jar).

For Gradle:

If you’re using Gradle, the equivalent command is:

bash

Copy

./gradlew build

 

After running the command, the JAR file will be available in the build/libs directory.

Step 3: Build the Docker Image

Now that you have your JAR file and the Dockerfile in place, it’s time to build the Docker image. Navigate to the directory where the Dockerfile is located and run the following command:

bash

Copy

docker build -t springboot-app.

 

This command will build the Docker image using the Dockerfile in the current directory. The t flag assigns a name (tag) to the image. In this case, we’ve named it springboot-app. Once the build process is complete, you will see a success message indicating that the image has been created.

Step 4: Run the Docker Container

Once the Docker image has been built, you can run it as a container. To do this, execute the following command:

bash

Copy

docker run -p 8080:8080 springboot-app

 

This command will:

• Run the container based on the springboot-app image.
• Bind the container’s port 8080 to the host’s port 8080, allowing you to access the application in a web browser.

If everything is set up correctly, your Spring Boot application will start inside the container, and you should be able to open a web browser and navigate to http://localhost:8080 to see the application running.

Step 5: Verify the Application

Once the container is running, open your browser and go to http://localhost:8080. If your application is working correctly, you should see the “Welcome, guest!” message (or the appropriate response you have configured).

You can also check the status of your running containers using the following command:

bash

Copy

docker ps

 

This will show you a list of active containers, including the container ID, image name, and port mapping.

Step 6: Stopping and Removing the Container

If you need to stop the container, you can run the following command:

bash

Copy

docker stop <container_id>

 

Replace <container_id> with the ID of your running container (you can find it using docker ps).

If you want to remove the stopped container, you can use the following command:

bash

Copy

docker rm <container_id>

 

Step 7: Push the Docker Image to Docker Hub (Optional)

If you want to share your Docker image with others or deploy it to other systems, you can push the image to Docker Hub or another container registry. To do this, you first need to log in to Docker Hub using the following command:

bash

Copy

docker login

 

Once logged in, tag your image with your Docker Hub repository name:

bash

Copy

docker tag springboot-app your_dockerhub_username/springboot-app:latest

 

Then, push the image to Docker Hub:

bash

Copy

docker push your_dockerhub_username/springboot-app:latest

 

Replace your_dockerhub_username with your actual Docker Hub username. This will upload the image to Docker Hub, making it accessible for deployment anywhere.

Summary of Building and Running a Dockerized Spring Boot Application

• Dockerfile: The Dockerfile contains instructions to create the Docker image, including the base image, working directory, JAR file, exposed ports, and the command to run the application.
• Building the Image: The Docker image is built using the docker build command, which compiles the Spring Boot JAR file into a containerized application.
• Running the Container: The container is run using the docker run command, which binds the container’s ports to the host system, allowing you to access the application in a browser.
• Pushing to Docker Hub: For sharing and deploying the image, you can push the image to Docker Hub or another container registry.

By following these steps, you can easily containerize your Spring Boot application and deploy it in any environment with Docker.

Deploying the Spring Boot Application on Docker Hub

Now that you have Dockerized your Spring Boot application, the next step is to deploy the Docker image to Docker Hub. Docker Hub is a cloud-based repository where you can store and share Docker images. By pushing your Docker image to Docker Hub, you can easily distribute your application and deploy it to any system with Docker installed.

In this section, we will walk through the steps to push the Docker image to Docker Hub and pull it from Docker Hub for deployment.

Prerequisites for Deploying to Docker Hub

Before you can push your Docker image to Docker Hub, make sure you have the following:

• A Docker Hub Account: If you don’t already have an account, sign up on Docker Hub.
• Docker Installed: Ensure Docker is installed on your machine. You can download it from the official Docker website.
• Docker Image: You need to have built your Docker image (as described in Part 3).

Once these prerequisites are in place, you’re ready to push your Docker image to Docker Hub.

Step 1: Create a Docker Hub Repository

Before pushing the image, you need to create a repository on Docker Hub. Follow these steps to create a repository:

1. Log in to your Docker Hub account.
2. On the Docker Hub dashboard, click on the “Create Repository” button.
3. Provide a name for your repository (e.g., springboot-app), and select whether you want the repository to be public or private.
4. Click “Create” to finish setting up the repository.

Your Docker Hub repository is now ready to receive the Docker image.

Step 2: Tag the Docker Image

Docker images need to be tagged before they can be pushed to a repository. The tag typically includes the repository name and optionally a version tag (e.g., latest). The syntax for tagging a Docker image is as follows:

bash

Copy

docker tag <local_image_name> <dockerhub_username>/<repository_name>:<tag>

 

For example, if your Docker Hub username is johnDoe and the image name is springboot-app, you would tag the image like this:

bash

Copy

docker tag springboot-app johnDoe/springboot-app: latest

 

In this case:

• springboot-app is the name of the local Docker image you want to push.
  JohnDoee/springboot-app is the name of your repository on Docker Hub.
• The latest is the tag that indicates the most recent version of the image. You can choose another tag (like v1.0, v1.1, etc.) if you want to maintain different versions of the image.

Step 3: Log in to Docker Hub

Before pushing the image, you need to log in to Docker Hub from your terminal. Run the following command:

bash

Copy

docker login

 

You will be prompted to enter your Docker Hub username and password. After successful login, you’ll be able to push images to your Docker Hub account.

Step 4: Push the Docker Image to Docker Hub

Once you’ve tagged your image and logged in to Docker Hub, you can push the Docker image to your repository using the following command:

bash

Copy

docker push johnDoe/springboot-app: latest

 

Replace johnDoe/springboot-app: latest with your repository name and tag. This command will upload your Docker image to the Docker Hub repository you created earlier.

The upload process may take some time, depending on the size of the image and your internet speed. Once the push is complete, you’ll see a success message indicating that the image has been successfully uploaded.

Step 5: Verify the Image on Docker Hub

After the image has been pushed to Docker Hub, navigate to your Docker Hub repository page. You should see the uploaded image along with its version tag (latest or any other tag you specified).

Docker Hub will provide details like the image size, the number of pulls, and any other tags you have associated with the image. You can also use the Docker Hub web interface to manage your image, add additional tags, or delete old images.

Step 6: Pulling the Docker Image from Docker Hub

Once the image is on Docker Hub, you or anyone else with Docker installed can pull the image from Docker Hub and run it. To pull the image, use the following command:

bash

Copy

docker pull johnDoe/springboot-app: latest

 

This command will download the Docker image from your Docker Hub repository to the local machine.

After pulling the image, you can run it using the docker run command:

bash

Copy

docker run -p 8080:8080 johnDoe/springboot-app: latest

 

This will run the Docker container, and you can access the Spring Boot application at http://localhost:8080 on the machine where the container is running.

Step 7: Deploying the Docker Image on Remote Servers

One of the significant benefits of Docker is that you can deploy your image to any server that has Docker installed. Whether you’re deploying to a cloud service like AWS, Google Cloud, or Azure, or an on-premise server, the process is the same.

To deploy your Docker container on a remote server:

1. Install Docker on the Remote Server: Ensure Docker is installed on the server where you want to deploy the application.
2. Log in to Docker Hub: On the remote server, run docker login and enter your Docker Hub credentials.
3. Pull the Docker Image: Run the docker pull command to download the image from Docker Hub.
4. Run the Docker Container: Use the docker run command to start the container and map the appropriate ports (e.g., -p 8080:8080).

Once the container is running on the remote server, you can access the application just like you would on your local machine, using the server’s public IP or domain name.

Step 8: Automating Docker Deployments with CI/CD Pipelines

In modern DevOps workflows, automation is crucial for streamlining deployments. Continuous Integration and Continuous Deployment (CI/CD) tools like Jenkins, GitLab CI, and GitHub Actions allow you to automate the process of building, testing, and deploying Docker images.

For example, you can configure a Jenkins pipeline to:

1. Build the Docker image: Automatically build the Docker image whenever code is pushed to the repository.
2. Push the image to Docker Hub: Push the newly built image to Docker Hub for easy access.
3. Deploy the image to a production server: Use the docker pull and docker run commands to deploy the image on a remote server automatically.

This level of automation helps reduce manual intervention and ensures consistent deployments, making your application more reliable and scalable.

Summary of Docker Hub Deployment

• Create a Docker Hub Repository: Set up a repository on Docker Hub to store your Docker images.
• Tag the Docker Image: Tag your Docker image with your Docker Hub repository name and version tag.
• Push the Image to Docker Hub: Use the docker push command to upload your image to Docker Hub.
• Pull and Run the Image: Use the docker pull and docker run commands to deploy the image locally or on remote servers.
• CI/CD Automation: Automate the process of building, pushing, and deploying Docker images with CI/CD tools.

By following these steps, you can easily deploy and manage your Spring Boot application in Docker containers. Docker Hub provides a convenient platform for storing and sharing Docker images, ensuring that your application is always accessible and ready for deployment across various environments.