Docker入门文档

Docker是一个开源的应用容器引擎。Docker可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的Linux机器上，也可以实现虚拟化。容器是完全使用沙箱机制相互之间不会有任何接口（类似 iPhone的app）,更重要的是容器性能开销极低。

  本内容整理来源于《微服务架构基础 Spring Boot+Spring Cloud+Docker.pdf》 下载地址在 http://www.86clouds.com/detail/383366928 

 ####【Docker安装】 ####

#更新apt索引包
$ apt-get update 

#使用Docker库
$ apt-get install apt-transport-https ca-certificates curl software-properties-common

#添加Docker官网的GPG   key
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg |  apt-key add - 

#添加Docker稳定的仓库源(根据Ubuntu镜像版本的不同进行选择安装)

amd64：
$  add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

armhf：
$  add-apt-repository "deb [arch=armhf] https://download.docker.com/linux/ubuntu $ (lsb___release -cs) stable"

s390x:
$  add-apt-repository "deb [arch=s390x] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

2.安装 DockerCE
设置好Docker仓库之后，就可以从存储库中安装和更新Docker,其实现步骤如下。
(1 )更新apt的索引包。
$  apt-get update
(2)安装不同版本的Docker。在安装Docker时，通常会根据个人情况选择安装不同的版 本。为此，Docker提供了两种安装方式，一是安装默认的最新版本的Docker,二是安装指定版 本的Docker,具体如下。
・安装最新版本的Docker,具体指令如下。
$  apt-get install docker-ce
需要注意的是，执行上述指令后，之前存在的任何版本的Docker都会被替换。安装指定版本的Docker,具体指令如下。
$  apt-get install docker-ce=<VERSION>
从上述指令可以看出，安装指定版本的Docker时，需要通过“=”将版本字符串附加到安 装包后。为了更好地选择指定版本的Docker,可以使用apt-cache madison指令查看Docker仓库 中的Docker版本信息，具体指令如下。
$ apt-cache madison docker-ce
 docker-ce | 5:19.03.3~3-0~ubuntu-xenial | https://download.docker.com/linux/ubuntu xenial/stable amd64 Packages
 docker-ce | 5:19.03.2~3-0~ubuntu-xenial | https://download.docker.com/linux/ubuntu xenial/stable amd64 Packages
 docker-ce | 5:19.03.1~3-0~ubuntu-xenial | https://download.docker.com/linux/ubuntu xenial/stable amd64 Packages
 docker-ce | 5:19.03.0~3-0~ubuntu-xenial | https://download.docker.com/linux/ubuntu xenial/stable amd64 Packages
 docker-ce | 5:18.09.9~3-0~ubuntu-xenial | https://download.docker.com/linux/ubuntu xenial/stable amd64 Packages
 docker-ce | 5:18.09.8~3-0~ubuntu-xenial | https://download.docker.com/linux/ubuntu xenial/stable amd64 Packages
 docker-ce | 5:18.09.7~3-0~ubuntu-xenial | https://download.docker.com/linux/ubuntu xenial/stable amd64 Packages
 docker-ce | 5:18.09.6~3-0~ubuntu-xenial | https://download.docker.com/linux/ubuntu xenial/stable amd64 Packages
 ................................................................................................................
执行上述指令后，就会显示出当前Docker仓库提供的在线的Docker的版本信息，其中第二列是版本字符串，第三列是存储库名称，用于指示安装包来自哪个存储库。
(3)安装完成后，可以使用 docker run hello-world指令运行测试，具体指令如下。
$  docker run hello-world


在没有网络或者网络条件较差的情况下，我们可以选择离线安装Docker (使用DEB格式的 安装文件)。这种安装方式的好处是不依赖于网络，但其缺点是后期使用时需要手动升级和维护, 并且每次升级时都需要下载一个新的.deb文件。
离线安装方式的具体实现步骤如下。
1.下载离线安装文件
通过官方提供的地址 https://download.docker.com/linux/ubuntu/dists/,下载安装 Docker的.deb
Ubuntu Xenial 16.04 ( LTS )版本，所以要单击图中的xenial链接并进入到pool/stable/目录下，然后根据情况选择amd64、armhf或者s390x版本的.deb文件
2.使用离线文件安装Docker
通过下载的.deb文件进行Docker离线安装非常简单，只需要在Ubuntu系统的终端中执行 如下指令。
$  dpkg -i /path/to/package.deb
需要注意的是，使用sudo dpkg -i指令安装Docker时，一定要指定读者下载的.deb文件 所在地址，例如上面指令表示执行/path/to/路径下的package.deb文件。


(4)  docker version  查看 docker版本 
Client: Docker Engine - Community
 Version:           19.03.3
 API version:       1.40
 Go version:        go1.12.10
 Git commit:        a872fc2
 Built:             Tue Oct  8 00:59:54 2019
 OS/Arch:           linux/amd64
 Experimental:      false

Server: Docker Engine - Community
 Engine:
  Version:          19.03.3
  API version:      1.40 (minimum version 1.12)
  Go version:       go1.12.10
  Git commit:       a872fc2
  Built:            Tue Oct  8 00:58:28 2019
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.2.10
  GitCommit:        b34a5c8af56e510852c35414db4c1f4fa6172339
 runc:
  Version:          1.0.0-rc8+dev
  GitCommit:        3e425f80a8c931f88e6d94a8c831b9d5aa481657
 docker-init:
  Version:          0.18.0
  GitCommit:        fec3683
  
  
############【Docker基本的使用介绍】################
  
$ 编写Dockerfile文件

$ docker build -t hellodocker .              -t参数指定了生成的镜像名称为 hellodocker  指令最后的点[•]代表的是当前目录下的应用上下文 如果Dockerfile不在则需要替换为Dockerfile的路径地址

$ docker images                              查看镜像


$ docker run -d -p 5000:80 hellodocker       访问程序，查看结果。使用宿主机的浏览器通过地址http://localhost:5000来访问容器中运行的程序
                                             创建并启动容器,镜像就类似一个Java类，必须有具体的实例才能使用
                                             docker run是Docker创建并启动容器的指令,-d参数表示在后台运行容器, -p参数将容器暴露的80端口映射到宿主机的 5000 端口
		  
		  
$ docker ps                                  查看Docker运行中的容器效果

$ docker stop 653347ecc6df                   停止容器


############【Dockerfile基本的介绍】################


指令	               说明
FROM	 			                 指定基础镜像
MAINTAINER		               指定镜像维护者信息
RUN					                 用于执行指定脚本命令
CMD					                 指定启动容器时执行的命令
EXPOSE				               指定容器暴露的端口
ENV					                 指定环境变量
ADD					                 将文件从宿主机复制到容器指定位置，同时对压缩文件有自动解压功能
COPY				                 将文件从宿主机复制到容器指定位置
ENTRYPOINT		               设置容器启动时需要运行的命令
WORKDIR			                 为后续的如RUN、CMD、ENTRYPOINT, COPY、ADD指定工作目录

############【Docker常用操作指令】################


docker images	                     列岀镜像
docker search	                     搜索镜像
docker pull	                       拉取镜像
docker build	                     构建镜像
docker rmi	                       删除镜像
docker run	                       创建并启动容器
docker ps	                         列岀容器
docker exec	                       执行容器
docker stop	                       停止容器
docker start	                     启动容器
docker rm	                         删除容器
                                     
                                     
$ docker images	                     执行上述指令后，系统会将所有本地镜像都展示出来
                                     
REPOSITORY                           镜像名称 
TAG                                  镜像的参数，类似于版本号，默认是latesto
IMAGE ID                             镜像ID,是唯一值。此处看到的是一个长度为12的字符串，实际上它是64 位完整镜像ID的缩写形式
CREATED                              距今创建镜像的时间
SIZE                                 镜像大小
                                     
                                     
$ docker search ubuntu               执行上述指令后，系统终端就会将搜索到的有关Ubuntu的镜像展示出来
                                     
NAME                                 表示镜像的名称，这里有两种格式的名称，其中不带有"/”的表示官方镜像，而带有7"的表示其他用户的公开镜像。公开镜像"/”前面是用户在±的用户名(后面是对应的镜像
DESCRIPTION                          表示镜像的描述，这里只显示了一小部分。
STARS                                表示该镜像的收藏数，用户可以在Docker Hub ±对镜像进行收藏，一般可以通 过该数字反映出该镜像的受欢迎程度。
OFFICIAL：                           表示是否为官方镜像。
AUTOMATED                            表示是否自动构建镜像。例如，用户可以将自己的Docker Hub绑定到如 Github上，当代码提交更新后，可以自动构建镜像。
                                     
                          
						  
$ docker pull ubuntu                                                     Docker会自动从Docker Hub上下载最新版本的Ubuntu到本地 
                                                                         
$ docker pull ubuntu:14.04                                               拉取指定版本的镜像到本地
                                                                                                        
$ cd workspace/dockerspace/                                              在Dockerfile文件所在目录构建镜像
                                                                         
$ docker build -t hellodocker2 .                                         进入Dockerfile文件所在目录后，可以使用docker build指令进行镜像构建
                                                                         
$ cd ~                                                                   在其他目录构建镜像
$ docker build -t hellodocker3 /home/shitou/workspace/dockerspace/.


$ docker rmi -f hellodocker2 hellodocker3                                当本地存放过多不需要的镜像时


$ docker run -d -p 5000:80 --name test hellodocker                       创建并启动容器


$ docker ps                                                              列出容器

CONTAINER ID                                                             表示生成的容器ID。
IMAGE                                                                    表示生成该容器的镜像名称。
COMMAND                                                                  表示启动容器时运行的命令，Docker要求在启动容器时必须运行一个命令。
CREATED                                                                  表示容器创建的时间。
STATUS                                                                   表示容器运行状态，例如Up表示运行中，Exited表示已停止。
PORTS                                                                    表示容器内部暴露的端口映射到主机的端口。
NAMES                                                                    表小生成容器的名称,由Docker引擎自动生成，可以像上述不例中使用—name 参数指定生成容器的名称。


$ docker stop f0c9a8b6e8c5             停止容器

$ docker ps -a                         查看该容器

$ docker start f0c9a8b6e8c5            启动容器


$ docker restart f0c9a8b6e8c5          重启容器



############【Docke管理指令】################


docker container	                   用于管理容器
docker image	                       用于管理镜像
docker network	                     用于管理Docker网络
docker node	                         用于管理Swarm集群节点
docker plugin	                       用于管理插件
docker secret	                       用于管理Docker机密
docker service	                     用于管理Docke一些服务
docker stack	                       用于管理Docker堆栈
docker swarm	                       用于管理Swa「m
docker system	                       用于管理Docke「
docker volume	                       用于管理数据卷

############【 Docker Hub远程镜像管理】################


1.登录 Docker Hub         

    要使用Docker Hub就需要先在其官网https://hub.docker.com/注册一个账号(需要用户名、 邮箱和密码)，通过邮件认证后，即可登录到Docker Hub中心
Docker Hub的仓库分为Public (公开)和Private (私有)两种，公开仓库 可以被其他开发者查看和拉取资源；而私有仓库不对外公开，只对内部创建组织的
成员公开。Docker Hub为免费用户只提供了一个私有仓库，如果需要使用更多的私有仓库，则可以单击上 图中的“Get more”链接通过付费的方式进行获取。

其他功能
    1.镜像管理：可以从社区或官方搜索、拉取、管理、推送镜像等。
    2.自动构建镜像：Docker Hub支持连接到源代码仓库，如GitHub和Bitbucket,当源代码 进行修改后可以进行自动化构建镜像。
    3.Webhooks (监测工具)：属于自动构建的一个特性，Webhooks能够让开发者成功推送仓 库后触发一些行为。Organizations (组织)：可以创建工作组，来协同开发、管理一个镜像仓库。
    4.GitHub和Bitbucket集成：支持集成代码仓库GitHub和Bitbucket到工作流中。

2.修改镜像名称

$  docker tag hellodocker:latest itheima/hellodocker:latest   修改镜像名称

3.登录认证

$ docker login 


4.推送镜像

$ docker push itheima/hellodocker:latest

 如果想要将推送的镜像仓库设置为私有的，有两种方式：一种方式就是推送完成后立即进入 Docker Hub仓库面板，进入对应仓库详情中的Settings菜单/功能下，单击“Make Private”按钮设 置为私有仓库；另一种方式就是在推送镜像之前，先在Docker Hub上通过Create Repository (创建 仓库)链接创建一个私有仓库，然后再以该私有仓库为名重命名一个本地镜像，推送到该指定私有仓库上。
 相比Docker Hub而言，Docker Registry的功能就不够全面了，且需要自己手动配置、升 级、维护和管理，所以说对于Docker镜像管理不太熟悉的人员推荐使用Docker Hubo如果开 发者想要严格控制镜像存储位置，完全拥有自己的镜像分配渠道，或者要想将镜像存储和分布紧 密嵌入到自己开发的程序中，贝U选择Docker Registry更适合。接下来，本小节将针对Docker Registry本地私有镜像仓库的管理进行详细讲解。
 
 
 
 
############【 Docker网络管理】################


$ docker network ls  

  Docker中默认的三种网络分别为bridge.host和none,其中名为bridge 的网络就是默认的bridge驱动网络，也是容器创建时默认的网络管理方式，配置后可以与宿主 机通信从而实现与互联网通信功能，而host和none属于无网络，容器添加到这两个网络时不能 与外界网络通信。


############【 Docker数据管理】################


(1)Docker数据存储机制

    使用Docker时，我们操作的都是镜像和由镜像生成的容器，所以想要更好地了解Docker 内部的数据存储机制，就必须从镜像、容器与数据存储的关系出发。
Docker镜像是通过读取Dockerfile文件中的指令构建的，Dockerfile中的每条指令都会创 建一个镜像层，并且每层都是只读的，这一系列的镜像层就构成了 Docker镜像

(2)Docker数据存储方式

    在默认情况下，Docker中的数据都是存放在容器层的，但是这样存储数据却有较多的缺陷， 具体表现如下。当容器不再运行时，容器中的数据无法持久化保存，
如果另一个进程需要这些数据，那么 将很难从容器中获取数据。容器层与正在运行的主机紧密耦合，不能轻易地移动数据。容器层需要一个存储驱动程序来管理文件
系统，存储驱动程序提供了一个使用Linux内核 的联合文件系统，这种额外的抽象化降低了性能。
    基于上述种种原因，多数情况下Docker数据管理都不会直接将数据写入容器层，而是使用 另一种叫做Docker volume数据外部挂载的机制进行数据管理。
针对Docker volume数据外部挂载机制，Docker提供了三种不同的方式将数据从容器映射 到Docker宿主机，它们分别为：volumes(数据卷)、bind mounts(绑定挂载)和tmpfs mounts (tmpfs挂载).这三种数据管理方式的具体选择，需要结合实际情况进行考虑，其中的volumes 数据卷是最常用也是官方推荐的数据管理方式。
无论选择使用哪种数据管理方式，数据在容器内看起来都一样的，而在容器外则会被被挂载 到文件系统中的某个目录或文件中。


(3)数据管理方式
volumes         存储在主机文件系统中(在Linux系统 下是存在于/var/lib/Docker/volumes/目录),并由 Docker 管理，非Docker进程无法修改文件系统的这个部分。
bind mounts     可以存储在主机系统的任意位置，甚至可能是重要的系统文件或目录，在 Docker主机或容器上的非Docker进程可以对它们进行任意修改。
tmpfs mounts    只存储在主机系统的内存中，并没有写入到主机的文件系统中。


==========================================================================================================================================================



############【 Docker Compose】################

    Docker Compose,俗称Docker编排工具，是用来定义和运行多容器应用的Docker工具。 通过该编排工具，可以使用yml文件来配置应用程序服务，
然后只需要一条简单的服 务部署指令就可以从配置中创建并启动所有服务
    对于简单的个别服务应用可以使用Dockerfile构建镜像，然后使用docker run或者 docker service create命令启动容器服务；对于多容器服务
如微服务架构项目,最好使用 Docker Compose编排工具进行统一管理。

1.安装

   (1)安装条件
        Docker Compose是依赖于Docker引擎的，所以在安装Docker Compose之前要确保机 器上已经安装了 Docker (可以使用docker -v指令查看)。
   	 
   (2)安装 Compose
   
       使用curl命令从GitHub的Compose仓库拉取Docker Compose,具体操作指令如下。
   $ sudo curl -L https://github.com/docker/compose/releases/download/1.16.1/ docker-compose-'uname -s'-'uname -m' -o /usr/local/bin/docker-compose
   
       执行上述指令后，就会从GitHub下载并安装Docker Compose工具，该过程需要耗时几分 钟。从上述指令也可以看出，指定下载的Docker Compose版本为1.16.1 读可以根据实际情况选择下载对应的版本，各个版本的信息可参考地址https://github.com/docker/compose/releases 查看。	 
   
   $ sudo chmod +x /usr/local/bin/docker-compose    更改Docker Compose的可执行文件权限
   
   $ docker-compose --version                       查看安装的Docker Compose效果及版本，具体操作指令如下。
   
   (3)卸载 Compose
   $ rm /usr/local/bin/docker-compose          


2.Compose file文件的使用说明


(1)编写Dockerfile文件。使用Dockerfile定义应用程序的环境，这样可以在任何地方使用它，Dockerfile的作用就是为每个服务构建镜像。
(2)定义yml文件(通常是docker-compose.yml )就是将前面介绍的服务部署指令及相 关参数都统一在该文件中编写和配置，这样就省去了针对不同服务各自运行的麻烦。
(3)运行服务部署指令。根据具体的部署需求，来执行相应的部署指令，Docker会读取 docker-compose.yml文件内容启动整个应用服务。
   在上述三步中，第一步中Dockerfile文件的编写已经在第7章有过讲解，而第三步的服务部 署指令会在后面服务部署环节进行说明，所以现在需要掌握的就是如何编写docker-compose.yml文件。接下来，将针对Compose file文件的定义和配置进行详细讲解。  https://docs.docker.eom/compose/compose-file 配置文档地址
   
【docker-compose.yml】
version: * 3 *
services:
  web:
   image: id/imagename:lable
restart: on-failure
container_name: my-web-container
ports:
  - 8080:8080
networks:
  - example-net
depends_on:
  - db
deploy:
  replicas: 2
  restart__policy:
     condition: on-failure
db:
  image: mysql:5.6
  restart: on-failure
  container_name: my-mysql-container
  ports:
   - 3306:3306
  volumes:
   - example-mysql:/var/lib/mysql
  networks:
   - example-net
  environment:
   MYSQL_ROOT_PASSWORD: root
   MYSQL_DATABASE: mysql_database
  deploy:
   replicas: 1
   restart__policy:
    condition: on-failure
   placement:
     constraints: [node.role == manager]
networks:
  example-net:
volumes:
  example-mysql:

总体来看：
     version     "3''表示文件是使用3版本的约束进行编写的。
     services    下面包含有web和db两个服务配置项，每一个服务配置项都有镜像image、 端口 ports.网络networks和部署deploy等配置信息，同时web服务配置依赖于db服务配置。
     networks   (网络)和volumes (数据卷)：在服务部署时会自动创建example-net网络和 example-mysql 数据卷。
结合上述示例进行整体介绍后，相信大家已经对Compose file文件的配置和样式已经有了 一个初步的了解。下面将对Compose file文件中一些常用的配置进行更详细的解释，具体说明 如下。


1.version (版本)
version通常在一个docker-compose.yml文件的最顶部，用来表示文件内容的约束版本(类似于XML文件约束),本书编写时的最新版本为3.3版本。

2.services (服务)
services用来声明服务，在services下的所有同缩进的应用名称都代表一个服务，如上面 示例中的web和db。在进行多服务部署的时候，有多少个服务需要同时部署，就需要在services 参数下面声明并配置多少个服务。

3.image (镜像)
所有启动的服务都是依赖镜像构建的，所以每一个服务下面首先要声明依赖的镜像名称，- 般都是xxx/xxx:lable的形式。如果是本地私有仓库镜像，一般为IP:PORT/xxx：lable (如果省略 了 lable标签，则默认是latest)的形式。

4.restart (重启策略)
restart  表示服务重启策略，在使用Compose file文件启动所有服务过程中，有些服务由于 个别原因可能会启动失败。为了保证服务正常启动，需要使用该参数来确保服务重启(在集群环 境下该属性会被忽略)。
restart服务重启策略可以设为四个值，分别如下。
    restart: "no"	         #服安默认值为n。，即服务失败后没有任何动作
    restart: always          #表示服务会一直重新启动
    restart: on-failure      #表示服务提示失败错误后会重新启动
    restart: unless-stopped  #表示只有服务柱停止后才会重启

5.container_name (容器名称)
container_name表示单个服务启动后的容器名称。在3版本以后，如果是在集群多实例环 境下部署，该参数就会被忽略。

6.ports (端口)
ports用于指定服务向外暴露的端口。Compose支持多种形式的ports端口映射，在上面示 例中使用了比较常规的端口映射方式(宿主机端口：容器端口)来暴露服务。

7.networks (网络)
networks用于配置服务网络。在前面介绍Docker时，已经介绍过在进行服务部署时最好使 用自定义网络，这里就可以使用networks参数。上面示例中指定了各个服务启动后的网络管理 为example-net,该网络会在服务启动时自动创建。

8.depends_on (服务依赖)
depends.on表示多个服务之间的依赖关系，用来确定服务启动的先后顺序。针对该参数， 需要特别注意以下两点。
depends.on决定了服务的依赖关系，如示例中的web依赖db,所以db服务会先于web 服务启动，但并不表示db服务完全启动成功后才启动web服务，它只决定启动的先后顺序而已。在3版本中，depends_on参数将会被忽略。

9.links (服务关联)
links表示多个服务之间的相互访问关系，即可以通过服务名称或别名来访问关联的服务； 同时也具有depends.on参数一样的服务依赖关系，即可以确定服务启动的先后顺序。针对该参 数，也需要注意以下几点。
同depends_on —样，links确定了服务的依赖关系，但它只决定服务启动的先后顺序而已。如果同时定义了 links和networks参数，使用links连接的服务必须有一个共同的网络。
在3版本中，links参数也将会被忽略。

10.deploy (服务集群部署)
deploy参数是Docker Compose针对Swarm集群部署提供的(在非集群环境下该参数及其 子参数会被忽略)。该参数及其子参数专门用于指定与服务部署和运行相关的配置，并且该参数 只有在3版本以及部署到Swarm集群时才会生效。

11.replicas (服务实例副本)
replicas表示服务实例的副本数量。在Swarm集群环境下，为了实现服务器端的负载均衡, 通常会将一个服务实例复制多个副本运行，如上述实例中的web服务就提供了 2个副本。

12.restart_policy (重启策略)
restart_policy参数同前面介绍的restart类似，都是用来配置服务重启策略的，只是该属性 配置在deploy参数下，并只在集群环境下生效。该参数包含多个子属性及属性值，具体示例 如下。
   restart_policy:'	.
        condition: on-failure     #表示服务重启的条件，值有 none、on-failure 和 any 
		delay: 5s                 #表示重启服务之间等待时间，默认为0 
		max_attempts : 3          #表示失败后尝试重启的次数
		window: 120s	          #表示等待多久来确定服务是否启动成功

13.placement (位置约束)
placement用来配置指定位置的约束，当服务在Swarm集群环境下部署时会随机分配到管 理节点和其他工作节点上。在上述示例中由于将mysql数据挂载到了本机example-mysql数据 卷中，所以使用了 placement的子参数constraints:[node.role == manager]指定该服务只在 manager管理节点上运行。

14.volumes (数据卷)
volumes表示数据卷，就是将容器中的数据备份到宿主机地址(具体可回顾前面章节介绍的 数据管理)□上述示例中是将mysql数据挂载到本地example-mysql数据卷中，如果该数据卷 不存在，服务启动时也会默认创建。

15.environment (环境变量)
environment用于配置服务启动时需要的环境变量，如上述示例中MYSQL_ROOT_ PASSWORD表示数据库root用户的密码，MYSQL_DATABASE表示数据库启动后自动创建的数据库。






==========================================================================================================================================================



############【 微服务与Docker】################


1.[添加Dockerfile文件]

   在Docker中，应用都是部署在容器中的，而容器又由镜像生成，镜像则通常是通过Dockerfile 文件构建的，所以微服务与Docker整合的第一步就是要提供Dockerfile文件。
第9章讲解整合时编写的微服务项目microservice-mallmanagement主要有4个子项目模 块（包括2个微服务模块和2个辅助服务模块），我们需要针对每一个子项目模块编写对应的 Dockerfile文件。这里以用户订单管理微服务模块为例，所编写的Dockerfile文件的具体内容如:

      FROM java:8-jre
      MAINTAINER shirx 〈shirx@qq.com>
      ADD ./target/microservice-userservice-0.0.1-SNAPSHOT.jar \
      /app/microservice-userservice.jar
      CMD ["java", H-Xmx200mn, "-jar", "/app/microservice-userservice.jar"]
      EXPOSE 8030

具体说明如下：
1~2行设置了一个基础镜像java:8-jre来提供项目的运行环境，并通过MAINTAINER配 置了该镜像的维护者信息。
3~4行通过ADD命令将生成的项目jar包（在target目录下）复制到容器内部的app目 录下，并重命名为 microservice-userservice.jar。
第5行通过CMD命令指定了由该镜像生成的容器的启动命令（其实就是java -jar microservice-userservice.jar 启动 jar 包的命令）o
第6行通过EXPOSE指令指定容器暴露的端口号为8030  跟项目配置文件application, yml中指定的端口相同。

将上述Dockerfile文件直接放在项目的根目录即可,其他服务编写的Dockerfile文件与文件基本相同，只需要将Dockerfile中的项目名称和版本号后缀，以及复制到容器内部的JAR包名称进行相应修改即可。

2.[添加 dockerfile-maven 插件]

   Dockerfile文件编写完成后，就可以使用Docker的相关指令构建镜像并运行容器，然后访 问容器中的应用了。只是上述所有的操作都是手动完成的，如果需要部署多个服务，将会非常麻烦。
针对这种情况,MAVEN提供了一个dockerfile-maven-plugin插件,很好地支持了与Docker 的整合。该插件的使用非常简单，只需要在所有需要生成Docker容器项目的pom文件中添加该插件


<build>
  <plugins>
    <plugin>
      <groupld>com.spotify</groupld> 
	     <artifactld>dockerfile-maven-plugin</artifactld> 
		 <version>l.3.6</version>
      <configuration>
        <!--生成的镜像名称-->
          <repository>
            ${docker.image.prefix}/${project.artifactld} </repository>
           <!―生成的镜像版本-->
          <tag>${project.version}</tag>
          <!--推送到私有镜像仓库或者DockerHub时需要开启用户认证-->
		  <useMavenSettingsForAuth>true</useMavenSettingsForAuth> 
	  </configuration>
         <!--直接使用mvn install命令打包项目，就会自动构建并推送镜像-->
     <executions>
       <execution>
         <id>default</id>
         <phase>install</phase>
         <goals>
           <goal>build</goal> 
		   <goal>push</goal>
         </goals>
        </execution>
     </executions>
    </plugin>
 </plugins>
</build>

<properties>
<!- 配置镜像前缀（就是仓库服务地址）-->
〈docker.image.prefix>l92.168.197.143:5000</docker.image.prefix>
</properties>


   通过<plugin>标签添加了一个版本为136的dockerfile-maven-plugin插件。
分别使用<repository>和<tag>标签配置了生成的镜像名称和标签。其中${docker. image.prefix}用于指定镜像前缀（需要继续配置）,${project.artifactld}用于将项目名称指定为镜 像名称；${project.version）用于将项目版本指定为镜像版本。

使用<useMavenSettingsForAuth>标签开启仓库用户认证。生成的镜像不管是推送到 DockerHub,还是本地私有镜像仓库，都必须先登录认证并通过后才可推送。该标签的作用就是 在使用maven插件的时候开启用户认证（本地未创建认证的私有仓库或者后续手动推送镜像则 不需要配置此标签）

在<execution>标签中分别使用<phase>和<goals>子标签配置了 mvn的执行命令和自动 化动作。其中上述配置表示在使用mvn install执行打包项目时，会先进行打包，然后自动执行 镜像构建和镜像推送任务，这种配置方式可以很好地完成项目与Docker的自动化整合工作（如 果想要手动构建和推送镜像则可以去除<executions>标签）。
在<properties>标签中使用< docker.image.prefix>子标签配置了生成的镜像前缀（也就是本地私有仓库地址）,来为${docker.image.prefix}赋值。

上述配置文件指定了＜docker.image.prefix＞标签（即镜像仓库前缀）,这里使用的地址 192.168.197.143:5000 就是第 8 章介绍 Docker Swarm 集群时搭建的 Docker 机器 managerl 中的私有仓库地址，后续项目将在该集群上进行部署。

上述 dockerfile-maven-plugin 插件的配置，需要在 microservice-mallmanagement 项目 的4个子项目模块的pom文件中分别添加，并且无需任何更改。


3.[添加 docker-compose.yml 编排文件]

version: "3"
services:
	mysql:
		image: mysql:5.6
		restart: on-failure
		ports:
			- 3306:3306	
		volumes:
			- microservice-mysql:/var/lib/mysql
		networks:
			- microservice-net
		environment:
			MYSQL__ROOT_PASSWORD: root
			MYSQL_DATABASE: microservice__mallmanagement
		deploy:	
			replicas: 1
			restart_policy:
				condition: on-failure
			placement:
				constraints: [node.role == manager]
	eureka-server:
		image: 192.168.197.143:5000/microservice-eureka-server:0.0.1-SNAPSHOT
		restart: on-failure
		ports:
			- 8761:8761
		networks:
			- microservice-net
		deploy:
			replicas: 1
			restart_policy:
			condition: on-failure
	gateway-zuul:
		image: 192.168.197.143:5000/microservice-gateway-zuul:0.0.1-SNAPSHOT
		restart: on-failure
		ports:
			-8050:8050
		networks:
			-microservice-net
		depends_on:
			-eureka-server
		deploy:
			replicas: 1 
			restart_policy:
				condition: on-failure
			placement:
				constraints: [node.role == manager]
	order-service:
		image: 192.168.197.143:5000/microservice-orderservice:0.0.1-SNAPSHOT
		restart: on-failure
		ports:
			-7900:7900
		networks:
			-microservice-net
		depends_on:
			-mysql
			-eureka-server
		deploy:
				replicas: 2 
				restart_policy:
					condition: on-failure
	user-service:
		image: 192.168.197.143:5000/microservice-userservice:0.0.1-SNAPSHOT
		restart: on-failure
		ports:
			-8030:8030
		networks:
			-microservice-net
		depends_on:
			-mysql
			-eureka-server
		deploy:
		replicas: 2 
		restart_policy:
			condition: on-failure
	visualizer:
		image: dockersamples/visualizer:stable
		ports:
			-8081:8080
		networks:
			-microservice-net
		volumes:
			-/var/run/docker.sock:/var/run/docker.sock
networks:
	microservice-net:
volumes:
	microservice-mysql:


 在文件中，提供了 6个启动服务，除包含了 microservice-mallmanagement项目自带的 eureka-server、gateway-zuuk order-service 和 user-service 4个子项目外，还包含了 mysql数据库服务和visualizer集群环境下可视化工具服务。这些服务都是通过networks配置了 —个指定的名称为microservice-net的自定义网络（服务部署时会自动创建该网络），
服务之间 可以通过该网络实现通信。需要注意的是，构建服务的镜像名称要与微服务整合时生成的镜像名称一致，否则无法找到 ,微服务项目与Docker的整合配置就已经完成，剩下的就是如何将项目进行打包，并 通过Docker进行部署了 



4.[环境搭建以及镜像准备]



1.搭建Docker主机

   要将微服务项目运行在Docker中，首先必须保证运行环境安装了Docker引擎，这里我们就选用前面第8章中的8.2小节搭建的名为manage"的Docker机器，作为本次微服务部署的主机，同时也是集群环境下的管理节点，
而另两台名为worked和worker2的Docker机器仍作 为集群环境下的工作节点（在实际开发中，Docker Swarm集群可能会涉及更多的工作节点，并 且会设置多个管理节点）
  需要说明的是，此次演示为了方便查看和管理，在managerl服务主机上搭建了本地私有镜像仓库，其仓库服务地址为192.168.197.143:5000,这与前面项目配置和整合文件编写的镜像前缀地址都是一致的，
否则无法推送到指定仓库。关于本地私有仓库的搭建，此处不再做详细说 明，具体内容可以参考第7章中7.4.4小节介绍的Docker Registry本地私有仓库配置。


2.安装应用编译工具JDK


  (1)下载Linux版本的JDK工具包，本书使用的是jdk-8u144-linux-x64.tar.gz版本，并 在Linux机器上使用tar命令进行解压，具体操作指令如下。
$ sudo tar -zxvf jdk-8ul44-linux-x64.tar,gz
  (2)将执行上述解压指令后产生的解压包移动到自定义目录下（这里将解压包直接移动到了 /usr/lib/jvm @录下，如果不存在，要先创建该目录），具体操作指令如下。
$ sudo mv jdkl.8.0 144/ /usr/lib/jvm
  (3)配置JDK环境变量。修改/etc/profile文件，在profile文件中添加以下配置(注意JDK 解压包名称和版本号)
  #set java environment
   export JAVA_H0ME=/usr/lib/jvm/jdkl.8.0_144/
   export JRE_HOME=${JAVA_HOME}/j re
   export CLASSPATH=.:${JAVA_HOME}/1ib:${JRE_HOME)/1ib
   export PATH=${JAVA_HOME}/bin:$PATH
   
     完成有关JDK的环境配置后，可以执行source/etc/profile指令使配置立即生效。我们可以 使用java -version命令查看安装后的效果。

3.安装应用打包工具Maven

     在前面介绍微服务与Docker整合配置时就已经说明，此次整合部署是通过Maven的install 命令自动执行打包、镜像构建和推送的，所以在此必须先要安装并配置好Maveno其具体配置 过程如下。
(1)下载Linux版本的Maven工具包，本书使用的是apache-maven-3.5.0-bin.tar.gz版 本，并在Linux机器上使用tar命令进行解压，具体操作指令如下：

$ sudo tar -zxvf apache-maven-3.5.0-bin.tar.gz

(2)将执行上述解压命令后产生的解压包移动到自定义目录下(这里将解压包直接移动到了 opt目录下)，具体操作指令如下：
$ sudo mv apache-maven-3.5.0/ /opt

(3)配置Maven环境变量。修改/etc/profile文件，在profile文件中添加以下配置(注意 Maven解压包名称和版本号)：

    #set maven envirment
    export M2_HOME=/opt/apache-maven-3.5.0/
    export M2=$M2_HOME/bin
    export MAVEN_OPTS=n-Xms2 5 6m -Xmx512mn
    export PATH=$M2:$PATH

    完成有关Maven的环境配置后，同样可以执行source /etc/profile指令使配置立即生效，然 后通过mvn -v命令查看安装配置后的Maven信息

4.镜像准备

     由于之前10.2小节中dockerfile-maven的配置，在完成打包后也会自动构建镜像并推送到指定仓库，但无论是推送到DockerHub还是本地私有镜像仓库，必须先登录认证才可进行推送。
所以为了能够自动打包、构建镜像和推送镜，在使用mvn install命令打包之前，除了需要预 先在dockerfile-maven插件配置中配置<useMavenSettingsForAuth>标签属性值为true外，还 需要在Maven的settings.xml配置文件（参考上一小节基础环境搭建时Maven的安装位置，此 示例中的地址为/opt/apache-maven-3.5.0/conf/settings.xml）中配置服务认证信息，具体配置 内容如下（注意要配置在<servers>标签内）。
    <server>
     <id>192.168.197.143:5000</id> 
	 <username>shitou</username>
	 <password>123</password>
    </server>
	
	
    读者在配置上述服务认证信息时，注意修改自己本地私有仓库的地址id以及登录认证用户 的用户名和密码。
配置完成后，就可以将微服务项目microservice-mallmanagement复制到managerl服 务主机的某个工作目录下，并进入到该项目pom文件所在位置（最外层的pom文件目录）， 
然后使用mvn install指令进行打包(首次打包会进行pom依赖文件的下载，所以需要一定的 时间)
     如果出现 HBUILD SUCCESS信息，就表示打包、镜像构建和推送成功。 如果某个过程执行失败，也可以从终端页面查看错误信息。
当确定全部执行成功后，我们还可以实际确认。先通过docker images指令查看镜像列表中 是否有生成的指定镜像，然后再次进入本地私有镜像仓库配置的挂载目录/mnt/registry/docker/ registry/v2/repositories进行确认，查看生成的镜像是否也推送到了本地仓库。在Docker机器上正式打包部署时，项目配置文件中的服务地址将不再是localhost的本地连接，需 要按照第9章介绍微服务项目整合时的配置文件提示进行相应修改。




5.微服务的手动部署


  非集群环境下的服务部署就是将整个微服务项目运行在单个Docker主机环境下。这里先在managerl机器上安装DockerCompose编排工具（参考10.1.2小节）,
通过该编排工具执行docker-compose.yml文件进行非集群环境下的服务部。具体部署服务过程如下。

1.登录私有仓库

   由于此次部署的微服务所需的镜像都存放在本地私有镜像仓库，并且本地私有仓库配置有用户认证，所以想要通过本地私有仓库的镜像部署服务，
就必须先登录认证，获取镜像的使用权限（DockerHub远程仓库镜像则不需要登录认证）具体操作指令如下。
$ docker login 192.168.197.143:5000

执行上述指令就可以登录到指定服务地址的Docker Registry本地私有镜像仓库了。此后该 Docker机器就会处于持续认证状态，我们可以使用docker logout 192.168.197.143:5000指令 退出认证。

2.部署服务

进入到项目docker-compose.yml文件所在目录下，执行服务部署指令来部署整个微服务 项目，具体指令如下。

$ docker-compose up

  使用docker-compose up指令是在前台部署整个服务，终端窗口会打印出所有启动信息。 如果不想看到这些信息，还可以使用docker-compose up -d指令在后台部署服务。
当服务部署完成后，可以通过docker ps指令查看所有服务是否都已正常运行（多个相互依 赖的服务同时部署过程可能需要一定的时间），
  所有的服务都已正常启动。此时，容器中对应的应用也已可以正常访问（后续会介绍具体的测试方式）。当不再需要某个服务时，
可以在项目docker-compose.yml文件所在同级目录下使用结束指令结束整个服务，具体操作指令下

$ docker-compose down



6.使用Jenkins自动部署微服务


   Jenkins官网提供了多种安装方式，包括基于Java的war包，Linux、MacOS和Windows系统等方式。这里我们选择比较通用的war包方式为例，在集群管理节点managerl机器上安装—Jenkins工具
(由于Jenkins是由java开发的，所以在安装Jenkins之前要确保已
安装了JDK并配置了系统环境)，具体步骤如下。

1.下载 Jenkins
在浏览器中输入Jenkins官网地址https://jenkins.io/download/访问其下载页面，选中页面 中 Long-term Support ( LTS,长期支持)版本最下方的 Generic java package ( .war),进行 Jenkins的war包下载，如图10-13所示。

2.启动Jenkins服务
将下载好的jenkins.war放到managerl机器中的某个目录下，直接使用如下指令即可启动 Jenkins 服务。
$ java -jar jenkins.war -一httpPort=49001
执行上述指令后，就会在Linux系统上通过war包的方式启动Jenkins服务。需要注意的是，Jenkins内部默认配置的端口是8080 (这与开发中很多端口有冲突),所以 我们在启动Jenkins服务时，使用一httpPort参数指定了服务启动的端口为49001 

3.Jenkins初始化安装
  通过浏览器访问地址http://192.168.197.143:49001就可以正式访问Jenkins服务，在首次安装访问Jenkins时，会涉及Jenkins的初始化安装
输入初始化认证密码后，会进入一个Jenkins插件定制安装界面，这也是首次启动访问 Jenkins时会出现的页面，页面中会提供Install suggested plugins （安装建议插件）和Select plugins to install（自行选择插件安装）两种方式，通常情况下，都会选择左侧的Install suggested plugins进行初始化插件安装


5.Jenkins集成插件配置

1,安装Maven插件
     因为我们之前创建的微服务是Maven项目，在使用Jenkins时也需要创建一个Maven项目 进行持续集成，所以这里需要配置Maven插件。
依次单击主页面的“系统管理”今“插件管理”今“可选插件”面板，然后在右侧搜索框输 入"Maven Integration plugin"关键字进行搜索。搜索出结果后，选中该插件，并单击下方的“直 接安装”按钮，即可进行Maven插件安装，其效果如图10-18所示。
2,系统全局插件配置
完成所需插件的安装后，必须在Jenkins ±进行全局插件配置，这样才能让Jenkins与其他 软件关联工作，这里配置的全局插件主要有JDK （项目编译工具）、Git （代码仓库GitHub管理 工具）、Maven （项目打包工具）和Docker （项目部署工具）。



6.服务自动化部署

	1.构建新任务
		构建一个maven项目

    2.源码管理”中选择Git
		并在Repository URL中输入该项目所在 的GitHub源码地址
	3.构建触发器		
		
		Build periodically        表示在某个时间点进行自动任务构建，比如"H 2 * * *"表示每天凌 晨2点开始执行项目构建（不管项目是否更新）
		PollSCM                   表示每隔一段时间会自动检查更新进行任务构建，比如“*/10****”表示每 10分钟开始检查源码，如果有更新就自动执行构建。
		当默认没有进行构建触发器配置时我们可以在对应的任务面板中选择“立即构建”按钮， 随时进行手工触发任务构建。
	4.服务发布配置		
   
        在Post Steps （服务发布配置）页面，选择"Add post-build step"下拉列表中的"Execute shell"选项，并在命令框中输入需要发布服务的shell指令
   
   
           docker stack deploy -c docker-compose-swarm.yml --with-registry-auth mallmanagement
   
          docker stack deploy -c docker-compose-swarm.yml 表示使用当前目录下 的docker-compose-swarm.yml展件部署服务到当前主机所在集群中；
		 --with-registry-auth 参数是对该集群下的所有节点进行通知，表示所有节点要到指定的本地私有仓库拉取镜像来启动服务（如果使用的是Docker Hub镜像仓库，此参数可省略）；
		 mallmanagement是自定义的整 个集群服务的总名称。