Springboot应用的Docker容器化部署指南-原创手记-慕课网

概述

Spring Boot应用的Docker容器化部署能够简化应用的部署流程，确保开发、测试和生产环境的一致性。通过使用Docker和Spring Boot的结合，可以快速构建和运行应用，并且易于扩展和维护。本文将详细介绍如何在项目中引入Docker支持，构建Docker镜像以及运行和部署容器。

引入Spring Boot和Docker

简介Spring Boot

Spring Boot 是一个基于Spring框架的开源项目，旨在简化新Spring应用的初始搭建以及开发过程。它通过提供默认配置和支持自动配置，使得开发者能够快速搭建和部署应用。Spring Boot的主要特点包括：

自动配置：通过使用预设的配置和属性，Spring Boot 能够自动配置各种常见的场景。
嵌入式容器：内置了Tomcat或Jetty等服务器，无需额外配置即可运行。
启动器依赖：通过在pom.xml或build.gradle文件中添加相应的启动器，可以快速引入所需的库。
嵌入式数据库：支持嵌入式数据库如H2或HSQLDB，无需安装额外的数据库服务。
命令行界面：提供了多样化的命令行工具，便于开发和调试。
API测试支持：内置测试工具和库，简化了API测试的编写。

以下是一个简单的Spring Boot项目的最小配置示例，展示如何使用Maven作为构建工具创建Spring Boot应用：

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.11</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

在上述配置中，spring-boot-starter-parent为父级依赖，引入了Spring Boot的默认配置，而spring-boot-starter-web则提供了构建Web应用的基本配置，包括内嵌的Tomcat服务器。

简介Docker

Docker 是一个开源的应用容器引擎，它使得开发者能够将应用及其依赖打包到一个可移植的容器中，便于应用程序的部署和运行。Docker 的核心概念包括：

镜像（Image）：Docker 容器的只读模板。镜像是用来创建容器的蓝本。
容器（Container）：从 Docker 镜像创建的运行实例。容器是执行环境，可以启动、停止、删除。
仓库（Repository）：存储和分发 Docker 镜像的场所。
标签（Tag）：标记Docker镜像的一个版本，帮助用户区分不同的镜像。
Dockerfile：用于构建 Docker 镜像的文件，定义了如何构建容器。

Docker 提供了一种轻量级的虚拟化方式，使得应用能够在一致的环境中运行，无论是在开发环境、测试环境还是生产环境中。以下是使用Dockerfile构建一个简单的Docker镜像的示例：

FROM java:8-alpine
WORKDIR /app
COPY target/*.jar app.jar
ENTRYPOINT ["java", "-jar", "app.jar"]

在该Dockerfile中，指定了使用java:8-alpine作为基础镜像，并将项目的jar文件复制到容器的/app目录，最后设置了容器的入口命令。

为何选择容器化部署

选择容器化部署有以下几个优势：

环境一致性：Docker容器可以在任何遵循Docker标准的环境中运行，确保了开发、测试、生产环境的一致性。
快速部署：容器化部署大大减少了应用的部署时间，使得应用能够更快地从开发环境迁移到生产环境。
资源利用率：容器比虚拟机更轻量级，能够更高效地利用服务器资源。
易于扩展：容器化使得应用的扩展变得容易，有利于实现负载均衡和弹性伸缩。
版本控制：Docker镜像可以被标记为不同的版本，便于管理和回滚。
安全性：容器采用了沙箱机制，隔离了不同应用之间的通信和资源占用，提高了安全性。

为了支持以上这些优势，下面展示一个简单的Docker配置示例，以及如何配置Spring Boot项目以支持Docker：

Docker配置示例

FROM openjdk:8-jdk-alpine
VOLUME /tmp
ARG JAR_FILE
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java", "-Djava.security.egd=file:/dev/./urandom", "-jar", "/app.jar"]

Spring Boot配置示例

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

通过这些配置，可以确保Spring Boot应用能够在Docker容器中稳定运行。

准备Spring Boot项目

创建Spring Boot项目

创建一个新的Spring Boot项目，首先需要定义项目的目录结构。一个典型的Spring Boot项目结构如下：

my-spring-boot-app/
├── pom.xml
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── example/
│   │   │           └── MySpringBootApplication.java
│   │   └── resources/
│   │       ├── application.properties
│   │       └── static/
│   │       └── templates/
│   └── test/
│       └── java/
│           └── com/
│               └── example/
│                   └── MySpringBootApplicationTests.java

在这个项目结构中：

pom.xml：Maven构建文件，用于定义项目依赖。
src/main/java/：存放项目的主要Java代码。
src/main/resources/：存放项目资源文件，如配置文件。
src/test/java/：存放测试代码。
MySpringBootApplication.java：主应用类，负责启动应用。
application.properties：项目配置文件。

在pom.xml中添加以下内容以创建Spring Boot项目的基本结构：

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>my-spring-boot-app</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.11</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

接下来，在src/main/java/com/example/目录下创建MySpringBootApplication.java，该类将是应用的入口点：

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

在这个类中，使用了@SpringBootApplication注解，它包含了以下功能：

@Configuration：定义了这是一个配置类。
@EnableAutoConfiguration：自动配置Spring Boot应用。
@ComponentScan：扫描并注册组件，应用中的其他组件可以通过Spring进行管理。

为了测试应用的功能，可以在src/main/resources/static目录下添加一个简单的HTML文件index.html：

<!DOCTYPE html>
<html>
<head>
    <title>My Spring Boot App</title>
</head>
<body>
    <h1>Welcome to My Spring Boot App!</h1>
</body>
</html>

同时，在src/main/resources/static目录下添加一个简单的Spring MVC控制器，用于返回静态文件：

package com.example;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class WebController {

    @RequestMapping("/")
    public String index() {
        return "index";
    }
}

上述控制器定义了一个index方法，当请求访问/路径时，将返回index视图，该视图对应于static目录下的index.html文件。

最后，可以在src/test/java/com/example/目录下创建一个测试类MySpringBootApplicationTests：

package com.example;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class MySpringBootApplicationTests {

    @Test
    void contextLoads() {
    }
}

这个测试类使用了@SpringBootTest注解，用于测试Spring Boot应用是否能正常加载上下文。

配置Docker支持

为了使Spring Boot应用能够支持Docker，需要在项目中添加Docker支持的配置。通常可以通过Maven插件或Gradle插件来实现。这里以Maven插件为例，具体配置如下：

在pom.xml文件中添加以下插件配置，用于构建Docker镜像：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
        <plugin>
            <groupId>com.spotify</groupId>
            <artifactId>docker-maven-plugin</artifactId>
            <version>1.2.0</version>
            <configuration>
                <imageName>my-spring-boot-app</imageName>
                <dockerDirectory>src/main/docker</dockerDirectory>
                <resources>
                    <resource>
                        <targetPath>/</targetPath>
                        <directory>${project.build.directory}</directory>
                        <include>${project.build.finalName}.jar</include>
                    </resource>
                </resources>
            </configuration>
        </plugin>
    </plugins>
</build>

这个配置使用了docker-maven-plugin插件，该插件可以将构建后的JAR文件复制到指定的目录，并构建Docker镜像。配置中的<imageName>指定了Docker镜像的名字，<dockerDirectory>指定了Docker文件的位置，<resources>部分指定了构建后的JAR文件的位置和名称。

此外，还需要在src/main/docker目录下创建Dockerfile，用于定义如何构建Docker镜像：

FROM openjdk:8-jdk-alpine
VOLUME /tmp
ARG JAR_FILE
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java", "-Djava.security.egd=file:/dev/./urandom", "-jar", "/app.jar"]

在该Dockerfile中，指定了使用openjdk:8-jdk-alpine作为基础镜像，设置了临时目录/tmp，并将构建后的app.jar文件复制到容器中，并设置容器启动时执行该JAR文件。

创建Docker镜像

编写Dockerfile

在上一节中，我们已经创建了一个简单的Dockerfile，用于构建Spring Boot应用的Docker镜像。这里我们将进一步完善Dockerfile，使其更加健壮。

Dockerfile的基本结构如下：

# 使用官方的Java运行时作为基础镜像
FROM openjdk:8-jre-alpine

# 设置工作目录
WORKDIR /app

# 将构建好的jar文件复制到容器中
COPY target/my-spring-boot-app.jar app.jar

# 暴露端口
EXPOSE 8080

# 容器启动时执行的命令
ENTRYPOINT ["java", "-jar", "app.jar"]

以下是对Dockerfile中每一步的详细解释：

FROM：指定基础镜像，这里使用了openjdk:8-jre-alpine，这是一个轻量级的Java运行时环境。
WORKDIR：设置工作目录，这里设置为/app。
COPY：将本地构建的my-spring-boot-app.jar文件复制到容器中的/app目录。
EXPOSE：暴露容器的端口，这里将应用运行的端口8080暴露出来。
ENTRYPOINT：指定容器启动时执行的命令，这里是启动Java应用的命令。

以上Dockerfile的基础结构确保了应用能够正确构建并运行在容器中。

构建Docker镜像

在构建Docker镜像之前，需要确保项目已经正确构建。在项目根目录下运行以下Maven命令来构建项目：

mvn clean package

完成后，将在target目录下生成一个JAR文件。接下来，使用Maven插件构建Docker镜像。

首先，确保Maven插件配置正确，如上一节所述，具体配置如下：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
        <plugin>
            <groupId>com.spotify</groupId>
            <artifactId>docker-maven-plugin</artifactId>
            <version>1.2.0</version>
            <configuration>
                <imageName>my-spring-boot-app</imageName>
                <dockerDirectory>src/main/docker</dockerDirectory>
                <resources>
                    <resource>
                        <targetPath>/</targetPath>
                        <directory>${project.build.directory}</directory>
                        <include>${project.build.finalName}.jar</include>
                    </resource>
                </resources>
            </configuration>
        </plugin>
    </plugins>
</build>

之后，运行以下命令构建Docker镜像：

mvn docker:build

这个命令会调用docker-maven-plugin插件构建Docker镜像。成功后，将生成一个名为my-spring-boot-app的镜像。

也可以直接使用docker build命令构建Docker镜像，例如：

docker build -t my-spring-boot-app .

该命令将当前目录下的Dockerfile用于构建镜像，并命名为my-spring-boot-app。

运行Docker容器

构建完Docker镜像后，接下来运行Docker容器。可以通过以下命令启动容器：

docker run -it --rm --name my-spring-boot-container -p 8080:8080 my-spring-boot-app

该命令解释如下：

docker run：运行一个新的容器。
-it：为容器提供一个交互式终端。
--rm：容器停止后自动删除容器。
--name my-spring-boot-container：设置容器的名字为my-spring-boot-container。
-p 8080:8080：将容器的8080端口映射到宿主机的8080端口。
my-spring-boot-app：指定要使用的镜像名称。

配置容器网络和端口

除了上述基本的容器启动命令外，还可以通过以下步骤进一步配置容器的网络和端口映射：

端口映射

端口映射是将容器内部的服务暴露到宿主机上的常用手段。例如，可以通过以下命令将容器的8080端口映射到宿主机的8000端口：

docker run -it --rm --name my-spring-boot-container -p 8000:8080 my-spring-boot-app

网络配置

Docker 提供了多种网络配置选项，包括桥接网络、overlay网络等。以下是一种简单的桥接网络配置示例：

docker run -it --rm --name my-spring-boot-container -p 8080:8080 --network host my-spring-boot-app

在上述命令中，使用了--network host选项，使容器使用宿主机的网络配置，从而省去了端口映射的步骤。

另外，可以创建自定义的桥接网络：

docker network create my-network
docker run -it --rm --name my-spring-boot-container -p 8080:8080 --network my-network my-spring-boot-app

上述命令首先创建了一个名为my-network的桥接网络，然后将容器加入到该网络中。这样可以更好地管理容器之间的网络通信。

其他配置选项

--env：设置环境变量，例如--env SPRING_PROFILES_ACTIVE=prod可以设置Spring Boot的活跃配置文件。
--volume：挂载宿主机的目录到容器中，例如--volume /path/to/local:/path/to/container可以将宿主机的/path/to/local目录挂载到容器的/path/to/container目录。

这些配置选项能够帮助更好地控制容器的运行环境和资源使用情况。

部署Spring Boot应用

部署到本地Docker环境

在本地开发环境中部署Spring Boot应用，可以通过以下步骤来完成：

构建Docker镜像：

mvn clean package docker:build

该命令会构建项目并生成Docker镜像。

启动Docker容器：

docker run -it --rm --name my-spring-boot-container -p 8080:8080 my-spring-boot-app

该命令会启动一个Docker容器，将容器的8080端口映射到本地的8080端口。

访问应用：

应用启动后，可以通过浏览器访问http://localhost:8080，查看应用是否正常运行。

部署到远程Docker环境

在生产环境中，通常会将应用部署到远程的Docker环境，例如云服务提供商提供的Docker集群。部署流程如下：

推送Docker镜像到远程仓库：

首先，需要创建Docker仓库账号，并在本地设置仓库地址。例如，使用Docker Hub：

docker login
docker tag my-spring-boot-app my-username/my-spring-boot-app
docker push my-username/my-spring-boot-app

上述命令中，my-spring-boot-app是本地镜像名称，my-username/my-spring-boot-app是推送至Docker Hub的镜像名称。最后使用docker push命令将镜像推送到远程仓库。

在远程服务器上拉取镜像并启动容器：

在远程服务器上，可以通过以下命令拉取并启动容器：

docker pull my-username/my-spring-boot-app
docker run -it --rm --name my-spring-boot-container -p 8080:8080 my-username/my-spring-boot-app

配置远程服务器网络：

在远程服务器上，可能需要配置防火墙和端口映射，确保端口8080对外开放。例如，使用iptables配置：

iptables -A INPUT -p tcp --dport 8080 -j ACCEPT

此外，可以使用Docker的网络配置选项，如桥接网络，以便更好地管理容器的网络通信。

环境变量和配置：

在远程部署时，可以通过环境变量来配置应用。例如，使用-e参数设置环境变量：

docker run -it --rm --name my-spring-boot-container -p 8080:8080 -e SPRING_PROFILES_ACTIVE=prod my-username/my-spring-boot-app

上述命令将SPRING_PROFILES_ACTIVE=prod环境变量传递给容器。

通过以上步骤，可以将Spring Boot应用部署到远程Docker环境，并确保应用能够正常运行。

监控和维护Docker容器

查看容器状态

为了监控Docker容器的状态，可以使用以下命令：

列出正在运行的容器：

docker ps

该命令会列出所有正在运行的容器，输出信息包括容器ID、容器名称、创建时间、运行时间、容器状态、分配的端口等。

列出所有容器（包括未运行的）：

docker ps -a

该命令会列出所有容器，无论是否正在运行。

查看容器详细信息：

docker inspect CONTAINER_ID_OR_NAME

该命令会输出容器的详细信息，包括配置、环境变量、网络配置等。

例如，假设容器的名称为my-spring-boot-container，可以使用以下命令查看容器的详细信息：

docker inspect my-spring-boot-container

日志管理和维护

Docker 提供了查看容器日志的功能，可以使用以下命令查看容器的日志：

查看容器日志：

docker logs CONTAINER_ID_OR_NAME

例如：

docker logs my-spring-boot-container

上述命令会显示容器的输出日志。如果需要实时查看日志，可以使用-f选项：

docker logs -f my-spring-boot-container

查看容器启动日志：

通过docker events命令可以查看容器的启动、停止等事件：

docker events --filter "type=container" --filter "event=start"

该命令会输出容器的启动事件，如果需要实时查看，可以去掉--filter参数。

清理容器日志：

如果容器的日志文件变得很大，可能需要清理日志文件。可以通过查看容器的日志文件路径，然后手动清理：

docker inspect --format='{{.LogPath}}' CONTAINER_ID_OR_NAME

例如：

docker inspect --format='{{.LogPath}}' my-spring-boot-container

该命令会输出容器的日志文件路径，可以手动清理该路径下的日志文件。

删除容器：

如果需要删除一个容器，可以使用以下命令：

docker rm CONTAINER_ID_OR_NAME

例如：

docker rm my-spring-boot-container

此外，如果容器正在运行，可以先停止容器，然后再删除：

docker stop my-spring-boot-container
docker rm my-spring-boot-container

通过以上命令，可以有效地监控和维护Docker容器的状态和日志，确保应用的稳定运行。