Use Docker to containerize Spring Boot applications to achieve continuous integration and continuous deployment

Use Docker to containerize Spring Boot applications to achieve continuous integration and continuous deployment

Docker is an open source containerization platform that can integrate applications and their dependent resources Packaged into a separate container and deployed and run through an image. It provides a lightweight, fast, and portable solution for building and deploying modern applications.

Spring Boot is a rapid development framework that provides a simple and scalable way to build Java applications. Combining Docker and Spring Boot, we can achieve the goal of quickly deploying, scaling and managing applications.

This article will introduce how to use Docker to containerize Spring Boot applications to implement continuous integration and continuous deployment processes, and provide corresponding code examples.

1. Preparation
   Before you start, make sure you have installed Docker and Java development environment, and have basic Spring Boot application development experience.
2. Creating a Spring Boot application
   First, we need to create a simple Spring Boot application. You can use Spring Initializr (https://start.spring.io/) to quickly create a new Spring Boot project, or use an existing Spring Boot project.

Here, we create a simple Hello World application as shown below:

@Controller
public class HelloWorldController {
  
    @GetMapping("/")
    public String hello(Model model) {
        model.addAttribute("message", "Hello, Docker!");
        return "hello";
    }
  
    public static void main(String[] args) {
        SpringApplication.run(HelloWorldController.class, args);
    }
}

This code creates a basic Spring MVC controller that when accessing the root path , returns a "Hello, Docker!" message.

3. Building Docker Image
   Next, we need to build an image that can be deployed by Docker. To do this, we need to create a Dockerfile to define the build rules for the image.

Create a file named Dockerfile in the root directory of the project and add the following content:

# 使用一个基础的Java 8镜像
FROM openjdk:8-jdk-alpine

# 将应用的jar包添加到容器中
COPY target/demo-0.0.1-SNAPSHOT.jar /app.jar

# 暴露8080端口
EXPOSE 8080

# 运行jar包
ENTRYPOINT ["java","-jar","/app.jar"]

The above Dockerfile uses the Java 8 image based on Alpine Linux as the base image. Then, copy the built jar package into the container and run the application through the ENTRYPOINT instruction.

The command to build the image is as follows:

$ docker build -t spring-boot-demo .

After the image is built, you can use the following command to verify whether the build is successful:

$ docker images

You should be able to see a name It is the mirror of spring-boot-demo.

4. Running Docker Container
   After we have the image, we can create and run the Docker container based on the image.

Run the following command to start the container:

$ docker run -d -p 8080:8080 spring-boot-demo

Among them, the -d parameter means running the container in the background, and the -p parameter means mapping the 8080 port of the host to the 8080 port of the container. .

To verify whether the container is started successfully, you can check the running status of the container through the following command:

$ docker ps

If you can see that the container named spring-boot-demo is running, it means the container is started successfully.

5. Deploy updates
   When the application has new updates, we can complete the application update and deployment through the following steps.

First, update the application code locally and rebuild the image:

$ docker build -t spring-boot-demo .

Then, stop and delete the old container:

$ docker stop [CONTAINER_ID]
$ docker rm [CONTAINER_ID]

After that, Run the new container again:

$ docker run -d -p 8080:8080 spring-boot-demo

6. Continuous Integration and Continuous Deployment
   The above steps can be done manually to build and deploy the application, but for large-scale and frequent updates, this is obviously Inefficient and error-prone. Therefore, we can use CI/CD tools (such as Jenkins, GitLab CI, etc.) to achieve automated continuous integration and continuous deployment.

The following is a simple example using Jenkins:

• Install and configure Jenkins
  Follow the official documentation of Jenkins, install and configure Jenkins, and ensure that Jenkins can Access to source code and build environment.
• Create Jenkins task
  Use the Pipeline function of Jenkins to create a new task and configure related parameters, such as source code warehouse address, build script, triggering method, etc.
• Configuring the build process
  In the Jenkins build script, add the following content:

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'mvn clean package -DskipTests'
            }
        }
        stage('Build Docker Image') {
            steps {
                sh 'docker build -t spring-boot-demo .'
            }
        }
        stage('Deploy') {
            steps {
                sh 'docker stop spring-boot-demo'
                sh 'docker rm spring-boot-demo'
                sh 'docker run -d -p 8080:8080 --name spring-boot-demo spring-boot-demo'
            }
        }
    }
}

This script specifies the application's build process and update deployment process, which can be based on Modify according to actual needs.

• Trigger build
  After configuring the build parameters and triggering method, save and manually trigger the build. Jenkins will automatically build and deploy the application according to the configured process.

Through the above steps, we can use Docker to containerize Spring Boot applications and realize the process of continuous integration and continuous deployment. In this way, we can greatly simplify the development, deployment and management of applications and improve development efficiency and deployment flexibility.

I hope this article can provide some reference for you to understand and practice continuous integration and continuous deployment of Docker containerized Spring Boot applications. I wish you success in your practice!

The above is the detailed content of Use Docker to containerize Spring Boot applications to achieve continuous integration and continuous deployment. For more information, please follow other related articles on the PHP Chinese website!