Springboot应用的Docker容器化部署入门教程-原创手记-慕课网

概述

本文详细介绍了Spring Boot应用的Docker容器化部署入门，从Spring Boot应用的创建和构建到使用Docker进行打包和部署，涵盖了整个流程。此外，文章还讲解了如何监控和维护容器化应用，确保应用的稳定性和可靠性。

Spring Boot 简介

Spring Boot 是什么

Spring Boot 是一个用来简化新 Spring 应用初始搭建以及开发过程的框架。它通过约定优于配置的方式，使开发人员能够快速搭建独立的、生产级别的 Spring 应用程序。Spring Boot 并不是对 Spring 的替代，而是对 Spring 的扩展和增强。它能够自动配置各种常用的框架，使得开发更加简单，几乎不需要任何 XML 配置。

Spring Boot 的优势

简化配置：
- 自动配置：Spring Boot 可以自动配置常见的场景，如数据源、JPA 等。开发人员只需要在配置文件中指定关键参数，就能完成复杂的配置工作。
- 无需 XML：使用注解配置替代 XML 配置，使得配置更加简洁明了。
嵌入式容器：
- Spring Boot 默认集成了 Tomcat、Jetty 或 Undertow 等 Web 服务器，使得应用可以以独立运行的方式启动，无需再部署到外部的 Web 容器中。
起步依赖管理：
- 通过依赖管理的方式，简化了 Maven 和 Gradle 的依赖配置。例如，只需添加一个 spring-boot-starter-web 依赖，即可引入 Web 项目所需的所有依赖。
快速集成其他库：
- 提供众多的 starter 依赖，简化了对各种框架和库的集成，例如 spring-boot-starter-data-jpa、spring-boot-starter-jdbc 等。
生产就绪特性：
- 热部署：支持热部署，方便开发调试。
- 健康检查：支持健康检查，方便监控和管理。
- 多环境配置：支持多种环境的配置，便于管理和切换不同环境的配置。

示例代码：创建简单的 Spring Boot 应用

首先，创建一个新的 Spring Boot 项目，可以使用 Spring Initializr：

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

下面是一个简单的 Spring Boot 应用示例：

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class DemoApplication {

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

    @RestController
    public class HelloController {
        @GetMapping("/")
        public String home() {
            return "Hello, Docker!";
        }
    }
}

这个示例展示了如何创建一个简单的 Spring Boot 应用，启动时会自动加载 Spring Boot 的配置，并提供一个简单的 HTTP 接口 /，返回 "Hello, Docker!"。

创建 Spring Boot 项目时，可以选择 Maven 或 Gradle 进行构建。以下是示例配置文件：

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>
    <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.5</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

Gradle 配置文件（build.gradle）

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

bootJar {
    manifest {
        attributes 'Main-Class': 'com.example.demo.DemoApplication'
    }
}

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

Docker 基础

Docker 是什么

Docker 是一个开源的应用容器引擎，它允许开发者打包应用及其依赖关系到一个可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口的传递，完全独立。Docker 使用客户端-服务器架构，Docker 客户端会连接到 Docker 守护进程(Daemon)。用户通过命令行与守护进程通信。

Docker 的优点

轻量级：
- 容器的启动速度远远超过虚拟机，容器之间的共享内核，使得容器体积很小，容器启动时间仅需几秒。这使得 Docker 在资源利用率上表现出色，特别适合部署大量轻量级应用。
隔离性：
- 每个容器都运行在独立的进程中，彼此之间相互隔离，不会相互影响。这种隔离性使得容器非常适合在共享主机上运行多个应用，降低了应用之间的干扰风险。
可移植性：
- Docker 镜像可以被上传到仓库，然后在任何支持 Docker 的环境中运行，这使得应用能够在不同的环境中保持一致，提高了应用的可移植性。
资源利用率高：
- 多个容器可以共享同一宿主机的操作系统，因此资源利用率高。例如，在一个服务器上可以同时运行多个容器，每个容器都可以独立运行，互不影响。
简化依赖管理：
- 通过 Dockerfile 定义应用的依赖项，确保应用在不同的环境中有相同的运行时依赖。这使得应用的部署和维护变得更加简单。

Docker 基本命令

运行 Docker 容器：

docker run -it --name my_container my_image

查看运行中的容器：
```
docker container ls
```
查看所有容器：
```
docker container ls -a
```
停止容器：
```
docker stop my_container
```
删除容器：
```
docker rm my_container
```
构建 Docker 镜像：
```
docker build -t my_image .
```
查看 Docker 镜像：
```
docker images
```
删除 Docker 镜像：
```
docker rmi my_image
```
进入容器的 shell：
```
docker exec -it my_container /bin/bash
```

示例代码：创建 Dockerfile

下面是一个简单的 Dockerfile 示例，用于构建一个包含 Spring Boot 应用的 Docker 镜像：

# 使用官方的 OpenJDK 基础镜像
FROM openjdk:11-jre-slim

# 设置工作目录
WORKDIR /app

# 将构建好的 JAR 文件拷贝到容器中
COPY target/*.jar app.jar

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

这个 Dockerfile 定义了一个基于 OpenJDK 11 的 Docker 镜像，将构建好的 JAR 文件拷贝到容器中并设置为启动命令。

构建 Spring Boot 应用

创建 Spring Boot 项目

使用 Spring Initializr 创建一个新的 Spring Boot 项目。可以通过 Spring Initializr 网站创建，也可以通过 IDE 插件创建。

例如，使用 IntelliJ IDEA 创建一个新的 Spring Boot 项目：

打开 IntelliJ IDEA。
点击 "File -> New -> Project"。
选择 "Spring Initializr"，点击 "Next"。
选择 Spring Boot 版本和语言（Java）。
输入项目名、语言和依赖（例如 spring-boot-starter-web），然后点击 "Next"。
点击 "Finish" 完成项目创建。

编写简单的 Spring Boot 应用

创建一个简单的 Spring Boot 应用，包括主类 DemoApplication 和一个控制器 HelloController。主类用于启动应用，控制器用于处理 HTTP 请求。

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class DemoApplication {

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

    @RestController
    public class HelloController {
        @GetMapping("/")
        public String home() {
            return "Hello, Docker!";
        }
    }
}

这个代码示例展示了如何创建一个简单的 Spring Boot 应用，启动时会自动加载 Spring Boot 的配置，并提供一个简单的 HTTP 接口 /，返回 "Hello, Docker!"。

构建 Spring Boot 应用的 JAR 文件

使用 Maven 或 Gradle 构建 Spring Boot 项目，生成一个可执行的 JAR 文件。

使用 Maven 构建 JAR 文件

在项目的 pom.xml 文件中添加 spring-boot-maven-plugin 插件：

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

使用 Maven 命令构建项目：

mvn clean package

构建完成后，在 target 目录下会生成一个 *.jar 文件。

使用 Gradle 构建 JAR 文件

在项目的 build.gradle 文件中添加 bootJar 插件：

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

bootJar {
    manifest {
        attributes 'Main-Class': 'com.example.demo.DemoApplication'
    }
}

使用 Gradle 命令构建项目：

./gradlew bootJar

构建完成后，在 build/libs 目录下会生成一个 *.jar 文件。

Spring Boot 应用的 Docker 化

创建 Dockerfile

在 Spring Boot 项目的根目录下创建一个 Dockerfile 文件，定义如何构建 Docker 镜像：

# 使用官方的 OpenJDK 基础镜像
FROM openjdk:11-jre-slim

# 设置工作目录
WORKDIR /app

# 将构建好的 JAR 文件拷贝到容器中
COPY target/*.jar app.jar

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

构建 Docker 镜像

在项目根目录执行以下命令，构建 Docker 镜像：

docker build -t my-spring-app .

构建完成后，可以在 Docker Hub 上查看镜像：

docker images

运行 Docker 容器

使用构建好的 Docker 镜像运行一个新的容器：

docker run -it --name my-spring-app-container my-spring-app

启动容器后，可以在浏览器中访问容器的 IP 地址和端口，测试应用是否运行正常。

部署 Spring Boot 应用

部署到本地 Docker 环境

部署到本地 Docker 环境时，可以使用上一步构建的 Docker 镜像运行容器。已构建的 Docker 镜像存储在本地 Docker 仓库中，可以通过 docker run 命令启动容器。

docker run -p 8080:8080 -d --name my-spring-app-container my-spring-app

该命令启动一个容器，并将容器的 8080 端口映射到主机的 8080 端口。

使用 Docker Compose 部署

Docker Compose 是一个用于定义和运行多容器 Docker 应用的工具。使用 Docker Compose 可以更加方便地管理和部署多个容器。

首先，在项目根目录下创建一个 docker-compose.yml 文件，定义应用的容器和服务：

version: '3.8'
services:
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=prod
    networks:
      - appnet

networks:
  appnet:
    driver: bridge

然后使用 docker-compose up 命令启动应用：

docker-compose up --build

--build 参数会自动构建 Docker 镜像。

部署到 Kubernetes

Kubernetes 是一个开源的容器编排平台，可以用来部署、管理和扩展容器化应用。以下是使用 Kubernetes 部署 Spring Boot 应用的基本步骤：

创建一个 deployment.yml 文件，定义应用的 Deployment：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: spring-app-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: spring-app
  template:
    metadata:
      labels:
        app: spring-app
    spec:
      containers:
      - name: spring-app
        image: my-spring-app
        ports:
        - containerPort: 8080

创建一个 service.yml 文件，定义应用的服务：

apiVersion: v1
kind: Service
metadata:
  name: spring-app-service
spec:
  selector:
    app: spring-app
  ports:
    - name: "http"
      port: 8080
      protocol: TCP
      targetPort: 8080

使用 kubectl 命令部署应用：

kubectl apply -f deployment.yml
kubectl apply -f service.yml

监控与维护

Docker 容器的监控

监控 Docker 容器的状态和性能非常重要，可以通过 docker stats 命令查看容器的实时资源使用情况：

docker stats

此外，还可以使用日志、指标和性能分析工具进行监控。例如，可以使用 Prometheus 和 Grafana 来监控容器的运行状态。

日志管理和维护

Docker 容器的日志可以通过 docker logs 命令查看：

docker logs my-spring-app-container

日志文件默认存储在 Docker 宿主机的 /var/lib/docker/containers/ 目录下，可以通过配置将日志文件输出到指定位置，便于集中管理和分析。例如，可以将日志输出到远程日志服务器，如 Logstash 或 ELK Stack。

版本管理和更新

版本管理和更新是容器化部署的重要环节。可以通过以下步骤进行：

版本标签：在构建 Docker 镜像时，添加版本标签：
```
docker build -t my-spring-app:1.0.0 .
```

环境变量：在启动容器时，可以使用环境变量来控制应用的行为，例如：

docker run -e SPRING_PROFILES_ACTIVE=prod -p 8080:8080 --name my-spring-app-container my-spring-app

更新应用：当需要更新应用时，重新构建 Docker 镜像并替换旧的容器：

docker build -t my-spring-app:1.1.0 .
docker stop my-spring-app-container
docker rm my-spring-app-container
docker run -p 8080:8080 --name my-spring-app-container my-spring-app:1.1.0

通过这种方式，可以方便地管理不同版本的应用，并确保应用的稳定性和可靠性。

总结

通过本文，您了解了如何使用 Spring Boot 和 Docker 进行应用的容器化部署。从创建和构建 Spring Boot 应用，到使用 Docker 进行打包和部署，最后到监控和维护容器化应用，整个过程都进行了详细的介绍。希望这些知识能够帮助您更好地理解和使用 Spring Boot 和 Docker。