Docker Compose


# Docker Compose

## 1、简介   

Docker Compose来轻松高效的管理容器，定义运行多个容器。  
Compose是Docker官方的开源项目,需要安装  
DockerFile让程序在任何地方运行。web服务、redis、mysql多个容器。  
如果一个一个启动就需要run3个，而Compose只需要编写一个yml文件就可以启动多个。  

```
version: "3.9"  # optional since v1.27.0
services:
  web:
    build: .
    ports:
      - "8000:5000"
    volumes:
      - .:/code
      - logvolume01:/var/log
    links:
      - redis
  redis:
    image: redis
volumes:
  logvolume01: {}
```

docker-compose up 100个服务。  

**Compose**：重要的概念。  

- 服务services, 容器。应用。（web、redis、mysql.…)
- 项目project。一组关联的容器。博客。web

## 2、安装方式1(通过curl)

```
#下载地址
curl -L https://get.daocloud.io/docker/compose/releases/download/v2.5.0/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
#赋权
sudo chmod +x /usr/local/bin/docker-compose
#验证
docker-compose version
```

## 3、安装方式2(推荐:手动安装)

- [docker-compose官网](https://github.com/docker/compose)下载匹配版本

- 下载docker-compose-linux-x86_64并上传linux

- 执行如下命令

  ```
  mv docker-compose-linux-x86_64 /usr/local/bin/docker-compose
  chmod +x docker-compose
  ```
- 验证docker-compose *--version*

## 4、测试示例

> 官网教程
>
> > 地址:https://docs.docker.com/compose/gettingstarted/
> > Docker Compose --> Getting started

### 1）为项目创建一个目录：

```
mkdir composetest
cd composetest
```

### 2）在项目目录中创建一个名为的文件app.py并将其粘贴到：

```
import time

import redis
from flask import Flask

app = Flask(__name__)
cache = redis.Redis(host='redis', port=6379)

def get_hit_count():
    retries = 5
    while True:
        try:
            return cache.incr('hits')
        except redis.exceptions.ConnectionError as exc:
            if retries == 0:
                raise exc
            retries -= 1
            time.sleep(0.5)

@app.route('/')
def hello():
    count = get_hit_count()
    return 'Hello World! I have been seen {} times.\n'.format(count)
```

### 3）在您的项目目录中创建另一个名为的文件requirements.txt并将其粘贴到:

```
flask
redis
```

### 4）创建 Dockerfile

```
# syntax=docker/dockerfile:1
FROM python:3.7-alpine
WORKDIR /code
ENV FLASK_APP=app.py
ENV FLASK_RUN_HOST=0.0.0.0
RUN apk add --no-cache gcc musl-dev linux-headers
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
EXPOSE 5000
COPY . .
CMD ["flask", "run"]
```

这告诉 Docker：

- 从 Python 3.7 映像开始构建映像。
- 将工作目录设置为/code.
- 设置命令使用的环境变量flask。
- 安装 gcc 和其他依赖项
- 复制requirements.txt并安装 Python 依赖项。
- 向镜像添加元数据以描述容器正在侦听端口 5000
- 将项目中的当前目录复制.到镜像中的workdir .。
- 将容器的默认命令设置为flask run.

### 5）在 Compose 文件中定义服务  

这个 Compose 文件定义了两个服务：web和redis.

```
version: "3.9"
services:
  web:
    build: .
    ports:
      - "8000:5000"
  redis:
    image: "redis:alpine"
```

### 6）使用 Compose 构建并运行您的应用程序


```
docker-compose up
```

### 7）测试

```
http://localhost:8000
```

默认的服务名 文件名_服务名_num    
多个服务器。集群。AB_num副本数量    
服务redis服务=>4个副本。  
集群状态。服务都不可能只有一个运行实例。弹性、10HA高井发。    
kubectl service负载均衡。   

### 8）停止

```
#在/usr/local/bin/docker-compose目录下执行
docker-compose down
#暴力停止
ctrl+c
```

**docker-compose小结** 
以前都是单个docker run启动容器。  
docker-compose。通过 docker-compose   编写yaml配置文件、可以通过compose一键启动所有服务，停止。！

Docker Compose

Docker网络

### Docker网络

#### 理解Docker网络

```
# 创建tomacat容器 启动 并执行 ip addr
docker run --name tomcat01 -p 8080:8080 tomcat
docker exec -it tomcat01 ip addr 
# 查询宿主机 docker网络 与tomcat容器网络ping
```

 **原理**  
1、我们每启动一个docker容器，docker就会给docker容器分配一个ip，我们只要安装了docker，就会有一介网卡dockero桥接模式，使用的技术是==veth-pair==技术！

2、veth-pair

```
#我们发现这个容器带来网卡，都是一对的
#evth-pair就是一对的虚拟设备接口，他们都是成对出现的，一段连着协议，一段彼此相连
#、正因为有这个特性，evth-pair充当一个桥梁，连接各种虚拟网络设备的
#openstac,Docker容器之间的连接，ovs的连接，都是使用 veth-pair技术
```

3、容器之间测试

![pasted-8.png](/static/img/844a2184e1cad6a3a0fb3d24de4aaaef.pasted-8.webp)

结论: tomcat01、tomcat02是共用一个路由器
所有容器不指定网络的情况下,都是docker0路由分配一个默认可用的ip

核心网络原理图  

![pasted-7.png](/static/img/e41dbb0007c1ce82f897d09a0f00975d.pasted-7.webp)

Docker中的所有网络接口都是虚拟的，虚拟的转发效率高!(内网传递文件!)  
只要容器删除，对应网络桥接一对就消失了!

#### --Link

思考一个场景，我们编写了一个微服务，database url=ip：，项目不重启，数据库ip换掉了，我们希望可以处理这个问题，可以名字来进行访问容器

```
# 启动2个tomcat 01 02
# 通过容器名尝试ping
[root@MiWiFi-RA81-srv ~]# docker exec -it tomcat02 ping tomcat01
ping: tomcat01: No address associated with hostname

# 如何解决呢?
## --link可以解决(注:单向的)
[root@MiWiFi-RA81-srv ~]# docker run -d --name tomcat03 --link tomcat02 mytomcat:1.0
80475d4b31170527c2e4a88c8c53ca9b43ee0657e3e9a65814c4e669f38cfb16
[root@MiWiFi-RA81-srv ~]# docker exec -it tomcat03 ping tomcat02
PING tomcat02 (172.17.0.5) 56(84) bytes of data.
64 bytes from tomcat02 (172.17.0.5): icmp_seq=1 ttl=64 time=0.073 ms
64 bytes from tomcat02 (172.17.0.5): icmp_seq=2 ttl=64 time=0.059 ms
64 bytes from tomcat02 (172.17.0.5): icmp_seq=3 ttl=64 time=0.045 ms
## 原理
### 查看docker网络
docker network ls
docker network inspect id
### 查看容器绑定link(找link)
### --link就是在hosts假如了映射 
1、docker inspect 容器id
2、docker inspect 97ec4ba0656d|grep tomcat02 -n
3、进入容器查看 /etc/hosts
172.17.0.5	tomcat02 fd273a7550ee
```

我们现在玩Doker不建议使用--link  
现在使用自定义网络!  
docker0不支持容器名连接访问!  

#### 自定义网络

查看所有的dcoker网络

```
docker network ls
```

**网络模式**

- bridge:桥接 docker(默认，自己创建也使用bridge模式）
- none:不配置网络
- host:和宿主机共享网络
- container:容器网络连通！（用的少！局限很大）

**测试**

```
# 直接启动run 默认就是带--net bridge
docker run -d -P --name tomcat01 tomcat
docker run -d -P --name tomcat01 --net bridge tomcat

# 创建网络
## --driver bridge   #指定bridge驱动程序来管理网络
## --subnet 192.168.0.0/16 #指定网段的CIDR格式的子网
## --gateway 192.168.0.1 	#指定主子网的IPv4或IPv6网关
docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mybridge
# 查看网络
docker network ls
docker network inspect 网络id
# 启动2个容器 指定创建的网络
docker run -d -P --name tomcat-net01 --net mynet mytomcat:1.0
docker run -d -P --name tomcat-net02 --net mynet mytomcat:1.0
# 测试2个容器网络
docker network inspect 网络id
docker exec -it tomcat-net01 ping 192.168.0.3
docker exec -it tomcat-net01 ping tomcat-net02
```

可以发现，在我们的自定义网络下，容器之间既可以通过容器名也可以通过ip地址进行网络通信。 我们自定义的网络默认已经帮我们维护了容器间的网络通信问题，这是实现网络互联的推荐方式。

**好处**:
redis:不同的集群使用不同的网络,保证集群是安全和健康的
mysql:不同的集群使用不同的网络,保证集群是安全和健康的

#### 网络连通

把不同的网络打通(自定义网络与默认网络打通)

```
# 测试打通
docker network connect mybridge tomcat03
# 连通之后就是讲tomcat03放到mybridge网络下
# 一个容器两个ip地址(阿里云公网ip私网ip)
docker network inspect 5bd453665e69
# 测试
[root@MiWiFi-RA81-srv ~]# docker exec -it tomcat-net01 ping tomcat03
PING tomcat03 (192.168.0.4) 56(84) bytes of data.
64 bytes from tomcat03.mynet (192.168.0.4): icmp_seq=1 ttl=64 time=0.259 ms
64 bytes from tomcat03.mynet (192.168.0.4): icmp_seq=2 ttl=64 time=0.075 ms
```

结论:假设要跨网络操作别人,就需要使用docker network connect连通!

#### 实战:部署Redis集群

三主三从的Redis集群

```
# 创建redis网络
docker network create redis --subnet 172.38.0.0/16
# 通过shell脚本创建6个redis配置文件信息
for port in $(seq 1 6); \
do \
mkdir -p /mydata/redis/node-${port}/conf
touch /mydata/redis/node-${port}/conf/redis.conf
cat << EOF >/mydata/redis/node-${port}/conf/redis.conf
port 6379 
bind 0.0.0.0
cluster-enabled yes 
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 172.38.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done
# 通过shell脚本创建并运行6级redis
for port in $(seq 1 6); \
do
docker run -p 637${port}:6379 -p 1637${port}:16379 --name redis-${port} \
-v /mydata/redis/node-${port}/data:/data \
-v /mydata/redis/node-${port}/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.1${port} redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf; \
done
# 进入redis01创建集群
docker exec -it redis01 /bin/sh
redis-cli --cluster create 172.38.0.11:6379 172.38.0.12:6379 172.38.0.13:6379 172.38.0.14:6379 172.38.0.15:6379 172.38.0.16:6379 --cluster-replicas 1
# 查看集群信息
redis-cli -c
cluster info
cluster nodes # 集群节点信息
```

#### 实战:SpringBoot项目打包镜像

```
# 构建SpringBoot项目
# 打包jar
# 编写dockerFile
FROM java:8
COPY *.jar /app.jar
CMD ["--server.port=8080"]
EXPOSE 8080
ENTRYPOINT ["java","-jar","/app.jar"]
# 上传到服务器(jar、dockeFile)
# 构建镜像
docker build -t demo .
# 发布运行
docker run
```

Docker网络

DockerFile介绍

### DockerFile

#### DockerFile介绍

dockerfile是用来构建dokcer镜像的文件！命令参数脚本！
构建步骤：

1. 编写一个dockerfile 文件
2. docker build 构建成为一个镜像
3. docker run运行镜像
4. docker push 发布镜像(DockerHub、阿里云镜像仓库!)  

查看一下官方是怎么做的？

![pasted-9.png](/static/img/1ac4ab75aefcc0f2b54227fcb25bda12.pasted-9.webp)

#### DockerFile构建过程

**基础知识**：  

1. 每个保留关键字（指令）都是必须是大写字母
2. 执行从上到下顺序执行
3. #表示注释
4. 每一个指令都会创建提交一个新的镜像层，并提交！ 

![pasted-4.png](/static/img/b372d6093143f38b54fe2cbc8154970e.pasted-4.webp)

dockerfile是面向开发的，我们以后要发布项目，做镜像，就需要编写dockerfile文件，这个文件十分简单！  
Docker镜像逐渐成为企业交付的标准，必须要掌握！  
步骤：开发，部署，运维。。。缺一不可！  
DockerFile：构建文件，定义了一切的步骤，源代码  
Dockerlmages：通过 DockerFile 构建生成的镜像，最终发布和运行的产品！  
Docker容器：容器就是镜像运行起来提供服务器  

#### DockerFile构建指令  

以前的话我们就是使用别人的，现在我们知道了这些指令后，我们来练习自己写一个镜像！

```
FROM            #基础镜镜像，一切从这里开始构建
MAINTAINER      #镜像是谁写的，姓名+邮箱
RUN             #镜像构建的时候需要运行的命令
ADD             #步骤：tomcat镜像，这个tomcat压缩包！添加内容
WORKDIR         #镜像的工作目录
VOLUME          #挂载的目录
EXPOSE          #保留端口配置
CMD             #指定这个容器启动的时侯要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT      #指定这个容器启动的时候要运行的命令，可以追加命令
ONBUILD         #当构建一个被继承 DockerFile这个时候就会运行 ONBUILD 的指令。触发指令。
COPY            #类似ADD，将我们文件拷贝到镜像中
ENV             #构建的时候设置环境变量！
```

![pasted-5.png](/static/img/4759fa539d11645e23122233f3d35bad.pasted-5.webp)

#### 实战测试(制作centos:7镜像)

**制作centos:7镜像**

```
#begin 创建dockerFile文件
FROM centos:7
MAINTAINER chenshaohua<1050449218@qq.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN yum -y install vim
RUN yum -y install net-tools

EXPOSE 80 

CMD /bin/bash
#end 
#构造新的镜像
docker build -f dockerFile-centos -t mycentos:0.1 .
#测试
docker run -it mycentos:0.1
ls ll ifconfig
```

**查看镜像历史记录,看官方怎么构建**

```
docker history 镜像id
```

**RUN命令与CMD命令的区别在哪里？**
简单说，RUN命令在 image 文件的构建阶段执行，执行结果都会打包进入 image 文件；CMD命令则是在容器启动后执行。另外，一个 Dockerfile 可以包含多个RUN命令，但是只能有一个CMD命令。

注意，指定了CMD命令以后，docker container run命令就不能附加命令了（比如前面的/bin/bash），否则它会覆盖CMD命令。  
CMD和ENTRYPOINT的区别在哪里？  

1. CMD ：指定容器启动的时候要运行的命令，只有最后一个会生效
2. ENTRYPOINT ：指定容器启动的时候要运行的命令,命令可以追加

#### 实战测试(制作Tomcat镜像)

1、准备镜像文件apache-tomcat-8.5.78.tar.gz、jdk-8u261-linux-x64.tar.gz压缩包

2、编写dockerFile文件

**文件名起 Dockerfile build不用加 -f 指定 官网默认找这个文件**
```
FROM centos:7
MAINTAINER chenshaohua<1050449218@qq.com>

COPY readme.txt /usr/local/readme.txt
#自动解压
ADD jdk-8u261-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-8.5.78.tar.gz /usr/local/

RUN yum -y install vim
#工作目录
ENV MYPATH /usr/local
WORKDIR $MYPATH
#配置java环境变量
ENV JAVA_HOME /usr/local/jdk1.8.0_261
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
#配置tomcat环境变量
ENV CATALINA_HOME /usr/local/apache-tomcat-8.5.78
ENV CATALINA_BASH /usr/local/apache-tomcat-8.5.78
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
#暴露端口
EXPOSE 8080
#执行命令
CMD /usr/local/apache-tomcat-8.5.78/bin/startup.sh && tail -F /usr/local/apache-tomcat-8.5.78/bin/logs/catalina.out
```

3、构建镜像

```
[root@MiWiFi-RA81-srv home]# docker build -t diytomcat .
```

4、启动镜像

```
docker run -d -p 9090:8080 --name diytomcat -v /home/dockerfile/tomcat/test:/usr/local/apache-tomcat-8.5.78/webapps/test -v /home/dockerfile/tomcat/logs/:/usr/local/apache-tomcat-8.5.78/logs diytomcat
```

5、访问测试

```
http://192.168.1.126:9090/
```

6、发布项目  
这里设置了数据卷，宿主机的/home/dockerfile/tomcat/test对应该容器的/usr/local/apache-tomcat-8.5.55/webapps/test。这样关于test项目的修复只需要在宿主机上修改就可以了，不需要进入到容器中修改。

```
#在/home/dockerfile/tomcat/test的目录下，新建index.html
<!DOCTYPE html>
<html>
    <head>
         <meta charset="UTF-8"/>
        <title>这是个标题</title>
    </head>
    <body>
        <h1>这是一个一个简单的HTML</h1>
        <p>Hello World！</p>
    </body>
</html>
#测试
http://192.168.1.126:9090/test/
##如果页面显示乱码，就需要修改tomcat的server.xml文件
<Connector port="8080" protocol="HTTP/1.1" 
               connectionTimeout="20000" 
               redirectPort="8443" URIEncoding="UTF-8" />
```

#### 发布镜像到阿里云

1. 登录阿里云，找到容器镜像服务
2. 创建命名空间
3. 创建镜像空间(选择本地服务)
4. 创建镜像空间阿里云有操作指南

#### 小结


![""](/images/pasted-6.png)

###

DockerFile

Docker容器数据卷详解

### 容器数据卷详解

#### 什么是容器数据卷

Docker将运用与运行的环境打包形成容器运行， Docker容器产生的数据，如果不通过docker commit生成新的镜像，使得数据做为镜像的一部分保存下来， 那么当容器删除后，数据自然也就没有了。 为了能保存数据在Docker中我们使用卷。|

卷就是目录或文件，存在于一个或多个容器中，由Docker挂载到容器，但卷不属于联合文件系统（Union FileSystem），因此能够绕过联合文件系统提供一些用于持续存储或共享数据的特性:。

卷的设计目的就是数据的持久化，完全独立于容器的生存周期，因此Docker不会在容器删除时删除其挂载的数据卷。

#### docker的理念回顾

- 将应用和环境打包成一个镜像！  
- 数据？如果数据都在容器中，那么我们容器删除，数据就会丢失！==需求：数据可以持久化==    
- MySQL，容器删了，删库跑路！==需求：MySQL数据可以存储在本地！==  
- 容器之间可以有一个数据共享的技术！Docker容器中产生的数据，同步到本地!  
- 这就是卷技术！目录的挂载，将我们容器内的目录，挂载到Linux上面！  

==总结:容器和主机共享目录。==

**数据卷的特点**:  

1. 数据卷可在容器之间共享或重用数据  
2. 卷中的更改可以直接生效  
3. 数据卷中的更改不会包含在镜像的更新中  
4. 数据卷的生命周期一直持续到没有容器使用它为止  

#### 使用数据卷

```
#运行时配置命令 -v
docker run -it -v 主机目录:容器目录 容器id /bin/bash
#验证
docker inspect 容器id
mounts写的挂在信息
```

#### 具名和匿名挂载

##### 具名挂载

就是指定文件夹名称，区别于指定路径挂载，这里的指定文件夹名称是在Docker指定的默认数据卷路径下的。通过docker volume ls命令可以查看当前数据卷的目录情况  

**查看指定的数据卷信息的命令**：docker volume inspect 数据卷名称

##### 匿名挂载

匿名挂载就是在指定数据卷的时候，不指定容器路径对应的主机路径，这样对应映射的主机路径就是默认的路径/var/lib/docker/volumes/中自动生成一个随机命名的文件夹。

##### 区别

所有的docker容器内的卷，没有指定目录的情况下都是在 ==/var/lib/docker/volumes/xxxx/_data==  
我们通过具名挂载可以方便的找到我们的一个卷，大多数情况在使用的
==具名挂载==

```
# 如何确定是具名挂载还是匿名挂载，还是指定路径挂载！
-v	容器内路径			#匿名挂载
-v	卷名：容器内路径	  #具名挂载
-v	/宿主机路径:容器内路径 #指定路径挂载！
```

**拓展**：

```
# 通过-v客器内路径：ro rw改变读写权限
ro readonly  # 只读
rw readwrite # 可读可写
# 一旦这个了设置了容器权限，容器对我们挂载出来的内容就有限定了！
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:ro nginx
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:rw nginx
# ro只要看到ro就说明这个路径只能通过宿主机来操作，容器内部是无法操作！
```

####

Docker容器数据卷详解

Docker镜像详解

### Docker镜像详解

#### 什么是镜像

镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需要的所有内容，包括代码，运行时（一个程序在运行或者在被执行的依赖）、库，环境变量和配置文件。

#### Docker镜像加载原理

Docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统是UnionFS联合文件系统。
**UnionFS（联合文件系统）**：Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtualfilesystem）。Union文件系统是Docker镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。
**特性**：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录

bootfs(boot file system)主要包含bootloader和kernel,bootloader主要是引导加载kernel,Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是bootfs。这一层与我们典型的Linux/Unix系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。

rootfs(root file system),在bootfs之上。包含的就是典型Linux系统中的/dev,/proc,/bin,/etc等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如Ubuntu，Centos等等。

**我的理解**:假如说安装linux7、linux7，第一次安装linux7,第二次安装linux8，第一次安装需要linux7的一些配置文件,直接在7里面拿而不需要下载了

#### 分层理解

**思考**：为什么Docker镜像要采用这种分层的结构呢？
最大的好处，我觉得莫过于是资源共享了！比如有多个镜像都从相同的Base镜像构建而来，那么宿主机只需在磁盘上保留一份base镜像，同时内存中也只需要加载一份base镜像，这样就可以为所有的容器服务了，而且镜像的每一层都可以被共享。 查看镜像分层的方式可以通过 docker image inspect 命令！

所有的Docker镜像都起始于一个基础镜像层，当进行修改或增加新的内容时，就会在当前镜像层之上，创建新的镜像层。
举一个简单的例子，假如基于Ubuntu Linux 16.04创建一个新的镜像，这就是新镜像的第一层；如果在该镜像中添加Python包，就会在基础镜像层之上创建第二个镜像层；如果继续添加一个安全补丁，就会创建第三个镜像层。
该镜像当前已经包含3个镜像层，如下图所示（这只是一个用于演示的很简单的例子）。

**特点**
Docker镜像都是只读的，当容器启动时，一个新的可写层被加载到镜像的顶部！
这一层就是我们通常说的容器层，容器之下的都叫镜像层！

#### 提交镜像

```
使用docker commit 命令提交容器成为一个新的版本

docker commit -a="作者" -m="提交的描述信息" 容器id 目标镜像名:[TAG]
```

###