docker的使用(二)

注意：要使用docker必须先启动docker(小鲸鱼)，否则会报错：

Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running?

1.docker镜像制作

docker官方和个人发布的镜像由于版本等各种原因，漏洞较多，已统计docker hub上超过30%的官方镜像包含高危漏洞。并且docker pull下载镜像的速度很慢。基于这种情况，我们可手动定制docker系统镜像。
两种方式构建镜像：
a.使用 docker commit
b.使用 docker build 和 Dockerfile文件

1.1 docker commit

docker commit：提交一个正在运行得容器为一个新的镜像。
本案例：制作一个Tomcat镜像，制作步骤：
1.1.1 拉取一个基础镜像(起始就是OS)

$ docker pull centos // 我们这里使用centos作为基础镜像

1.1.2 创建一个交互式容器

$ docker run -it --name=container4 centos:latest

1.1.3 软件上传：将宿主机Tomcat、jdk上传到容器的root目录中

$ docker cp /Users/xxx/Desktop/apache-tomcat-9.0.37.tar.gz container4:/root
$ docker cp /Users/xxx/Desktop/jdk-8u261-linux-x64.tar.gz container4:/root

1.1.4 创建交互式container4容器root目录，并对Tomcat、jdk进行解压

$ docker run -it --name=container4 centos /bin/bash // 创建交互式容器
$ cd /root/  // 进入root目录
$ tar -zxvf apache-tomcat-9.0.37.tar.gz -C /usr/local/    // 解压Tomcat
$ tar -zxvf jdk-8u261-linux-x64.tar.gz -C /usr/local/   // 解压jdk

1.1.5 对Tomcat、jdk进行环境变量的配置
jdk配置：

$ vi /etc/profile
在最后添加：
JAVA_HOME=/usr/local/jdk1.8.0_261
export PATH=$Java_Home/bin:$Path
退出保存
$ :wq
让配置文件生效：
$ source /etc/profile
测试是否配置成功:
$ java -version  // 打印java版本号

Tomcat配置：

$ vi /usr/local/apache-tomcat-9.0.37/bin/setclasspath.sh
在最上面添加:
export JAVA_HOME=/usr/local/jdk1.8.0_261
export JRE_HOME=/usr/local/jdk1.8.0_261/jre
退出保存
$ :wq

1.1.6 根据container4容器提交制作一个镜像

$ docker commit container4 mytomcat_os // 新的镜像名叫mytomcat_os

1.1.7 端口映射

// 创建守护式容器container5设置端口
$ docker run -itd --name=container5 -p 8888:8080 mytomcat_os /bin/bash 
// 启动Tomcat
$ docker exec container5 /usr/local/apache-tomcat-9.0.37/bin/startup.sh
// 关闭Tomcat
$ docker exec container5 /usr/local/apache-tomcat-9.0.37/bin/shutdown.sh

1.1.8 验证Tomcat已经启动
打开浏览器输入：http://宿主机ip:8888 就可以访问Tomcat(8888是刚才设置的端口号)
说明自己制作的mytomcat_os镜像可以提供给别人使用了。

访问Tomcat

1.1.9 容器/镜像打包
1.1.9.1 镜像打包：
a.镜像打包：

  /**
   * 将mytomcat_os镜像打包到宿主机桌面的test目录下取名叫/tomcat_os.tar 
   */
  $ docker save -o /Users/xxx/Desktop/test/tomcat_os.tar mytomcat_os

b.将打包的镜像上传到其它服务器

  $ cd /Users/xxx/Desktop/test
  // 将打包的镜像传递到其它服务器的root目录下
  $ scp tomcat_os.tar 其它服务器ip:/root

c.导入镜像

  // 需要操作那台服务器把打包的镜像导入
  $ docker load -i /root/tomcat_os.tar

1.1.9.2.容器打包：
a.容器打包

// 将container5容器打包到宿主机桌面的test目录下取名为container5.tar 
$ docker export -o /Users/xxx/Desktop/test/container5.tar container5

b.将打包的镜像上传到其它服务器

  $ cd /Users/xxx/Desktop/test
  // 将打包的镜像传递到其它服务器的root目录下
  $ scp container5.tar 其它服务器ip:/root

c.导入容器

// 将root目录下的container5容器导入到tomcat_os镜像中去
$ docker import container5.tar tomcat_os:latest

1.2 docker builer

DockerFile使用基本的基于DSL语法的指令来构建一个Docker镜像，之后使用docker builder命令，基于该该DockerFile的指令构建一个新的镜像。

1.2.1 DSL语法

DSL语法

DSL语法：
1）FROM（指定基础image）
构建指令，必须指定且需要在DockerFile其它指令的前面，后续的指令都依赖于该指令指定的image。FROM指令指定的基础image可以是官方远程仓库中的，也可以位于本地仓库的。
FROM命令告诉docker我们构建的镜像是以哪个(发行版)镜像为基础的。第一条指令必须是FROM指令。并且，如果同一个DockerFile中创建多个镜像时，可以使用多个FROM指令。
该命令有两种格式：
a.指定基础image为该image的最后修改的版本
FROM <image>
b.指定基础image为该image的一个tag版本
FROM <image>:<tag>
RUN后面都要执行的命令，比如我们想在镜像中安装vim，只需要在DockerFile中写入 RUN yum install -y vim

2）MAINTAINER（用来指定镜像创建者信息）
构建命令，用于将image的制作者相关信息写入image中，当我们对该image执行docker inspect命令时，输出有关响应的字段信息。
格式：
MAINTAINER <name>

3）RUN （用于安装软件）
构建命令，RUN可以运行任何被基础image支持的命令，如基础image选择了ubuntu镜像，那么软件管理部分职能使用ubuntu的命令。
该指令有两种格式：
RUN <commad>
RUN ["executable", "param1", "param2", ...]

4）CMD（设置container启动时执行的操作）
设置指令，该操作可以是执行自定义脚本，也可以是执行系统命令，该命令只能在文件中存在一次，如果有多个，则只执行最后一次
该命令有三种格式：
CMD ["executable", "param1", "param2"]
CMD command param1 param2
当DockerFile指定了ENTRYPOINT，那么使用下面的格式
CMD ["param1", "param2"]
其中，ENTRYPOINT指定的是一个可执行的脚本或者程序的路径，该指定的脚本或者程序将会以param1和param2作为参数执行。
所以如果CMD指令使用上面的形式，那么DockerFile中必须有配套的ENTRYPOINT。

5）ENTRYPEOINT（设置container启动时执行的操作）
设置指令，指定容器启动时执行的命令，可以多次设置，但最后一次才有效。
两种格式：
ENTRYPOINT ["executable", "param1", "param2"]
ENTRYPOINT command param1 param2
改名了使用分为两种情况，一种是独自使用，另一种是和CMD指令配合使用.
当独自使用时，如果你还使用了CMD命令且CMD是一个完成的可执行的命令，那么CMD命令和ENTRYPOINT会相互覆盖，只有最后一个CMD或ENTRYPOINT有效。

CMD指令将不会被执行，只有ENTRYPOINT指令被执行
CMD echo "hello world"
ENTRYPOINT ls -l

另一种用法和CMD指令配合使用来指定ENTRYPOINT默认参数，这时CMD指令不是一个完整的可执行命令，仅仅是参数部分；ENTRYPOINT指令只能使用JSON方式执行命令，二不能指定参数。

FROM ubuntu
CMD ["-l"]
ENTRYPOINT ["/usr/local/ls"]

6）USER（设置container的运行用户）
设置指令，设置启动容器的用户，默认是root用户

// 指定memcached的运行用户
ENTRYPOINT ["memcached"]
USER daemon
或者
ENTRYPOINT ["memcached", "-u", "daemon"]

7）EXPOSE（指定容器需要映射到宿主机的端口）
设置指令，该指令会将容器中的端口映射成宿主机中的某个端口，当你需要访问容器的时候，可以不是用勇气的IP地址而是使用宿主机的IP地址和映射后的端口。
要完成整个操作需要两个步骤，首先DockerFile使用EXPOSE设置需要映射的容器端口，然后再运行容器的时候指定-p选项加上EXPOSE设置的端口，这样EXPOSE设置的端口号会被随机映射成宿主机的一个端口号。
也可以指定需要映射的宿主机的那个端口，这时要确保宿主机上的端口号没有被使用。EXPOSE指令可以一次设置多个端口号，相应的运行容器的时候，可以配套的多次使用-p选项。
格式：
EXPOSE <port> [<port>, ...]
// 映射一个端口
EXPOSE port1
// 相应的运行容器使用的命令
docker run -p port1 image

// 映射多个端口
EXPOSE port1 port2 port3
// 相应的运行容器使用的命令
docker run -p port1 -p port2 -p port3 image

// 还可以指定需要映射到宿主机上的某个端口号
docker run -p host_port1: port1 -p host_port2: port2 -p host_port3: port3 image

端口映射是docker比较重要的一个功能，原因在于我们每次运行容器的时候容器的IP地址不能指定而是在桥接网卡的地址范围内随机生成的。
宿主机IP地址是固定的，我们可以将容器的端口映射到宿主机的一个端口，免去每次访问容器中的某个服务时，都要查看容器的IP地址。
对于一个运行得容器，可以使用docker port加上容器中需要映射的端口和容器的ID来查看该端口号在宿主机上的映射端口。

8）ENV（用于设置环境变量）
格式：
ENV <key> <value>
设置后，后续的RUN命令都可以使用，container启动后，可以通过docker inspect查看这个环境变量，也可以通过在docker run --env key=value 时设置或者修改环境变量
加入你安装了JAVA程序，需要设置JAVA_HOME，那么在DockerFile中这样写：ENV JAVA_HOME/path/to/java/dirent

9）ADD(从src复制文件到container的dest路径)
主要用于宿主机的文件添加到镜像中
构建命令，所有拷贝到container的文件和文件夹权限为0755，uid和gid为0；如果是一个目录，那么会将改目录下所有文件添加到container中，不包括目录；
如果文件是可识别的压缩格式，则docker会帮忙解压；如果<src>是文件且<dest>中不使用斜杠结束，则会<dest>视为文件，<src>的内容会写入<dest>
如果<src>是文件且<dest>中使用斜杠结束，则会<src>拷贝到<dest>目录下。
格式：
ADD <src> <dest>
<src>是相对被构建的源目录相对路径，可以是文件或目录路径，也可以是一个远程文件url;
<dest>是container的绝对路径

10）VOLUME（指定挂载点）
设置命令，使容器中的一个目录具有持久花存储数据的功能，该目录可以被容器本身使用，也可以共享给其它容器使用，我们知道容器使用的是AUFS，这种文件系统不能持久化数据，当容器关闭后，所有的更改都会丢失。当容器中的应用有持久化数据的需求时，可以在DockerFile中使用该命令。
格式：
VOLUME ["<mountpoint>"]
例如：
FROM base
VOLUME ["/tmp/data"]
运行通过该DockerFile生成image容器，/tmp/data目录中的数据在容器关闭后，里面的数据还存在。
例如一个容器有持久化数据需求，且想使用上面容器共享的/tmp/data目录，那么可以运行下面命令启动一个容器：
docker run -it -rm -volumes -from containerID imageName bash
其中：containerID为第一个容器的ID，imageName为第二个容器运行image名字

11）WORKDIR（切换目录）
设置指令，可以多次切换（相当于cd命令）对RUN，CMD，ENTRYPOINT生效。
格式：
WORKDIR /path/to/workdir
// 在/p1/p2下执行vim a.txt
WORKDIR /p1 WORKDIR /p2 RUN vim a.txt

12）ONBUILD（在子镜像中执行）
格式：
ONBUILD <DockerFile关键字>
ONBUILD指定的命名在构建镜像时并不执行，而是在它的子镜像中执行。

1.2.1 案例
通过dockerfile构建镜像步骤：
a.创建一个目录
b.在目录下创建dockerfile文件以及其它文件
c.通过docker build构建镜像
d.通过构建的镜像启动容器

例子：
1.创建一个目录：/Users/xxx/Desktop/rw-test
2.编辑Dockerfile文件 vim Dockerfile
3.编辑内容如下：

#pull down centos image
FROM docker.io/centos
MAINTAINER xxx xxxxxxxxx@qq.com

#install nginx
RUN yum install -y pcre pcre-devel openssl openssl-devel gcc wget vim net-tools
RUN yum -y install make
RUN useradd www -M -s /sbin/nologin
RUN cd /usr/local/src && wget http://nginx.org/download/nginx-1.8.0.tar.gz && tar -zxvf nginx-1.8.0.tar.gz
RUN cd /usr/local/src/nginx-1.8.0 && ./configure --prefix=/usr/local/nginx --user=www --group=www --with-http_stub_status_module --with-http_ssl_module && make && make install

ENTRYPOINT /usr/local/nginx/sbin/nginx && tail -f /usr/local/nginx/logs/access.log

4.在rw_test目录下构建镜像:

/**
 * -t: 表示选择指定生成镜像的用户名，仓库名和tag
 * --rm=true : 表示指定生成镜像过程中删除中间生成的临时容器
 */
$ docker build -t rwnginx --rm=true . //注意最后还有个符号

5.测试

$ docker run -itd --name test_nginx -p 8899:80 rw_nginx /bin/bash
$ docker exec test_nginx /bin/bash
通过浏览器访问：http://宿主机ip:8899

2.docker镜像仓库

将本地制作的镜像上传到docker镜像仓库的好处是，如果你有N多台服务器，都需要你本地上自定义的镜像，每一个去scp效率就会贼慢了，但可以通过将本地镜像上传到镜像仓库，每台服务器去docker pull 下载下来就省去时间了。
上传镜像仓库的方式有三种：
1.直接上传到docker.hub（国内访问非常缓慢一般不用，我这里不介绍了）
2.通过阿里云的方式上传。

去参考官方文档。
a.创建阿里云账号，找到容器镜像服务
b.创建命名空间
c.创建镜像仓库
d.操作指令

$ sudo docker login --username=[账号名称] registry.cn-hangzhou.aliyuncs.com
$ sudo docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/360buy/portal:[镜像版本号]
$ sudo docker push registry.cn-hangzhou.aliyuncs.com/360buy/portal:[镜像版本号]

3.搭建私有仓库
a.启动Docker Registry，使用D从OK而官方提供的Registry镜像就可以搭建本地私有镜像仓库，具体指令如下：

/** 指令参数说明:
 * -d: 表示在后台运行该容器
 * -p 5000:5000: 将私有镜像仓库内部默认暴露的5000端口映射到宿主机的5000端口
 * --restart=always: 表示容器启动后自动启动本地私有镜像仓库
 * --name registry: 生成的容器命名是registry
 * -v /Users//Desktop/test:/var/lib/registry: 表示将容器的默认存储位置/var/lib/registry中的数据挂载到宿主机/Users//Desktop/test目录下，这样当容器销毁后，在容器中的/var/lib/registry数据会自动备份到宿主机指定目录。
 * registry:2 表示registry镜像版本号是2
 */
$ docker run -d \  
  -p 5000:5000 \
  --restart=always \
  --name registry \
  -v /Users/xxx/Desktop/test:/var/lib/registry \
  registry:2

启动Docker Registry

b.重命名镜像。由于推送到本地私有镜像仓库的镜像名必须符合“仓库IP:端口号/repository”的形式，因此需要按要求修改镜像名称，具体命令如下：

// 重命名我们原本名为mytomcat_os的镜像，新名称叫localhost:5000/myhellodocker
$ docker tag mytomcat_os:latest localhost:5000/myhellodocker

重命名镜像

c.推送仓库。将制定镜像推送到本地私有镜像仓库：

$ docker push localhost:5000/myhellodocker

d.查看本地仓库镜像

// 注意使用地址时，注意镜像名称
http://localhost:5000/v2/myhellodocker/tags/list

由于做了目录挂载，因此可以在本地的该目录下查看到：
/Users/xxx/Desktop/docker/registry/v2/repositories
推送：不需要（不安全，需要配置仓库认证）

e. 配置私有仓库认证
1）查看Docker Registry私有仓库搭建所在服务器地址：$ ifconfig
举例：服务器的地址为：192.168.200.141
2）生成自签名证书（在home目录下执行上述命令后）
要确保Docker Registry本地镜像仓库安全性，还需要一个安全认证证书，来确保其它Docker机器不能随意访问，所以需要在搭建Docker Registry本地镜像仓库的主机上生成自签名证书(若已购买证书就无需生成)，具体操作命令：

$ mkdir registry && cd registry && mkdir certs && cd certs
/** 参数说明
 * -x509：自谦发证书的格式
 * -days 3650：证书有效期
 * 192.168.200.141:5000：具体部署Docker Registry本地镜像仓库的地址和端口
 * rsa:2048：证书算法长度
 * domain.crt：生成的证书名和格式
 */
$ openssl req -x509 -days 3650 -subj '/CN=192.168.200.141:5000/' \
-nodes -newkey rsa:2048 -keyout domain.key -out domain.crt

3）生成用户名和密码
为了确保其它Docker机器与Docker Registry本地镜像仓库交互，还需要生成连接认证的用户名和密码，登录之后才被允许连接到这个景象仓库。

$ cd .. && mkdir auth  //返回上一级目录，创建auth文件夹
$ docker run --entrypoint htpasswd registry:2 -Bbn 账号 密码 > auth/htpasswd

4）启动Docker Registry本地镜像仓库服务（需要将之前创建的registry容器删除）

$ docker run -d \
-p 5000:5000 \
--restart=always \
--name registry \
-v /Users/xxx/Desktop/test:/var/lib/registry \
-v `pwd`/auth:/auth \
-e "REGISTRY_AUTH=htpasswd" \
-e "REGISTRY_AUTH_HTPASSWD_REALM=Registry Realm" \
-e REGISTRY_AUTH_HTPASSWD_PATH=/auth/htpasswd \
-v `pwd`/certs:/certs \
-e REGISTRY_HTTP_TLS_CERTIFICATE=/certs/domain.crt \
-e REGISTRY_HTTP_TLS_KEY=/certs/domain.key \
registry:2

5）配置Docker Registry访问接口

$ sudo mkdir -p /etc/docker/certs.d/192.168.200.141:5000
$ sudo cp certs/domain.crt /ect/docker/certs.d/192.168.200.141:5000

6）Docker Registry私有仓库进行登记
在其它Docker机器需要指定访问仓库地址

$ sudo vim /etc/docker/daemon.json // 编辑daemon.json文件（上一章提到的镜像加速器那里，添加一个key-value）
// 内容如下
{"insecure-registries":["192.168.200.141:5000"]}
// 重启并加载docker配置文件
$ sudo /etc/init.d/docker restart

7）验证测试

// 在其它Docker机器
// 1.装备镜像
$ docker tag mytomcat_os:latest 192.168.200.141:5000/mytomcat
$ docker push 192.168.200.141:5000/mytomcat
// 2.推送镜像

推送过程出现错误提示：no basic auth credentials(没有通过身份验证)，这就说明身份验证的配置有效。想要成功推送，需要先登录。

$ docker login 192.168.200.141:5000
// 输入用户名密码，再次推送
$ docker push 192.168.200.141:5000/mytomcat

结果认证：
去Docker Registry主机上的挂载/Users/xxx/Desktop/test/docker/registry/v2/repositories目录看是否推送成功，有没有这个镜像

3.docker网络管理

查看docker网络

$ docker network ls

查看docker网络

默认三种网络，其中名为bridge网络是默认驱动网络，也是容器创建时默认的网络管理方式，配置后可以与宿主机痛心从而实现互联网通讯功能。host/none属于无网络，容器添加到这两个网络不能与外界网络通讯。
这里介绍三种网络都是非集群环境下docker提供默认网络，而在Docker Swarm集群环境下，除了这三种还提供了docker_gwbridge和ingress两种默认网络。

查看容器使用的网络情况

$ docker network inspect bridge

3.1 自定义网络

// 1.创建一个基于bridge驱动的名称为newBridgeNetwork的网络，其中--driver(可简写成-d)用于网络驱动类型。
// 说明：--driver bridge可以省略，省略时默认使用基于bridge驱动来创建新网络
$ docker network create --driver bridge newBridgeNetwork
// 移除名称为newBridgeNetwork的自定义网络。
$ docker network rm newBridgeNetwork
// 查看网络
$ docker network ls
// 2.可以在容器创建的时候去指定网络类型，若不指定则是docker默认网络类型bridge。 
// busybox是镜像名，本地没有镜像会拉取这个镜像，可改成centos或自定义镜像等
$ docker run -itd --name=customNetworkContainer --network=newBridgeNetwork busybox
// 查看容器网络情况
$ docker inspect customNetworkContainer
// 3. 容器添加一种默认的bridge网络管理方式。添加后再查看网络情况。
// bridge是网络驱动名称(docker默认使用的)
$ docker network connect bridge customNetworkContainer
// 4.断开网络连接的指令
$ docker network disconnect bridge customNetworkContainer

3.2 容器间的网络通信

1、创建两个使用bridge网络的容器，名称分别为c1、c2

$ docker run -itd --name=c1 busybox
$ docker run -itd --name=c2 busybox

2、创建一个自定义网络(名为newBridgeNetwork)和使用该网络的容器(名为c3)

// 上面 3.1已经创建的就不需要再创建了
$ docker network create --driver bridge newBridgeNetwork
// 创建使用自定义网络的容器c3
$ docker run --network=newBridgeNetwork -itd --name=c3 busybox

3、为c2容器新增一个我们自定义的网络连接

$ docker network connect newBridgeNetwork c2

4、c1、c2、c3的网络分配情况
c1: 172.17.0.3 [bridge]
c2: 172.17.0.4 和 172.18.0.4 [bridge 和 newBridgeNetwork]
c3: 172.18.0.3 [newBridgeNetwork]

4 搭建docker swarm集群

swarm介绍：通过把多个Docker Engine狙击在一起形成一个打的docker-engine对外提供集群服务。同时这个集群对外提供Swarm API(命令)，用户可以想使用Docker Engine一样使用Docker集群。

swarm集群

4.1 swarm架构

作为管理Docker集群的工具，需要将其部署起来，可以单独讲swarm部署于一个节点。另外自然需要一个docker集群，集群上每个节点均安装了docker。

swarm架构

swarm架构解析

4.2 docker swarm使用

搭建步骤
1 环境准备：

1.1 准备三台已经安装docker engine的centos/Ubuntu系统主机(我这里使用三台linux系统主机)(docker版本必须在1.12以上，老版本不支持swarm)
1.2 docker容器主机的ip地址固定，集群中所有工作节点必须能访问该管理节点
1.3 集群管理节点必须使用响应的协议并且保证端口可用
集群管理通信：TCP 端口2377
节点通信： TCP和UDP 端口7946
覆盖型网络：UDP 端口4789 overlay驱动
举例：三台容器主机ip地址分别为：
192.168.200.162(管理节点)
192.168.200.163(工作节点)
192.168.200.158(工作节点)
主机名称分别为：manager1、work1和work2
修改主机名称：

$ vim /etc/hostname  // 编辑主机名称，修改完成后重启服务器
$ init 6 // 重启服务器，重启完成后要启动docker
$ systemctl start docker // 启动docker
$ hostname // 打印主机名称

2 创建docker swarm
2.1 在manager1机器上创建docker swarm集群

// --advertise-addr：将这个IP地址的机器设置为集群管理节点；若是设置单节点无需设置这个参数
// 执行了创建swarm集群会给你返回一串命令告诉你怎么去添加工作节点，里面包含了一串token，这里记为xxxxxxxx(下面会用到)
$ docker swarm init --advertise-addr 192.168.200.162
// 查看管理节点集群信息
$ docker node ls
// 查看网络信息
$ docker network ls

2.2 想docker swarm添加工作节点：在两个工作节点服务器中分别执行如下命令：

// --token xxxxxxxx：表示集群到manager1主机上的令牌(创建集群的时候产生)
// 192.168.200.162：表示manager1主机上IP地址
// 2377：集群管理通信端口（这个端口号不能被其它应用占用了）
$ docker swarm join --token xxxxxxxx 192.168.200.162:2377
// 注意：要是没有加入成功有可能防火墙阻挡了，需要把主机防火墙关闭：$ systemctl stop firewalld

// 查看管理节点集群信息
$ docker node ls

2.3 在docker swarm中部署服务
在docker swarm集群中部署服务时，可以使用Docker Hub上自带的镜像来启动服务，也可以使用自己通过DockerFile构建的镜像来启动服务。若是使用DockerFile构建的镜像来启动服务那必须推送到Docker Hub中心仓库。
这里我使用Docker Hub上自带的alpine镜像为例部署集群服。

3 部署服务

/**
 * docker service create：用于swarm集群中创建一个服务
 * --replicas：指定了该服务只有一个副本实例
 * --name：服务名称helloworld
 * alpine：镜像名，若本地没有镜像会去仓库拉取
 * ping docker.com：表示服务启动后执行的命令
 */
$ docker service create --replicas 1 --name helloworld alpine ping docker.com
// 查看docker swarm集群中的服务
$ docker service ls// 查看服务列表
$ docker service inspect [服务名称helloworld] // 查看部署具体服务的详细信息
$ docker service ps [服务名称helloworld] // 查看服务在集群节点上的分配以及运行情况

// 修改副本数量(创建的副本会随机分配到不同的节点上)
$ docker service scale [服务名称]=5

// 删除服务(在管理节点上操作)
$ docker service rm [服务名称]

4 举个例访问服务

// 查看集群环境下网络列表
$ docker network ls

// 在manager1上创建overlay为驱动的网络（默认使用的网络连接ingress）
// -d和--driver是等价的；网络类型是基于overlay；名称为my-multi-host-network
$ docker network create -d=overlay my-multi-host-network

// 在集群管理节点manager1部署一个nginx服务
$ docker service create \
--network my-multi-host-network \
--name my-web \
-p 8080:80 \
--replicas 2 \
nginx

// 在管理节点上查看服务运行情况：
$ docker service ps my-web

// 访问验证(若服务在manager1去做的，访问ip就是manager1的ip)：http://192.168.200.162:8080

5 docker compose编排工具

介绍：
虽然上面的教程可以部署我们的项目，但是在微服务架构中，涉及的服务数量巨多，若你每一个服务都手动用指令去配置环境、创建服务、指定网络、磁盘挂载等等操作，你的时间成本将会巨大！
为此Docker提供了Docker Compose编排工具来对多服务应用进行统一部署，主要用来构建基于Docker的复杂应用，通过一个配置文件来管理多个docker容器，非常适合组合使用多个容器进行开发的场景。
通过该编排工具，可以使用yml(或yaml)文件来配置应用程序服务，然后只需要一条简单的服务部署指令就可以从配置中创建并启动所有服务。

5.1 docker compose安装与卸载

1 环境要求：依赖于docker引擎

// 访问查看docker compose版本信息
https://github.com/docker/compose/releases

2 下载docker-compose工具

$ curl -L https://github.com/docker/compose/releases/download/1.24.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

3 设置docker compose可执行文件权限

// ps小知识 x: execute 可执行权限；r: read 可读权限；w: write 可写权限
$ chmod +x /usr/local/bin/docker-compose

4 验证成功，查看版本号

$ docker-compose --version

ps 卸载

$ sudo rm /usr/local/bin/docker-compose

5.2 举例docker compose的使用

步骤：分三步(在创建的一个空目录下执行)
1 编写DockerFile文件（为每个服务苟江需要的镜像，方便迁移-不是必须的）
2 编写docker-compose.yml文件 (编写部署服务相关指令)
3 运行docker-compose up (启动yml文件中服务)

案例：
1 准备：两个镜像（本次演示不通过DockerFile创建了）

$ docker pull mysql:5.7
$ docker pull wordpress

2 需要创建一个空白目录，例如 $mkdir rwtest。$ touch docker-compose.yml，编辑该文件 $ vim docker-compose.yml。内容如下：

version: '3' # 文件版本
services:
  db:
    image: mysql:5.7 # 镜像
    volumes:
      - db_data: /var/lib/mysql # 目录挂载
    restart: alaways # docker启动的话，db服务会运行起来
    environment:
      MYSQL_ROOT_PASSWORD: wordpress
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: wordpress

  wordpress:
    depends_on:
      - db # 连接db
    image: wordpress: latest
    ports: 
      - "8001: 80" # 端口映射
    restart: alaways
    environment:
      WORDPRESS_DB_HOST: db: 3306
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: wordpress
volumes:
  db_data:

该文件内容等同于下面两条指令：

// $ docker run --name db -e MYSQL_ROOT_PASSWORD=123456 -d mysql
// $ docker run --name some-wordpress --link db:mysql -p 8001:80 -d wordpress

3 运行docker-compose up (启动yml文件中服务)
4 浏览器访问 http://ip:8001
5 停止/重启服务 $ docker-compose stop/restart

6 常用docker可视化工具

1 docker UI (local 只能看当前服务器)
2 shipyard (停止维护)
3 portainer
4 daocloud

6.1 工具使用

6.1.1 使用docker UI
安装docker UI

// 1.拉取docker UI镜像
$ docker pull uifd/ui-for-docker
// 2.创建容器
$ docker run -d -p 9000:9000 --privileged -v /var/run/docker.sock:/var/run/docker.sock uifd/ui-for-docker
// 3.访问可视化，打开浏览器
http:ip:9000   // ip为当前服务器的ip

6.1.2 使用portainer
安装portainer

$ docker run -d -p 9001:9000 -v /var/run/docker.sock:/var/run/docker.sock portainer/portainer

6.2.3 使用daocloud （更简单，但收费的）
1.注册daocloud
2.在daocloud找到集群管理，添加主机。
3.并且会提示要在你需要添加的主机上运行指令，复制下来执行就可，我下面写个例子

$ curl -sSL https://get.daocloud.io/daomonit/install.sh | sh -s 24a7c865945f25697fe9255dad8e54eb431d785b