微服务----Docker

数据卷 

参考文档

https://topsale.gitbooks.io/java-cloud-dubbo/content/

　　

 单体应用：

项目的架构完完全全属于传统的 MVC 架构，所有的子系统都集成在一个很繁杂的 JVM 进程中。

优点：

这种单体架构的优点在于方便管理，所有代码在同一项目中，但是当需求越来越多，项目规模越来越大，其坏处也很明显。

缺点：

1. 项目过于臃肿，部署效率低下
2. 系统高可用性差，资源无法隔离
3. 开发成本高
4. 无法灵活拓展
5. 牵一发而动全身，修改很麻烦

 微服务：

服务化：用通俗的语言来说，服务化就是把传统单体应用中通过 JAR 包依赖产生的本地方法调用，改造成 RPC 接口产生的远程方法调用。这些服务是围绕业务功能构建的，可以通过全自动部署机制独立部署。 这些服务的集中管理最少，可以用不同的编程语言编写，并使用不同的数据存储技术。

目的：解决单体应用带来的缺点

如果部署：将单体应用拆分为多个服务，生成多个实例（部署在doctor之上），有负载均衡服务器访问

 Doctor：

下面的图片比较了 Docker 和传统虚拟化方式的不同之处。传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程；而容器内的应用进程直接运行于宿主的内核，容器内没有自己的内核，而且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便。

传统的虚拟机技术，创建的操作体统，需要占用计算机资源，且各个系统资源不能共享（一个操作体统虚拟化的cpu不能给另一个操作提供使用），虚拟机之上操作系统不可以在装虚拟机

docker之上安装的操作系统占用的所有的资源都来自宿主机，资源共享。docker之上操作系统还可以装docker

 

 Docker 使用客户端-服务器 (C/S) 架构模式，使用远程 API 来管理和创建 Docker 容器。

 

Docker 镜像

我们都知道，操作系统分为内核和用户空间。对于 Linux 而言，内核启动后，会挂载 root 文件系统为其提供用户空间支持。而 Docker 镜像（Image），就相当于是一个 root 文件系统。比如官方镜像 ubuntu:16.04 就包含了完整的一套 Ubuntu 16.04 最小系统的 root 文件系统。

Docker 镜像是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数（如匿名卷、环境变量、用户等）。镜像不包含任何动态数据，其内容在构建之后也不会被改变。

安装

• 它仅适用于 64 位 Linux 安装
• 它需要 Linux 内核版本 3.10 或更高版本。（可以升级内核）

uname --m   #查看系统64位还是32位
uname -r      #查看内核版本

使用脚本安装 Docker

curl -sSL https://get.daocloud.io/docker | sh

查看版本

docker version

 如果使用非root用户直接运行docker时  执行 sudo usermod -aG docker 用户名 命令，然后重新登陆(xShell和服务器断开连接，如果不行，试着重启一个docker)，否则会报错，没有权限

sudo usermod -aG docker zy   //本机普通用户的用户名为zy

重启docker

service docker restart

启动docker

service docker start

停止docker服务

service docker stop

查看docker服务的运行状态

systemctl status docker.service

配置加速器 

1：

sudo vim  /lib/systemd/system/docker.service
添加 --registry-mirror=https://jxus37ac.mirror.aliyuncs.com 到 ExecStart：

　　

配置加速器的另一种方式，适用Ubuntu 16.04+、Debian 8+、CentOS 7

请在/etc/docker/daemon.json 中写入如下内容（如果文件不存在请新建该文件），注意，一定要保证该文件符合 json 规范，否则 Docker 将不能启动。如果使用了第二中，必须将第一种设置的给删除掉;

{
  "registry-mirrors": [
    "https://registry.docker-cn.com"  //mirror地址，上面的地址也可以，我本人测试速度好像都差不多
  ]
}

2：保存配置

systemctl daemon-reload

3：重启服务

service docker restart

4.查看是否配置成功

　　在命令行执行 docker info,出现下面的信息，则成功

　　

　　

 第一个Docker应用程序

用docker命令运行一个镜像，启动一个docker容器

docker run --name [mytomcat] -d tomcat:lastest  --name:自定义docker名字，-d:后台启动，tomcat:lastest:指定的镜像

启动docker容器，并执行docker容器中的程序

docker run ubuntu:18.04 /bin/echo "hellow"

解释这段代码：启动Ubuntu:18.04 这个镜像，生成一个docker容器（images启动才生成docker容器），由这个容器中的echo，来打印"hellow"，所以第一次执行的时候，会去下载镜像，等下载完毕后才执行echo，第二次执行，速度就很快了，原因，镜像已经被下载了，直接使用即可，所有的镜像存放在：https://hub.docker.com/search?q=&type=image

在主线程中运行的(不是在容器中输入这些命令)

docker images                           //查看所有的镜像
docker ps -a                            //查看docker容器运行过的容器
docker ps                               //正在运行的docker容器(后台)
docker rm [9996c85163（CONTAINER ID）]   //删除由docker ps -a 中展示的信息
docker rm  ID[NAME] ID[NAME]            //删除多个容器，输入制定的容器ID或者NAME
docker rmi ID                           //删除镜像
docker logs -f  CONTAINER ID            //打印后台日志（可以加一个参数 -f，使它一直处于监听模式）

docker stop  CONTAINER ID               //停止后台一直运行的容器(服务)
docker restart CONTAINER ID             //重新启动一个容器
docker start CONTAINER ID               //启动一个停止的容器

docker exec -it CONTAINER ID /bin/bash  //进入正在运行的docker容器，此时会进入到容器之中，通过ps命令来查看该容器运行的程序
docker top CONTAINER ID(如果不行使用NAME) //容器正在运行的进程 
docker inspect CONTAINER ID[NAME]       //查看docker底层信息
docker pull ubuntu:14.04                //提前下载指定的镜像
docker search mysql                     //搜索镜像，一般下载后面有official(ok)表示官方版
docker tag ID  zy/ubuntu:dev            //为镜像添加一个新的标签(tag)  共用一个镜像ID 

docker                                   //查看所有的选项 
docker [commend] --help docker ps --help // 查看帮助（ps这个指令的帮助）
docker pull tomcat                       //下载最新的tomcat（latest）
docker pull tomcat:9-jdk11               //下载指定版本的tomcat　
docker image prune                       //删除所有的虚悬镜像
docker container prune                   //将所有已经停止的容器全部删除
docker cp CONTAINER ID：/usr/local/ .    //将容器中的数据copy到宿主机上

　　

进入镜像容器中

ctrl+d 退出容器

退出，容器被释放掉，但是镜像(ubuntu:18.04)还在 (注意：之前在该容器中的配置的一个数据等，和下载的东西，随着容器的释放，都会被清空，解决：下面)

docker run -it ubuntu:18.04 /bin/bash  //此时会新建一个docker容器

　　-it ：已交互式  ，可以在后面再加 --rm ：只要容器退出，自动删除容器

输入 ls -l  可以观察到，由完整的目录结构，结论：该容器(docker通过镜像创建)就是一个独立运行的操作系统，部署在操作系统之上的一个容器操作系统

理解：镜像相当于类，容器相当于该类创建的实例，对该实例(docker容器)的任意操作，都不会影响到该类(镜像)，由于该docker容器，由镜像创建，所以docker容器启动的时候会加载镜像中的配置信息，如果我们将java对象全部封装到镜像中，那么实例出来的docker就会配置这些java对象，就相当于一次配置，多次使用了。并且镜像支持面向对象中的继承，例如tomcat镜像继承了java镜像，那这个tomcat镜像已经装载过java了。在将myshop镜像(程序)继承tomcat镜像，那么，用这个镜像实例出来的docker容器，就自动配置了tomacat和java。并且这个镜像可以放在任何的计算机上使用。只需要new一个docker容器出来。

运行web应用程序

 docker 容器中运行一个 Python Flask 应用来运行一个web应用

docker run -d -P training/webapp python app.py
docker run -d -p 5000:5000 training/webapp python app.py //指定端口(左边的5000代表宿主机的5000端口，右边的5000代表容器的5000端口)

• -d：让容器在后台运行
• -P：将容器内部使用的网络端口映射到我们使用的主机上，宿主机的随机端口映射到docker容器中暴露的端口(在Dockfile中的EXPOSE配置)，通过docker ps，来查看宿主机上那个一端口被映射了。并通过这个端口来访问tomcat
• training/webapp 镜像
• python app.py  调用容器中的Python命令，调用app.py

　　

更新Docker镜像(在原有的镜像中添加自己的配置生成的新的镜像)

步骤1：通过  docker run -it ubuntu:18.04 /bin/bash 创建出一个新的容器

 可以对Docker中的镜像源进行修改(可以选择省略)

 首先更新数据源

apt-get update

可以修改数据源

如果发现报：Not Fount 镜像，这是就会下载不了东西，例如apt-get install vim，没有vim就不能编辑镜像(source.list文件)；解决，通过echo，将镜像路径覆盖写入到source.list 文件中

 例如

echo deb http://mirrors.aliyun.com/ubuntu/ bionic main restricted universe multiverse > source.list  //第一次覆盖写入
echo deb http://mirrors.aliyun.com/ubuntu/ bionic-security main restricted universe multiverse >>source.list  //第二次追加
echo deb http://mirrors.aliyun.com/ubuntu/ bionic-updates main restricted universe multiverse  >>source.list
echo deb http://mirrors.aliyun.com/ubuntu/ bionic-backports main restricted universe multiverse >>source.list

步骤二：保存容器(将该容器中的配置生成一个新(持久化)的镜像)，可以通过  docker images 来查看镜像 

注意：如果在生成的镜像中又要添加新的配置，必须重新再生成一个镜像，配置才可以被保存;

docker commit -m="has update" -a="zy" 9a3dcafd7a83 zy/ubuntu:v2

• -m：提交的描述信息
• -a：指定镜像作者
• 9a3dcafd7a83：容器ID
• zy/ubuntu:v2：指定要创建的目标镜像名
• v2：指tag标签(类似18.04)

进入 通过该镜像创建一个容器(里面的配置不变)

docker run -it zy/ubuntu:v2  /bin/bash

Dockerfile定制镜像文件

前戏：进入/usr/local （自己安装的程序放到这托管） mkdir  docker   cd  /docker

1、创建自己的镜像目录  mkdir myubuntu  cd  myubuntu

　　可以将所有需要打包到镜像中的文件，放到这个目录下，例如tomcat.tar.gz，jdk等，copy tomact  /home ，在通过RUN tar  -zxvf  tomcate 解压包等等操作；

2.、在该镜像目录下创建文件：vim  Dockerfile  (固定)

FROM ubuntu:18.04                         //表示基于ubuntu:18.04来制作镜像，可以是本地制作完成的镜像；也可以是官网上的镜像；
MAINTAINER 1847003070@qq.com              //设置镜像的作者，可以指定邮箱
RUN /bin/bash -c 'echo "Hello World"'     //RUN 表示需要执行的命令
copy a.txt /home                          //将宿主机中的a.txt文件长传到镜像的/home目录下
WORKDIR /home                             //指定工作目录，不指定的话，会自动创建

EXPOSE  80                                //暴露端口
EXPOSE  8080                              //暴露多个端口

CMD ["/bin/echo","this is a echo test"]   //用于执行映像的应用程序(例如在window窗口中启动java服务应用程序一样),cmd只可以存在一个，后面会提到最多使用两个；

3、构建镜像

docker build -t zy/ubuntu:latest .    //latest（tag标签）不写的话，默认为latest 

• -t：指定要创建的目标镜像名
• .：Dockerfile 文件所在目录，可以指定 Dockerfile 的绝对路径

　　

Dockerfile指令

1、COPY命令使用 

　　真正意义上的copy文件其实不在宿主机上，而是当执行 docker build -t zy/ubuntu:latest .  命令后，将( . )当前目录打包成一个zip包发送了，docker服务器，服务器解压后形成的目录，copy的是这个服务器上的目录中的文件，所有如果命令中有  copy ../a.txt /home，是无法获取上一级的目录，原因，服务器上根本就没有这个目录。所以只能将所需要打包到镜像的文件放到和Dockerfile同级目录。一起打包成压缩包，发到服务器，服务器就会有这些文件了。。

2、RUN命令和WORKDIR命令使用

 注意1：如果此时通过这个镜像创建的容器，启动时的工作目录为图中的目录(WORKDIR)，如果需要在一开始启动的目录为/usr/local/tomcat，自己在最后将WORKDIR工作目录切换一下

 注意2：每一个run都是一个全新的容器。

3.ADD

ADD 指令和 COPY 的格式和性质基本一致。但是在 COPY 基础上增加了一些功能。

比如 <源路径> 可以是一个 URL，这种情况下，Docker 引擎会试图去下载这个链接的文件放到 <目标路径> 去。下载后的文件权限自动设置为 600，如果这并不是想要的权限，那么还需要增加额外的一层 RUN 进行权限调整，另外，如果下载的是个压缩包，需要解压缩，也一样还需要额外的一层 RUN 指令进行解压缩。所以不如直接使用 RUN 指令，然后使用 wget 或者 curl 工具下载，处理权限、解压缩、然后清理无用文件更合理。因此，这个功能其实并不实用，而且不推荐使用。

如果 <源路径> 为一个 tar 压缩文件的话，压缩格式为 gzip, bzip2 以及 xz 的情况下，ADD 指令将会自动解压缩这个压缩文件到 <目标路径> 去。

在某些情况下，这个自动解压缩的功能非常有用，比如官方镜像 ubuntu 中：

FROM scratch
ADD ubuntu-xenial-core-cloudimg-amd64-root.tar.gz /
...

 //此时会自动将  ubuntu-xenial-core-cloudimg-amd64-root.tar.gz 解压

因此在 COPY 和 ADD 指令中选择的时候，可以遵循这样的原则，所有的文件复制均使用 COPY 指令，仅在需要自动解压缩的场合使用 ADD

4.EXPOET 

EXPOSE 指令是声明运行时容器提供服务端口，这只是一个声明，在运行时并不会因为这个声明应用就会开启这个端口的服务。在 Dockerfile 中写入这样的声明有两个好处，一个是帮助镜像使用者理解这个镜像服务的守护端口，以方便配置映射；另一个用处则是在运行时使用随机端口映射时，也就是 docker run -P 时，会自动随机映射 EXPOSE 的端口。

此外，在早期 Docker 版本中还有一个特殊的用处。以前所有容器都运行于默认桥接网络中，因此所有容器互相之间都可以直接访问，这样存在一定的安全性问题。于是有了一个 Docker 引擎参数 --icc=false，当指定该参数后，容器间将默认无法互访，除非互相间使用了 --links 参数的容器才可以互通，并且只有镜像中 EXPOSE 所声明的端口才可以被访问。这个 --icc=false 的用法，在引入了 docker network 后已经基本不用了，通过自定义网络可以很轻松的实现容器间的互联与隔离。

要将 EXPOSE 和在运行时使用 -p <宿主端口>:<容器端口> 区分开来。-p，是映射宿主端口和容器端口，换句话说，就是将容器的对应端口服务公开给外界访问，而 EXPOSE 仅仅是声明容器打算使用什么端口而已，并不会自动在宿主进行端口映射。

 5.CMD

容器启动时执行

指令格式

• shell 格式：CMD <命令>
• exec 格式：CMD ["可执行文件", "参数1", "参数2"...]
• 参数列表格式：CMD ["参数1", "参数2"...]。在指定了 ENTRYPOINT 指令后，用 CMD 指定具体的参数。

之前介绍容器的时候曾经说过，Docker 不是虚拟机，容器就是进程。既然是进程，那么在启动容器的时候，需要指定所运行的程序及参数。CMD 指令就是用于指定默认的容器主进程的启动命令的。

在运行时可以指定新的命令来替代镜像设置中的这个默认命令，比如，ubuntu 镜像默认的 CMD 是 /bin/bash，如果我们直接 docker run -it ubuntu 的话，会直接进入 bash。我们也可以在运行时指定运行别的命令，如 docker run -it ubuntu cat /etc/os-release。这就是用 cat /etc/os-release 命令替换了默认的 /bin/bash 命令了，输出了系统版本信息。

在指令格式上，一般推荐使用 exec 格式，这类格式在解析时会被解析为 JSON 数组，因此一定要使用双引号 "，而不要使用单引号。

如果使用 shell 格式的话，实际的命令会被包装为 sh -c 的参数的形式进行执行。比如：

CMD echo $HOME

在实际执行中，会将其变更为：

CMD [ "sh", "-c", "echo $HOME" ]

这就是为什么我们可以使用环境变量的原因，因为这些环境变量会被 shell 进行解析处理。提到 CMD 就不得不提容器中应用在前台执行和后台执行的问题。这是初学者常出现的一个混淆。Docker 不是虚拟机，容器中的应用都应该以前台执行，而不是像虚拟机、物理机里面那样，用 upstart/systemd 去启动后台服务，容器内没有后台服务的概念。一些初学者将 CMD 写为：

CMD service nginx start

然后发现容器执行后就立即退出了。甚至在容器内去使用 systemctl 命令结果却发现根本执行不了。这就是因为没有搞明白前台、后台的概念，没有区分容器和虚拟机的差异，依旧在以传统虚拟机的角度去理解容器。

对于容器而言，其启动程序就是容器应用进程，容器就是为了主进程而存在的，主进程退出，容器就失去了存在的意义，从而退出，其它辅助进程不是它需要关心的东西。

而使用 service nginx start 命令，则是希望 upstart 来以后台守护进程形式启动 nginx 服务。而刚才说了 CMD service nginx start 会被理解为 CMD [ "sh", "-c", "service nginx start"]，因此主进程实际上是 sh。那么当 service nginx start 命令结束后，sh 也就结束了，sh 作为主进程退出了，自然就会令容器退出。

正确的做法是直接执行 nginx 可执行文件，并且要求以前台形式运行。比如：

CMD ["nginx", "-g", "daemon off;"]

　　

Docker 部署 tomcat

docker pull  tomcat    //下载镜像

通过docker run -it tomcat /bin/bash 或者docker run -it tomcat  bash 可以创建容器，并进入，会发现自己处于/usr/local/tomcat 目录下，所以tomcat下载的镜像本身就是基于linux系统的。

运行容器(启动tomcat)

docker run --name tomcat -p 8080:8080 -v $PWD/test:/usr/local/tomcat/webapps/test -d tomcat

• -p 8080:8080：将容器的8080端口映射到主机的8080端口
• -v $PWD/test:/usr/local/tomcat/webapps/test：将主机中当前目录下的test挂载到容器的/test，如果主机当前目录没有test，会自动创建一个test目录
• --name：指定容器的名字 为 tomcat
• -d ：后台运行

 创建一个简单的网页

1、docker exec -it CONTAINER ID /bin/bash     //进入tomcat容器
2、cd test                                    //进入test这个虚拟目录，如果没有可以自己创建
3、echo “hellow” > index.html                 //写一个简单的html
4、可以访问这个 ：IP:8080/test/

 补充：如果直接将tomcat 的webapps目录挂载到本地；那么自己需要在本地创建一个ROOT目录，tomcat的根目录在ROOT中；

Docker 部署 MySQL

参考：https://hub.docker.com/_/mysql 

docker pull mysql:5.7.26    //下载镜像，注意使用mysql 5.7

1、启动一个简单的mysql

docker run --name some-mysql -p 3306:3306  -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7.26  //如果版本不是latest的话，需要指定版本号

2、使用数据卷启动MySQL

docker run -p 3306:3306 --name mysql 
-v /usr/local/docker/mysql/conf:/etc/mysql 
-v /usr/local/docker/mysql/logs:/var/log/mysql 
-v /usr/local/docker/mysql/data:/var/lib/mysql 
#-v /home/mysql/mysql-files:/var/lib/mysql-files 
-e MYSQL_ROOT_PASSWORD=123456 
-d mysql:5.7.26  //不指定版本默认为latest

• -p 3306:3306：将容器的3306端口映射到主机的3306端口
• -v /usr/local/docker/mysql/conf:/etc/mysql：将主机当前目录下的 conf 挂载到容器的 /etc/mysql
• -v /usr/local/docker/mysql/logs:/var/log/mysql：将主机当前目录下的 logs 目录挂载到容器的 /var/log/mysql
• -v /usr/local/docker/mysql/data:/var/lib/mysql：将主机当前目录下的 data 目录挂载到容器的 /var/lib/mysql
• -v  /home/mysql/mysql-files:/var/lib/mysql-files              :如果启动报错，加上这个；可以改为/usr/local/docker/mysql/mysql-files  和前几个保持在一个目录下
• -e MYSQL\_ROOT\_PASSWORD=123456：初始化root用户的密码

      注意1：注意如果修改了密码，前提必须将宿主机中的mysql文件(主要为data目录)删除(宿主机挂载的目录)，不然密码不生效；

 　 注意2：如果发现启动tomcat没有报错，但是mysql并没有启动，可以修改这样  -d mysql:[mysql版本号]，没有指定版本的话，默认找latest版本

修改mysql储存大小

　　1、在docker中  cat  /etc/mysql/conf.d/mysqldump.cnf(如果没有，-将v /usr/local/docker/mysql/conf:/etc/mysql 挂载点删除掉，重新生成一个docker)

　　

　　2、将上面复制的文字追加到 /etc/mysql/mysql.conf.d/mysqld.cnf  （可以修改后面的数字，表示储存大小）

　　

    3.将容器中的 /etc/mysql中的数据全部copy到宿主机中的conf目录中(下次生成docker是的挂载数据卷配置目录就是这个conf目录)。

步骤
1、docker cp mysql（CONTAINT ID）:/etc/mysql  .    //克隆数据
2、cd mysql
3、mv * [conf]                                     //将mysql中的配置文件全部移动到conf目录中

　4.启动mysql的时候加上之前删除的挂载数据卷的那条配置

　 重新生成mysql容器(docker)。

Docker部署应用

1、Dockerfile文件：

FROM tomcat
MAINTAINER Lusifer

ADD app.war /usr/local/tomcat/webapps/app.war   //Docker启动tomcat后，自动解压war文件

2、构建镜像

docker build -t zy/tomcat .

3、启动容器（启动tomcat）

docker run --name tomcat -p 8080:8080 zy/tomcat //--name 起一个别名

方式二：　　

1、Dockerfile

FROM tomcat
MAINTAINER zy
WORKDIR /usr/local/tomcat/webapps/ROOT
RUN rm -rf *
COPY my-shop.zip .
RUN unzip my-shop.zip
RUN rm -rf my-shop.zip
WORKDIR /usr/local/tomcat

2.----

3.----　　

数据卷 

创建数据卷的方式：

没有指定宿主机目录的情况下：

　　方式一：生成镜像时候：dockerfile 中指定 VOLUME 后的目录，如 VOLUME /data

　　　　　　这里的 /data 目录就会在运行时自动挂载为匿名卷，任何向 /data 中写入的信息都不会记录进容器存储层，从而保证了容器存储层的无状态化。当然，运行时可以覆盖这个挂载设置,比如 docker run -d -v mydata:/data xxxx

　　方式二：docker run 命令中加 -v 选项。 如 ：docker run -d -P -v /webapp training/webapp python app.py

　　注意： 这里只是定义的 /webapp 数据卷，但是不知道宿主机上与之对应的在哪里。我们需要仔细的观察 docker inspect 的结果，是非常长的一段东西。在这里我只摘出我们需要的部分：

"Mounts": [
    {
        "Type": "volume",
        "Name": "ae15b45565ac99bc8f770b226684f7ef707eb8a4d9b8111a0e6b8410ab7b7942",
        "Source": "/var/lib/docker/volumes/ae15b45565ac99bc8f770b226684f7ef707eb8a4d9b8111a0e6b8410ab7b7942/_data",
        "Destination": "/webapp",
        "Driver": "local",
        "Mode": "",
        "RW": true,
        "Propagation": ""
    }
]

　　 这里 “Name”: “ae15b45565ac99bc8f770b226684f7ef707eb8a4d9b8111a0e6b8410ab7b7942”，这个并不是容器 id 而是数据卷的 ID，我们可以在 /var/lib/docker/volumes/ 下找到名子为这个

　　 数字的目录。它就是我们数据卷在宿主机上对应的目录。

备份数据库

　　直接将挂载的三个目录打包成一个tar包；(可以修改一下tar包的名字，指定年月日，放到一个专门存放数据库配置的文件夹中)，注意数据库存放好之后，不要放在这台服务器上(否则服务器崩了，数据库文件打不开了)，copy到另一个地方；

tar -zcvf backup.tar.gz .
mv backup.tar.gz /xx/xx.20190x0x.tar.gz  

恢复数据库

　　如果从新开启一台服务器，就将这个tar压缩包，上传到新的服务器上，解压到一个特定的目录，启动mysql的时候，挂载目录为这个上传的目录即可

docker-compose

通过docker-compose 来管理docker

一、下载

使用脚本脚本下载

　　如果需要使用最新版：打开；https://github.com/docker/compose/releases/ 查看最新版，将下面的版本号改一下即可(注意，需要下载的是Latest release(稳定版))

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

给 docker-compose 添加执行的权限：

sudo chmod +x /usr/local/bin/docker-compose

查看 docker-compose 的版本(测试是否安装成功)

docker-compose version

正常下载

　　

1、将下载的文件上传到指定的服务器(可以将文件名改为docker-compose)

2、添加到环境变量

cat /etc/environment 

 可以看到：PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games"

将上传的文件移动到环境变量的目录下(任意)：例如/usr/local/bin

3、给文件设置root用户：ront组

4、添加可以执行的权限

二、使用

创建一个 docker-compose.yml 配置文件：

注意不能有tab键，空格不能使用tab，必须使用空格键

version: '3'
services:
  tomcat:
    restart: always
    image: tomcat
    container_name: tomcat
    ports:
      - 8080:8080

• version：指定脚本语法解释器版本
• services：要启动的服务列表
  • tomcat：服务名称，可以随便起名，不重复即可
  • restart：启动方式，这里的 always 表示总是启动，即使服务器重启了也会立即启动服务
  • image：镜像的名称，默认从 Docker Hub 下载
  • container_name：容器名称，可以随便起名，不重复即可
  • ports：端口映射列列表，左边为宿主机端口，右边为容器端口

docker-compose up           //前台运行
docker-compose up -d       //后台运行
docker-compose stop        //停止服务
docker-compose down      //停止并删除容器  //注意在装载 docker-compose.yml 文件的目录下执行命令
docker-compose logs ID     //查看日志
docker ps                  //运行的docker

　　

Docker Compose 运行 Tomcat

添加一个数据卷

version: '3'
services:
  tomcat:
    restart: always
    image: tomcat
    container_name: tomcat
    ports:
      - 8080:8080
    volumes:
      - /usr/local/docker/tomcat/webapps:/usr/local/tomcat/webapps
    environment:
      TZ: Asia/Shanghai

Docker Compose 运行 MySQL

docker-compose.yml 配置文件：

version: '3'
services:
  mysql:
    restart: always
    image: mysql
    container_name: mysql
    ports:
      - 3306:3306
    environment:
      TZ: Asia/Shanghai
      MYSQL_ROOT_PASSWORD: 123456
    command:
      --character-set-server=utf8mb4
      --collation-server=utf8mb4_general_ci
      --explicit_defaults_for_timestamp=true
      --lower_case_table_names=1
      --max_allowed_packet=128M
      --sql-mode="STRICT_TRANS_TABLES,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION,NO_ZERO_DATE,NO_ZERO_IN_DATE,ERROR_FOR_DIVISION_BY_ZERO"
    volumes:
      - mysql-data:/var/lib/mysql

volumes:
  mysql-data:

挂载目录：/var/lib/docker/volumes/tomcat_mysql-data/_data   初始化的时候，_data中的数据要情况，才可以从新加载配置；

参数：

     lower_case_table_names ：忽略大小写 

  - mysql-data:/var/lib/mysql：不指定专门的数据卷位置，直接放在docker安装目录的数据卷目录下，取名为mysql-data，(名字的前面还会加上一个前缀，服务的名字) 

注意：--sql-mode="STRICT_TRANS_TABLES,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION,NO_.........................如果报错，就不要添加了

如果需要将两个服务同时部署

直接添加多个服务

docker-compose.yml 配置文件：

version: '3'
services:
  tomcat:
    restart: always
    image: tomcat
    container_name: tomcat
    ports:
      - 8080:8080
    volumes:
      - /usr/local/docker/tomcat/webapps:/usr/local/tomcat/webapps
    environment:
      TZ: Asia/Shanghai
  mysql:
    restart: always
    image: mysql
    container_name: mysql
    ports:
      - 3306:3306
    environment:
      TZ: Asia/Shanghai
      MYSQL_ROOT_PASSWORD: 1234567
    command:
      --character-set-server=utf8mb4
      --collation-server=utf8mb4_general_ci
      --explicit_defaults_for_timestamp=true
      --lower_case_table_names=1
      --max_allowed_packet=128M
    volumes:
      - mysql-data:/var/lib/mysql   //没有指定宿主机的目录，会有一个默认的目录，在/var/lib/docker/volumes,即docker安装目录

volumes:
  mysql-data:  //统一管理数据卷的地方。(添加这一个的目的可能是由于mysql没有配置宿主机数据卷路径的原因)

　　

注意事项

使用docker-compose的时候，如果全部设置  restart: always ，注意服务器启动的时候，就会自动启动这些docker容器，如果内存不够这些容器启动的话，则服务器在启动的时候就会陷入内存溢出，死循环，同时服务器也就启动不了。特别是云服务器就会比较麻烦(如果不行的话，可以下一个工单，让云服务器的管理人员帮你解决一下。或者云服务器加内存)

参考文献

https://topsale.gitbooks.io/java-cloud-dubbo/content/chapter3/Docker%E7%AE%80%E4%BB%8B.html