章节 VI. 部署 Spring Boot 应用程序

Cloud Foundry 提供默认的构建包，如果没有指定其它的构建包，则会发挥作用。Cloud Foundry Java 构建包 对 Spring 应用有极好的支持，包括 Spring Boot。你可以部署独立的可执行 jar 应用程序以及传统的 .war 包应用程序。

当你构建完应用程序（例如，通过使用 mvn clean package）并安装 installed the cf 命令行工具之后，使用 cf push 命令部署应用程序，替换到编译的 .jar 的路径。在推送应用程序之前，一定要使用 cf 命令行客户端登录。下面的行展示使用 cf push 命令部署应用程序。

$ cf push acloudyspringtime -p target/demo-0.0.1-SNAPSHOT.jar

	Note
	在前面的示例中，我们可以将 acloudyspringtime 替换为你的应用程序的名称，作为给 cf 的值。

有关更多选项请参阅 cf push 文档。如果有一个 Cloud Foundry manifest.yml 文件存在于同一目录中，则考虑。

此时，cf 开始上传应用程序，产生类似于以下示例的输出：

Uploading acloudyspringtime... OK
Preparing to start acloudyspringtime... OK
-----> Downloaded app package (8.9M)
-----> Java Buildpack Version: v3.12 (offline) | https://github.com/cloudfoundry/java-buildpack.git#6f25b7e
-----> Downloading Open Jdk JRE 1.8.0_121 from https://java-buildpack.cloudfoundry.org/openjdk/trusty/x86_64/openjdk-1.8.0_121.tar.gz (found in cache)
       Expanding Open Jdk JRE to .java-buildpack/open_jdk_jre (1.6s)
-----> Downloading Open JDK Like Memory Calculator 2.0.2_RELEASE from https://java-buildpack.cloudfoundry.org/memory-calculator/trusty/x86_64/memory-calculator-2.0.2_RELEASE.tar.gz (found in cache)
       Memory Settings: -Xss349K -Xmx681574K -XX:MaxMetaspaceSize=104857K -Xms681574K -XX:MetaspaceSize=104857K
-----> Downloading Container Certificate Trust Store 1.0.0_RELEASE from https://java-buildpack.cloudfoundry.org/container-certificate-trust-store/container-certificate-trust-store-1.0.0_RELEASE.jar (found in cache)
       Adding certificates to .java-buildpack/container_certificate_trust_store/truststore.jks (0.6s)
-----> Downloading Spring Auto Reconfiguration 1.10.0_RELEASE from https://java-buildpack.cloudfoundry.org/auto-reconfiguration/auto-reconfiguration-1.10.0_RELEASE.jar (found in cache)
Checking status of app 'acloudyspringtime'...
  0 of 1 instances running (1 starting)
  ...
  0 of 1 instances running (1 starting)
  ...
  0 of 1 instances running (1 starting)
  ...
  1 of 1 instances running (1 running)

App started

祝贺你！现在的应用程序是在线的！

一旦应用程序激活，就可以使用 cf apps 命令验证已部署应用程序的状态，如下面的示例所示：

$ cf apps
Getting applications in ...
OK

name                 requested state   instances   memory   disk   urls
...
acloudyspringtime    started           1/1         512M     1G     acloudyspringtime.cfapps.io
...

一旦 Cloud Foundry 确认你的应用程序已经部署，你应该能够在给定的 URI 处找到应用程序。在前面的示例中，你可以在 http://acloudyspringtime.cfapps.io/ 找到。

61.1.1 绑定到服务

默认情况下，有关运行的应用程序的元数据以及服务连接信息作为环境变量暴露给应用程序（例如：$VCAP_SERVICES）。这种架构决策是由于 Cloud Foundry 的多语言（任何语言和平台可以作为构建包）支持的性质。过程范围的环境变量是语言不可知的。

环境变量并不总是用于最简单的 API，因此 Spring Boot 自动提取它们，并将数据平铺成可以通过 Spring 的 Environment 抽象访问的属性，如下面的示例所示：

@Component
class MyBean implements EnvironmentAware {

	private String instanceId;

	@Override
	public void setEnvironment(Environment environment) {
		this.instanceId = environment.getProperty("vcap.application.instance_id");
	}

	// ...

}

所有 Cloud Foundry 属性都用 vcap 进行前缀。可以使用 vcap 属性访问应用程序信息（例如应用程序的公共 URL）和服务信息（例如数据库凭据）。有关完整的细节请参阅 ‘CloudFoundryVcapEnvironmentPostProcessor’ Javadoc。

	Tip
	Spring 云连接器项目更适合于诸如配置数据源之类的任务。Spring Boot 自动配置支持和 spring-boot-starter-cloud-connectors 启动器。

Heroku 是另一个流行的 PaaS 平台。为了自定义 Heroku 构建，你需要提供一个 Procfile，它提供了部署应用程序所需的命令。Heroku 为 Java 应用程序分配一个 port 来使用，然后确保到外部 URI 的路由工作。

你必须配置应用程序以监听正确的端口。下面的示例展示了我们的启动 REST 应用程序的 Procfile：

                web: java -Dserver.port=$PORT -jar target/demo-0.0.1-SNAPSHOT.jar
            

Spring Boot 使 -D 参数可用作为从 Spring Environment 实例访问的属性。server.port 配置属性被提供给嵌入式 Tomcat、Jetty 或 Undertow 实例，该实例在启动时使用端口。$PORT 环境变量由 Heroku PaaS 分配给我们。

这应该是你需要的一切。Heroku 部署最常见的部署工作流程是 git push 代码到生产，如下面的示例所示：

$ git push heroku master

Initializing repository, done.
Counting objects: 95, done.
Delta compression using up to 8 threads.
Compressing objects: 100% (78/78), done.
Writing objects: 100% (95/95), 8.66 MiB | 606.00 KiB/s, done.
Total 95 (delta 31), reused 0 (delta 0)

-----> Java app detected
-----> Installing OpenJDK 1.8... done
-----> Installing Maven 3.3.1... done
-----> Installing settings.xml... done
-----> Executing: mvn -B -DskipTests=true clean install

       [INFO] Scanning for projects...
       Downloading: https://repo.spring.io/...
       Downloaded: https://repo.spring.io/... (818 B at 1.8 KB/sec)
		....
       Downloaded: http://s3pository.heroku.com/jvm/... (152 KB at 595.3 KB/sec)
       [INFO] Installing /tmp/build_0c35a5d2-a067-4abc-a232-14b1fb7a8229/target/...
       [INFO] Installing /tmp/build_0c35a5d2-a067-4abc-a232-14b1fb7a8229/pom.xml ...
       [INFO] ------------------------------------------------------------------------
       [INFO] BUILD SUCCESS
       [INFO] ------------------------------------------------------------------------
       [INFO] Total time: 59.358s
       [INFO] Finished at: Fri Mar 07 07:28:25 UTC 2014
       [INFO] Final Memory: 20M/493M
       [INFO] ------------------------------------------------------------------------

-----> Discovering process types
       Procfile declares types -> web

-----> Compressing... done, 70.4MB
-----> Launching... done, v6
       http://agile-sierra-1405.herokuapp.com/ deployed to Heroku

To git@heroku.com:agile-sierra-1405.git
 * [new branch]      master -> master

你的应用程序现在应该在 Heroku 上运行。

OpenShift 是 Kubernetes 容器编排平台的 Red Hat 公共（和企业）扩展。与 Kubernetes 类似，OpenShift 对于安装基于 Spring 的应用程序有很多选择。

OpenShift 具有描述如何部署 Spring Boot 应用程序的许多资源，包括：

Amazon Web 服务提供了多种安装基于 Spring Boot 的应用程序的方法，既可以作为传统的 web 应用程序（war），也可以作为带有嵌入式 web 服务器的可执行 jar 文件。选项包括：

每个都有不同的特点和定价模式。在本文中，我们只描述最简单的选择：AWS Elastic Beanstalk。

61.4.1 AWS Elastic Beanstalk

正如官方 Elastic Beanstalk Java 指南中所描述的，部署 Java 应用程序有两个主要选项。你可以使用 Tomcat 平台或 Java SE 平台。

使用 Tomcat 平台

此选项适用于生成 war 文件的 Spring Boot 项目。无需特殊配置。你只需要遵循官方指南。

使用 Java SE 平台

此选项适用于生成 jar 文件并运行嵌入式 Web 容器的 Spring Boot 项目。Elastic Beanstalk 环境在端口 80上 运行 nginx 实例来代理在端口 5000 上运行的实际应用程序。若要配置它，请在 application.properties 文件中添加以下行：

server.port=5000

	Upload binaries instead of sources
	默认情况下，Elastic Beanstalk 上传源代码，并在 AWS 中编译它们。但是，最好是上传二进制文件。为此，将与类似以下的行添加到你的 .elasticbeanstalk/config.yml 文件中： deploy: artifact: target/demo-0.0.1-SNAPSHOT.jar

	Reduce costs by setting the environment type
	默认情况下，Elastic Beanstalk 环境是负载平衡的。负载均衡器具有显著的成本。为了避免成本，将环境类型设置为单一实例，如 Amazon 文档中所描述的。还可以使用 CLI 和以下命令创建单实例环境： eb create -s

Boxfuse 通过将 Spring Boot 可执行 jar 或 war 转换为一个最小的 VM 映像来工作，该映像可以在 VirtualBox 上或在 AWS 上进行不变的部署。Boxfuse 提供了对 Spring Boot 的深度集成，并使用 Spring Boot 配置文件中的信息来自动配置端口和健康检查 URL。Boxfuse 不仅利用它生成的映像的信息，还利用它提供的所有资源（实例、安全组、弹性负载平衡器等等）的信息。

一旦你创建了一个 Boxfuse 账户，将它连接到你的 AWS 帐户，安装了 Boxfuse 客户端的最新版本，并确保应用程序是由 Maven 或 Gradle（例如，通过使用 mvn clean package）构建的，你就可以使用类似于以下内容将 Spring Boot 应用程序部署到 AWS：

$ boxfuse run myapp-1.0.jar -env=prod

有关的更多选项请参阅 boxfuse run 文档。如果在当前目录中存在 boxfuse.conf 文件，则考虑该文件。

	Tip
	默认情况下，Boxfuse 在启动时激活一个名为 boxfuse 的 Spring 配置文件。如果你的可执行 jar 或 war 包含 application-boxfuse.properties 文件，Boxfuse 将其配置基于其所包含的属性。

此时，boxfuse 为你的应用程序创建一个映像，上传它，并在 AWS 上配置和启动必要的资源，输出类似于以下示例的结果：

Fusing Image for myapp-1.0.jar ...
Image fused in 00:06.838s (53937 K) -> axelfontaine/myapp:1.0
Creating axelfontaine/myapp ...
Pushing axelfontaine/myapp:1.0 ...
Verifying axelfontaine/myapp:1.0 ...
Creating Elastic IP ...
Mapping myapp-axelfontaine.boxfuse.io to 52.28.233.167 ...
Waiting for AWS to create an AMI for axelfontaine/myapp:1.0 in eu-central-1 (this may take up to 50 seconds) ...
AMI created in 00:23.557s -> ami-d23f38cf
Creating security group boxfuse-sg_axelfontaine/myapp:1.0 ...
Launching t2.micro instance of axelfontaine/myapp:1.0 (ami-d23f38cf) in eu-central-1 ...
Instance launched in 00:30.306s -> i-92ef9f53
Waiting for AWS to boot Instance i-92ef9f53 and Payload to start at http://52.28.235.61/ ...
Payload started in 00:29.266s -> http://52.28.235.61/
Remapping Elastic IP 52.28.233.167 to i-92ef9f53 ...
Waiting 15s for AWS to complete Elastic IP Zero Downtime transition ...
Deployment completed successfully. axelfontaine/myapp:1.0 is up and running at http://myapp-axelfontaine.boxfuse.io/

你的应用程序现在应该在 AWS 上运行。

请参阅关于在 EC2 上部署 Spring Boot 应用程序的博客文章 以及 Boxfuse Spring Boot 集成的文档 ，以开始使用 Maven 构建来运行应用程序。

Google Cloud 有几个可以用来启动 Spring Boot 应用程序的选项。最容易入门的可能是 App Engine，但是你也可以找到在具有容器引擎的容器中或者在具有计算引擎的虚拟机上运行 Spring Boot 的方法。

为了在 App Engine 中运行，可以先在 UI 中创建一个项目，它为你设置一个唯一的标识符，并且还设置 HTTP 路由。将 Java 应用程序添加到项目中，并将其留空，然后使用 Google Cloud SDK 从命令行或 CI 构建中将你的 Spring Boot 应用程序推到该槽中。

App Engine 标准要求你使用 WAR 包。按照这些步骤将 App Engine 标准应用程序部署到 Google Cloud。

另外，App Engine Flex 要求你创建一个 app.yaml 文件来描述应用程序所需的资源。通常，你把这个文件放在 src/main/appengine 中，它应该类似于下面的文件：

service: default

runtime: java
env: flex

runtime_config:
  jdk: openjdk8

handlers:
- url: /.*
  script: this field is required, but ignored

manual_scaling:
  instances: 1

health_check:
  enable_health_check: False

env_variables:
  ENCRYPT_KEY: your_encryption_key_here

你可以通过将项目 ID 添加到构建配置来部署应用程序（例如，使用 Maven 插件），如下面的示例所示：

<plugin>
	<groupId>com.google.cloud.tools</groupId>
	<artifactId>appengine-maven-plugin</artifactId>
	<version>1.3.0</version>
	<configuration>
		<project>myproject</project>
	</configuration>
</plugin>

然后使用 mvn appengine:deploy 部署（如果你需要先验证，则生成失败）。

默认脚本支持大多数 Linux 发行版，并在 CentOS 和 Ubuntu 上进行测试。其它平台，如 OS X 和 FreeBSD，需要使用自定义的 embeddedLaunchScript。

Spring Boot 应用程序可以通过使用 init.d 或 systemd 轻松地作为 Unix/Linux 服务启动。

62.2.1 作为一个 init.d 服务 (System V) 安装

如果你配置了 Spring Boot 的 Maven 或 Gradle 插件来生成一个完全可执行的 jar，并且没有使用定制的 embeddedLaunchScript，那么可以将应用程序用作 init.d 服务。为此，将 jar 与 init.d 进行链接，以支持标准 start、stop、restart 和 status 命令。

脚本支持以下特性：

• 将服务作为拥有 jar 文件的用户启动
• 通过使用 /var/run/<appname>/<appname>.pid 来追踪应用程序的 PID
• 写控制台日志到 /var/log/<appname>.log

假设你有一个安装在 /var/myapp 中的 Spring Boot 应用程序，安装一个 Spring Boot 应用程序作为 init.d 服务，创建一个 symlink，如下：

$ sudo ln -s /var/myapp/myapp.jar /etc/init.d/myapp

一旦安装完毕，就可以以通常的方式启动和停止服务。例如，在基于 Debian 的系统中，可以用以下命令启动它：

$ service myapp start

	Tip
	如果应用程序无法启动，请检查写入 /var/log/<appname>.log 的日志文件是否存在错误。

还可以通过使用标准操作系统工具来标记应用程序自动启动。例如，在 Debian 上，你可以使用以下命令：

$ update-rc.d myapp defaults <priority>

保护一个 init.d 服务

	Note
	下面是一组关于如何保护运行为 init.d 服务的 Spring Boot 应用程序的指南。它并不是一个详尽的列表，只列出了为加强应用程序及其运行环境而应该做的一切。

当作为 root 执行时，就像使用 root 启动 init.d 服务一样，默认的可执行脚本作为拥有 jar 文件的用户运行应用程序。你不应该运行 Spring Boot 应用程序作为 root，因此应用程序的 jar 文件永远不应该是 root 用户拥有的。相反，创建一个特定的用户来运行应用程序，并使用 chown 使其成为 jar 文件的所有者，如下面的示例所示：

$ chown bootapp:bootapp your-app.jar

在这种情况下，默认的可执行脚本将应用程序运行为 bootapp 用户。

	Tip
	为了减少应用程序用户帐户被破坏的机会，你应该考虑防止它使用登录 shell。例如，可以将帐户的 shell 设置为 /usr/sbin/nologin。

还应该采取措施防止修改应用程序的 jar 文件。首先，配置其权限，使其不能写入，只能由其所有者读取或执行，如下例所示：

$ chmod 500 your-app.jar

其次，如果应用程序或正在运行的帐户受到损害，还应该采取措施限制损坏。如果攻击者确实获得访问权限，则可以使 jar 文件可写并更改其内容。防止这种情况的一种方法是使用 chattr 使其不可变，如下面的示例所示：

$ sudo chattr +i your-app.jar

这将阻止任何用户，包括 root 用户，修改 jar。

如果 root 用于控制应用程序的服务，并使用 .conf 文件定制其启动，则 root 用户将读取和评估 .conf 文件。应该相应地加以保护。使用 chmod 使文件只能由所有者读取，并使用 chown 使所有者 root，如下面的示例所示：

$ chmod 400 your-app.conf
$ sudo chown root:root your-app.conf

62.2.2 作为 systemd 服务安装

systemd 是 System V init 系统的继承者，现在正被许多现代 Linux 发行版所使用。尽管你可以在 systemd 中继续使用 init.d 脚本，但也可以通过使用 systemd ‘service’ 脚本启动 Spring Boot 应用程序。

假设你在 /var/myapp 中安装了 Spring Boot 应用程序，要将 Spring Boot 应用程序安装为 systemd 服务，请创建一个名为 myapp.service 的脚本并将其放置在 /etc/systemd/system 目录中。下面的脚本提供了一个例子：

[Unit]
Description=myapp
After=syslog.target

[Service]
User=myapp
ExecStart=/var/myapp/myapp.jar
SuccessExitStatus=143

[Install]
WantedBy=multi-user.target

	重点
	请记住更改应用程序的 Description、User 和 ExecStart 字段。

	Note
	ExecStart 字段不声明脚本操作命令，这意味着默认使用 run 命令。

注意，与作为 init.d 服务运行时不同，运行应用程序、PID 文件和控制台日志文件的用户由 systemd 本身管理，因此必须通过使用 ‘service’ 脚本中的适当字段进行配置。详情请见服务单元配置手册页。

若要标记应用程序在系统引导时自动启动，请使用以下命令：

$ systemctl enable myapp.service

详情请参阅 man systemctl。

62.2.3 自定义启动脚本

由 Maven 或 Gradle 插件编写的默认嵌入式启动脚本可以以多种方式定制。对于大多数人来说，使用默认脚本以及一些自定义通常是足够的。如果发现无法自定义需要的内容，请使用 embeddedLaunchScript 选项完全写入自己的文件。

在写入脚本时自定义启动脚本

在开始写入脚本到 jar 文件中时，自定义启动脚本的元素通常是有意义的。例如，init.d 脚本可以提供一个描述。既然你知道前面的描述（而且它不需要改变），你也可以在生成 jar 时提供它。

要自定义编写的元素，请使用 Spring Boot Maven 或 Gealle 插件的 embeddedLaunchScriptProperties 选项。

默认脚本支持以下属性替换：

名称	描述	Gradle 默认值	Maven 默认值
mode	脚本模式。	auto	auto
initInfoProvides	“INIT INFO” 的 Provides 部分	${task.baseName}	${project.artifactId}
initInfoRequiredStart	“INIT INFO”的 Required-Start 部分。	$remote_fs $syslog $network	$remote_fs $syslog $network
initInfoRequiredStop	“INIT INFO” 的 Required-Stop 部分。	$remote_fs $syslog $network	$remote_fs $syslog $network
initInfoDefaultStart	“INIT INFO” 的 Default-Start 部分。	2 3 4 5	2 3 4 5
initInfoDefaultStop	“INIT INFO” 的 Default-Stop 部分。	0 1 6	0 1 6
initInfoShortDescription	“INIT INFO” 的 Short-Description 部分。	${project.description} 的单行版本 (回落到 ${task.baseName})	${project.name}
initInfoDescription	“INIT INFO” 的 Description 部分。	${project.description} (回落到 ${task.baseName})	${project.description} (回落到 ${project.name})
initInfoChkconfig	“INIT INFO” chkconfig 部分	2345 99 01	2345 99 01
confFolder	CONF_FOLDER 的默认值	包含 jar 的文件夹	包含 jar 的文件夹
inlinedConfScript	引用在默认启动脚本中应内联的文件脚本。这可以用来在加载任何外部配置文件之前设置诸如 JAVA_OPTS 之类的环境变量。
logFolder	LOG_FOLDER 的默认值。仅适用于 init.d 服务
logFilename	LOG_FILENAME 的默认值。仅适用于 init.d 服务
pidFolder	PID_FOLDER 的默认值。仅适用于 init.d 服务
pidFilename	PID_FOLDER 中的 PID 文件的名称默认值。仅适用于 init.d 服务
useStartStopDaemon	start-stop-daemon 命令存在时，是否可以用来控制进程	true	true
stopWaitTime	STOP_WAIT_TIME 默认值，以秒为单位。仅适用于 init.d 服务	60	60

在运行脚本时自定义脚本

对于在编写 jar 之后需要定制的脚本项，可以使用环境变量或配置文件。

下面的环境属性在默认脚本中支持：

变量	描述
MODE	操作的模式。缺省值取决于构建 jar 的方式，但通常是 auto（这意味着它试图通过检查它是否是 init.d 符号链接来猜测它是否是 init 脚本）。你可以显式地将其设置为 service，以便 stop|start|status|restart 命令能够工作，或者如果你希望在前台运行脚本，则可以运行该命令。
USE_START_STOP_DAEMON	当 start-stop-daemon 命令可用时，是否可以用于控制进程。默认为 true。
PID_FOLDER	pid 文件夹的 root 名称（默认为 /var/run）。
LOG_FOLDER	放置日志文件的文件夹的名称（默认为 /var/log）。
CONF_FOLDER	要读取的 .conf 文件的文件夹名称（默认为 jar 文件的相同文件夹）。
LOG_FILENAME	LOG_FOLDER 中的日志文件的名称（默认为 <appname>.log）。
APP_NAME	应用程序的名称。如果 jar 是从 symlink 中运行的，脚本会猜到应用程序的名称。如果它不是一个链接，或者你想要明确地设置应用程序名称，这可能是有用的。
RUN_ARGS	传递给程序的参数（Spring Boot 应用程序）。
JAVA_HOME	java 可执行文件的位置是通过默认使用 PATH 发现的，但是如果 $JAVA_HOME/bin/java 有可执行文件，则可以显式设置它。
JAVA_OPTS	在启动时传递给 JVM 的选项。
JARFILE	jar 文件的显式位置，如果脚本被用来启动一个实际上没有嵌入的 jar。
DEBUG	如果不是空，则在 shell 进程中设置 -x 标志，使脚本中的逻辑更容易看到。
STOP_WAIT_TIME	在强制关闭之前停止应用程序的时间（默认为 60）。

	Note
	PID_FOLDER、LOG_FOLDER 和 LOG_FILENAME 变量仅对 init.d 服务有效。对于 systemd，使用服务脚本进行等效定制。有关的详细信息请参阅服务单元配置手册页。

除了 JARFILE 和 APP_NAME，前面部分列出的设置可以使用 .conf 文件来配置。该文件预计将与 jar 文件相邻，并具有相同的名称，但用 .conf 而不是 .jar 添加。例如，名为 /var/myapp/myapp.jar 的 jar 使用名为 /var/myapp/myapp.conf 的配置文件，如下面的示例所示：

myapp.conf. 

JAVA_OPTS=-Xmx1024M
LOG_FOLDER=/custom/log/folder

	Tip
	如果不喜欢将配置文件放在 jar 文件旁边，可以设置 CONF_FOLDER 环境变量来定制配置文件的位置。

若要了解如何妥善保护此文件，请参阅保护 init.d 服务的准则。

可以使用 winsw 启动 Spring Boot 应用程序作为 Windows 服务。

（单独保存的示例）一步一步描述如何为 Spring Boot 应用程序创建 Windows 服务。