数据卷
参考文档
https://topsale.gitbooks.io/java-cloud-dubbo/content/
单体应用：
项目的架构完完全全属于传统的 MVC 架构，所有的子系统都集成在一个很繁杂的 JVM 进程中。
优点：
这种单体架构的优点在于方便管理，所有代码在同一项目中，但是当需求越来越多，项目规模越来越大，其坏处也很明显。
缺点：
- 项目过于臃肿，部署效率低下
- 系统高可用性差，资源无法隔离
- 开发成本高
- 无法灵活拓展
- 牵一发而动全身，修改很麻烦
微服务：
服务化：用通俗的语言来说，服务化就是把传统单体应用中通过 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