Docker学习汇总

Docker学习汇总（狂神说Docker笔记）

Docker安装

uname -a 查看linux内核版本

cat /etc/os-release 查看系统版本信息

yum makecache fast 更新yum

Docker命令

镜像命令

docker images查看本机所有镜像

# 查看docker镜像
# docker images
REPOSITORY           TAG                     IMAGE ID            CREATED             SIZE
centos              latest                  470671670cac        2 years ago         237MB
mysql                5.7                    1e4405fe1ea9        2 years ago         437MB

#解释
REPOSITORY #镜像的仓库
TAG				 #镜像的标签版本
IMAGE ID	 #镜像的ID
CREATED		 #镜像的创建时间
SIZE			 #镜像的大小
# 可选项
-a, --all             #显示所有的镜像
-q, --quiet           #只显示镜像id
-aq										#显示所有镜像的id

docker search 搜索docker镜像

> # docker search mysql
NAME                             DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
mysql                            MySQL is a widely used, open-source relation…   12320               [OK]
mariadb                          MariaDB Server is a high performing open sou…   4738                [OK]

# 可选项
--filter=STARS=3000			#搜索出镜像stars大于3000的镜像

docker pull 下拉镜像

# 下载镜像 
# docker pull 镜像名[:tag]
如果不写tag则默认下载最新的版本
#下载指定版本
# docker pull mysql:5.7

docker rmi 删除镜像

# -f 强制删除，包括运行的容器
# docker rmi -f IMAGE ID
# docker rmi -f IMAGE ID1 IMAGE ID2 IMAGE ID3
# 删除所有的镜像
# docker rmi -f $(docker images -aq)

容器命令

docker run 运行容器

docker run [可选参数] image
#参数说明
--name=“Name” 		#容器的名字 tomcat01 tomcat01用来区分容器
-d							  #后台运行
-it								#使用交互方式运行，可进入容器查看内容，运行命令
-p								#指定容器的端口		-p 8080:8080
# -p的三种形式
    -p 主机端口:容器端口
    -p 容器端口
    容器端口
-P （大P）					#随机指定端口

# docker run -it centos /bin/bash
# exit 退出交互模式

docker ps 列出所有运行的容器

# docker ps [OPTIONS]
列出当前正在运行的容器
#参数选项
-a         #列出所有容器
-n=？      #显示最近创建的容器（只显示n个）
-q         #只显示当前容器的编号

docker ps -a
docker ps -a -n=3
docker ps -aq

退出容器

exit 				  #直接退出容器并关闭
Ctrl + P+ Q 	#容器不关闭退出（相当于后台运行）

删除容器

docker rm 容器id										#删除指定的容器，不能删除正在运行的容器，如果要强制删除 rm -f
docker rm -f $(docker ps -aq)			 #删除所有的容器
docker ps -a -q |xargs docker rm	 #运用linux命令特性管道符删除所有的容器

启动和停止容器的操作

docker start 容器id			#启动容器
docker restart 容器id		#重启容器
docker stop 容器id			#停止当前正在运行的容器
docker kill 容器id			#强制停止当前容器

常用的其他命令

后台启动容器

#docker run -d 镜像名
docker run -d centos
#问题 docker ps ，发现centos停止了
#主要是因为docker容器使用后台运行，就必须要有一个前台进程，docker发现没有应用就会自动停止
#容器启动发现自己没有提供服务，就会立刻停止，相当于没启动

查看日志

docker logs -tf --tail 10 容器id  查看容器的日志只显示10条但是会随时更新
# 自己编写一段shell脚本
# docker run -d centos /bin/sh -c "while true;do echo test;sleep 1;done"
# 显示日志
-tf 					#显示所有日志
--tail number #要显示的日志条数 

查看容器中进程信息ps

#命令 docker top 容器id
> docker top d46157653984
PID                 USER                TIME                
2787                root                0:00                
2851                root                0:00    
# 可用作杀死进程时使用

查看镜像源数据docker inspect

#命令
docker inspect 容器id
#测试
> docker inspect d46157653984
[
    {
        "Id": "d461576539848f068655b9ef81a922f53073f2f141601fe0188ad03502eefdbc",
        "Created": "2022-03-29T07:54:55.625834481Z",
        "Path": "/bin/sh",
        "Args": [
            "-c",
            "while true;do echo test;sleep 1;done"
        ],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 2787,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2022-03-29T07:54:56.158194582Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:5d0da3dc976460b72c77d94c8a1ad043720b0416bfc16c52c45d4847e53fadb6",
        "ResolvConfPath": "/var/lib/docker/containers/d461576539848f068655b9ef81a922f53073f2f141601fe0188ad03502eefdbc/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/d461576539848f068655b9ef81a922f53073f2f141601fe0188ad03502eefdbc/hostname",
        "HostsPath": "/var/lib/docker/containers/d461576539848f068655b9ef81a922f53073f2f141601fe0188ad03502eefdbc/hosts",
        "LogPath": "/var/lib/docker/containers/d461576539848f068655b9ef81a922f53073f2f141601fe0188ad03502eefdbc/d461576539848f068655b9ef81a922f53073f2f141601fe0188ad03502eefdbc-json.log",
        "Name": "/dazzling_kirch",
        "RestartCount": 0,
        "Driver": "overlay2",
        "Platform": "linux",
        "MountLabel": "",
        "ProcessLabel": "",
        "AppArmorProfile": "",
        "ExecIDs": null,
        "HostConfig": {
            "Binds": null,
            "ContainerIDFile": "",
            "LogConfig": {
                "Type": "json-file",
                "Config": {}
            },
            "NetworkMode": "default",
            "PortBindings": {},
            "RestartPolicy": {
                "Name": "no",
                "MaximumRetryCount": 0
            },
            "AutoRemove": false,
            "VolumeDriver": "",
            "VolumesFrom": null,
            "CapAdd": null,
            "CapDrop": null,
            "Capabilities": null,
            "Dns": [],
            "DnsOptions": [],
            "DnsSearch": [],
            "ExtraHosts": null,
            "GroupAdd": null,
            "IpcMode": "private",
            "Cgroup": "",
            "Links": null,
            "OomScoreAdj": 0,
            "PidMode": "",
            "Privileged": false,
            "PublishAllPorts": false,
            "ReadonlyRootfs": false,
            "SecurityOpt": null,
            "UTSMode": "",
            "UsernsMode": "",
            "ShmSize": 67108864,
            "Runtime": "runc",
            "ConsoleSize": [
                0,
                0
            ],
            "Isolation": "",
            "CpuShares": 0,
            "Memory": 0,
            "NanoCpus": 0,
            "CgroupParent": "",
            "BlkioWeight": 0,
            "BlkioWeightDevice": [],
            "BlkioDeviceReadBps": null,
            "BlkioDeviceWriteBps": null,
            "BlkioDeviceReadIOps": null,
            "BlkioDeviceWriteIOps": null,
            "CpuPeriod": 0,
            "CpuQuota": 0,
            "CpuRealtimePeriod": 0,
            "CpuRealtimeRuntime": 0,
            "CpusetCpus": "",
            "CpusetMems": "",
            "Devices": [],
            "DeviceCgroupRules": null,
            "DeviceRequests": null,
            "KernelMemory": 0,
            "KernelMemoryTCP": 0,
            "MemoryReservation": 0,
            "MemorySwap": 0,
            "MemorySwappiness": null,
            "OomKillDisable": false,
            "PidsLimit": null,
            "Ulimits": null,
            "CpuCount": 0,
            "CpuPercent": 0,
            "IOMaximumIOps": 0,
            "IOMaximumBandwidth": 0,
            "MaskedPaths": [
                "/proc/asound",
                "/proc/acpi",
                "/proc/kcore",
                "/proc/keys",
                "/proc/latency_stats",
                "/proc/timer_list",
                "/proc/timer_stats",
                "/proc/sched_debug",
                "/proc/scsi",
                "/sys/firmware"
            ],
            "ReadonlyPaths": [
                "/proc/bus",
                "/proc/fs",
                "/proc/irq",
                "/proc/sys",
                "/proc/sysrq-trigger"
            ]
        },
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/5b3924a86dad43b8a19dbfae2ebd1c17b17b74ff2d8901f7ec684e997a870081-init/diff:/var/lib/docker/overlay2/95f47c54ab28371f2bcb03ebccd70e038ae4bfc29f6e9823dd2c5a34532301ce/diff",
                "MergedDir": "/var/lib/docker/overlay2/5b3924a86dad43b8a19dbfae2ebd1c17b17b74ff2d8901f7ec684e997a870081/merged",
                "UpperDir": "/var/lib/docker/overlay2/5b3924a86dad43b8a19dbfae2ebd1c17b17b74ff2d8901f7ec684e997a870081/diff",
                "WorkDir": "/var/lib/docker/overlay2/5b3924a86dad43b8a19dbfae2ebd1c17b17b74ff2d8901f7ec684e997a870081/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "d46157653984",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Cmd": [
                "/bin/sh",
                "-c",
                "while true;do echo test;sleep 1;done"
            ],
            "Image": "centos",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {
                "org.label-schema.build-date": "20210915",
                "org.label-schema.license": "GPLv2",
                "org.label-schema.name": "CentOS Base Image",
                "org.label-schema.schema-version": "1.0",
                "org.label-schema.vendor": "CentOS"
            }
        },
        "NetworkSettings": {
            "Bridge": "",
            "SandboxID": "4eb32e69b293324da661d5a33c91d42b4e2aa645a1bd5312ed6ad0d50348f411",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/4eb32e69b293",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "1e247237c5ecd9535c62b094047a910679f0cbb7e50043d18e718956db518f7c",
            "Gateway": "172.17.0.1",
            "GlobalIPv6Address": "",
            "GlobalIPv6PrefixLen": 0,
            "IPAddress": "172.17.0.2",
            "IPPrefixLen": 16,
            "IPv6Gateway": "",
            "MacAddress": "02:42:ac:11:00:02",
            "Networks": {
                "bridge": {
                    "IPAMConfig": null,
                    "Links": null,
                    "Aliases": null,
                    "NetworkID": "e265197e4228b6151748ffa8d59ca9c4dac67509aae44d2f9d8f0cab16cb5fcd",
                    "EndpointID": "1e247237c5ecd9535c62b094047a910679f0cbb7e50043d18e718956db518f7c",
                    "Gateway": "172.17.0.1",
                    "IPAddress": "172.17.0.2",
                    "IPPrefixLen": 16,
                    "IPv6Gateway": "",
                    "GlobalIPv6Address": "",
                    "GlobalIPv6PrefixLen": 0,
                    "MacAddress": "02:42:ac:11:00:02",
                    "DriverOpts": null
                }
            }
        }
    }
]

docker exec进入当前正在运行的容器

# 通常我们都是使用后台方式运行容器，有时需要进入容器，修改一些配置
#命令
docker exec -it 容器id bashshell
#测试
> docker exec -it d46157653984 /bin/bash
[root@d46157653984 /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@d46157653984 /]# ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 07:54 ?        00:00:01 /bin/sh -c while true;do echo test;sleep 1;done
root      3396     0  0 08:51 pts/0    00:00:00 /bin/bash
root      3415     1  0 08:51 ?        00:00:00 /usr/bin/coreutils --coreutils-prog-shebang=sleep /usr/bin/sleep 1
root      3416  3396  0 08:51 pts/0    00:00:00 ps -ef

# 方式二
docker attach 容器id
> docker attach d46157653984
正在执行的当前代码..

#docker exec			#进入容器后开启一个新的终端，可以再里面操作(常用)
#docker attach		#进入当前正在执行的终端，不会开启新的进程

从容器内拷贝文件到主机上

docker cp 容器id:容器内路径 
> docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
713eb5c9693f        centos              "/bin/bash"         31 seconds ago      Up 30 seconds                           priceless_heisenberg
# 进入docker容器
> docker attach 713eb5c9693f
[root@713eb5c9693f /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@713eb5c9693f /]# ls /home/
# 在容器内新建一个文件
[root@713eb5c9693f /]# touch /home/aaa.txt
[root@713eb5c9693f /]# exit
exit
# 将文件拷贝出来到主机上
> docker cp 713eb5c9693f:/home/aaa.txt /Users/xxx/Desktop
> ls /Users/xxx/Desktop
aaa.txt
#拷贝是一个手动过程，未来我们使用-v卷的技术，可以实现

查看docker容器cpu占用

docker status

> docker status
CONTAINER ID   NAME             CPU %     MEM USAGE / LIMIT   MEM %     NET I/O     BLOCK I/O   PIDS
179f69881a04   ecstatic_hertz   0.00%     828KiB / 12.45GiB   0.01%     976B / 0B   0B / 0B     1

commit镜像

docker commit 提交容器成为一个新的副本
# 命令和git原理类似
docker commit -m="提交的镜像描述" -a="作者" 容器id 容器镜像名[TAG]

命令小结

  attach      Attach local standard input, output, and error streams to a running container
  #当前shell下 attach连接指定运行的镜像
  build       Build an image from a Dockerfile # 通过Dockerfile定制镜像
  commit      Create a new image from a container's changes #提交当前容器为新的镜像
  cp          Copy files/folders between a container and the local filesystem #拷贝文件
  create      Create a new container #创建一个新的容器
  diff        Inspect changes to files or directories on a container's filesystem #查看docker容器的变化
  events      Get real time events from the server # 从服务获取容器实时时间
  exec        Run a command in a running container # 在运行中的容器上运行命令
  export      Export a container's filesystem as a tar archive #导出容器文件系统作为一个tar归档文件[对应import]
  history     Show the history of an image # 展示一个镜像形成历史
  images      List images #列出系统当前的镜像
  import      Import the contents from a tarball to create a filesystem image #从tar包中导入内容创建一个文件系统镜像
  info        Display system-wide information # 显示全系统信息
  inspect     Return low-level information on Docker objects #查看容器详细信息
  kill        Kill one or more running containers # kill指定docker容器
  load        Load an image from a tar archive or STDIN #从一个tar包或标准输入中加载一个镜像[对应save]
  login       Log in to a Docker registry #
  logout      Log out from a Docker registry
  logs        Fetch the logs of a container
  pause       Pause all processes within one or more containers
  port        List port mappings or a specific mapping for the container
  ps          List containers
  pull        Pull an image or a repository from a registry
  push        Push an image or a repository to a registry
  rename      Rename a container
  restart     Restart one or more containers
  rm          Remove one or more containers
  rmi         Remove one or more images
  run         Run a command in a new container
  save        Save one or more images to a tar archive (streamed to STDOUT by default)
  search      Search the Docker Hub for images
  start       Start one or more stopped containers
  stats       Display a live stream of container(s) resource usage statistics
  stop        Stop one or more running containers
  tag         Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE
  top         Display the running processes of a container
  unpause     Unpause all processes within one or more containers
  update      Update configuration of one or more containers
  version     Show the Docker version information
  wait        Block until one or more containers stop, then print their exit codes

容器数据卷

容器的持久化和同步操作，容器间也是可以数据共享的

使用数据卷

• 方式一：直接运用命令来挂载 -v

docker run -it -v 主机目录:容器内目录
#测试
docker run -it -v /home/ceshi:/home centos /bin/bash
# 启动起来后我们可以通过 docker inspect 容器ID 查看卷如何挂载的，如下图

测试文件的同步

再来测试

1. 停止容器
2. 宿主机上修改文件
3. 启动容器
4. 容器内的文件仍然被同步

好处：以后修改文件只需要再本地修改即可，容器内会自动同步。

具名挂载和匿名挂载

#匿名挂载
docker run -P --name nginx01 -v /etc/nginx nginx
#查看所有volume的情况
> docker volume ls

#这种就是匿名挂载，在查看时是乱码表示的
# 具名挂载
> docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx
# 通过-v 卷名:容器内路径
#查看下卷
docker volume ls
# 可以发现刚才挂载的juming-nginx已经存在

所有的docker容器内的卷，没有指定目录的情况下都是在/var/lib/docker/volumes/xxx/_data

我们通过具名挂载可以方便的找到我们的一个卷，大多数情况在使用具名挂载。

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

拓展

# 通过 -v 容器内路径:ro rw 改变读写权限，
ro readonly #只读
rw readwrite #可读可写
docker run -d -P --name nginx03 -v juming-nginx:/etc/nginx:ro nginx
docker run -d -P --name nginx03 -v juming-nginx:/etc/nginx:rw nginx
#ro 只要看到ro就说明这个路径智能通过宿主机来操作，容器内部无法操作

初识Dockerfile

Dockerfile就是用来构建docker镜像的构造文件命令脚本

通过这个脚本可以生成镜像

#创建一个dockerfile文件，名字可以随便，但是最好是Dockerfile
#文件中的内容太 指令(大写
)
FROM centos
VOLUME ["volume01","volume02"]
CMD echo "---end---"
CMD /bin/bash

启动写的镜像

查看下卷挂载

docker inspect 容器id

测试下刚才的文件是否同步过去了。

这种方式使用的十分多，因为我们通常会构建自己的镜像，

假设构建镜像的时候没有卷挂载，要手动镜像挂载 -v 卷名:容器内路径。

数据卷容器

多个mysql实现数据同步

启动三个容器，通过自己创建的镜像启动

docker run -it --name docker01 kuangshen/centos
docker run -it --name docker02 --volumes-from docker01 kuangshen/centos
docker run -it --name docker03 --volumes-from docker01 kuangshen/centos

通过以上三条命令创造的三个容器，卷volume01和卷volume02是互通的

#测试：可以删除docker01容器，在docker02和docker03中的数据不受影响

多个mysql实现数据共享

#启动mysql01
docker run -d -p 3306:3306 -v /etc/mysql/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7
#启动mysql02
docker run -d -p 3307:3306 --volumes-from mysql01 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 mysql:5.7

结论

容器之间的配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用位置。

但是一旦持久化到了本地，这是本地数据是不会删除的

Dockerfile

Dockerfile介绍

dockerfile是用来构建docker镜像的文件，命令参数脚本

构建步骤

1. 编写一个Dockerfile文件
2. docker build 构建成为一个镜像
3. docker run 运行镜像
4. docker push 发布镜像（dockerhub，阿里云）

很多官方镜像都是基础包，很多功能没有，我们通常会自己搭建自己的镜像。

Dockerfile构建过程

基础知识

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

• Dockerfile：构建文件，定义一切的步骤，源代码
• DockerImages:通过dockerfile构建生成的镜像，最终发布和运行产品
• Docker容器：容器就是镜像运行起来的服务

DockerFile常用指令

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

创建一个自己的centos

1. 编写dockerfile文件

# 使用centos版本
FROM centos:7
#作者信息
MAINTAINER yuanxu<[email protected]>
#环境变量
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

2. 通过这个dockerfile文件构建镜像

docker build -f dockerfile01 -t centos001:1.0 .


Successfully built 71e016ad91a2
Successfully tagged centos001:1.0

注意，最后有一个点必须得加上，否则会报错

通过上图我们可以看到，我们的镜像已经被构建成功，并且ifconfig已经能够运行成功，证明我们的net-tools已经被安装成功了

可以通过docker history 镜像ID来查看docker本地进行的变更历史

CMD和ENTERPOINT区别

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

测试CMD

• 编写dockerfile

FROM centos:7
# 注意此处"ls" 和"-a"之间必须添加空格，否则命令无法执行
CMD ["ls", "-a"]

• 构建镜像

docker build -f dockerfile02 -t cmd-test:3.0 .

• run运行，发现我们的ls -a命令生效
  

• 想追加一个-l指令变为 ls -al

> docker run cmd-test:3.0 -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:345: starting container process caused "exec: \"-l\": executable file not found in $PATH": unknown.

发现会报错，原因是因为CMD指令的特性，新的指令会覆盖旧的指令，添加-l指令后，-l指令直接替换ls -a，所以-l执行失败而报错。

测试ENTRYPOINT

• 编写dockerfile

FROM centos:7
ENTRYPOINT ["ls", "-a"]

• 构建镜像

docker build -f dockerfile02 -t entrypoint:1.0 .

• run运行，发现ls -a命令生效
• 想追加一个-l指令变为ls -al

发现追加成功。

dockerfile中很多命令都十分相似，想了解，应该对比测试。

实战：Tomcat镜像

Docker网络

自定义网络

> docker network --help

Usage:	docker network COMMAND

Commands:
  connect     Connect a container to a network
  create      Create a network															#创建网络
  disconnect  Disconnect a container from a network
  inspect     Display detailed information on one or more networks #显示网口详细信息
  ls          List networks		#显示所有的网络
  prune       Remove all unused networks
  rm          Remove one or more networks #删除网络

docker network ls 显示当前所有的网络

> docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
94904d2257fd        bridge              bridge              local		
3d9c46325fc5        host                host                local		
b088101353ed        none                null                local

网络模式

bridge:桥接docker（默认网络，自己创建网络也是用bridge模式）

none：不配置网络，一般不用

host：和宿主机共享网络

containter：容器网络联通（用的很少，局限性很大）

测试

# 我们直接启动的命令，--net bridge 而这个就是我们的docker0
docker run -d -P --name tomcat01  tomcat
#等价于
docker run -d -P --name tomcat01 --net bridge tomcat

docker0的特点：默认的，域名不能访问。但是--link可以打通，但是很麻烦，需要双向绑定。

我们可以自定义一个网络。

> docker network create --help

Usage:	docker network create [OPTIONS] NETWORK

Options:
      --attachable           Enable manual container attachment
      --aux-address map      Auxiliary IPv4 or IPv6 addresses used by
                             Network driver (default map[])
      --config-from string   The network from which copying the
                             configuration
      --config-only          Create a configuration only network
  -d, --driver string        Driver to manage the Network (default "bridge")
      --gateway strings      IPv4 or IPv6 Gateway for the master subnet
      --ingress              Create swarm routing-mesh network
      --internal             Restrict external access to the network
      --ip-range strings     Allocate container ip from a sub-range
      --ipam-driver string   IP Address Management Driver (default
                             "default")
      --ipam-opt map         Set IPAM driver specific options (default
                             map[])
      --ipv6                 Enable IPv6 networking
      --label list           Set metadata on a network
  -o, --opt map              Set driver specific options (default map[])
      --scope string         Control the network's scope
      --subnet strings       Subnet in CIDR format that represents a
                             network segment

选项

名称，简写	默认	说明
--attachable	false	启用手动容器安装
--aux-address	map[]	网络驱动程序使用的辅助IPv4或IPv6地址
--driver, -d	bridge	驱动程序管理网络
--gateway		用于主子网的IPv4或IPv6网关ip地址
--internal	false	限制对网络的外部访问
--ip-range		从子范围分配容器ip
--ipam-driver	default	IP地址管理驱动程序
--ipam-opt	map[]	设置IPAM驱动程序的具体选项
--ipv6	false	启用IPv6网络
--label		在网络上设置元数据
--opt, -o	map[]	设置驱动程序特定选项
--subnet		表示网段的CIDR格式的子网

自定义网络如下

#自定义网络
#--driver bridge 桥接
# --subnet 子网
# --gateway IP地址
docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
#可以看到mynet已经创建成功
> docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
94904d2257fd        bridge              bridge              local
3d9c46325fc5        host                host                local
156d84302f82        mynet               bridge              local
b088101353ed        none                null                local

查看创建的网络详情

docker network inspect mynet

启动两个Tomcat，再次查看网络

docker exec -it tomcat01 ping tomcat02
docker exec -it tomcat02 ping tomcat01
#都可以直接ping通

自定义网络docker，当我们维护好了对应的关系，推荐平时使用这样的网络。

网络连通

docker network connet

docker-compose

docker-compose up 执行流程

1. 创建网络
2. 执行docker-compose yaml
3. 启动服务

docker-compose yaml编写

version: "2" #版本
services: #服务
        服务1:web
                #服务配置
                images:
                build
                network
        服务2: redis
            ...
        服务3:mysql
            ...
volumes:
networks:
config

注意depends_on选项

官方文档https://docs.docker.com/compose/compose-file/#specifying-durations