1. Docker

1 容器简介

1.1 容器与虚拟机区别

1. 虚拟机：需要安操作系统，为了安装一个很小的应用，却要先安一个非常大的操作系统，浪费资源，且部署麻烦
2. 容器：实际上就是先安装了一个满足应用运行的最小的操作系统，然后将应用运行在这个操作系统上

1.2 容器的应用

1. 方便部署应用。例如买的MySql阿里云服务器，实际上买的是个虚拟机，但上面的MySql实际上是跑在虚拟机中的容器内的

2 Docker简介

1. Docker是提供应用打包、部署、运行的容器化平台，是容器化技术的代表
2. 利用Docker不仅可以创建容器，还可以通过Docker引擎(类似JVM)向本地物理机申请一定资源，我们可以利用Docker将应用打包，然后记录运行这些应用需要哪些硬件要求，例如硬盘大小、cpu数，内存大小
3. docker-ce为社区版，docker-ee为企业版
4. Docker对系统内核有一定要求，至少为CentOS7以上，且其所在的虚拟机必须启用虚拟化管理程序，VMware Fusion中需要，右键虚拟机–处理器与内存–高级选项–在此虚拟机中启用虚拟化管理程序
5. 利用yum下载Docker时，是从美国网站下载，非常慢，因此需要更换yum软件源地址

3 Docker安装

1. 为CentOS7防火墙添加允许端口号

2. 通过ssh连接CentOS7

3. 安装组件yum-utils、device-mapper-persistent-data、lvm2

   #1. -y表示自动确认
   #2. yum-utils：yum工具集，可以方便地修改yum的安装源
   #3. device-mapper-persistent-data、lvm2：这两个组件是数据存储的驱动包，Docker需要进行数据存储时需要他们
   yum install -y yum-utils device-mapper-persistent-data lvm2
   

4. 修改yum安装源

   #1. yum-config-manager：是yum-utils提供的
   yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
   

5. 将新配置的yum源的软件包信息在本地缓存一份，提高搜索软件速度

   yum makecache fast
   

6. 安装Docker社区版

   yum -y install docker-ce
   

7. 启动Docker服务

   service docker start
   

8. 查看Docker版本号

   #可以查询到Docker服务端版本号和客户端版本号，说明Docker安装后启动正常
   docker version
   

4 Docker部署hello-world

1. 从Docker中央仓库获取hello-world镜像

   docker pull hello-world
   

2. 运行hello-world

   #控制台打印Hello from Docker，说明执行成功
   docker run hello-world
   

5 Docker镜像加速

1. docker pull默认从Docker中央仓库下载镜像，有时速度特别慢，因此可以配置镜像加速地址，加快下载速度

2. 常用镜像加速地址https://hub-mirror.c.163.com、https://mirror.baidubce.com、https://fskvstob.mirror.aliyuncs.com

3. CentOS7中配置镜像加速地址

   sudo cp -n /lib/systemd/system/docker.service /etc/systemd/system/docker.service
   sudo sed -i "s|ExecStart=/usr/bin/docker daemon|ExecStart=/usr/bin/docker daemon --registry-mirror=https://fskvstob.mirror.aliyuncs.com|g" /etc/systemd/system/docker.service
   sudo sed -i "s|ExecStart=/usr/bin/dockerd|ExecStart=/usr/bin/dockerd --registry-mirror=https://fskvstob.mirror.aliyuncs.com|g" /etc/systemd/system/docker.service
   sudo systemctl daemon-reload
   sudo service docker restart
   

6 Docker体系结构

1. server：由Docker daemon提供服务
2. REST API：server对外暴露了REST类型的API，我们可以通过HTTP请求去要求server对容器进行管理
3. client：client通过REST API向server发送HTTP请求，Docker相当于是CS架构，docker run实际上就是client提供的

7 容器与镜像

1. 镜像：是只读的文件，提供了运行程序完整的软硬件资源，类似应用程序的安装文件
2. 容器：是镜像的实例、是运行环境，由Docker负责创建。容器之间资源和应用彼此隔离
3. 当我们通过docker pull tomcat下载一个tomcat镜像后，Docker可以通过docker run tomcat创建多个安装了tomcat的容器

8 Docker执行流程

1. Registy：注册中心，也叫远程仓库，存放镜像文件
2. docker pull redis：发送请求给Docker daemon，Docker daemon会先在本地仓库查找是否有redis镜像，如果有进行提示，如果没有，去Registry中下载redis镜像
3. docker run redis：Docker daemon根据镜像，创建容器并启动

9 Docker部署tomcat

1. 从远程仓库获取tomcat镜像

   #1. tags表示镜像版本号，如果不指定，默认下载latest版，一般latest版是下载最多的那个版本
   #2. hub.docker.com是docker官方提供的中央仓库，保存了所有docker镜像，可以登陆该网站查看不通版本的信息，以及不通版本的tags名
   docker pull tomcat:8.5.46-jdk8-openjdk
   

2. 启动容器

   #容器启动后，tomcat应用也会被启动，容器内部会启动一个8080端口，但这个8080端口不是容器所在虚拟机的8080端口，因此无法通过外界访问
   docker run tomcat:8.5.46-jdk8-openjdk
   #-p：将容器所在虚拟机的8000端口，与容器内的8080端口进行映射，同时创建容器
   docker run -p 8000:8080 tomcat:8.5.46-jdk8-openjdk
   #-d：后台运行容器
   docker run -p 8000:8080 -d tomcat:8.5.46-jdk8-openjdk
   

3. 查看容器id

   #查看运行中的容器
   docker ps
   #查看被kill或stop的容器
   docker ps -a
   

4. 停止容器

   #1. 停止容器类似关闭虚拟机，重新启动虚拟机后，如果应用没配置开机自动启动，需要人为启动该应用，tomcat中会自动启动
   #2. a73d8e449065为容器id
   docker stop b78f92b99179
   docker kill b78f92b99179
   

5. 启动容器

   docker start b78f92b99179
   #重启容器
   docker restart b78f92b99179
   

6. 删除容器

   #1. 删除容器类似删除虚拟机，因此再创建的容器和这个虚拟机完全没有关系，且再次创建的容器，数据也和这个容器中数据完全不同
   #2. 运行中的容器，无法直接被删除，需要先通过stop停止该容器再删除，也可以通过-f强制删除
   docker rm b78f92b99179
   #3. 强制删除所有容器
   docker rm -f `docker ps -aq`
   

7. 查看本地下载好的所有镜像

   docker images
   

8. 删除镜像

   #如果当前镜有正在运行的容器，无法被删除，可以通过-f强制删除
   docker rmi tomcat:8.5.46-jdk8-openjdk
   

10 进入容器内部执行命令

1. 进入容器

   #1. /bin/bash表示进入容器后，执行/bin/bash
   #2. -it，表示采用交互形式执行命令，这样，就可以继续输入命令给容器内部的linux系统
   docker exec -it b78f92b99179 /bin/bash
   

2. 查看容器内部结构

   #1. 发现当前在/usr/local/tomcat目录中，其实就是tomcat的文件夹,里面也有webapps文件夹
   #2. 尝试输入ll命令，无法执行，因为ll命令只存在于标准的linux中，但是这个linux操作系统只提供可以安装tomcat和jdk的最基本的环境，没有多余的命令。正因为这样，该操作系统尺寸才非常小
   #3. 查看该操作系统版本，是内核为3.10.0的linux
   cat /proc/version
   #4. 查看jdk版本，是1.8.0_222
   java -version
   #5. 容器在宿主机的位置：/var/lib/docker中，镜像在其image路径下，容器在containers路径下
   

11 Dockerfile构建自定义Tomcat镜像

1. Dockerfile是一个包含用于组合镜像的命令的文本文档，也就是说是个脚本
2. Docker通过读取Dockerfile中的指令自动生成镜像

11.1 构建流程

1. mkdir -p /usr/image/first-dockerfile：创建文件夹用于存放Dockerfile

2. cd /usr/image/first-dockerfile：进入该文件夹

3. vi Dockerfile：编写Dockerfile

   #FROM：设置基准镜像，此处表示从tomcat最后一个版本的镜像之上，进行扩展
   FROM tomcat
   #MAINTAINER：设置当前镜像构建者为mashibing.com
   MAINTAINER mashibing.com
   #WORKDIR：功能等同于mkdir+cd，创建并进入指定目录
   WORKDIR /usr/local/tomcat/webapps
   #ADD：功能等同于cp，将容器所在虚拟机上的docker-web文件夹，复制到容器内部linux的/usr/local/tomcat/webapps/docker-web中
   ADD docker-web ./docker-web
   

4. 创建docker-web文件夹，并在其内部放入一个index.html

5. 自定义镜像

   #docker build -t 镜像名<:tags> Dockerfile所在目录，如果不加tags，默认是latest最新版
   docker build -t mashibing.com/mywebapp:1.0 /usr/image/first-dockerfile
   #如果当前就位于Dockerfile所在文件夹，可以使用相对路径"."
   docker build -t mashibing.com/mywebapp:1.0 .
   

6. 为新定义的镜像创建容器

   docker run -d -p 8001:8080 mashibing.com/mywebapp:1.0
   

7. 测试该容器，在浏览器中输入http://localhost:8001/docker-web/index.html，如果显示index.html中内容，说明整个流程成功

11.2 镜像分层

1. 构建自定义镜像时，控制台打印如下信息

   Sending build context to Docker daemon  3.584kB
   #使用Dockerfile构建镜像时，分为好几步，每步都会创建一个新的镜像，这个镜像存放于缓存中，创建新镜像时利用写时复制技术，也就是只记录增量部分
   Step 1/4 : FROM tomcat
    ---> 625b734f984e
   Step 2/4 : MAINTAINER mashibing.com
    ---> Running in 7c40c3374bf0
   Removing intermediate container 7c40c3374bf0
    ---> dd3ee6bea2b6
   Step 3/4 : WORKDIR /usr/local/tomcat/webapps
    ---> Running in 4cacccae03a4
   Removing intermediate container 4cacccae03a4
    ---> 863ad7a3ce89
   Step 4/4 : ADD docker-web ./docker-web
    ---> eb934c0b5c41
   Successfully built eb934c0b5c41
   Successfully tagged mashibing.com/mywebapp:1.0
   

2. 再次构建时，控制台打印如下信息

   Sending build context to Docker daemon  3.584kB
   Step 1/4 : FROM tomcat
    ---> 625b734f984e
   #如果步骤和之前一致，那么可以直接使用缓存中的镜像，加快构建速度，Using cache就表示使用缓存中镜像
   Step 2/4 : MAINTAINER mashibing.com
    ---> Using cache
    ---> dd3ee6bea2b6
   Step 3/4 : WORKDIR /usr/local/tomcat/webapps
    ---> Using cache
    ---> 863ad7a3ce89
   Step 4/4 : ADD docker-web ./docker-web
    ---> Using cache
    ---> eb934c0b5c41
   Successfully built eb934c0b5c41
   Successfully tagged mashibing.com/mywebapp:1.0
   

12 Dockerfile中的基础命令

1. FROM：设置基准镜像

   #基于centos:lastest
   FROM centos
   #非常少见，表示基于一个空的基准镜像
   FROM scratch
   #基于tomcat，注意要尽量使用官方提供的基准镜像
   FROM tomcat:9.0.22-jdk8-openjdk
   

2. LABEL、MAINTAINER：设置镜像相关信息

   #MAINTAINER：设置镜像构建者为mashibing.com
   MAINTAINER mashibing.com
   #LABEL：设置描述信息，只放在文件中便于我们阅读，不会产生实质的功能影响
   LABEL version = "1.0"
   LABEL description = "马士兵教育"
   

3. WORKDIR：创建目录并进入

   #通常使用绝对路径，让Dockerfile文档更清晰更容易维护
   WORKDIR /usr/local
   

4. ADD、COPY：将容器外部文件复制到容器内部

   #ADD和COPY功能相同，ADD除了复制，还具备下载远程文件功能，类似wget，可以将远程网址中内容下载到容器指定目录中
   ADD hello / 
   #复制的同时会解压缩
   ADD test.tar.gz /
   

5. ENV：设置环境变量

   ENV JAVA_HOME /usr/local/openjdk8
   #1. Dockerfile前面通过EVN设置环境变量后，后面就可以通过${JAVA_HOME}表示这个环境变量的值
   #2. 使用环境可提高程序维护性
   #3. RUN表示运行指令，后面会说明
   RUN ${JAVA_HOME}/bin/java -jar test.jar
   

6. EXPOSE：将容器内部端口对外暴露

   #将容器内部端口暴露给容器所在虚拟机，注意，暴露后还需要将8080端口与对容器所在虚拟机中某一端口进行端口映射，才能真正提供服务
   EXPOSE 8080
   

13 Dockerfile中的执行指令

13.1 指令执行方式

1. linux中执行脚本有三种方式，sh、exec、source
   1. sh：sh script.sh、./script.sh，会在当前shell下，生成一个子shell并执行命令，执行完毕后退出子shell，回到当前shell
   2. exec：exec script.sh，会用exec进程替换当前进程，并且保持进程pid不变，执行完毕后直接退出当前shell，并不会回到之前的shell
   3. source：source script.sh，在当前进程中执行脚本，执行完毕后不退出当前shell
2. 对应Dockerfile中的所有执行指令都可以有两种执行方式，sh和exec，推荐使用exec执行

13.2 常用执行指令

1. RUN：build创建镜像时执行，用于对镜像内部资源或文件进行调整

   #shell方式：等同于sh script.sh，而script.sh中只有一行代码，yum install -y vim
   RUN yum install -y vim 
   #exec方式：等同于exec script.sh
   RUN ["yum","install","-y","vim"] 
   

2. ENTRYPOINT：容器启动时执行，Dockerfile中如果ENTRYPOINT有多条，只有最后一条会被执行

3. CMD：容器启动后执行，Dockerfile中如果CMD有多条，只有最后一条会被执行

   #1. 如果docker run时，提供了容器启动后的执行命令，Dockerfile中的最后一条CMD就会被忽略
   #2. 不会执行CMD，ls在容器启动后执行
   docker run mashibing.com/docker_run ls
   #3. 会执行CMD，因为未提供容器启动后执行命令
   docker run mashibing.com/docker_run
   #4. 注意，tomcat镜像中，一定是通过CMD启动了tomcat服务，可以如下方式进行验证
   #a. 尝试创建tomcat容器时，提供容器启动后命令(ls)来替代CMD，但通过docker ps命令，发现容器直接退出，这是因为容器内必须有一个活跃的进程，如果没有，容器认为空闲，就会自行退出，猜测是由于ls替代了CMD中启动tomcat的脚本，导致tomcat没有启动，因此容器人为空闲直接退出
   docker run -d -p 8001:8080 mashibing.com/mywebapp:1.0 ls
   #b. -it表示交互模式执行，然后在容器启动后，执行/bin/bash，这样，就会一直有一个/bin/bash进程在容器中，这样容器就不会自动退出了
   docker run -d -it -p 8001:8080 mashibing.com/mywebapp:1.0 /bin/bash
   #c. 进入容器，查看是否有tomcat进程
   docker exec -it da4160a3b5a0 /bin/bash
   ps
   #d. 发现确实没有，证明了确实tomcat镜像中，存在一条CMD命令来启动tomcat，在容器中人为启动tomcat后，发现外界可以正常通过浏览器访问tomcat中资源
   #e. 通过docker stop关闭这个容器，再通过docker start启动，发现tomcat服务不在了，说明docker stop就类似关闭虚拟机，虚拟机关闭后重启，相关服务需要手工启动，除非CMD中定义了启动命令，这样每次容器启动，都会再次调用CMD中命令启动tomcat服务
   

4. ENTRYPOINT与CMD组合使用

   FROM centos
   #1. 如果先写ENTRYPOINT后写CMD，他们会组合起来使用，下面构建的Dockerfile所生成的容器，启动后，会执行ps -ef
   ENTRYPOINT ["ps"]
   CMD ["-ef"]
   
   #2. 由于这种特性，所以可以执行如下命令，让外界输入的启动命令替代CMD，从而实现从外界为ENTRYPOINT传递参数的效果
   #3. 实际上容器启动后，会执行ps -aus
   docker run mashibing.com/docker_run -aus
   

14 构建Redis镜像

1. 创建/usr/image路径，将redis源代码压缩包redis-4.0.14.tar.gz、redis配置文件redis-7000.conf都放入其中，并在其内编写Dockerfile文件

2. Dockerfile

   FROM centos
   #1. redis为c语言开发，redis-4.0.14.tar.gz为是redis的源代码，我们需要对其进行编译后才能使用，所以需要下载一些编译器组件组件，包括gcc、gcc-c++
   #2. net-tools：网络工具包
   #3. make：安装、编译工具
   RUN ["yum" , "install" , "-y" ,"gcc","gcc-c++","net-tools","make"]
   WORKDIR /usr/local
   ADD redis-4.0.14.tar.gz .
   WORKDIR /usr/local/redis-4.0.14/src
   #对源代码使用gcc编译后，再进行安装
   RUN make && make install
   WORKDIR /usr/local/redis-4.0.14
   ADD redis-7000.conf .
   EXPOSE 7000
   #容器启动后，通过redis-server redis-7000.conf命令来启动redis
   CMD ["redis-server","redis-7000.conf"]
   

3. 构建镜像：docker build -t mashibing.com/docker-redis .

4. 启动容器：docker run -p 7000:7000 mashibing.com/docker-redis

5. 其实可以不用自己构建Redis镜像，官方已经存在构建好的镜像，直接通过docker pull redis和docker run reids就可以启动redis

15 利用--link实现容器间单向通信

1. 容器间单项通信场景：容器A为tomcat服务，容器B为mysql数据库服务，tomcat需要访问数据库，而数据库无需访问tomcat

2. Docker会为每个容器都分配一个虚拟ip，该ip无法从Docker外部直接访问，只用于Docker内部的容器间彼此通信。Docker内所有容器天然就是互通的，但如果容器间通过虚拟ip进行通信，例如tomcat中配置的jdbc的url为虚拟ip，会有很大局限性，例如如果数据库容器被删除，重启的数据库容器，虚拟ip无法保证和原来相同，就会导致tomcat无法正确连接数据库

3. 具体操作

   #1. 使用tomcat镜像启动一个容器，将该容器命名为web
   docker run -d --name web tomcat
   #2. 模拟使用mysql镜像创建的容器，将该容器命名为database
   #此处基于centos创建容器后，由于没有活动的进程，该容器会自动退出，如果想让这个容器一直运行，需要通过-it进入交互模式，访问/bin/bash
   docker run -d --name database -it centos /bin/binsh
   #3. 查看两个容器的虚拟IP，inspect用于查看容器的元数据。其中web容器ip为172.17.0.4，database容器ip为172.17.0.3
   docker inspect 63f00d49721f | grep IPAddress
   docker inspect 93987e6aa300 | grep IPAddress
   #4. 进入到web容器中
   docker exec -it 63f00d49721f /bin/bash
   #a. ping database容器的ip是通的
   ping 172.17.0.3
   #b. ping容器名不通，因为我们还没尽进行网络配置
   ping database
   #5. 删除之前web容器
   docker rm -f 63f00d49721f
   #6. 重新创建web容器，同时通过--link，指定该容器可以连接到名为database的容器
   docker run -d --name web --link database tomcat
   #7. 此时进入web容器内部，ping database是通的
   #8. 我们只需将jdbc数据库连接字符串中ip地址改为database即可
   

16 利用网桥实现容器间双向通信

1. 我们可以为需要双向通信的两个容器，都通过–link指定其需要通信的容器，但操作起来比较麻烦

2. Docker内容器是可以访问外网的，这是因为Docker在物理网卡与容器间，提供了一个默认的网桥

   

3. 网桥还能对容器在网络层面进行分组，将多个容器绑定在同一个网桥上，那么这几个容器就可以通过容器名来互相访问

4. 具体操作

   #1. 创建第一个容器
   docker run -d --name web tomcat
   #2. 创建第二个容器
   docker run -d -it --name database centos /bin/bash
   #3. docker network：调用docker的网络服务，ls列出当前docker网络服务的明细，有bridge，host，none，每个docker在网络服务中都提供一个默认的网桥，这个网桥会承担容器和外界的桥梁
   docker network ls
   #4. 创建一个新网桥，叫做my-bridge
   docker network create -d bridge my-bridge
   #5. 发现出现了一个新的网桥，以后使用这个网桥的容器，彼此间默认可以使用容器名访问
   docker network ls
   #6. 将两个容器时，都与该网桥进行绑定
   docker network connect my-bridge web
   docker network connect my-bridge database
   #7. 测试是否互通
   docker exec -it 4753bd0cc6b8 /bin/bash
   ping web
   docker exec -it 1529b0c2de0f /bin/bash
   ping database
   

5. 网桥原理

   1. 每创建一个网桥，就会在宿主机上安装一个虚拟网卡，这个虚拟网卡同时也承担一个网关的作用，相当于web和database都和这个虚拟网卡绑定，所以在Docker内部就可以通过容器名互联互通
   2. 虚拟网卡想和外界通讯时，需要通过物理网卡进行地址转换

   

17 利用volume实现容器间数据共享

1. volume：数据卷，是保存数据的单位

2. 需要容器间共享数据的场景：Docker中有两个tomcat容器，他们部署的网页文件一模一样，但此时必须在每个容器中都存放一份网页文件，如果他们能共享一份数据，就不必每当网页更新都需要对两个容器分别部署

3. 具体操作

   #方案一：启动容器时，通过设置-v，将Docker所在宿主机上内容挂载到容器中，-v就是volume缩写
   #1. 将Docker所在宿主机上的/usr/webapps，挂载到容器内部的/usr/local/tomcat/webapps上
   #2. 这种方式书写麻烦，每创建一个新容器，都需要写一遍，如果挂载路径需要修改，每个容器都需要改一次
   docker run --name t1 -p 8000:8080 -d -v /usr/webapps:/usr/local/tomcat/webapps tomcat
   
   #方案二：先创建共享容器，然后通过--volumes-from挂载共享容器
   #1. 创建共享容器：通过create创建共享容器，只创建不启动，/bin/true没有任何含义，只是占位符
   docker create --name webpage -v /usr/webapps:/usr/local/tomcat/webapps tomcat /bin/true
   #2. 创建容器时，通过--volumes-from，指定参考的共享容器，共享容器的挂载信息，将使用到新的容器上，所以共享容器webpage的作用只是定义一个挂载点
   docker run -p 8002:8080 --volumes-from webpage --name t3 -d tomcat
   docker run -p 8003:8080 --volumes-from webpage --name t4 -d tomcat
   

4. 验证：宿主机中/usr/webapps/docker-web/index.html下内容变化，浏览器中输入http://localhost:8002/docker-web/index.html、http://localhost:8003/docker-web/index.html所返回的结果也跟着变化

18 容器编排工具：Docker Compose

1. 容器编排：在哪些宿主机上安装哪些容器、这些容器以什么方式互相通讯、以及这些容器如何被管理
2. Docker Compose：单机容器编排工具，如果需要对多台机器部署，需要使用Kubernates
3. Docker Compose需要通过yml来定义如何进行容器编排
4. WINDOWS/MAC默认提供Docker Compose，Linux需安装

18.1 Docker Compose安装

1. 官网安装文档：https://docs.docker.com/compose/install/

2. 安装流程

   #1. 下载并安装
   sudo curl -L "https://github.com/docker/compose/releases/download/1.27.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
   #2. 修改文件夹权限
   sudo chmod +x /usr/local/bin/docker-compose
   #3. 查看是否正确安装
   docker-compose --version
   

18.2 利用Docker Compose部署开源博客WordPress

1. 官网部署文档：https://docs.docker.com/compose/wordpress/

2. 创建/usr//wordpress文件夹，并在其内编写docker-compose.yml，文件名不允许自己定义

   cd /usr/
   mkdir wordpress
   cd wordpress
   vim docker-compose.yml
   

3. docker-compose.yml

   version: '3.3'
   
   services:
      db:
        image: mysql:5.7
        volumes:
          - db_data:/var/lib/mysql
        restart: always
        environment:
          MYSQL_ROOT_PASSWORD: somewordpress
          MYSQL_DATABASE: wordpress
          MYSQL_USER: wordpress
          MYSQL_PASSWORD: wordpress
   
      wordpress:
        depends_on:
          - db
        image: wordpress:latest
        ports:
          - "8000:80"
        restart: always
        environment:
          WORDPRESS_DB_HOST: db:3306
          WORDPRESS_DB_USER: wordpress
          WORDPRESS_DB_PASSWORD: wordpress
          WORDPRESS_DB_NAME: wordpress
   volumes:
       db_data: {}
   

4. 根据docker-compose.yml文件进行容器编排

   #1. up：表示对当前路径下的yml文件进行解析与执行，-d：后台执行
   #2. 注意使用docker-compose之前，docker服务必须是启动状态，service docker start
   docker-compose up -d
   #3. 执行完毕后，打印如下信息，表示创建了一个作为wordpress数据库的容器wordpress_db_1，和作为wordpress应用的容器wordpress_wordpress_1
   #Creating wordpress_db_1 ... done
   #Creating wordpress_wordpress_1 ... done
   

5. 浏览器中输入http://192.168.246.134:8000，此时就进入了wordpress安装向导，根据提示安装wordpress，然后就可以登陆了

18.3 Docker Compose应用实战

1. 将bsbdj文件夹拷贝到虚拟机内包含两个文件夹

   1. bsbdj-app
      1. bsbdj.jar：由springboot开发的jar包，通过java -jar bsbdj.jar直接可以启动一个tomcat，并对外暴露80端口
      2. application-dev.yml、application.yml：为springboot配置文件
   2. bsbdj-db
      1. init-db.sql：数据库初始化文件

2. bsbdj-app下创建Dockerfile文件

   #由于bsbdj.jar是springboot开发，所以需要java运行时环境，在hub.docker.com中，搜索java，然后选择Linux-x86-64版本，在其内的的tags中搜索8u222，得到应该选择8u222-jre版本，该镜像包含一个jdk和一个linux环境
   FROM openjdk:8u222-jre
   WORKDIR /usr/local/bsbdj
   ADD bsbdj.jar .
   ADD application.yml .
   ADD application-dev.yml .
   #由于application-dev.yml中配置的tomcat启动端口是80，所以需要将内部的80端口向外暴露
   EXPOSE 80
   CMD ["java","-jar","bsbdj.jar"]
   

3. 此时可以构建bsbdj-app的镜像，并创建容器，但该容器无法正确提供服务，因为数据尚未启动

4. bsbdj-db下创建Dockerfile文件

   #由于应用是基于mysql5.7开发，因此基准镜像应选择mysql5.7的镜像
   #https://registry.hub.docker.com/中搜索mysql
   #Description中有详细的对镜像的说明，比如如何启动mysql服务实例、如何指定mysql初始密码、mysql中数据如何初始化，Tags中有镜像的具体信息，其内搜索5.7，找到对应镜像为mysql:5.7
   FROM mysql:5.7
   #mysql:5.7镜像创建的容器，启动后会自动加载/docker-entrypoint-initdb.d目录下的文件，对数据库进行初始化，因此将数据库初始化脚本放入其中
   WORKDIR /docker-entrypoint-initdb.d
   ADD init-db.sql .
   

5. 此时可以构建bsbdj-db的镜像，并创建容器，测试该Dockerfile创建出的镜像是否正确

   #1. 创建镜像
   docker build -t mashibing.com/bsbdj-db .
   #2. 启动容器
   #-e表示设置环境变量，mysql的镜像创建容器时，会使用MYSQL_ROOT_PASSWORD环境变量，来作为root的初始密码，并加载/docker-entrypoint-initdb.d内文件对数据库进行初始化
   docker run -d -e MYSQL_ROOT_PASSWORD=root mashibing.com/bsbdj-db
   #3. 进入容器内部后执行
   #a. 连接数据库
   mysql -uroot -proot
   #b. 切换到bsbdj用户
   use bsbdj
   #c. 查看表中数据是否存在，数据存在说明容器创建没问题
   select * from t_user;
   

6. bsbdj下创建docker-compose.yml文件

   #1. docker-compose采用其3.3版本的配置规则
   version: '3.3'
   #2. docker compose会自动根据配置文件中内容创建镜像，启动容器
   #a. Dockerfile：用于描述如何构建镜像
   #b. docker-compose.yml：文件用于描述整体需要做哪些，比如先构建镜像，再启动容器
   #3. services：描述要部署的容器有哪些
   services:
     #4. 注意，db和app谁应该先启动，谁就放在上面
     #5. 设置容器别名为db，与之前--name作用相同，该名也指代容器内的linux系统主机名
     db:
     	#6. 指定Dockerfile所在路径
       build: ./bsbdj-db/
       #7. 容错机制，如果容器异常停止，Docker会自动将其重启
       restart: always
       #8. 设置环境变量，与之前的-e作用相同
       environment:
         #初始化mysql的密码
         MYSQL_ROOT_PASSWORD: root
     app:
       build: ./bsbdj-app/
       #表示app容器底层依赖db容器，docker就会为这两个容器设置网桥，他们间就能互相通讯了
       depends_on:
         - db
       #表示内部暴露80，并映射到宿主机上的80端口，yaml中双引号单引号都可以
       ports:
         - "80:80"
       restart: always
   

7. 根据docker-compose.yml文件进行容器编排

   #1. bsbdj文件夹下执行
   #2. 前台执行
   docker-compose up
   #3. 后台执行
   docker-compose up -d
   #4. 查看容器名，分别为bsbdj_app_1和bsbdj_db_1
   docker ps
   

8. 如果为后台执行，可以通过docker-compose logs <容器别名>查看日志，发现应用仍然无法连接数据库，因为数据库连接的url的地址还是使用的ip地址而没使用容器名，对其进行修改后重启

9. 将当前文件夹下，docker-compose.yml文件中涉及到的所有容器进行关闭：docker-compose down，并重新构建docker-compose up -d

10. 浏览器中输入：<192.168.246.134:80>发现已可以正确提供服务