云中的 Java：持续集成设置教程

年复一年，我们见证了IT行业日益快速的发展。 自从开创性的口号“一次编写，随处运行”为软件开发社区设定了一个全新的期望水平以来，已经过去了二十多年。 今天，我们拥有一组不断扩展的工具，它们共同将 Java 开发，尤其是软件开发，带入了一个全新的可能性世界。

敏捷、DevOps 以及持续集成和部署等方法，以及微服务的发展，共同提高了软件开发过程的生产力，使开发软件比以往任何时候都更加愉快。 利用自动化和设置正确的工具集可以使软件产品的开发和交付变得异常轻松。

本文将从 Java 开发人员的角度来看待这个新世界，他们跨入 DevOps 并搜索以最大限度地优化产品开发和交付。

今天，诸如 Spring Boot、Docker、Cloud、Amazon Web Services、持续交付等术语被广泛使用，但被人们所理解的却很少。 本文将采用最简单的方式来介绍所有这些技术并解释这些术语，并以教程的形式进行总结，我们将在其中开发一个小软件，并使用所有提到的工具为生产交付做好准备。

为什么选择这些工具？

使用 Docker 简化部署

“一次编写，随处运行”是概念上的突破，它产生了 Java 虚拟机 (JVM) 等技术，使您的代码可以在任何地方运行。 几十年后，现在我们来到了这里，一个名为 Docker 的东西被呈现给了 IT 社区。 Docker 是一个包含工具，您可以在其中放置软件并轻松运行它，几乎可以在您希望的任何地方。

然而，Java 开发人员可能会看着 Docker 并说“我们为什么需要它，我们已经有了 JVM，它被公认为主要的可移植解决方案。” 但是是吗？

“编写一次，随处运行”听起来不错，而且效果很好……至少在大多数情况下是这样。 直到您遇到多个 JVM 供应商、多个 Java 版本、多个操作系统以及以上所有内容的各种排列和组合。 然后，您会发现自己从优雅的“一次编写，随处运行”范式切换到适得其反的“一次编写，到处调试”的陷阱。

这就是 Docker 帮助挽救局面的地方。

Docker 简化了软件的开发、测试和交付。 如果你有想要测试的软件，把它放在 Docker 容器中，它就会运行，并且为所有相关方安装都没有痛苦。

使用 Spring Boot 加速开发

在“随处运行”口号推出后不到十年，Spring 框架就出现了。 今天，Spring 生态系统继续蓬勃发展，并产生了许多有价值的基于 Spring 的项目，其中最著名的可能是 Spring Boot。 如 Spring Boot 网站所述：

Spring Boot 可以轻松创建可以运行的独立的、生产级的基于 Spring 的应用程序。

Spring Boot 使您能够在几分钟内启动并运行应用程序。 软件开发人员可以专注于软件开发，然后可以从为他们完成所有配置的工具中受益。

在本教程中，我们将使用 Spring Boot 来开发我们的微服务。

与 Jenkins 的持续集成 (CI)

DevOps 是一项快速发展的运动，它紧密集成了软件开发和系统管理团队，其目标是使软件开发和交付生命周期对所有相关方尽可能无痛、无缝和高效：开发人员、系统管理员、测试人员，最终， 终端用户。

持续集成 (CI)，是 DevOps 革命的基石之一。 这个想法是，每当开发人员将代码提交到代码存储库时，都会自动对其进行测试和打包以交付（部署）到生产环境。

CI 携手并进：

• 持续交付——自动交付为最终用户业务测试准备的包，手动触发生产部署。
• 持续部署——将打包产品自动部署到生产环境。

存在许多可用于实施 CI 过程的工具。 其中最流行的是 Jenkins，一种开源 CI 工具。 Jenkins 拥有超过一千个插件和庞大的社区，在开始考虑实施持续集成、交付或部署时，它是一个简单的选择。

在我们的教程中，Jenkins 将用于将我们的产品交付到云端，更具体地说，是 Amazon (AWS) 云。

使用 AWS 进行云计算

如果您有一些系统管理员经验，想象一下从您的肩上消除系统管理的一些担忧。 您有一些应用程序； 您知道他们需要多少资源，但您并不确切知道您需要的硬件规模。 您进行估算，购买资源，然后系统投入生产。 如果你幸运的话，你会发现你高估了并且拥有比你需要的更多的资源。 但考虑到墨菲定律，您更有可能发现自己低估了资源需求，并最终在巨大的时间压力下争先恐后地获得更多的内存或处理能力。 相比之下，如果您要部署到云中，您只需将系统放在那里并根据需要调整大小，并使用云提供商提供的灵活性。 使用云，您无需担心系统资源不足，也无需担心 90% 的内存或 CPU 处于空闲状态。

当然，在决定选择哪个供应商方面存在挑战。 云战争仍在进行中。 微软、亚马逊和谷歌为计算的未来而发生的冲突是你最近可以在科技世界新闻中找到的一个示例标题。 对于这个博客，我选择了 Amazon Web Services (AWS)，主要是基于它目前的受欢迎程度和市场份额。

AWS 的优势之一是亚马逊在您注册后提供了许多服务：

在本教程中，我们将使用以下两种 AWS 服务：Elastic Compute Cloud EC2（更具体地说，Amazon EC2 Container Registry，或 Amazon ECR）和 Amazon S3（简单存储服务）。

亚马逊 ECR

我们需要将 Docker 镜像存储在某个地方。 Amazon ECR 是一项托管的 AWS Docker 注册表服务。 如 Amazon ECR 网站所述：

…使开发人员可以轻松存储、管理和部署 Docker 容器映像。 Amazon ECR 与 Amazon EC2 Container Service (ECS) 集成，简化了从开发到生产的工作流程。 Amazon ECR 无需操作您自己的容器存储库或担心扩展底层基础设施。

亚马逊 S3

如前所述，我们开发的应用程序将是一个将文件上传到 Amazon S3 的 Spring Boot 微服务。 如 Amazon S3 网站所述：

…为开发人员和 IT 团队提供安全、持久、高度可扩展的云存储。 Amazon S3 是易于使用的对象存储，具有简单的 Web 服务界面，可以从 Web 上的任何位置存储和检索任意数量的数据。

实用的“操作方法”教程

目标是准备部署一个将文件上传到 Amazon S3 的 Spring Boot 微服务。 步骤如下：

• 开发微服务
• 定义服务将被 docker 化的构建过程
• 使用 Bitbucket 托管 Git 代码存储库
• 将 Bitbucket 与 Jenkins 集成，使用 Gradle 打包应用程序
• 将其推送到远程 Amazon ECR

以下是设置所有需要的组件的教程：

• Spring Boot 示例应用程序 - 使用 Gradle 打包和 dockerized 的微服务
• 在新的 Ubuntu 服务器上安装 Jenkins
• Bitbucket 通过 webhook 与 Jenkins 集成
• 詹金斯作业配置
• Amazon ECR 用于存储包含我们应用程序的 Docker 映像

先决条件

为了能够使用AWS云资源，我们需要先在亚马逊注册。 通过注册，我们将获得一个立即获得免费套餐使用权益的帐户，以便在注册后的 12 个月内获得动手体验。

如前所述，在本教程中，我们将使用 Amazon S3 和 Amazon ECR。 对于两者，我们都需要访问密钥来连接服务。

注册 AWS 后，我们转到我们的帐户安全凭证，我们选择访问密钥并单击“创建新访问密钥”。 单击后，将生成一个密钥及其 ID。 您需要将其存储在安全的地方，因为我们稍后将在配置 AWS Jenkins 集成和开发我们的 S3 文件上传时使用它。

下一个先决条件是我们需要一个 Amazon S3 存储桶（存储容器）。 我们的 Spring Boot 服务将在 Amazon S3 存储中上传和下载文件。 存储桶创建非常简单，只需点击几下。 Create a Bucket 文档中提供了有关如何执行此操作的完整说明。

我们还将使用 Bitbucket 托管我们的代码并触发对 Jenkins 的请求，因此还需要一个 Bitbucket 帐户。 Bitbucket 是开发人员的绝佳选择，它的主要好处之一是您可以创建无限数量的私有存储库。

应用程序开发

与其深入了解 Spring 注释的所有细节以及它们的工作原理，不如从纯粹的开发人员角度关注整个设置中更具挑战性的部分； 即安装和配置 Linux、Jenkins 和 CI 所需的其他工具。 本教程中使用的所有代码示例，包括 Spring Boot 微服务应用程序，都可以在项目的 Bickbucket 存储库中找到。

我们的应用程序组合很简单。 我们的StorageWebserviceApplication.java文件中有一个 Spring Boot 应用程序入口点。 上传和下载文件的逻辑在StorageService.java中。 StorageController.java是一个 Rest 控制器，包含用于文件上传和下载的 API 端点。 这是项目层次结构：

我们选择 Gradle 作为构建工具，它将打包我们的应用程序并组成 Docker 映像。 所以接下来，我们将讨论 Gradle 构建文件、服务组件和 Dockerfile。

为了能够使用 AWS API，我们需要在构建文件中包含依赖项，如使用 Gradle 的 AWS 文档中所定义。

总结起来，我们 Gradle 脚本的 AWS 依赖配置部分如下所示：

 buildscript { ... repositories { mavenCentral() } dependencies { ... classpath("io.spring.gradle:dependency-management-plugin:0.5.4.RELEASE") } } .. apply plugin: "io.spring.dependency-management" dependencyManagement { imports { mavenBom ('com.amazonaws:aws-java-sdk-bom:1.10.47') } } dependencies { .. compile ('com.amazonaws:aws-java-sdk-s3') }

如前所述，在将文件上传到 Amazon S3 时，我们通过将文件上传到 S3存储桶来实现。

要连接到存储桶，我们的 Amazon S3 客户端需要提供凭证。 凭据是我们之前创建的访问密钥。 我们在application.properties文件中定义访问密钥 ID 和值； 我们将存储桶命名为toptal-s3-example 。

现在我们的主要服务组件如下：

 @Service public class StorageService { @Value("${aws.accesKeyId}") private String awsAccessKeyId; @Value("${aws.secretKey}") private String awsSecretKey; @Value("${aws.bucketName}") private String awsBucketName; private AWSCredentials credentials; private AmazonS3 s3client;; @PostConstruct public void init(){ credentials = new BasicAWSCredentials(awsAccessKeyId, awsSecretKey); s3client = new AmazonS3Client(credentials); } public void uploadFile(MultipartFile file) throws IOException { File fileForUpload = transformMultipartToFile(file); s3client.putObject(new PutObjectRequest(awsBucketName, file.getOriginalFilename(), fileForUpload)); } public InputStream downloadFile(String amazonFileKey) throws IOException { S3Object fetchFile = s3client.getObject(new GetObjectRequest(awsBucketName, amazonFileKey)); InputStream objectData = fetchFile.getObjectContent(); return objectData; } …

StorageService从application.properties文件中读取凭证，并使用它们实例化BasicAWSCredentials对象，随后实例化AmazonS3Client对象。 接下来是在 Amazon S3 客户端对象上调用putObject进行文件上传和getObject进行文件下载的简单问题。

我们将在 Docker 容器中运行该服务，并且在 Gradle 构建过程中，我们将构建 Docker 映像。 我们将通过额外配置build.gradle文件来做到这一点，如下所示：

 buildscript { ... dependencies { ... classpath('se.transmode.gradle:gradle-docker:1.2') } } ..... apply plugin: 'docker' ... task buildDocker(type: Docker, dependsOn: build) { push = false applicationName = "storageservice" dockerfile = file('src/main/docker/Dockerfile') doFirst { copy { from jar into stageDir } } }

Buildscript部分和apply plugin非常标准。 我们还定义了一个buildDocker任务，它读取存储在src/main/docker/Dockerfile中的 Docker 配置，并将 JAR 文件复制到 Docker 构建中。

Dockerfile 包含一个纯 Docker 命令列表，我们将使用这些命令准备我们的图像：

 FROM frolvlad/alpine-oraclejdk8 ADD storageWebService-0.0.1-SNAPSHOT.jar storageService.jar EXPOSE 8080 CMD ["java", "-Djava.security.egd=file:/dev/./urandom", "-jar", "/storageService.jar"]

运行我们的应用程序的先决条件是安装了 Java 虚拟机 (JVM)。 Docker 提供了一个安装了 Java 的镜像列表，我们将选择最小的一个，基于最小的 5MB Alpine Linux。 frolvlad/alpine-oraclejdk8映像拥有我们所需的一切，而且非常小（仅 170 MB）。

FROM命令将提到的镜像设置为我们自己构建的基础。 我们将构建的 JAR 文件ADD到名为storageService.jar的容器文件系统中。 接下来，我们使用EXPOSE命令定义 Docker 容器在运行时监听8080端口。 但是，这不会启用从主机到8080的通信。 镜像完成后，我们要运行它，我们还需要使用以下命令在容器上发布端口docker run -p 8080:8080 amazonRepository/storageservice ，其中amazonRepository是我们稍后将配置的存储库教程。 使用CMD ，我们定义在运行容器时将执行哪些命令。 CMD命令括号中的值仅表示当我们运行容器时将执行以下操作：

 java -Djava.security.egd=file:/dev/./urandom -jar /storageService.jar

需要选项-Djava.security.egd=file:/dev/./urandom来帮助缓解启动期间的 JVM 延迟。 如果省略，由于在启动过程中需要一个随机数生成过程，它会使应用程序启动极其缓慢。

这总结了“应用程序开发”部分。 完成此操作后，我们在此处创建的服务将在稍后运行 Docker 容器时自动启动。 因此，让我们开始安装和配置设置持续集成过程所需的其他工具。

应用程序和系统操作

首先，我们需要一个干净的 Linux 服务器来设置 Jenkins CI 工具。 请注意，以下说明专门针对 Ubuntu 14.04。 请记住，其他 Linux 发行版的说明可能略有不同。 使用的 Jenkins 版本是 2.7.1，屏幕和说明可能会根据使用的 Jenkins 版本略有不同。

因此，我们转到我们的 Linux 服务器控制台并开始安装先决条件。

JDK先决条件

我们需要安装 JDK。 以下是安装 JDK8 的说明。

 sudo add-apt-repository ppa:webupd8team/java sudo apt-get install python-software-properties sudo apt-get update sudo apt-get install oracle-java8-installer java -version

安装 Docker

为了让 Jenkins 能够触发 Docker 构建，我们需要安装docker-engine ，如下所示：

 sudo apt-get install apt-transport-https ca-certificates sudo apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 58118E89F3A912897C070ADBF76221572C52609D #create a docker list file sudo vi /etc/apt/sources.list.d/docker.list #add the following entry in the docker.list file (change trusty to #the release you are running on if you are running on different, ie. #xenial, precise...): deb https://apt.dockerproject.org/repo ubuntu-trusty main #save and exit the file sudo apt-get update apt-cache policy docker-engine sudo apt-get install docker-engine

由于我们现在已经安装了 Docker 引擎，使用以下命令我们将启动一个hello-world Docker 映像以确认 Docker 正常工作。

 sudo docker run hello-world

Hello-world图像输出如下所示，我们可以确认引擎工作正常。

安装 AWS 命令​​行界面 (CLI)

接下来，我们将安装 AWS CLI。 稍后，在 Jenkins 作业配置中，我们将使用 CLI 执行 AWS 身份验证和 Docker 映像推送到 Amazon EC2 容器注册表的命令。

要安装 AWS CLI，我们遵循 Amazon CLI 文档中详细描述的指南。

在这两个安装选项中，我们将选择使用 Pip 进行安装，这是一个用于安装和管理 Python 程序的包管理系统。 我们只需运行以下三个命令即可安装 Pip 和 AWS CLI：

 #install Python version 2.7 if it was not already installed during the JDK #prerequisite installation sudo apt-get install python2.7 #install Pip package management for python sudo apt-get install python-pip #install AWS CLI sudo pip install awscli

AWS ECR

作为构建过程的最后一步，我们将把 Docker 镜像推送到 Amazon 容器注册表。 在 Amazon Web 服务控制台中，我们找到了 AWS EC2 容器服务。

我们选择左侧的Repositories子菜单，然后单击Get started 。

然后我们会看到用于配置存储库的第一个屏幕，我们在其中输入存储库名称并单击下一步按钮。

单击下一步，然后向我们显示一个屏幕，其中包含有关如何将图像推送到存储库的说明。

我们将看到一个如何构建 Docker 镜像并将其推送到注册表的示例，但我们现在不需要关心这个。 有了这个，我们创建了一个存储库。

安装和配置 Jenkins

要安装 Jenkins，我们在 shell 中输入以下命令：

 #Download Jenkins key and pipe it to apt-key tool, apt-key command #add will read from input stream, as defined by „–„. When added #apt will be able to authenticate package to be installed. wget -q -O - https://jenkins-ci.org/debian/jenkins-ci.org.key | sudo apt-key add - #create a sources list for jenkins sudo sh -c 'echo deb http://pkg.jenkins-ci.org/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list' #update your local package list sudo apt-get update #install jenkins sudo apt-get install jenkins

安装完成后，Jenkins 会自动启动。 使用以下命令检查服务状态：

 sudo service jenkins status

Jenkins 将连接到 Bitbucket Git 存储库，为此，我们需要安装 Git。

 #install Git sudo apt-get install git

Jenkins 将触发 Gradle 构建过程，在此过程中将创建 Docker 映像。 为此，需要将 Jenkins 用户添加到docker用户组：

 #add Jenkins user to docker user group sudo usermod -aG docker jenkins

在构建过程中，Jenkins 会将 Docker 镜像推送到 Amazon ECR。 要启用此功能，我们需要为 Jenkins 用户配置 AWS。

首先，我们需要切换到jenkins用户。 为此，我们需要设置密码。

 #change Jenkins password sudo passwd jenkins #switch to Jenkins user su – jenkins #configure AWS aws configure

输入aws configure命令后，我们开始输入生成的秘密访问密钥和密钥 ID（这些是我们在流程前面生成的凭证）。 就我而言，该帐户的区域是us-west-2 ，因此我输入了该区域。 我们还将 AWS 命令​​的默认输出格式设置为 JSON。

我们现在可以继续通过可在端口 8080 上访问的 Web 控制台配置 Jenkins。

当我们访问 URL 时，我们会看到以下入门屏幕。

如屏幕上所述，我们需要输入密码。 完成此操作后，设置向导会提示我们执行以下操作：

• 选择要安装的插件 - 我们将选择安装建议的插件。
• 通过输入用户凭据创建第一个管理员用户

完成后，单击保存并完成。 至此，我们完成了 Jenkins 设置配置。

在我们开始定义构建作业之前，我们需要添加一些额外的插件。 我们将转到Manage Jenkins并单击Manage plugins 。 在Available选项卡中，我们首先找到Bitbucket plugin ，选中该框，然后单击Download and install after restart 。

然后，您将看到类似于以下屏幕的内容。

插件安装后，我们对设置作业所需的以下附加插件重复该过程：

• Gradle 插件
• Docker 构建步骤插件
• Cloudbees Docker 自定义构建环境插件
• 亚马逊 ECR 插件

我们使用的 Docker 构建步骤插件将向 Docker 守护进程发送请求。 为此，我们需要在端口 2375 上启用 TCP 套接字。为此，我们输入位于etc/default/docker docker 的 Docker 配置文件。

 sudo vi /etc/default/docker

在这里，我们在配置中添加以下行：

 DOCKER_OPTS='-H tcp://127.0.0.1:2375 -H unix:///var/run/docker.sock'

我们保存并退出文件并重新启动 Docker 和 Jenkins 服务。

 sudo service docker restart sudo service jenkins restart

Jenkins 重新启动后，我们转到 Jenkins 控制台，然后从Manage Jenkins中选择Configure System 。

我们找到Docker builder部分并输入http://localhost:2375作为 REST API URL，单击Apply确认更改。 然后我们单击测试连接以希望确认一切正常。

我们保存配置并继续进行 Jenkins 作业配置。

作业配置

我们进入 Jenkins 主页并创建一个New Item 。

我们选择一个Freestyle 项目并输入项目名称，如以下屏幕所示：

单击OK ，我们将看到作业配置页面。 我们希望在每次推送到我们的 Bitbucket Git 存储库时构建项目。 为此，我们首先需要定义我们要连接的存储库。

第 1 步：源代码管理

在源代码管理下，我们选择 Git 并输入我们的 Bitbucket 存储库的 URL。 URL 的格式为https://bitbucket.org/bitbucketUsername/repositoryName 。

我们输入 URL 后，Jenkins 会自动尝试测试连接。 由于我们还没有输入凭据，它会显示一个错误，表明它无法连接。

打开下拉列表Add ，然后单击Credentials Jenkins provider。

我们将看到以下屏幕，我们在其中输入 Bitbucket 帐户的用户名和密码。

添加新凭据记录后，我们确保在凭据下拉列表中选择它，这样就完成了源代码管理设置。

第 2 步：构建触发器

检查触发器远程构建并定义身份验证令牌。 确保定义一个随机且安全的令牌。

第 3 步：Bitbucket Webhook

Jenkins 已经为我们提供了我们将在 Bitbucket 上使用的 URL。 我们转到我们的 Bitbucket 存储库页面，然后在设置菜单中单击Web hooks 。 随后单击Add webhook会出现以下屏幕，我们将其填写如下：

URL 具有以下结构： http://JENKINS_URL _HOST:PORT/job/JOB_NAME/build?token=TOKEN 。

分别使用 Jenkins URL、运行它的端口、您创建的作业的名称以及您之前定义的令牌输入上面的值。

保存 Webhook 后，您将看到以下屏幕，您可以根据需要对其进行编辑，或者查看我们每次推送新代码时生成的请求。

使用此配置，无论分支如何，都会在每次存储库推送时触发 webhook。 在 Jenkins 方面，我们可以定义哪个分支推送将触发构建。

为了让 Bitbucket 能够将代码推送到 Jenkins，我们需要重新配置 Jenkins 全局安全性以允许匿名读取访问。 此外，对于我们的设置，我们必须禁用默认的 Jenkins 选项，以防止跨站点请求伪造。 为此，请转到Manage Jenkins并选择Configure global security 。 选中允许匿名读取访问并选中防止跨站点伪造攻击。 然后保存配置。

请注意，这只是为了简单起见。 完整设置超出了本教程的范围，它将包括进一步保护 Jenkins 在反向代理后面、TLS 连接上以及启用 CSRF 预防。

第 4 步：Gradle 构建

我们现在可以返回 Jenkins 作业并继续配置它。 在构建部分，我们添加了一个构建步骤： Invoke gradle script 。

在此表格中，我们输入以下内容：

如屏幕所示，我们将使用 Gradle 包装器，这是一个方便的 Gradle 功能，不需要您在主机上安装 Gradle。 确保选中Make gradlew executable框。

在任务中，我们指定build和buildDocker 。

第 5 步：Docker 标记图像

这部分构建标记了之前由 Gradle 的dockerBuild任务准备的 Docker 映像。 为此，我们向作业添加了一个新的构建步骤：执行 Docker 命令。 我们选择Tag image命令并设置图像名称、我们将在其中推送图像的目标存储库和标记：

第 6 步：Docker 推送到 Amazon ECR

最后，我们需要定义如何将我们的图像推送到 Amazon ECR。 为此，我们添加了一个新的Execute shell构建步骤并设置命令以向 AWS 进行身份验证并将映像推送到 Amazon ECR：

 #region for our account is us-west-2 aws ecr get-login --region us-west-2 | bash #push the previously tagged image docker push 058432294874.dkr.ecr.us-west-2.amazonaws.com/springbootdocker:${BUILD_NUMBER} 

至此，我们完成了构建过程。 将新代码推送到 repo 后，该作业将激活，我们将“自动”将新的 Docker 映像上传到 Docker 注册表。

然后可以将映像拉到我们安装了docker-engine的任何位置，并且可以使用以下命令运行：

 docker run -p 8080:8080 amazonRepository/springbootdocker

此命令将启动我们的 Spring Boot 微服务，并使用以下端点将我们的文件上传和下载到 S3 存储桶：

• http://hostnameURL:8080/api/storage/upload
• http://hostnameURL:8080/api/storage/download?fileName=xyz

Java 和持续集成的进一步步骤

总是有更多的事情要做。 本教程涵盖了很多基础知识，但我认为这只是进一步学习的起点。 将 Jenkins 置于 Web 代理服务器（如 Nginx）之后，并建立 TLS 连接，这只是可以而且可以说应该做更多事情的两个例子。

我们的 Docker 映像在 Amazon ECR 上可用并准备好进行部署。 我们现在可以手动部署它。 但是，更好的解决方案是进一步自动化。 CI只是第一步，下一步就是持续交付。 高可用性怎么样？ Amazon AWS EC2 提供了在集群环境中在云中注册容器的功能，这对于基于生产的服务是必需的。 可以在以下 AWS 博客文章中找到开发持续交付流程的一个很好的工作示例。

结论

总而言之，我们已经建立了一个流畅而干净的软件开发流程。 利用可用的工具，我们创建了一个有助于最大限度提高生产力的基础设施。 现在，我们不必担心 Java 服务的配置，这是一个带有 REST 端点的简单 Web 服务。 我们让 Spring Boot 约定处理一切，只关注服务逻辑。 每次将代码推送到 Bitbucket Git 存储库时，我们都会利用 Jenkins 构建一个新的 Docker 映像，最后，我们将云设置为负责存储我们的 Docker 映像和文件。 当我们部署包含在 Docker 映像中的服务时，我们将不受操作系统的任何限制（只要操作系统安装了docker-engine ）。