Springboot应用的Docker容器化部署教程

概述

本文提供了详细的指导，介绍了如何将Springboot应用打包并使用Docker进行容器化部署，涵盖了从编写Dockerfile到构建、推送和运行Docker镜像的全过程，帮助开发者轻松实现Springboot应用的Docker容器化部署。

Spring Boot 应用简介

什么是 Spring Boot

Spring Boot 是一个基于 Spring 框架的简化开发工具，它允许开发者快速构建独立运行的、生产级别的基于 Spring 的应用。Spring Boot 设计初衷是简化 Spring 应用的初始搭建以及开发、配置等过程，使其更加容易上手。Spring Boot 包含了一系列自动配置功能，使得开发者在编写代码时无需过多关注底层配置细节。

Spring Boot 的主要特点

1. 自动配置：Spring Boot 会依据应用所引入的依赖自动配置所需的 bean。
2. 起步依赖：Spring Boot 提供了一套起步依赖，即预先定义好了一套依赖集合，开发者只需要在项目中引入这些起步依赖，就可以使用对应的功能。
3. 命令行界面：Spring Boot 通过 POM 中的父配置实现，可以使用 spring-boot:run 命令运行应用。
4. 嵌入式 Web 服务器：Spring Boot 可以内嵌 Tomcat、Jetty 或者 Undertow 作为 Web 服务器，从而简化开发环境的配置。
5. 配置优先：Spring Boot 允许用户通过配置文件覆盖默认配置。
6. 外部配置支持：Spring Boot 支持从多种来源（如命令行参数、环境变量、系统属性等）加载配置。

创建一个简单的 Spring Boot 应用

创建一个简单的 Spring Boot 应用，首先需要设置项目的基本环境。这里以使用 Maven 为例。

1. 创建 Maven 项目

在 pom.xml 文件中定义项目的基本信息和依赖关系：

<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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.0</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

2. 添加主应用类

在 src/main/java/com/example 目录下创建 DemoApplication.java 文件，这是应用的主入口点：

package com.example;

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

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

3. 创建一个简单的 REST API

在 src/main/java/com/example/controller 目录下创建 HelloController.java 文件：

package com.example.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api")
public class HelloController {

    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, World!";
    }
}

运行 mvn spring-boot:run 命令启动应用，然后访问 http://localhost:8080/api/hello，可以看到返回 "Hello, World!"。

Docker 简介

什么是 Docker

Docker 是一种开源的应用容器引擎，它使得开发人员可以将应用及其依赖打包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器或 Windows 机器上，也可以实现跨平台部署。开发人员可以通过编写 Dockerfile 文件来定义应用的运行环境，然后使用 Docker 命令来创建、部署和运行容器化的应用。

Docker 的主要特点

1. 轻量级：Docker 利用 Linux 内核的 namespaces 和 cgroups 技术，使容器拥有独立的文件系统和进程空间，容器之间相互隔离。
2. 可移植性：Docker 容器可以在不同的主机上运行，包括物理机、虚拟机、云主机和本地开发环境。
3. 自动化：Docker 提供了自动化构建和部署的功能，支持持续集成和持续部署。
4. 快速启动：Docker 容器可以在几秒内启动，启动速度远超过虚拟机。
5. 版本控制：Docker 支持版本控制，方便开发者管理不同的应用版本。
6. 资源利用效率高：Docker 利用操作系统级别的资源隔离和限制，可以大幅度提高资源利用率。

安装 Docker

在 Ubuntu 上安装 Docker

1. 更新软件包索引：

sudo apt-get update

1. 安装 Docker：

sudo apt-get install docker.io

1. 验证安装：

sudo docker --version

输出类似于 Docker version 20.10.0, build [版本号]，则说明安装成功。

在 Windows 或 macOS 上安装 Docker

1. 下载 Docker for Mac 或 Docker for Windows 的安装包。
2. 按照安装向导进行安装。
3. 打开 Docker Desktop，验证 Docker 是否安装成功。

Spring Boot 应用打包

使用 Maven 或 Gradle 打包 Spring Boot 应用

使用 Maven 打包

在 pom.xml 文件中添加 Spring Boot 的 starter parent 依赖，这样 Maven 就会自动配置打包相关的内容。

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

然后使用 Maven 命令进行打包：

mvn clean package

打包完成后，会在 target 目录下生成一个 .jar 文件，这个文件是一个独立运行的可执行文件，包含了所有依赖的库。

使用 Gradle 打包

在 build.gradle 文件中添加 Spring Boot 的依赖：

plugins {
    id 'org.springframework.boot' version '2.7.0'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
    id 'java'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
}

然后运行 Gradle 命令进行打包：

./gradlew bootJar

在 build/libs 目录下会生成打包后的 .jar 文件。

生成可执行的 jar 包

Spring Boot 打包生成的 jar 文件默认是可执行的，可以通过以下命令来运行：

java -jar target/demo-0.0.1-SNAPSHOT.jar

运行后，Spring Boot 应用将会启动，监听默认的 8080 端口。

Dockerfile 编写

什么是 Dockerfile

Dockerfile 是一个文本文件，包含了一组指令，用于构建 Docker 镜像。Docker 使用 Dockerfile 中的指令来自动构建镜像，然后可以运行该镜像以生成容器实例。

编写 Dockerfile 的基本步骤

1. 基础镜像：指定基础镜像，例如 FROM openjdk:11-jre-slim。
2. 维护者：指定维护者信息，例如 MAINTAINER yourname@example.com。
3. 工作目录：设置工作目录，例如 WORKDIR /app。
4. 添加文件：将应用文件添加到镜像中，例如 ADD target/*.jar app.jar。
5. 环境变量：设置环境变量，例如 ENV JAVA_OPTS=""。
6. 运行命令：设置容器启动时运行的命令，例如 ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app/app.jar"]。

构建 Docker 镜像

要构建 Docker 镜像，首先编写 Dockerfile 文件，然后使用 docker build 命令：

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

# 设置维护者信息
MAINTAINER yourname@example.com

# 设置工作目录
WORKDIR /app

# 将应用 jar 文件添加到镜像中
ADD target/*.jar app.jar

# 设置环境变量
ENV JAVA_OPTS=""

# 设置容器启动时运行的命令
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app/app.jar"]

执行构建命令：

docker build -t your-app-name .

-t 参数用来指定镜像标签，. 表示 Dockerfile 在当前目录下。

使用 Docker 运行 Spring Boot 应用

使用 docker run 命令来运行容器化应用：

docker run -p 8080:8080 your-app-name

该命令将容器的 8080 端口映射到主机的 8080 端口。

监控和管理 Docker 容器

查看运行中的容器

使用 docker ps 来查看运行中的容器：

docker ps

查看容器的日志

使用 docker logs 查看容器的输出日志：

docker logs -f your-container-id

停止容器

使用 docker stop 命令停止容器：

docker stop your-container-id

删除容器

使用 docker rm 命令删除容器：

docker rm your-container-id

Docker 镜像推送与拉取

将 Docker 镜像推送到 Docker Hub

首先，需要在 Docker Hub 上创建一个账号，并创建一个仓库。登录 Docker Hub：

docker login

然后将镜像推送到 Docker Hub：

docker tag your-app-name yourusername/your-app-name:latest
docker push yourusername/your-app-name:latest

从 Docker Hub 拉取镜像

在本地运行以下命令来拉取镜像：

docker pull yourusername/your-app-name:latest

Spring Boot 应用容器化部署

假设已经有一个 Spring Boot 项目，项目结构如下：

src/main/java/com/example/DemoApplication.java
src/main/resources/application.properties
Dockerfile

编写 Dockerfile

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

# 设置维护者信息
MAINTAINER yourname@example.com

# 设置工作目录
WORKDIR /app

# 将应用 jar 文件添加到镜像中
ADD target/*.jar app.jar

# 设置环境变量
ENV JAVA_OPTS=""

# 设置容器启动时运行的命令
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app/app.jar"]

打包和推送应用到 Docker Hub

先执行打包命令：

mvn clean package

构建 Docker 镜像并推送：

docker build -t your-app-name:latest .
docker tag your-app-name:latest yourusername/your-app-name:latest
docker push yourusername/your-app-name:latest

运行应用

本地拉取镜像并运行：

docker pull yourusername/your-app-name:latest
docker run -p 8080:8080 yourusername/your-app-name:latest

通过以上步骤，实现了一个简单的 Spring Boot 应用的 Docker 化部署，可以方便地在任何 Docker 环境中运行和管理这个应用。