Spring 实战(第五版)
  • Spring 实战(第 5 版)
  • 第一部分 Spring 基础
  • 第 1 章 Spring 入门
    • 1.1 什么是 Spring?
    • 1.2 初始化 Spring 应用程序
      • 1.2.1 使用 Spring Tool Suite 初始化 Spring 项目
      • 1.2.2 检查 Spring 项目结构
    • 1.3 编写 Spring 应用程序
      • 1.3.1 处理 web 请求
      • 1.3.2 定义视图
      • 1.3.3 测试控制器
      • 1.3.4 构建并运行应用程序
      • 1.3.5 了解 Spring Boot DevTools
      • 1.3.6 回顾
    • 1.4 俯瞰 Spring 风景线
      • 1.4.1 Spring 核心框架
      • 1.4.2 Spring Boot
      • 1.4.3 Spring Data
      • 1.4.4 Spring Security
      • 1.4.5 Spring Integration 和 Spring Batch
      • 1.4.6 Spring Cloud
    • 1.5 小结
  • 第 2 章 开发 Web 应用程序
    • 2.1 展示信息
      • 2.1.1 建立域
      • 2.1.2 创建控制器类
      • 2.1.3 设计视图
    • 2.2 处理表单提交
    • 2.3 验证表单输入
      • 2.3.1 声明验证规则
      • 2.3.2 在表单绑定时执行验证
      • 2.3.3 显示验证错误
    • 2.4 使用视图控制器
    • 2.5 选择视图模板库
      • 2.5.1 缓存模板
    • 2.6 小结
  • 第 3 章 处理数据
    • 3.1 使用 JDBC 读写数据
      • 3.1.1 为域适配持久化
      • 3.1.2 使用 JdbcTemplate
      • 3.1.3 定义模式并预加载数据
      • 3.1.4 插入数据
    • 3.2 使用 Spring Data JPA 持久化数据
      • 3.2.1 添加 Spring Data JPA 到数据库中
      • 3.2.2 注解域作为实体
      • 3.2.3 声明 JPA repository
      • 3.2.4 自定义 JPA repository
    • 3.3 小结
  • 第 4 章 Spring 安全
    • 4.1 启用 Spring Security
    • 4.2 配置 Spring Security
      • 4.2.1 内存用户存储
      • 4.2.2 基于 JDBC 的用户存储
      • 4.2.3 LDAP 支持的用户存储
      • 4.2.4 自定义用户身份验证
    • 4.3 保护 web 请求
      • 4.3.1 保护请求
      • 4.3.2 创建用户登录页面
      • 4.3.3 登出
      • 4.3.4 阻止跨站请求伪造攻击
    • 4.4 了解你的用户
    • 4.5 小结
  • 第 5 章 使用配置属性
    • 5.1 微调自动配置
      • 5.1.1 理解 Spring 环境抽象
      • 5.1.2 配置数据源
      • 5.1.3 配置嵌入式服务器
      • 5.1.4 配置日志
      • 5.1.5 使用特殊的属性值
    • 5.2 创建自己的配置属性
      • 5.2.1 定义配置属性持有者
      • 5.2.2 声明配置属性元数据
    • 5.3 使用 profile 文件进行配置
      • 5.3.1 定义特定 profile 的属性
      • 5.3.2 激活 profile 文件
      • 5.3.3 有条件地使用 profile 文件创建 bean
    • 5.4 小结
  • 第二部分 集成 Spring
  • 第 6 章 创建 REST 服务
    • 6.1 编写 RESTful 控制器
      • 6.1.1 从服务器获取数据
      • 6.1.2 向服务器发送数据
      • 6.1.3 更新服务器上的资源
      • 6.1.4 从服务器删除数据
    • 6.2 启用超媒体
      • 6.2.1 添加超链接
      • 6.2.2 创建资源装配器
      • 6.2.3 嵌套命名关系
    • 6.3 启用以数据为中心的服务
      • 6.3.1 调整资源路径和关系名称
      • 6.3.2 分页和排序
      • 6.3.3 添加用户端点
      • 6.3.4 向 Spring Data 端点添加用户超链接
    • 6.4 小结
  • 第 7 章 调用 REST 服务
    • 7.1 使用 RestTemplate 调用 REST 端点
      • 7.1.1 请求 GET 资源
      • 7.1.2 请求 PUT 资源
      • 7.1.3 请求 DELETE 资源
      • 7.1.4 请求 POST 资源
    • 7.2 使用 Traverson 引导 REST API
    • 7.3 小结
  • 第 8 章 发送异步消息
    • 8.1 使用 JMS 发送消息
      • 8.1.3 接收 JMS 消息
      • 8.1.2 使用 JmsTemplate 发送消息
      • 8.1.1 设置 JMS
    • 8.2 使用 RabbitMQ 和 AMQP
      • 8.2.1 添加 RabbitMQ 到 Spring 中
      • 8.2.2 使用 RabbitTemplate 发送消息
      • 8.2.3 从 RabbitMQ 接收消息
    • 8.3 使用 Kafka 发送消息
      • 8.3.1 在 Spring 中设置 Kafka
      • 8.3.2 使用 KafkaTemplate 发送消息
      • 8.3.3 编写 Kafka 监听器
    • 8.4 小结
  • 第 9 章 集成 Spring
    • 9.1 声明简单的集成流
      • 9.1.1 使用 XML 定义集成流
      • 9.1.2 在 Java 中配置集成流
      • 9.1.3 使用 Spring Integration 的 DSL 配置
    • 9.2 探索 Spring Integration
      • 9.2.1 消息通道
      • 9.2.2 过滤器
      • 9.2.3 转换器
      • 9.2.4 路由
      • 9.2.5 分割器
      • 9.2.6 服务激活器
      • 9.2.7 网关
      • 9.2.8 通道适配器
      • 9.2.9 端点模块
    • 9.3 创建 Email 集成流
    • 9.4 总结
  • 第三部分 响应式 Spring
  • 第 10 章 Reactor 介绍
    • 10.1 理解响应式编程
      • 10.1.1 定义响应式流
    • 10.2 Reactor
      • 10.2.1 图解响应式流
      • 10.2.2 添加 Reactor 依赖
    • 10.3 通用响应式操作实战
      • 10.3.1 创建响应式类型
      • 10.3.2 响应式类型结合
      • 10.3.3 转换和过滤响应式流
      • 10.3.4 对反应类型执行逻辑操作
    • 10.4 总结
  • 第 11 章 开发响应式 API
    • 11.1 使用 Spring WebFlux
      • 11.1.1 Spring WebFlux 介绍
      • 11.1.2 编写响应式 Controller
    • 11.2 定义函数式请求处理程序
    • 11.3 测试响应式 Controller
      • 11.3.1 测试 GET 请求
      • 11.3.2 测试 POST 请求
      • 11.3.3 使用线上服务器进行测试
    • 11.4 响应式消费 REST API
      • 11.4.1 通过 GET 方式获取资源
      • 11.4.2 通过 POST 方式发送资源
      • 11.4.3 删除资源
      • 11.4.4 处理请求错误
      • 11.4.5 请求转换
    • 11.5 保护响应式 web API
      • 11.5.1 配置响应式 Web 安全
      • 11.5.2 配置响应式用户信息服务
    • 11.6 总结
  • 第 12 章 响应式持久化数据
    • 12.1 理解 Spring Data 响应式历程
      • 12.1.1 Spring Data 响应式精髓
      • 12.1.2 在响应式与非响应式之间进行转换
      • 12.1.3 开发响应式库
    • 12.2 使用响应式 Cassandra 库
      • 12.2.1 开启 Spring Data Cassandra
      • 12.2.2 理解 Cassandra 数据模型
      • 12.2.3 Cassandra 持久化实体映射
      • 12.2.4 编写响应式 Cassandra 库
    • 12.3 编写响应式 MongoDB 库
      • 12.3.1 开启Spring Data MongonDB
      • 12.3.2 MongoDB 持久化实体映射
      • 12.3.3 编写响应式 MongoDB 库
    • 12.4 总结
  • 第四部分 云原生 Spring
  • 第 13 章 服务发现
    • 13.1深入思考微服务
    • 13.2 配置服务注册
      • 13.2.1 配置 Eureka
      • 13.2.2 扩展 Eureka
    • 13.3 注册并发现服务
      • 13.3.1 配置 Eureka 客户端属性
      • 13.3.2 消费服务
    • 13.4 总结
  • 第 14 章 配置管理
    • 14.1 共享配置
    • 14.2 运行配置服务器
      • 14.2.1 启动配置服务器
      • 14.2.2 填写配置库
    • 14.3 消费共享的配置
    • 14.4 服务应用程序和特定配置文件的属性
      • 14.4.1 服务特定应用程序的属性
      • 14.4.2 服务配置文件属性
    • 14.5 为配置的属性加密
      • 14.5.1 在 Git 中加密属性
      • 14.5.2 在 Vault 中存储密码
    • 14.6 远程刷新配置属性
      • 14.6.1 手动刷新配置属性
      • 14.6.2 自动刷新配置属性
    • 14.7 总结
  • 第 15 章 处理失败和时延
    • 15.1 了解断路器
    • 15.2 定义断路器
      • 15.2.1 缓解时延
      • 15.2.2 管理断路器阈值
    • 15.3 管理失败事件
      • 15.3.1 介绍 Hystrix 面板
      • 15.3.2 了解 Hystrix 线程池
    • 15.4 聚合多个 Hystrix 流
    • 15.5 总结
  • 第五部分 部署Spring
  • 第 16 章 使用 SpringBoot Actuator
    • 16.1 介绍 Actuator
      • 16.1.1 配置 Actuator 基本路径
      • 16.1.2 启用和禁用 Actuator 端点
    • 16.2 使用 Actuator 端点
      • 16.2.1 获取重要的应用程序信息
      • 16.2.2 查看配置详细信息
      • 16.2.3 查看应用程序活动
      • 16.2.4 利用运行时指标
    • 16.3 自定义 Actuator
      • 16.3.1 向 /info 端点提供信息
      • 16.3.2 自定义健康指标
      • 16.3.3 注册自定义指标
      • 16.3.4 创建自定义端点
    • 16.4 保护 Actuator
    • 16.5 总结
  • 第 17 章 管理 Spring
    • 17.1 使用 SpringBoot Admin
      • 17.1.1 创建 Admin 服务端
      • 17.1.2 注册 Admin 客户端
    • 17.2 深入 Admin 服务端
      • 17.2.1 查看普通应用程序运行状况和信息
      • 17.2.2 观察关键指标
      • 17.2.3 检查环境属性
      • 17.2.4 查看并设置 log 级别
      • 17.2.5 监控线程
      • 17.2.6 追踪 HTTP 请求
    • 17.3 保护 Admin 服务端
      • 17.3.1 在 Admin 服务端中启用登录
      • 17.3.2 使用 Actuator 进行认证
    • 17.4 总结
  • 第 18 章 使用 JMX 监控 Spring
    • 18.1 使用 Actuator MBean
    • 18.2 创建自己的 MBean
    • 18.3 发送通知
    • 18.4 总结
  • 第 19 章 部署 Spring
    • 19.1 权衡部署选项
    • 19.2 构建并部署 WAR 文件
    • 19.3 将 JAR 文件推送到 Cloud Foundry
    • 19.4 在 Docker 容器中运行 SpringBoot
    • 19.5 终章
    • 19.6 总结
由 GitBook 提供支持
在本页

这有帮助吗?

  1. 第 19 章 部署 Spring

19.4 在 Docker 容器中运行 SpringBoot

上一页19.3 将 JAR 文件推送到 Cloud Foundry下一页19.5 终章

最后更新于3年前

这有帮助吗?

在云端部署各种应用程序,Docker 已经成为了事实上的标准 。许多不同的云端环境,包括 AWS、Microsoft Azure、Google Cloud Platform 和 Pivotal Web Service(举几个例子),都接受用于部署应用程序的 Docker 容器。

容器化应用程序(如使用 Docker 创建的应用程序)的思想吸引了很多人,这是自真实世界集装箱的类比。集装箱都有一个标准尺寸和格式,无论在其中放什么货物。正因为如此,集装箱很容易堆放在船上,或用火车、卡车来运输。以类似的方式,容器化应用程序共享一个公共的容器格式,这种格式可以在任何位置部署和运行,而不用考虑其内部的应用程序如何。

虽然创建 Docker 镜像并不困难,但 Spotify 已经创建了一个 Maven 插件,可以根据 Spring Boot 的构建产物创建 Docker 镜像,这就像吹口哨一样容易。要使用 Docker 插件,需要在 Spring Boot 项目的 pom.xml 文件中,将如下内容添加到 <build>/<plugins> 部分:

<build>
  <plugins>
...
    <plugin>
      <groupId>com.spotify</groupId>
      <artifactId>dockerfile-maven-plugin</artifactId>
      <version>1.4.3</version>
      <configuration>
        <repository>
          ${docker.image.prefix}/${project.artifactId}
        </repository>
        <buildArgs>
          <JAR_FILE>target/${project.build.finalName}.jar</JAR_FILE>
        </buildArgs>
        </configuration>
    </plugin>
  </plugins>
</build>

在 <configuration> 部分,您需要设置一些属性,以创建 Docker 镜像。<repository> 元素描述 Docker 镜像的名称,这将显示在 Docker 存储库中。如本文所述,名称基于 Maven 项目 artifact ID,前缀为从 Maven 属性解析的值,名称为 docker.image.prefix。artifact ID 是 Maven 已经知道的东西,所以您只需要指定 prefix 属性:

<properties>
...
  <docker.image.prefix>tacocloud</docker.image.prefix>
</properties>

如果这是 Tacl Cloud 中的配料服务,则生成的 Docker 镜像像将作为 tacocloud/ingredient-service 服务保存在 Docker 存储库中。

在 <buildArgs> 元素下,可以指明镜像中应包含的 Maven 构建产物。如图所示,它使用 Maven 属性 project.build.finalName 以确定 target 目录中 JAR 文件的名称。

除了您在 Maven 构建中提供的信息之外,所有 Docker 镜像都是在名为 Dockerfile 的文件中定义的。此文件标识镜像要基于的基础镜像,以及应设置的环境变量、应该挂载的卷,并且(最重要的)入口点要执行的命令(容器启动时执行)。对于大多数 Spring Boot 应用程序,以下 Dockerfile 是一个很好的示例:

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

将此 Docker 文件逐行分解,可以看到以下内容:

  • FROM 指令标识新镜像所基于的基础镜像。新的镜像扩展了基础镜像。在本例中,基础映像是 openjdk:8-jdk-alpine,这是基于 OpenJDK 版本8 的容器镜像。

  • ENV 指令设置了一个环境变量。指定激活状态的属性文件,可以覆盖些 Spring Boot 应用程序属性。因此,在本例中,您将环境变量 SPRING_PROFILES_ACTIVE 设置为 docker,以确保 Spring Boot 应用程序以 docker 作为激活状态的属性文件。

  • VOLUME 指令在容器中创建挂载点。在本例中,它在 /tmp 处创建挂载点,以便容器可以在必要时写入数据到 /tmp 目录。

  • ARG 指令声明一个可在构建时传入的参数。在本例中,它声明了一个名为 JAR_FILE 的参数,该参数与 Maven 插件的 <buildArgs> 部分中给出的参数相同。

  • COPY 指令将文件从给定路径复制到另一路径。在本例中,它将 Maven 插件中指定的 JAR 文件,复制为镜像里名为 app.jar 的文件。

  • ENTRYPOINT 指令描述了当容器启动时应该做什么。作为数组给定要执行的命令。在本例中,使用 java 命令行运行可执行文件 app.jar。

请特别注意 ENV 指令。一般来说,在 Spring Boot 应用程序镜像中,都需要设置 SPRING_PROFILES_ACTIVE 环境变量。这使得在 Docker 中运行的应用程序,可以设置特有的 bean 和配置属性。

对于配料服务,您需要以某种方式指明,应用程序运行所需要的 Mongo 数据库存在于另一个容器中。默认情况下,Spring Data 会尝试连接本地主机,上侦听 27017 端口的 Mongo 数据库。这种情况只有在本地运行所有服务时才会发生。所以您需要配置 spring.data.mongodb.host 属性,来告诉 Spring Data 到哪里寻找 Mongo。

虽然您可能还不知道 Mongo 数据库将在哪里运行,但是可以将 Spring Data 配置为:当名称为 docker 的属性文件处于激活状态时,连接主机名为 Mongo 的容器中的 Mongo 数据库。这通过将以下特定于 docker 的属性添加到 application.yml 文件中:

---
spring:
  profiles: docker

  data:
    mongodb:
      host: mongo

稍后,当您启动 Docker 容器时,您将把 mongo 主机映射到运行在不同容器中的 Mongo 数据库。但现在您已经准备好构建 Docker 镜像了。使用 Maven 包装器,执行 package 和 dockerfile:build,来构建 JAR 文件,然后生成 Docker 镜像:

$ mvnw package dockerfile:build

此时,您可以使用 docker images 命令来确认本地镜像库中的镜像。(列 CREATED 和 SIZE 被省略,以便于阅读和排版):

$ docker images
REPOSITORY                    TAG         IMAGEID
tacocloud/ingredient-service  latest      7e8ed20e768e

在启动容器之前,需要为 Mongo 数据库创建一个容器。下面的命令运行一个名为 tacocloudmongo 的新 Docker 容器,数据库使用 Mongo 3.7.9 版本:

$ docker run --name tacocloud-mongo -d mongo:3.7.9-xenial

现在,您终于可以运行配料服务容器,并将其链接到刚刚启动的 Mongo 容器了:

$ docker run -p 8080:8081 \
          --link tacocloud-mongo:mongo \
          tacocloud/ingredient-service

此处显示的 docker run 命令有几个重要组成部分需要注意:

  • 因为您在容器中配置了 Spring Boot 应用程序运行在端口 8081 上,-p 参数将内部端口映射到主机的端口 8080。

  • --link 参数将容器链接名为 tacocloudmongo 的容器,并为其分配一个 mongo 主机名,以便 Spring Data 可以通过那个主机名连接数据库。

  • 最后,指定在新容器中运行的镜像名称(在本例中为 tacocloud/IngreditService)。

现在您已经构建了 Docker 映像,并且已经可以在本地容器中运行,您可以将镜像推送到 Dockerhub 或其他镜像存储库。如果您在 dockerhub 上有帐户并已登录,您可以像这样使用 Maven 推送镜像:

$ mvnw dockerfile:push

这样,您就可以将镜像部署到,几乎任何支持 Docker 容器的云平台,包括 AWS、Microsoft Azure 和 Google Cloud Platform。您可以选择一个,并按照特定于平台的使用指南部署 Docker 容器。以下是一些流行云的平台使用指南链接:

AWS ——

Microsoft Azure ——

Google Cloud Platform ——

Pivotal Web Services (PWS) ——

Pivotal Container Service (PKS) ——

https://www.docker.com
https://aws.amazon.com/getting-started/tutorials/deploy-dockercontainers/
https://docs.docker.com/docker-for-azure/deploy/
https://cloud.google.com/kubernetes-engine/docs/tutorials/hello-app
https://docs.run.pivotal.io/devguide/deploy-apps/push-docker.html
https://pivotal.io/platform/pivotal-container-service