Docker进阶实战

文章目录

前言
一、容器数据卷
- 1.数据卷介绍
- 2.数据卷使用
- - 2.1 数据卷的常用命令
- 3.MySql在Docker中的持久化问题
- 4. 匿名和具名挂载
- - 4.1 匿名挂载
  - 4.2 具名挂载
  - 4.3 挂载信息查看与权限写入
二、DockerFile
- 1. 概述
- 2. 构建过程
- - 2.1 基础知识
- 2.2 DockerFile 指令
- 3. 实战
- - 3.1 构建centos 镜像
  - 3.2 构建tomcat 镜像
三、DockerNet
- 1. 认识网络模式
- 2. 默认网络
- - 2.1 Host
  - 2.2 Container
  - 2.3 None
  - 2.4 Bridge
- 3. Docker：网络模式详解
- - 3.1 Bridge模式的拓扑
  - 3.2 Docker：网络模式详解
  - 3.3 容器联通
- 4. 自定义网络
- - 4.1 查看默认的网桥信息
  - 4.2 自定义网络
  - 4.3 自定义网络的好处
- 5.网络连通
- 6. Redis集群部署实战
- 7. SpringBoot微服务打包发布
四、Docker Compose
- 1. Compose 简介
- 2. Compose 安装
- 3. 使用
- - 3.1 准备
  - 3.2 创建 Dockerfile 文件
  - 3.3 创建 docker-compose.yml
- 4 .使用 Compose 部署前后分离项目实战
- - 4.1 打包前后端项目
  - 4.2 编写DockerFile
  - 4.3 编写docker-compose.yaml
  - 4.4 启动部署
五、Docker Machine
六、Docker Swarm
总结

前言

Dokcer 进阶

如果还没想清楚，就用蛮力算法。——Ken Thompson

一、容器数据卷 1.数据卷介绍

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

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

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

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

容器之间的数据共享技术，Dokcer容器中产生的数据，同步到本地。核心就是目录的挂载，讲容器内部的目录，挂载到Linux上面
小结：容器的持久化和同步操作！容器也是可以数据共享的！

2.数据卷使用

直接使用命令方式来挂载 -v
# docker run -it -v 主机目录/容器目录  
测试
# docker run -it -v /home/test:/home cnetos /bin/bash
启动之后查看容器详细信息
#  docker inspect <容器id> 
> Mounts 			挂载信息
> Type				类型
> Source			主机内地址
> Destination		docker容器内地址

双向绑定数据。数据互通。在本地主机修改即可，无需进入docker容器中。

2.1 数据卷的常用命令

1.创建数据卷
# docker volume create <卷名称>
2.查看所有数据集
# docker volume ls
3.查看指定的数据卷信息
# docker volume inspect <卷名称>
{
"Driver": "local",
"Labels": {},
"Mountpoint": "/var/lib/docker/volumes/my-vol/_data",
"Name": "my-vol",
"Options": {},
"Scope": "local"
}
4.删除数据卷
# docker volume rm <卷名称>
5.删除容器的时候删除与之相关的数据卷
# docker rm -v ...
> 数据卷是被设计用来持久化数据的，它的生命周期独立于容器，Docker 不会在容器被删除后自动删除数据卷。
> 并且也不存在垃圾回收这样的机制来处理没有任何容器引用的数据卷 。如果需要在删除容器的同时移除数据卷。
> 可以在删除容器的时候使用 docker rm -v 这个命令。
6.无主的数据卷可能会占据很多空间，要清理请使用以下命令
# docker volume prune

使用 --mount创建数据卷挂载一个主机目录作为数据卷
使用 --mount 标记可以指定挂载一个本地主机的目录到容器中去。

$ docker run -d -P 
--name web 
# -v /src/webapp:/opt/webapp 
--mount type=bind,source=/src/webapp,target=/opt/webapp 
training/webapp 
python app.py

上面的命令挂载主机的/src/webapp目录到容器的/opt/webapp目录。用户可以放置一些程序到本地目录中，来查看容器是否正常工作。本地目录的路径必须是绝对路径，如果目录不存在 Docker 会自动为你创建它。

Docker 挂载主机目录的默认权限是读写，用户也可以通过添加readonly 参数指定为只读。

$ docker run -d -P 
--name web 
# -v /src/webapp:/opt/webapp:ro 
--mount type=bind,source=/src/webapp,target=/opt/webapp,readonly 
training/webapp 
python app.py
加了readonly之后，就挂载为只读了。如果你在容器内/src/webapp目录新建文件，会显示如下错误
/src/webapp # touch new.txt
touch: new.txt: Read-only file system

3.MySql在Docker中的持久化问题

实例
安装MySql,MySql的数据持久化问题

1.获取镜像
# docker pull mysql
2.运行容器，需要挂载数据到本地，需要配置密码
官方命令
# docker run --name some-mysql -e MYSQL_ROOT_PASWORD=my-secret -d mysql:tag
自定义命令
# docker run -d -p 3344:3306 -v/home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7
> -d 后台运行
> -p 端口映射
> -v 数据卷
> -e 配置环境参数
> --name 容器名字
启动成功之后，使用本地数据库连接工具，进行测试
服务器3344端口映射到容器内的3306端口，进行连接 
利用卷的挂载，实现数据持久化

4. 匿名和具名挂载

我们使用Docker与宿主机做关联时，常常是要进行挂载数据和配置文件的，那么Dokcer中就提供了两种挂载方式，分别是具名挂载与匿名挂载。顾名思义，具名就是有具体名称的挂载方式，而匿名就是没有名字，或者说没有指定名字，而被系统随机分配名字的方式。
挂载命令
匿名挂载，具名挂载，指定路径挂载的命令区别如下：
-v 容器内路径 #匿名挂载
-v 卷名:容器内路径 #具名挂载
-v /宿主机路径:容器内路径 #指定路径挂载

4.1 匿名挂载

如下运行并匿名挂载Nginx容器：

匿名挂载命令格式
# docker run -d -P --name nginx01 -v /etc/nginx nginx

查看所有的数据卷volume的情况, VOLUME NAME这里的值是真实存在的目录。

# docker volume ls
DRIVER    VOLUME NAME
local     198f39c04b7705350088ad8f9ab6072068da3547db375f99bb305cbf92abdb9f
local     10913c9dbecc738bf7ce2614bca085d23d8ea57998051e1967ab865476d7a845
local     ba800c642e0e295b2a275e0d3809ddc6bd2d1f11565b4741dfea506fd6e0e4f6
local     fc1eccb2b19c84dd769c572a0389658fefc3248b19b9bbe3573c3cd299fa28a0

这种随机名称的挂载即为匿名挂载

4.2 具名挂载

如下运行并具名挂载Nginx容器：

具名挂载
# docker run -d -P --name nginx02 -v <具体名称>:/etc/nginx nginx
# docker volume ls

DRIVER    VOLUME NAME
local     0cd45ab893fc13971219ac5127f9c0b02491635d76d94183b0261953bdb52d26
local     668a94251e562612880a2fdb03944d67d1acdbbdae6ef7c94bee8685644f2956
local     e605f3dc4bf11ab693972592b55fb6911e5bf2083425fd58869c5f574998a09a
local     juming-nginx

4.3 挂载信息查看与权限写入

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

查看挂载信息
# docker volume inspect <卷名称>
[
    {
        "CreatedAt": "2022-05-14T21:45:11+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/liusiqi/_data",
        "Name": "nginx",
        "Options": null,
        "Scope": "local"
    }
]
> 可以看到Mountpoint参数即为挂载路径 url：/var/lib/docker/volumes/liusiqi/_data
> Docker所有的数据卷默认在/var/lib/docker/volumes/ 目录下

权限写入

指定数据卷映射的相关参数：
ro —— readonly 只读。设置了只读则只能操作宿主机的路径，不能操作容器中的对应路径。
rw ----- readwrite 可读可写

1.只读具名
# docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:ro nginx
2.读写具名
# docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:rw nginx

二、DockerFile 1. 概述

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

编写dockerfile 文件
docker build 构建成为一个镜像
docker run 运行镜像
docker push 发布镜像（dokcerHub ，阿里云镜像仓库）

例子:centos7的官方构筑

FROM centos:7
ENV container docker
RUN (cd /lib/systemd/system/sysinit.target.wants/; for i in *; do [ $i == 
systemd-tmpfiles-setup.service ] || rm -f $i; done); 
rm -f /lib/systemd/system/multi-user.target.wants/*;
rm -f /etc/systemd/system/*.wants/*;
rm -f /lib/systemd/system/local-fs.target.wants/*; 
rm -f /lib/systemd/system/sockets.target.wants/*udev*; 
rm -f /lib/systemd/system/sockets.target.wants/*initctl*; 
rm -f /lib/systemd/system/basic.target.wants/*;
rm -f /lib/systemd/system/anaconda.target.wants/*;
VOLUME [ "/sys/fs/cgroup" ]
CMD ["/usr/sbin/init"]

关系图

解析过程图

2. 构建过程 2.1 基础知识

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

dockerfile面向开发的，发布项目，作镜像就需要编写dockerfile文件。

DockerFile：构建文件，定义步骤，类似源代码
DockerImages: 通过 DockerFile 构建生成镜像，最终发布和运行产品
Docker容器：容器就是镜像进行运行来提供服务的

2.2 DockerFile 指令

指令	说明
FROM	指定基础镜像
MAINTAINER	镜像是谁写的，姓名+邮箱
RUN	镜像构建的时候需要运行的命令
ADD	将本地文件添加到容器中，tar类型文件会自动解压(网络压缩资源不会被解压)，可以访问网络资源，类似wget
WORKDIR	镜像的工作目录
VOLUME	挂载的目录
EXPOSE	保留端口配置
CMD	指定这个容器启动的时候要运行的命令（只有最后一个会生效）
EMTRYPOINT	指定这个容器启动的时候要运行的命令，可以追加命令
ONBUILD	当构建一个被继承DockerFile，这个时候就会运行ONBUILD的指令，触发指令
COPY	功能类似ADD，但是是不会自动解压文件，也不能访问网络资源
ENV	构建的时候设置环境变量

CMD 和 ENTRYPOINT 区别

CMD ：指定这个容器启动的时候要运行的命令，职业最后一个会生效，可被替代
ENTRYPOINT：指定这个容器启动的时候要运行的命令，可以追加命令

3. 实战 3.1 构建centos 镜像

编写dockerfile
自定义一个带有vim 和net-tools 的centos并进行发布

FROM centos:7
MAINTAINER 姓名<邮箱>

ENV MYPATH /usr/local
WORKDIR $MYPATH

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

EXPOSE 80

CMD echo $MYPATH
CMD echo "-----end----"
CMD /bin/bash

进行镜像build

build自定义的镜像，注意build语句最后有一个.n 
# docker build -f dockerfile文件名 -t 镜像名称 .

查看镜像的编译历史

查看编译历史
# dokcer history 镜像id

例：
nginx 编译历史

IMAGE          CREATED      CREATED BY                                      SIZE      COMMENT
7425d3a7c478   4 days ago   /bin/sh -c #(nop)  CMD ["nginx" "-g" "daemon…   0B        
      4 days ago   /bin/sh -c #(nop)  STOPSIGNAL SIGQUIT           0B        
      4 days ago   /bin/sh -c #(nop)  EXPOSE 80                    0B        
      4 days ago   /bin/sh -c #(nop)  ENTRYPOINT ["/docker-entr…   0B        
      4 days ago   /bin/sh -c #(nop) COPY file:09a214a3e07c919a…   4.61kB    
      4 days ago   /bin/sh -c #(nop) COPY file:0fd5fca330dcd6a7…   1.04kB    
      4 days ago   /bin/sh -c #(nop) COPY file:0b866ff3fc1ef5b0…   1.96kB    
      4 days ago   /bin/sh -c #(nop) COPY file:65504f71f5855ca0…   1.2kB     
      4 days ago   /bin/sh -c set -x     && addgroup --system -…   61.1MB    
      4 days ago   /bin/sh -c #(nop)  ENV PKG_RELEASE=1~bullseye   0B        
      4 days ago   /bin/sh -c #(nop)  ENV NJS_VERSION=0.7.2        0B        
      4 days ago   /bin/sh -c #(nop)  ENV NGINX_VERSION=1.21.6     0B        
      4 days ago   /bin/sh -c #(nop)  LABEL maintainer=NGINX Do…   0B        
      4 days ago   /bin/sh -c #(nop)  CMD ["bash"]                 0B        
      4 days ago   /bin/sh -c #(nop) ADD file:4a0bb88956083aa56…   80.4MB

tomcat 编译历史

IMAGE          CREATED      CREATED BY                                      SIZE      COMMENT
6a1271dfce51   3 days ago   /bin/sh -c #(nop)  CMD ["catalina.sh" "run"]    0B        
      3 days ago   /bin/sh -c #(nop)  EXPOSE 8080                  0B        
      3 days ago   /bin/sh -c set -eux;  nativeLines="$(catalin…   0B        
      3 days ago   /bin/sh -c set -eux;   savedAptMark="$(apt-m…   20.2MB    
      3 days ago   /bin/sh -c #(nop)  ENV TOMCAT_SHA512=53bfdba…   0B        
      3 days ago   /bin/sh -c #(nop)  ENV TOMCAT_VERSION=10.0.20   0B        
      3 days ago   /bin/sh -c #(nop)  ENV TOMCAT_MAJOR=10          0B        
      3 days ago   /bin/sh -c #(nop)  ENV GPG_KEYS=A9C5DF4D22E9…   0B        
      3 days ago   /bin/sh -c #(nop)  ENV LD_LIBRARY_PATH=/usr/…   0B        
      3 days ago   /bin/sh -c #(nop)  ENV TOMCAT_NATIVE_LIBDIR=…   0B        
      3 days ago   /bin/sh -c #(nop) WORKDIR /usr/local/tomcat     0B        
      3 days ago   /bin/sh -c mkdir -p "$CATALINA_HOME"            0B        
      3 days ago   /bin/sh -c #(nop)  ENV PATH=/usr/local/tomca…   0B        
      3 days ago   /bin/sh -c #(nop)  ENV CATALINA_HOME=/usr/lo…   0B        
      4 days ago   /bin/sh -c #(nop)  CMD ["jshell"]               0B        
      4 days ago   /bin/sh -c set -eux;   arch="$(dpkg --print-…   343MB     
      4 days ago   /bin/sh -c #(nop)  ENV JAVA_VERSION=11.0.15     0B        
      4 days ago   /bin/sh -c #(nop)  ENV LANG=C.UTF-8             0B        
      4 days ago   /bin/sh -c #(nop)  ENV PATH=/usr/local/openj…   0B        
      4 days ago   /bin/sh -c { echo '#/bin/sh'; echo 'echo "$J…   27B       
      4 days ago   /bin/sh -c #(nop)  ENV JAVA_HOME=/usr/local/…   0B        
      4 days ago   /bin/sh -c set -eux;  apt-get update;  apt-g…   11.3MB    
      4 days ago   /bin/sh -c apt-get update && apt-get install…   152MB     
      4 days ago   /bin/sh -c set -ex;  if ! command -v gpg > /…   19MB      
      4 days ago   /bin/sh -c set -eux;  apt-get update;  apt-g…   10.7MB    
      4 days ago   /bin/sh -c #(nop)  CMD ["bash"]                 0B        
      4 days ago   /bin/sh -c #(nop) ADD file:68a5d7d0db5926251…   124MB

3.2 构建tomcat 镜像

准备镜像文件 tomcat 压缩包，jdk的压缩包！

通过ftp传入服务器上

编写dockerFile 文件
建议: 本地编辑ftp传入服务或者，拷贝

FROM centos:7

MAINTAINER  姓名 <邮箱>

COPY readme.txt /usr/local/readme.txt

# ADD 进容器无需解压
ADD apache-tomcat-9.0.62.tar.gz /usr/local/
ADD jdk-8u202-linux-x64.tar.gz /usr/local/
# 下载vim
RUN yum -y install vim
# 配置基础目录
ENV MYPATH /usr/local
# 工作目录
WORKDIR $MYPATH
# 配置环境变量
ENV JAVA_HOME /usr/local/jdk1.8.0_202
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.62
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.62
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
# 暴露端口
EXPOSE 8080

# 启动tomcat 并且动态打印日志
CMD /usr/local/apache-tomcat-9.0.62/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.62/bin/logs/catalina.out

启动容器

#  docker run -d -p 3355:8080 --name diytomcat -v /home/dockerfile/tomcat/test:/usr/local/apache-tomcat-9.0.62/webapps/test
> -d 后台运行
> -p 绑定端口
> --name 命名
> -v 挂载

编写index.html 进行测试



  
       
      这是个标题
  
  
      DockerFIle 测试

在网页中输入ip+端口注意要加上/test

三、DockerNet 1. 认识网络模式

查看Dokcer的所有网络：

# docker network ls

Docker自身的4种网络工作方式，和一些自定义网络模式

安装Docker时，它会自动创建三个网络，bridge（创建容器默认连接到此网络）、 none 、host

host：容器将不会虚拟出自己的网卡，配置自己的IP等，而是使用宿主机的IP和端口。
Container：创建的容器不会创建自己的网卡，配置自己的IP，而是和一个指定的容器共享IP、端口范围。
None：该模式关闭了容器的网络功能。
Bridge：此模式会为每一个容器分配、设置IP等，并将容器连接到一个docker0虚拟网桥，通过docker0网桥以及Iptables nat表配置与宿主机通信。

以上都是不用动手的，真正需要配置的是自定义网络。

DockerComposeDocker内置这三个网络，运行容器时，你可以使用该–network标志来指定容器应连接到哪些网络。

该bridge网络代表docker0所有Docker安装中存在的网络。除非你使用该

docker run --network= < NETWORK>

选项指定，否则Docker守护程序默认将容器连接到此网络。

我们在使用docker run创建Docker容器时，可以用 --net 选项指定容器的网络模式，Docker可以有以下4种网络模式：

host模式：使用 --net=host 指定。

none模式：使用 --net=none 指定。

bridge模式：使用 --net=bridge 指定，默认设置。

container模式：使用 --net=container:NAME_or_ID 指定。

2. 默认网络 2.1 Host 2.2 Container 2.3 None 2.4 Bridge 3. Docker：网络模式详解 3.1 Bridge模式的拓扑

当Docker server启动时，会在主机上创建一个名为docker0的虚拟网桥，此主机上启动的Docker容器会连接到这个虚拟网桥上。虚拟网桥的工作方式和物理交换机类似，这样主机上的所有容器就通过交换机连在了一个二层网络中。接下来就要为容器分配IP了，Docker会从RFC1918所定义的私有IP网段中，选择一个和宿主机不同的IP地址和子网分配给docker0，连接到docker0的容器就从这个子网中选择一个未占用的IP使用。如一般Docker会使用172.17.0.0/16这个网段，并将172.17.0.1/16分配给docker0网桥（在主机上使用ifconfig命令是可以看到docker0的，可以认为它是网桥的管理接口，在宿主机上作为一块虚拟网卡使用）。单机环境下的网络拓扑如下，主机地址为10.10.0.186/24。

3.2 Docker：网络模式详解

Docker容器完成bridge网络配置的过程如下：

在主机上创建一对虚拟网卡veth pair设备。veth设备总是成对出现的，它们组成了一个数据的通道，数据从一个设备进入，就会从另一个设备出来。因此，veth设备常用来连接两个网络设备。
Docker将veth pair设备的一端放在新创建的容器中，并命名为eth0。另一端放在主机中，以veth65f9这样类似的名字命名，并将这个网络设备加入到docker0网桥中。
从docker0子网中分配一个IP给容器使用，并设置docker0的IP地址为容器的默认网关。

Docker 利用 veth-pair技术实现桥接：

Docker中的所有的网络接口都是虚拟的。只要容器停止或者删除，容器对应的网桥也会删除。

3.3 容器联通

在微服务部署的场景下，注册中心是使用服务名来唯一识别微服务的，而我们上线部署的时候微服务对应的IP地址可能会改动，所以我们需要使用容器名来配置容器间的网络连接。使用–link可以完成这个功能。

== --link 功能已经是过去的技术了，这里做一个了解，真实项目使用场景中抛弃这种方式 ==

创建tomcat04 link 到已经创建好的tomcat01

# docker run -P -d --name tomcat04 --link tomcat01  tomcat:8.0

使用tomcat 04 去ping tomcat01

docker exec -it tomcat04 ping tomcat01

我们看到这种link方式直接使用容器名称就可以ping通了。

但是反过来容器Tomcat01通过容器名Tomcat04直接ping容器Tomcat04是不行的。这是因为 –link的底层操作是修改容器的hosts文件达到ip地址与容器名称映射的。

4. 自定义网络

建议使用自定义的网桥来控制哪些容器可以相互通信，还可以自动DNS解析容器名称到IP地址。Docker提供了创建这些网络的默认网络驱动程序，你可以创建一个新的Bridge网络，Overlay或Macvlan网络。你还可以创建一个网络插件或远程网络进行完整的自定义和控制。

你可以根据需要创建任意数量的网络，并且可以在任何给定时间将容器连接到这些网络中的零个或多个网络。此外，您可以连接并断开网络中的运行容器，而无需重新启动容器。当容器连接到多个网络时，其外部连接通过第一个非内部网络以词法顺序提供。

4.1 查看默认的网桥信息

# docker network inspect bridge

无容器纯净的网络信息

[
    {
        "Name": "bridge",
        "Id": "e83d01603ae8672ded8b5c7ef7e82c0cb900341f4290c70db5a6be4796d29850",
        "Created": "2022-05-13T18:39:19.710131055+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": null,
            "Config": [
                {
                    "Subnet": "172.17.0.0/16",
                    "Gateway": "172.17.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {},
        "Options": {
            "com.docker.network.bridge.default_bridge": "true",
            "com.docker.network.bridge.enable_icc": "true",
            "com.docker.network.bridge.enable_ip_masquerade": "true",
            "com.docker.network.bridge.host_binding_ipv4": "0.0.0.0",
            "com.docker.network.bridge.name": "docker0",
            "com.docker.network.driver.mtu": "1500"
        },
        "Labels": {}
    }
]

我们可以看到子网掩码和网关的值，这就是网络的基础配置

“Subnet”: “172.17.0.0/16”,
“Gateway”: “172.17.0.1”

4.2 自定义网络

# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

指令	说明
–driver bridge	指定bridge驱动程序来管理网络
–subnet 192.168.0.0/16	指定网段的CIDR格式的子网
–gateway 192.168.0.1	指定主子网的IPv4或IPv6网关

查看自定义网络信息

# docker network inspect mynet

这就是我们自定义网络的信息，发现子网掩码和网关的值就是我们自定义的
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/16",
                    "Gateway": "192.168.0.1"
                }
            ]
        },

4.3 自定义网络的好处

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

指定自定义网路来创建容器

# docker run -d -P --name tomcat-net-01 --net mynet tomcat 
# docker run -d -P --name tomcat-net-02 --net mynet tomcat 
# docker network inspect mynet

查看自定义网路信息

 "Containers": {
           "9aa606ae62a6d77aa6c40a744ee3c0eed4772f5b1d1431801c02d97f09d5e8fc": {
               "Name": "tomcat-net-02",
               "EndpointID": "da83160897db652df09d582038d8a0fe14da24358080d07f7d5aae37cc950bec",
               "MacAddress": "02:42:c0:a8:00:03",
               "IPv4Address": "192.168.0.3/16",
               "IPv6Address": ""
           },
           "c56e201f175aa039644cd4c8048f483a3cd54b01f1801631734870afb686a886": {
               "Name": "tomcat-net-01",
               "EndpointID": "7877f0e43a170de3e5416c0a84f2710f05e223d7bd06b40a286e4b61d31ef2b6",
               "MacAddress": "02:42:c0:a8:00:02",
               "IPv4Address": "192.168.0.2/16",
               "IPv6Address": ""
           }
       }

通过容器名来测试容器tomcat-net-01 和容器tomcat-net-02之间是否能正常网络通信。

root@VM-12-15-ubuntu:~# docker exec -it tomcat-net-01 ping tomcat-net-02
PING tomcat-net-02 (192.168.0.2) 56(84) bytes of data.
64 bytes from tomcat-net-02.mynet (192.168.0.2): icmp_seq=1 ttl=64 time=0.091 ms
64 bytes from tomcat-net-02.mynet (192.168.0.2): icmp_seq=2 ttl=64 time=0.067 ms
64 bytes from tomcat-net-02.mynet (192.168.0.2): icmp_seq=3 ttl=64 time=0.064 ms
64 bytes from tomcat-net-02.mynet (192.168.0.2): icmp_seq=4 ttl=64 time=0.066 ms

root@VM-12-15-ubuntu:~# docker exec -it tomcat-net-02 ping tomcat-net-01
PING tomcat-net-01 (192.168.0.3) 56(84) bytes of data.
64 bytes from tomcat-net-01.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.057 ms
64 bytes from tomcat-net-01.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.070 ms
64 bytes from tomcat-net-01.mynet (192.168.0.3): icmp_seq=3 ttl=64 time=0.074 ms
64 bytes from tomcat-net-01.mynet (192.168.0.3): icmp_seq=4 ttl=64 time=0.046 ms

发现不用配置 --link 也可以实现直接用容器名称ping通网络

5.网络连通

不同网络直接不可以直接ping通，这时候就需要进行网络连接。图中，net01 与 net02 属于mynet 网络，想要tomcat01 直接ping通 net01 。

连通网络

connect 的原理 就是 把一个容器的连接到 想要连接的网络上
# docker network connect  mynet tomcat01

查看 mynet

# docker network inspect mynet

"Containers": {
            "33f14e1a2d365c5d8af4b75ccac09a41dd1770ba80343568c3ddb22c488158db": {
                "Name": "tomcat-net-01",
                "EndpointID": "2cd736c5cd7261d3fabc679c69e4422d3bf978913adece65be65b540a7284b7e",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            },
            "7c3ff77c72ce4e42a550280b7258be861882c3c5f0b6f6aad5c2de6c19d726b1": {
                "Name": "tomcat-net-02",
                "EndpointID": "3a770656df1b290a730dd9f91694fcb3f7623d3b39031d49c7ad338a40512272",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",
                "IPv6Address": ""
            },
            "83c7a5d8df01b4ad7cadf3a5655d150b81b15b08fda56e35df9148a1acd03b09": {
                "Name": "tomcat01",
                "EndpointID": "d27de557fb44d51a8b4216af3a7fc25679c00dc1c6bfc614db1f54db09aa830a",
                "MacAddress": "02:42:c0:a8:00:04",
                "IPv4Address": "192.168.0.4/16",
                "IPv6Address": ""
            }
        }

发现在mynet 的网络信息中多了tomcat01 的信息。可以看到给容器tomcat-01分配了一个ip地址，这样就可以实现不同网络的互联。

6. Redis集群部署实战 7. SpringBoot微服务打包发布四、Docker Compose 1. Compose 简介

Compose 是用于定义和运行多容器 Docker 应用程序的工具。通过 Compose，您可以使用 YML 文件来配置应用程序需要的所有服务。然后，使用一个命令，就可以从 YML 文件配置中创建并启动所有服务。
如果你还不了解 YML 文件配置，可以先阅读 YAML 入门教程。

Compose 使用的三个步骤：

使用 Dockerfile 定义应用程序的环境。
使用 docker-compose.yml 定义构成应用程序的服务，这样它们可以在隔离环境中一起运行。
最后，执行 docker-compose up 命令来启动并运行整个应用程序。

docker-compose.yml 的配置案例如下（配置参数参考下文）：

# yaml 配置实例
version: '3'
services:
  web:
    build: .
    ports:
   - "5000:5000"
    volumes:
   - .:/code
    - logvolume01:/var/log
    links:
   - redis
  redis:
    image: redis
volumes:
  logvolume01: {}

2. Compose 安装

Linux 上我们可以从 Github 上下载它的二进制包来使用，最新发行的版本地址：https://github.com/docker/compose/releases。
运行以下命令以下载 Docker Compose 的当前稳定版本：

$ sudo curl -L "https://github.com/docker/compose/releases/download/v2.2.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

要安装其他版本的 Compose，请替换 v2.2.2。

Docker Compose 存放在 GitHub，不太稳定。
你可以也通过执行下面的命令，高速安装 Docker Compose。

$ curl -L https://get.daocloud.io/docker/compose/releases/download/v2.4.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

将可执行权限应用于二进制文件：

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

创建软链：

$ sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose

测试是否安装成功：

$ docker-compose --version
cker-compose version 1.24.1, build 4667896b

3. 使用

步骤来源于官网，可移步官网。官网地址

3.1 准备

创建一个测试目录：

# mkdir composetest
# cd composetest

在测试目录中创建一个名为 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)

在此示例中，redis 是应用程序网络上的 redis 容器的主机名，该主机使用的端口为 6379。
在 composetest 目录中创建另一个名为 requirements.txt 的文件，内容如下：

flask
redis

3.2 创建 Dockerfile 文件

在 composetest 目录中，创建一个名为 Dockerfile 的文件，内容如下：

FROM python:3.7-alpine   //从 Python 3.7 映像开始构建镜像。
WORKDIR /code   //将工作目录设置为 /code。
ENV FLASK_APP app.py   //设置 flask 命令使用的环境变量。
ENV FLASK_RUN_HOST 0.0.0.0   //设置 flask 命令使用的环境变量。
RUN apk add --no-cache gcc musl-dev linux-headers   //安装 gcc，以便诸如 MarkupSafe 和 SQLAlchemy 之类的 Python 包可以编译加速。
COPY requirements.txt requirements.txt  
RUN pip install -r requirements.txt   //复制 requirements.txt 并安装 Python 依赖项。
COPY . .     // 将 . 项目中的当前目录复制到 . 镜像中的工作目录。
CMD ["flask", "run"]    //容器提供默认的执行命令为：flask run。

镜像下载比较慢，推荐切换国内镜像

3.3 创建 docker-compose.yml

在测试目录中创建一个名为 docker-compose.yml 的文件，然后粘贴以下内容：

# yaml 配置
version: '3'
services:
  web:
    build: .
    ports:
     - "5000:5000"
  redis:
    image: "redis:alpine"

该 Compose 文件定义了两个服务：web 和 redis。

web：该 web 服务使用从 Dockerfile 当前目录中构建的镜像。然后，它将容器和主机绑定到暴露的端口 5000。此示例服务使用 Flask Web 服务器的默认端口 5000 。
redis：该 redis 服务使用 Docker Hub 的公共 Redis 映像。

在测试目录中，执行以下命令来启动应用程序：

# docker-compose up
# docker-compose up -d  //后台运行

小结：

Docker 镜像。 run => 容器
DockerFile 共建镜像（服务打包）
docker-compose 启动项目（编排，配置，依赖，挂载；多个微服务/环境）
Dokcer 网络

4 .使用 Compose 部署前后分离项目实战

采用SpringBoot + Vue + mysql

4.1 打包前后端项目 4.2 编写DockerFile 4.3 编写docker-compose.yaml 4.4 启动部署五、Docker Machine

待更新

六、Docker Swarm

待更新

总结

你的无畏源于无知。 — 三体

Docker进阶实战

DockerFIle 测试

Linux相关栏目本月热门文章