年复一年，我们见证了IT行业的快速发展. “写一次”这一开创性的口号至今已有20多年了, “随处运行”为软件开发社区设定了一个全新的期望水平. 今天我们在这里，有了一套不断扩大的工具，我们共同采取了 Java development 特别是软件开发，进入了一个全新的可能性世界.

方法论，比如敏捷, DevOps, 持续集成和部署——随着微服务的发展——共同提高了软件开发过程的生产力，使开发软件比以往任何时候都更愉快. 利用自动化和设置正确的工具集可以使软件产品的开发和交付令人惊讶地轻松.

本文将从a的角度来研究这个新的宇宙 Java developer 谁进入DevOps并搜索优化 product development 和最大限度的交付.

Today, 术语，如弹簧引导, Docker, Cloud, Amazon Web Services, 持续交付被广泛使用，但却没有被广泛理解. 本文将采用最简单的方法介绍所有这些技术并解释这些术语, 并以教程的形式将其包装起来，其中我们将开发一小部分软件，并使用所有提到的工具为生产交付做好准备.

Why These Tools?

使用Docker简化部署

”Write once, “随处运行”是概念上的突破，它产生了Java虚拟机(JVM)等技术，使您的代码可以在任何地方运行. And now here we are, 几十年后, 一种叫做Docker的东西出现在IT社区. Docker是一个包含工具，您可以在其中放置软件并轻松运行它, 几乎任何你想去的地方.

However, Java开发人员可能会看着Docker说:“我们为什么需要它, 我们已经有了JVM, 哪一个是公认的主要便携式解决方案.” But is it?

“一次编写，随处运行”听起来不错，而且效果很好……至少大多数时候是这样. 直到遇到多个JVM供应商, 多个Java版本, 多种操作系统, 以及以上所有元素的各种排列和组合. 然后你会发现自己从优雅的“写一次”转变为“写一次”, “随处运行”范式变成了适得其反的“一次写入”, debug everywhere“ pitfall.

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

Docker简化了软件的开发、测试和交付. 如果你有你想测试的软件, 把它放到Docker容器中, 它将运行，并且安装对所有相关方都是无痛的.

用Spring Boot加速发展

距离“到处跑”的口号被提出还不到十年, Spring框架出现了. Today, 春天的生态系统继续蓬勃发展, 并产生了许多有价值的基于spring的项目, 也许最引人注目的是春靴. As stated on the Spring Boot website:

Spring Boot使创建独立系统变得很容易, 您可以直接运行的基于Spring的生产级应用程序.

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

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

与Jenkins的持续集成

DevOps是一个快速发展的运动，它紧密地集成了软件开发和系统管理团队, 以使软件开发和交付生命周期无痛为目标, seamless, 并且对所有相关方(开发人员)都尽可能高效, sysadmins, testers, and ultimately, end users.

持续集成(CI)是DevOps革命的基石之一. 其思想是，每当开发人员向代码存储库提交代码时, 它被自动测试和打包，以便交付(部署)到生产环境.

CI与以下因素密切相关:

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

可用于实现CI流程的工具有很多. 其中最流行的是Jenkins，一个开源的持续集成工具. 它有一千多个插件和一个庞大的社区, 当开始考虑实现持续集成时，Jenkins是一个简单的选择, delivery, or deployment.

In our tutorial, Jenkins将用于将我们的产品交付到云端, more specifically, 亚马逊(AWS)云.

使用AWS的云计算

如果你有一些系统管理经验, 想象一下，从您的肩上卸下一些系统管理的烦恼. You have a few applications; you have an idea of how much resource they will require, 但是您不知道所需的硬件尺寸. 你做出估计，购买资源，然后系统投入生产. 如果你幸运的话，你会发现你高估了，并且拥有比你需要的更多的资源. 但是根据墨菲定律, 您很可能会发现低估了资源需求，最终在巨大的时间压力下争先恐后地获得更多的内存或处理能力. In contrast, 如果你部署到云端, 您只需将系统放在那里并根据需要调整大小即可, 利用云提供商提供的灵活性. With the cloud, 您也不需要担心系统资源耗尽, 也不需要担心90%的内存或CPU处于闲置状态.

当然，决定选择哪个提供者是一个挑战. 云之战仍在进行中. 微软、亚马逊和谷歌争夺计算机的未来 你能在最近的科技界新闻中找到一个例子吗. For this blog, 我选择了亚马逊网络服务(AWS), 主要是基于它目前的受欢迎程度和市场份额.

AWS的优势之一是，在你注册后，亚马逊会提供很多服务:

在本教程中，我们将使用以下两个AWS服务:Elastic Compute Cloud EC2(更具体地说，是EC2), Amazon EC2容器注册表, or Amazon ECR), 和Amazon S3(简单存储服务).

Amazon ECR

我们需要将Docker映像存储在某个地方. Amazon ECR是一个托管的AWS Docker注册服务. As stated on the Amazon ECR web site:

使开发人员可以轻松地存储、管理和部署Docker容器映像. Amazon ECR与Amazon EC2容器服务(ECS)集成, 简化您的开发到生产工作流程. Amazon ECR消除了操作您自己的容器存储库或担心扩展底层基础设施的需要.

Amazon S3

As mentioned, 我们开发的应用程序将是一个Spring Boot微服务，它将上传文件到Amazon S3. As stated on the Amazon S3 web site:

为开发人员和IT团队提供安全、持久、高度可扩展的云存储. Amazon S3是易于使用的对象存储, 通过简单的web服务接口，可以存储和检索web上任何地方的任意数量的数据.

一个实用的“如何”教程

目标是为部署Spring Boot微服务做准备，该微服务将上传文件到Amazon S3. 步骤如下:

• 开发微服务
• 定义将在其中对服务进行码头化的构建过程
• 使用Bitbucket来托管Git代码库
• 将Bitbucket与Jenkins集成，使用Gradle打包应用程序
• 将其推送到远程Amazon ECR

下面是设置所有所需组件的教程:

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

Prerequisites

为了能够使用AWS云资源，我们需要 register at Amazon first. 通过注册，我们将获得一个即时账户 Free Tier usage benefits, 以便在注册后的12个月内获得实践经验.

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

在与AWS注册后，我们进入我们的帐户 Security credentials, where we choose Access keys 点击“创建新访问密钥”. 单击后，将生成一个密钥及其ID. 你得把这个放在安全的地方, 因为我们将在稍后配置AWS Jenkins集成和开发S3文件上传时使用它.

下一个先决条件是我们需要一个Amazon S3桶(存储容器). 我们的Spring Boot服务将上传和下载文件到Amazon S3存储. 桶的创建非常简单，只需要点击几下即可. 中提供了如何执行此操作的完整描述 创建Bucket文档.

我们还会用到 Bitbucket 用于托管我们的代码并触发对Jenkins的请求，因此也需要一个Bitbucket帐户. Bitbucket对开发人员来说是一个很好的选择, 它的主要优点之一是您可以创建无限数量的私有存储库.

应用程序开发

而不是深入了解Spring注释的所有细节及其工作原理, I will instead focus, 从纯粹的开发者角度来看, on the more challenging part of the whole setup; namely, 安装和配置Linux, Jenkins, 以及CI所需的其他工具. 本教程中使用的所有代码示例, 包括Spring Boot微服务应用程序, are available on the 项目的Bickbucket存储库.

我们的应用程序组合很简单. 中有一个Spring Boot应用程序入口点 StorageWebserviceApplication.java file. 上传和下载文件的逻辑输入 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.依赖关系管理”
 
dependencyManagement {
	imports {
    	mavenBom ('com.amazonaws: aws-java-sdk-bom: 1.10.47')
	}
}
 
dependencies {
   	..
   	compile ('com.amazonaws: aws-java-sdk-s3”)
}

如前所述，当将文件上传到Amazon S3时，我们通过将文件上传到S3来完成 bucket.

要连接到存储桶，我们的Amazon S3客户端需要提供凭据. 凭据是我们前面创建的访问密钥. 中定义访问键ID和值 application.properties file; we have named our bucket toptal-s3-example.

我们目前的主要服务内容如下:

@Service
公共类StorageService {
 
  	@Value("${aws.accesKeyId}")
  	private String awsAccessKeyId;
 
  	@Value("${aws.secretKey}")
  	私有字符串awsSecretKey;
 
  	@Value("${aws.bucketName}")
  	private String awsBucketName;
  	
  	 私人awcredential证书;
  	 private AmazonS3 s3client;;
 
  	@PostConstruct
	public void init(){
        	 凭证= new basicawscredals (awsAccessKeyId, awsSecretKey);
        	 s3client = new AmazonS3Client(凭据);
	}
 
 
  	uploadFile(MultipartFile文件)抛出IOException {
        	文件fileForUpload = transformMultipartToFile(文件);
        	s3client.putObject(new PutObjectRequest(awsBucketName).fileForUpload getOriginalFilename ()));
  	}
  	
  	公共InputStream downloadFile(String amazonFileKey)抛出IOException {
        	S3Object fetchFile = s3client.getObject(new GetObjectRequest(awsBucketName, amazonFileKey));
        	InputStream objectData = fetchFile.getObjectContent();
        	return objectData;
  	}
…

StorageService 对象中读取凭据 application.properties 文件并使用它们进行实例化 BasicAWSCredentials 对象，然后是 AmazonS3Client object. 接下来是一个简单的调用问题 putObject for file upload and getObject 用于文件下载，在Amazon S3客户机对象上.

我们将在Docker容器中运行该服务, 在Gradle构建过程中, 我们将构建Docker镜像. 我们将通过额外配置 build.gradle file, as follows:

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

The Buildscript part and apply plugin are pretty standard. 我们也定义了a buildDocker 任务，该任务读取存储在 src / main /码头工人/ Dockerfile，并将JAR文件复制到Docker构建中.

Dockerfile包含一个纯Docker命令列表，我们将用它来准备我们的镜像:

从frolvlad / alpine-oraclejdk8
添加storageWebService-0.0.1-SNAPSHOT.jar storageService.jar
EXPOSE 8080
CMD ["java", "-Djava.security.egd=file:/dev/./urandom"， "-jar"， "/storageService . conf ".jar"]

运行我们的应用程序的先决条件是安装Java虚拟机(JVM)。. Docker提供了一个安装了Java的镜像列表, 我们选一个最小的, 基于最小5MB的Alpine Linux. frolvlad / alpine-oraclejdk8 image有我们需要的所有内容，而且非常小(只有170 MB).

The FROM Command将上述映像设置为构建我们自己的映像的基础. We ADD 将构建的JAR文件放到容器文件系统中 storageService.jar. 接下来，我们定义Docker容器监听端口 8080 at runtime with the EXPOSE command. 然而，这将不能使通信 8080 from the host. 当图像完成时, 我们要运行它, 我们还需要使用以下命令在容器上发布端口 docker执行-p 8080:8080 amazonRepository/storageservice, where amazonRepository 是我们将在本教程后面配置的存储库吗. With CMD，定义在运行容器时将执行哪些命令. 的括号中的值 CMD 命令的意思是，当我们运行容器时，将执行以下命令:

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

The option -Djava.security.egd=file:/dev/./urandom 在启动期间需要帮助减轻JVM延迟吗. If omitted, 它将使应用程序启动极其缓慢，因为在启动过程中需要一个随机数生成过程.

这就是“应用程序开发”部分的总结. With this done, 当我们稍后运行Docker容器时，我们在这里创建的服务将自动启动. So, 让我们开始安装和配置设置持续集成过程所需的其他工具.

应用与系统操作

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

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

JDK Prerequisite

我们需要安装一个JDK. 以下是安装JDK8的说明.

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

Install Docker

为了让Jenkins能够触发Docker构建，我们需要安装 docker-engine as follows:

安装apt-transport-http ca-certificates

执行命令apt-key adv——keyserver hkp://p80.pool.sks-keyservers.net:80—recv-keys 58118E89F3A912897C070ADBF76221572C52609D

创建docker列表文件
执行命令vi /etc/apt/sources.list.d/docker.list

在docker中添加以下条目.列表文件(如果您运行的是不同的版本，请将trust_#更改为您正在运行的版本. #xenial, precise...):
deb http://apt.dockerproject./repo ubuntu- trusted main
#保存并退出文件
 
sudo apt-get update
Apt-cache policy docker-engine
安装docker-engine

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

Sudo docker运行hello-world

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

安装AWS命令行接口

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

要安装AWS CLI，我们需要遵循在 Amazon CLI文档.

两个安装选项中的一个, 我们将选择使用Pip进行安装, 用于安装和管理Python程序的包管理系统. 我们将通过运行以下三个命令来安装Pip和AWS CLI:

#安装Python版本2.如果在JDK #先决条件安装期间尚未安装，则为7
Sudo apt-get install python2.7
为python安装Pip包管理
安装python-pip
#install AWS CLI
Sudo PIP安装awscli

AWS ECR

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

We select Repositories 在左边的子菜单上点击 Get started.

然后，我们将看到配置存储库的第一个屏幕，在这里输入存储库名称并单击 Next Step button.

Clicking on Next Step 然后向我们显示一个屏幕，说明如何将图像推送到存储库.

我们提供了一个如何构建Docker映像并将其推送到注册表的示例, 但我们现在不需要担心这个. 这样，我们就创建了一个存储库.

安装和配置Jenkins

为了安装Jenkins，我们在shell中输入以下命令:

#下载Jenkins密钥并将其管道到apt-key工具, Apt-key命令#add将从输入流中读取, as defined by „–„. When added
#apt将能够验证要安装的包.
wget -q - o - http://jenkins-ci.org/debian/jenkins-ci.org.键| sudo apt-key add -
#为Jenkins创建一个资源列表
Sudo sh -c 'echo deb http://pkg.jenkins-ci.org/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'

更新您的本地包列表
sudo apt-get update

#install jenkins
Sudo apt-get install Jenkins

安装完成后，Jenkins会自动启动. 使用如下命令查看服务状态。

Sudo服务Jenkins状态

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

#install Git
安装git

Jenkins将触发Gradle的构建过程，在此过程中会创建一个Docker镜像. 要做到这一点，需要将Jenkins用户添加到 docker user group:

将Jenkins用户添加到docker用户组
sudo usermod -aG docker jenkins

在构建过程中，Jenkins将把Docker镜像推送到Amazon ECR. 要启用这一点，我们需要为Jenkins用户配置AWS.

首先，我们需要切换到 jenkins user. 为此，我们需要设置一个密码.

#更改Jenkins密码
sudo passwd jenkins

#切换到Jenkins用户
su – jenkins

#configure AWS
aws configure

After entering the aws configure command, 我们开始输入生成的秘密访问密钥和密钥ID(这些是我们在流程早期生成的凭据). 在我的例子中，该帐户的区域是 us-west-2, and so I input that. 我们还将AWS命令的默认输出格式设置为JSON.

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

当我们访问URL时，将显示以下内容 Getting started screen.

如屏幕所示，我们需要输入密码. 完成这些后，安装向导提示我们执行以下操作:

• 选择要安装的插件-我们将选择 安装建议的插件.
• 通过输入用户凭证创建第一个admin用户

When done, click Save and Finish. 至此，我们已经完成了Jenkins设置配置.

在开始定义构建作业之前，我们需要添加一些额外的插件. We will go to Manage Jenkins and click on Manage plugins. In the Available Tab，我们首先找到 Bitbucket plugin，选中复选框，然后单击 重新启动后下载并安装.

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

安装插件后, 我们对以下设置作业所需的附加插件重复此过程:

• Gradle plugin
• Docker构建步骤插件
• Cloudbees Docker自定义构建环境插件
• Amazon ECR plugin

我们使用的Docker build step插件会向Docker守护进程发送请求. 为此，我们需要在端口2375上启用TCP套接字. 要做到这一点，我们输入Docker配置文件位于 etc/default/docker.

Sudo vi /etc/default/docker

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

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

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

Sudo service docker restart
Sudo服务Jenkins重启

在Jenkins重新启动后，我们进入Jenkins控制台，从 Manage Jenkins, we choose Configure System.

We find the Docker builder section and enter http://localhost:2375 对于REST API URL，单击 Apply 确认更改. We then click the Test Connection 希望能确认一下一切都好.

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

Job Configuration

我们进入Jenkins主页，创建一个 New Item.

We choose a Freestyle project 并输入项目名称，如下所示:

Clicking on OK，我们将看到作业配置页面. 我们希望项目在每次推送到Bitbucket Git存储库时都进行构建. 要实现这一点，我们首先需要定义要连接的存储库.

步骤1:源代码管理

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

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

打开下拉列表 Add, and click on Credentials Jenkins provider.

我们看到了下面的屏幕, 输入Bitbucket帐户的用户名和密码.

添加新的凭据记录后, 我们确保在凭据下拉列表中选择它, 这就结束了 源代码管理 setup.

步骤2:构建触发器

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

第三步:Bitbucket Webhook

Jenkins已经为我们提供了我们将在Bitbucket上使用的URL. 我们进入Bitbucket存储库页面，在设置菜单中单击 Web hooks. 然后点击 Add webhook 显示如下屏幕，我们按如下方式填写:

URL的结构如下: http://JENKINS_URL _HOST:港口/工作/ JOB_NAME /构建?token=TOKEN.

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

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

通过这种配置，webhook会在每次存储库推送时触发，而不管分支是什么. 在Jenkins端，我们可以定义哪个分支推送将触发构建.

Bitbucket可以把代码推送给Jenkins, 我们需要重新配置Jenkins全局安全，允许匿名读访问. Additionally, for our setup, 我们必须禁用默认的Jenkins选项，以防止跨站点请求伪造. To do this, go to Manage Jenkins and choose 配置全局安全. Check 允许匿名读访问 and check 防止跨站点伪造漏洞. 然后保存配置.

请注意，这样做只是为了简单起见. 完整的设置超出了本教程的范围, 这将包括通过反向代理进一步保护詹金斯, on TLS connection, 并启用CSRF预防.

Step 4: Gradle Build

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

在此表单中，我们输入以下内容:

如屏幕所示, 我们将使用Gradle包装器, 这是一个方便的Gradle特性，不需要在主机上安装Gradle. 一定要检查 使gradlew可执行 box.

在任务中，我们指定 build and buildDocker.

步骤5:Docker标签图像

这部分构建标记了之前由Gradle准备的Docker映像 dockerBuild task. 为此，我们在作业中添加了一个新的构建步骤: 执行Docker命令. We choose the Tag image 命令并设置图像名称，我们将推送图像的目标存储库，并标记:

步骤6:将Docker推送到Amazon ECR

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

我们账户的区域是us-west-2
登录—region us-west-2
#push先前标记的图像
Docker push 058432294874.dkr.ecr.us-west-2.amazonaws.com/springbootdocker: $ {BUILD_NUMBER}

至此，我们已经完成了构建过程. 将新代码推送到repo之后, 这个工作将激活, 我们将有一个新的Docker镜像“自动”上传到Docker注册表。.

然后图像可以被拉到我们拥有的任何地方 docker-engine 已经安装，可以用下面的命令运行:

执行命令-p 8080:8080 amazonRepository/springbootdocker

这个命令将启动我们的Spring Boot微服务, 使用以下端点上传和下载我们的文件到S3桶:

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

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

总有更多的事情要做. 本教程涵盖了很多内容, 但我认为这只是一个进一步学习的起点. 将詹金斯置于网络代理服务器之后, like Nginx, 建立TLS连接, 这仅仅是两个例子吗, and arguably should, be done.

我们的Docker镜像在Amazon ECR上可用，并且可以部署. 我们现在可以使用它并手动部署它. 然而，更好的解决方案是将其进一步自动化. 持续集成只是第一步，下一步是持续交付. 那么高可用性呢? Amazon AWS EC2提供了在集群环境的云中注册容器的功能，这对于基于生产的服务是必需的. 下面是开发持续交付过程的一个很好的工作示例 AWS blog post.

Conclusion

总而言之，我们已经建立了一个顺利而干净的软件开发过程. 利用可用的工具, 我们已经创建了一个基础设施，帮助我们最大限度地提高生产力. Now, 我们不必担心Java服务的配置，它是一个带有REST端点的简单web服务. 我们让Spring Boot约定处理所有事情，只关注服务逻辑. 每次我们将代码推送到Bitbucket Git存储库时，我们都会利用Jenkins构建一个新的Docker映像, and in the end, 我们已经设置了云来负责存储Docker映像和文件. 当我们部署包含在Docker镜像中的服务时, 我们将不受操作系统的任何限制(只要操作系统具有 docker-engine installed).