Docker

Docker学习笔记

一、Docker出现的原因

复制代码

Docker主要解决了环境不一致、资源浪费、部署复杂、依赖管理等问题，通过容器化实现应用的隔离、轻量、快速部署和跨环境一致性。

原理流程：

复制代码

 1.常规：Java编写-->apk软件 --->发布（应用商店）-->张三使用apk-->安装即可使用！

 2.Docker: Java编写-->jar(环境)--->打包项目带上环境（镜像）---> (放入Docker仓库：商店)--->张三下载发布的镜像运行即可

核心思想：打包装箱，每个箱子之间相互隔离。
Docker是一种容器化技术，容器化技术的一个特点是：模拟的不是一个完整的操作系统，和虚拟机模拟一个完整的系统不相同。
容器内的应用直接运行在宿主机的内容，容器是没有自己的内核的，也没有虚拟我们的硬件，所以就轻便了。
每个容器间是互相隔离，每个容器内都有一个属于自己的文件系统，互不影响。

二、常用的名词解释

镜像(image):

docker镜像就好比是一个模板,可以通过这个模板来创建容器服务,tomcat镜像===>run ==>tomcat01 容器(提供服务器)通过这个镜像可以创建多个容器(最终服务运行或者项目运行就是在容器中的)
容器(container): Docker利用容器技术，独立运行一个或者一个组应用，通过镜像来创建的。目前就可以把这个容器理解为就是一个简易的linux系统。
仓库(repository)：仓库就是存放镜像的地方。
Docker的原理

三、centos安装Docker

复制代码

  1.查看系统CentOS版本是否是3.10及其以上。查看命令如下：

       unmae -r

  2.如果之前安装过，需要卸载：

js 复制代码

yum remove docker  docker-common docker-selinux docker-engine

复制代码

   3.安装yum-utils:

js 复制代码

yum install -y yum-utils

复制代码

   4.配置yum的源：注意这里建议直接装阿里云的，其作用是确保Yum获取到最新的软件包信息，提高后续使用Yum进行软件包安装、更新、搜索等操作时的效率

html 复制代码

yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

复制代码

   5.查看可安装的版本：

js 复制代码

yum list docker-ce --showduplicates | sort -r

复制代码

   6.我这边安装的版本如下（默认最新版本）：

js 复制代码

yum -y install docker-ce

复制代码

   7.启动docker:

js 复制代码

systemctl start docker //启动
systemctl enable docker //设置开机自启动

复制代码

   8.查看docker是否安装成功

js 复制代码

docker version

复制代码

   9.创建目录：sudo mkdir -p /etc/docker

  10.当运行docker pull nginx或者（docker run hello-world）时出现docker: Error response from daemon: Get             "https://registry-1.docker.io/v2/错误时（网上阿里云的镜像加速器很多都不行）

解决方法如下：

复制代码

a.修改Docker的配置文件sudo vi /etc/docker/daemon.json，添加以下内容：

js 复制代码

{
    "runtimes": {
        "nvidia": {
            "args": [],
            "path": "nvidia-container-runtime"
        }  //启用NVIDIA GPU容器运行时支持，使容器能够访问宿主机GPU
    },
    "registry-mirrors": [
        "https://docker.registry.cyou",
        "https://docker-cf.registry.cyou",
        "https://dockercf.jsdelivr.fyi",
        "https://docker.jsdelivr.fyi",
        "https://dockertest.jsdelivr.fyi",
        "https://mirror.aliyuncs.com",
        "https://dockerproxy.com",
        "https://mirror.baidubce.com",
        "https://docker.m.daocloud.io",
        "https://docker.nju.edu.cn",
        "https://docker.mirrors.sjtug.sjtu.edu.cn",
        "https://docker.mirrors.ustc.edu.cn",
        "https://mirror.iscas.ac.cn",
        "https://docker.rainbond.cc"
    ]
}

复制代码

  b.重新加载服务：systemctl daemon-reload

  c.重启docker服务：systemctl restart docker

ps:以下镜像也可以

md 复制代码

{
  "debug": true,
  "experimental": true,
  "features": {
    "buildkit": true
  },
  "insecure-registries": [],
  "registry-mirrors": [
    "https://docker.1ms.run",
    "https://docker.mirrors.tuna.tsinghua.edu.cn",
    "https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo",
    "https://mirrors.ustc.edu.cn/docker-ce/linux/centos/docker-ce.repo",
    "http://hub-mirror.c.163.com",
    "https://mirror.ccs.tencentyun.com",
    "https://mirror.baidubce.com",
    "https://mirror.ccs.tencentyun.com",
    "https://ccr.ccs.tencentyun.com"
  ],
  "storage-driver": "overlay2"
}

三、Docker run的原理如下：

四、Docker的底层原理

docke是什么工作的？

Docker 是一个 Client-Server 结构的系统，Docker的守护进行运行在宿主主机上。通过Socket从客户端访问!

DockerServer接收到 Docker-Client的指令，就会执行这个命令!

docker为什么比vm快？

1.docker有着比虚拟机更少的抽象层

2.docker利用的是宿主主机的内核，vm则是虚拟机的内核

所以说，新建一个容器的时候，docker不需要想虚拟机一样重新加载一个操作系统内核，避免引导。虚拟机是加载 Guest Os，分钟级别的，而docker 是利用宿主机的操作系统吗，省略了这个复杂的过程，秒级!

docker search 搜索镜像

--filter=STARS=3000搜索出来的镜像就是STARS大于3000的，例如：docker search mysql --filter=STARTS=3000

docker pull 下载镜像

js 复制代码

[root@lucky liuwei]# docker pull mysql
Using default tag: latest  //如果不写tag就默认下载最新的
latest: Pulling from library/mysql
cea172a6e83b: Pull complete  //分层下载，docker image的核心，联合文件系统
daac2c594bdd: Pull complete 
cb8acbf2440c: Pull complete 
fae51f7de1fb: Pull complete 
b2ead3e96e6b: Pull complete 
769c3ac51f88: Pull complete 
79f239a40e62: Pull complete 
c11056354384: Pull complete 
49978e7ccddf: Pull complete 
548990e33276: Pull complete 
Digest: sha256:0596fa224cdf3b3355ce3ddbfd7ce77be27ec9e51841dfc5d2e1c8b81eea69d2
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest //默认下载的mysql的真实地址 ，即docker pull mysql==docker pull docker.io/library/mysql:latest

docker rmi删除镜像

删除指定的命令：docker rmi -f 镜像的id
docker rmi -f 容器id 容器id 容器id 容器id
删除多个容器docker rmi -f $(docker images -aq) # 删除全部的容器

容器命令

说明:我们有了镜像才可以创建容器，linux，下载一个 centos 镜像来测试学习。

docker pull centos

新建容器并启动

docker run $可选参数$ image

md 复制代码

#参数说明


--name='Name      容器名字 tomcat0l tomcat02，用来区分容器
-d                后台方式运行
-it               使用交互方式运行，进入容器查看内容
-p (小写三种方式)  指定容器的端口-p 8080:8080
    -p ip:主机端口:容器端口
    -p 主机端口:容器端口 (常用)
    -p 容器端口
    容器端口
-P(大写)           随机指定端口

#测试，启动并进入容器
docker run -it centos /bin/bash  //启动并进入centos容器

ls  //查看容器内的centos基础版本

exit //从容器中退回主机
docker ps    //列出当前正在运行的容器
docker ps -a  //列出当前正在运行的容器+带出历史运行过的容器
docker ps -n=?  //显示最近创建的容器
docker ps -q  //只显示容器的编号

#推出容器
exit           //直接容器停止并退出
Ctrl + P + Q   //容器不停止退出

#删除容器

docker rm 容器id                   //删除指定的容器，不能删除正在运行的容器，如果要强制删除 docker rm -f
docker rm -f $(docker ps -aq)     //删除所有容器
docker ps -a-q|xargs docker rm    //删除所有的容器


#启动和停止容器的操作
docker start 容器id        //启动容器
docker restart 容器id      //重启容器
docker stop 容器id         //停止当前正在运行的容器
docker ki11 容器id         //强制停止当前容器

#常用的其它命令-后台启动容器
docker run -d 镜像名     //后台启动容器
docker run - d centos   //会启动发现centos停止了，
                        //常见的坑:docker容器使用后台运行，就必须要有要一个前台进程，docker发现没有应用，就会自动停止
                        //nginx，容器启动后，发现自己没有提供服务，就会立刻停止，就是没有程序了


#查看日志
docker 1ogs -f -t --tail   // 容器，没有日志
docker 1ogs tf             // 显示日志
docker 1ogs --tail number  // 显示number条数日子


#查看容器中进程信息
docker top 容器id  //   查看容器中进程信息

#查看镜像的元数据
docker inspect 容器id 

#进入当前正在运行的容器
我们通常容器都是使用后台方式运行的，需要进入容器，修改一些配置
docker exec -it  容器id  bashShell  //进入容器后开启一个新的终端（常用）
docker attach 容器id               //进入容器正在执行的终端，不会启动新的进程！

#容器内拷贝文件到宿主主机上

docker cp 容器id：容器内路径  目的主机路径

部署Nginx

md 复制代码

docker pull nginx  下载Nginx镜像
# -d   后台运行
# --name  给容器命名
#  -p 宿主机端口，容器内部端口
docker run -d --name 容器名称 -p 3344:80 nginx

思考问题:我们每次改动nginx配置文件，都需要进入容器内部?十分的麻烦，我要是可以在容器外部提供一个映射路径，达到在

容器修改文件名，容器内部就可以自动修改?- 数据卷!

部署tomcat

md 复制代码

docker pull tomcat:9.0 //下载镜像

docker run -d -p 3344:8080 --name tomcat03 tomcat   //启动运行


docker exec -it tomcat03 /bin/bash  //进入容器

思考问题:我们以后要部署项目,如果每次都要进入容器是不是十分麻烦?我要是可以在容器外部提供一个映射路径，webapps我们在外部放置项目，就自动同步到内部就好了!

查看容器状态并进行修改

md 复制代码

docker state  //查看状态
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2  //修改配置文件 -e 环境配置修改

可视化

portainer(少用)

复制代码

概念：Docker图形化界面管理工具!提供一个后台面板供我们操作!

md 复制代码

docker run -d -p 8088:9000 --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer   //下载启动portainer

curl localhost:8088   //连接

五、Docker镜像讲解

镜像是什么

镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件,它包含运行某个软件所需的所有内

容，包括代码、运行时、库、环境变量和配置文件。

所有的应用，直接打包docker镜像，就可以直接跑起来！

如何得到镜像:

从远程仓库下载
朋友拷贝给你
自己定制一个镜像-DockerFile

** Docker镜像加载原理**

UnionFS（联合文件系统）

UnionFS（联合文件系统）：Union文件系统(UnionFs)是一种分层、轻量级并且高性能的文件系统，它文持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into asingle virtualfilesvstem)。Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承,基于基础镜像(没有父镜像),可以制作各种具体的应用镜像。

特性:一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录。

docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFs。

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等等。

平时我们安装进虚拟机的CentOS都是好几个G，为什么Docker这里才200M?

答：对于一个精简的0S，roots 可以很小，只需要包含最基本的命令，工县和程序库就可以了，因为底层直接用Host的kerel，自己只需要提供rootfs就可以了。由此可见对于不同的linux发行版,bootfs基本是一致的,rootfs会有差别,因此不同的发行版可以公用

bootfs.

特点

Docker镜像都是只读的，当容器启动时，一个新的可写层被加载到镜像的顶部！

这一层就是我们通常说的容器层，容器之下的都叫镜像层!

commit镜像

md 复制代码

docker commit 提交容器成为一个新的副本


#命令和git相似
docker commit -m="提交的描述信息" -a="作者" 容器id 目标镜像名，[TAG]

实战测试

md 复制代码

#1.启动一个默认的tomcat

#2.发现这个默认的tomcat是没有webapps应用，镜像的原因，官方的镜像默认webapps下面是没有文件的！

#3.自己拷贝进去了基本的文件
#4.将我们操作过的容器通过commit提交为一个镜像!我们以后就使用我们修改过的镜像即可，这就是我们自己的一个修改的镜像

六、容器数据卷

什么是容器数据卷？

数据?如果数据都在容器中，那么我们容器删除，数据就会丢失! 需求:数据可以持久化

容器之间可以有一个数据共享的技术!Docker 容器中产生的数据，同步到本地! 这就是卷技术!目录的挂载，将我们容器内的目录，挂载到Linux上面！以到达数据持久化的目的。

总结一句话:容器的持久化和同步操作!容器间也是可以数据共享的!

使用数据卷

md 复制代码

方式一：直接使用命令挂载
docker run -it -v 主机目录:容器内目录

好处:我们以后修改只需要在本地修改即可，容器内会自动同步!

实战测试

md 复制代码

#运行容器，需要做数据挂载! #安装启动mysq1 ，需要配置密码的，这是要注意点!
#官方测试:docker run --name some-mysg1 -e MYSOL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

#启动自己的
docker run -d -p 3310:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql

-d 后台运行
-p 端口映射
-v 卷挂载
-e 环境配置
--name 容器名字

md 复制代码

#启动成功之后，我们在本地使用 sqlyog 来接测试一下
#sqlyog-连接到服务器的3310 --- 3310 和容器内的 3306映射，这个时候我们就可以连接上了!
#在本地测试创建一个数据库，查看一下我们映射的路径是否ok!

注意：假如我们删除了容器，我们会发现，我们挂载到本地的数据卷依旧没有丢失，这就实现了容器数据持久化功能!

具名和匿名挂载

md 复制代码

# 匿名挂载
-v 容器内路径!
docker run -d -P --name nginx01 -v /ect/nginx nginx

# 查看所有的 volume 的情况
docker volume ls

#这里发现，这种就是匿名挂载，我们在-v 只写了容器内的路径，没有写容器外的路径!


#具名挂载
docker run -d -P --name nginx02 -v juming-nginx:/ect/nginx nginx

#通过-v 卷名：容器内路径
#查看一下这个卷
docker volume inspect juming-nginx

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

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

md 复制代码

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


#拓展
# 通过 -v 容器内路径:ro rw 改变读写权限
ro  readonly     //只读
rw  readwrite    //可读可写

#一旦这个了设置了容器权限，容器对我们挂载出来的内容就有限定了!

docker run -d -P --name nginx02 -v juming-nginx:/ect/nginx:ro nginx
docker run -d -P --name nginx02 -v juming-nginx:/ect/nginx:rw nginx
#ro  只要看到ro就说明这个路径只能通过宿主机来操作，容器内部是无法操作

初识Dockerfile

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

通过这个脚本可以生成镜像，镜像是一层一层的，脚本一个个的命令，每个命令都是一层!

md 复制代码

#创建一个dockerfile文件，名字可以随机 建议 Dockerfile
# 文件中的内容 指令(大写) 参数
FROM tomcat
VOLUME ["volume01","volume02"]

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

#这里的每一个命令。就像是镜像的一层！

数据卷容器

多个mysql数据同步的问题！

md 复制代码

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

#这个时候。可以实现两个容器的同步！

七、DockerFile

DockerFile介绍

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

构建步骤：

1、编写一个 dockerfile 文件

2、docker build 构建成为一个镜像

3、docker run 运行镜像

4、docker push 发布镜像(DockerHub、阿里云镜像仓库!)

DockerFile的构造过程

基础知识

1、每个保留关键字(指令)都是必须是大写字母

2、执行从上到下顺序执行

3、# 表示注释

4、每一个指令都会创建提交一个新的镜像层，并提交!

dockerfile是面向开发的，我们以后要发布项目即做镜像，就需要编写dockerfile文件，这个文件十分简单!

Docker镜像逐渐成为企业交付的标准，必须要掌握!

DockerFile: 构建文件，定义了一切的步骤，源代码

Dockerlmages:通过 DockerFile 构建生成的镜像，最终发布和运行的产品!

Docker容器:容器就是镜像运行起来提供服务器！

dockerfile的指令

md 复制代码

FROM        // 基础镜镜像，一切从这里开始构建
MAINTAINER  // 镜像是谁写的，姓名+邮箱
RUN         // 镜像构建的时候需要运行的命令
ADD         // 步骤:tomcat镜像，这个tomcat压缩包!添加内容
WORKDIR     // 镜像的工作目录
VOLUME      // 挂载的目录
EXPOST      // 保留端口配置

CMD         // 指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT  // 指定这个容器的时候要运行命令，可以追加命令
ONBUILD     // 当构建一个被继承 DockerFi1e 这个时候就会运行 ONBUILD 的指令。触发指令。
COPY        // 类似ADD ，将我们文件拷贝到镜像中
ENV         // 构建的时候设置环境变量！

实战测试

创建自己的centos

md 复制代码

#1、编写Dockerfile的文件

[root@lucky dockerfile]# cat mydockerfile 
FROM centos
MAINTAINER liuwei
ENV MYPATH /usr/local
WORKDIR $MYPATH
RUN yum -y install vim
RUN yum -y install net-tools
EXPOSE 80
CMD echo $MYPATH
CMD eche "-----end-------"
CMD /bin/bash
[root@lucky dockerfile]# 

#2、通过该文件构建自己的镜像
#命令 docker build -f dockerfile文件路径 -t 镜像名:[tag]
 docker build -f mydockerfile -t mycentos:0.1 .

#3、测试运行

实战：Tomcat镜像

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

2、编写dockerfile文件，官方命名Dockerfile ，build会自动寻找这个文件，就不需要-f指定了！

md 复制代码

FROM tomcat

# 编写的作者信息
MAINTAINER liuwei
# 复制当前目录下readme.txt文件，到容器/usr/local中
COPY readme.txt /usr/local/readme.txt
# 添加jdk，ADD 命令会自动解压到/usr/local目录 
ADD jdk-8u202-linux-x64-demos.tar.gz /usr/local/
# 添加tomcat，ADD 命令会自动解压到/usr/local目录 
ADD apache-tomcat-7.0.108.tar.gz /usr/local
# 设置MYPATH
ENV MYPATH /usr/local
# 工作目录,引用MYPATH
WORKDIR $MYPATH
# 配置环境变量：JAVA_HOME环境变量
ENV JAVA_HOME /usr/local/jdk1.8.0_11
# 配置CLASSPATH
ENV CLASSPATH $JAVA_HOME/lib//dt.jar:$JAVA_HOME/lib/tools.jar
# 环境变量： tomcat环境变量
ENV CATALINA_HOME /usr/local/apache-tomcat-7.0.108

ENV CATALINA_BASH /usr/local/apache-tomcat-7.0.108
# 设置环境变量 分隔符是：
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 8080

CMD /usr/local/apache-tomcat-7.0.108/bin/startup.sh && tail -F /usr/local/apache-tomcat-7.0.108/bin/logs/catalina.out
_HOME/bin
# 设置暴露的端口
EXPOSE 8080
# 设置默认命令，这里设置了启动指定目录下的startup.sh程序以及日志
CMD /usr/local/apache-tomcat-7.0.108/bin/startup.sh && tail -F /usr/local/apache-tomcat-7.0.108/bin/logs/catalina.out

3、构建镜像

md 复制代码

docker build -t diytomcat . //构建镜像

4、启动镜像

md 复制代码

docker run -d -p 9090:8080 --name liuweitomcat -v /home/liuwei/build/tomcat/test:/url/local/apache-tomcat-7.0.108/webapps/test -v /home/liuwei/build/tomcat/tomcatlogs/:/url/local/apache-tomcat-7.0.108/logs diytomcat

5、启动容器测试

md 复制代码

docker exec -it cdde57bc2b23 /bin/bash

6、项目发布

由于做了卷挂载，我们直接在本地（挂载位置）编写项目就可以发布了！

小结

八、Docker网络

理解docker0

清除所有环境

md 复制代码

docker rm -f $(docker ps -aq)   //移除所有容器

docker rmi -f $(docker images -aq)  //清空所有镜像

s

三个网络

md 复制代码

#启动一个tomcat
docker run -d -P --name tomcar01 tomcat
#查看网络地址 ip addr

我们每启动一个docker容器，docker就会给docker容器分配一个ip,我们只要安装了docker,就会有一个网卡 docker0

桥接模式，使用的技术是 evth-pair 技术!

再次测试ip addr时，会发现多了连个网卡（后台启动了两个容器）

可以发现，这个容器带的网卡，都是一对对的（我这里inet地方是ipv6）

evth-pair 就是一对的虚拟设备接口，他们都是成对出现的，一段连着协议，一段彼此相连。

正因为有这个特性，evth-pair 充当一个桥梁，连接各种虚拟网络设备的

绘制通信的网络模型

结论:tomcat01和tomcat02 是公用的一个路由器，docker0。

Docker 使用的是Linux的桥接，宿主机中是一个Dokcer容器的网桥 docker0。

只要容器删除，对应网桥的一对就被删除！

--link

md 复制代码

docker run -d -P  --name tomcat03 --link tomcat02 tomcat   //通过--link连接后即可ping通tomcat03和tomcat02

docker exec -it tomcat02 ping tomcat03     //此时ping不通，因为tomcat02没有连接tomcat03


原因：--link 就是我们在hosts配置中增加了一个 映射（目前不建议使用了！）

自定义网络

查看docker网络

网络模式

md 复制代码

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

测试

md 复制代码

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

 # docker0特点，默认，域名不能访问，--link可以打通连接！
 # 此时自定义一个网络！
 docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

在这个网络里启动两个tomcat

md 复制代码

docker run -d -P --name tomcat-net-01 --net mynet tomcat
docker run -d -P --name tomcat-net-02 --net mynet tomcat


#测试结果如下
[root@lucky liuwei]# docker run -d -P --name tomcat-net-01 --net mynet tomcat
02b6b7d5fd08f427bbfb149e5ef595e4045c28df037cb534f1e46ac481d7ca12
[root@lucky liuwei]# docker run -d -P --name tomcat-net-02 --net mynet tomcat
c073b10c946fa455ed522eb08ae34760dfc0b51e2d86c7d218ecfe52926aa24b
[root@lucky liuwei]# docker network inspect mynet
[
    {
        "Name": "mynet",
        "Id": "80bbe30d201aaa348c6479b383bc70ac1fb610f2cad36b806eaa12eff4e2b3ae",
        "Created": "2025-04-10T17:34:49.924055471+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/16",
                    "Gateway": "192.168.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {
            "02b6b7d5fd08f427bbfb149e5ef595e4045c28df037cb534f1e46ac481d7ca12": {
                "Name": "tomcat-net-01",
                "EndpointID": "af1aa58d2fbc91243e389f566a0d43ac967b7088d945c6e4b5573d20607177dd",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",
                "IPv6Address": ""
            },
            "c073b10c946fa455ed522eb08ae34760dfc0b51e2d86c7d218ecfe52926aa24b": {
                "Name": "tomcat-net-02",
                "EndpointID": "aab8e597af54bd71a70babd9a122569cc252a00fd174a8dcb0480e4087174c32",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            }
        },
        "Options": {},
        "Labels": {}
    }
]
[root@lucky liuwei]#

此时不再使用--link也能ping通，我们自定义的网络docker都已经帮我们维护好了对应的关系，推荐我们平时这样使用网络!

网络联通

问题，此时两个网络要打通，即172.168.0.1与192.168.0.1连接起来

通过docker network connect进行联通

md 复制代码

#测试
docker network connect mynet tomcat01  //运行此命令进行连通

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

Docker学习笔记

一、Docker出现的原因

二、常用的名词解释

三、centos安装Docker

三、Docker run的原理如下：

四、Docker的底层原理

五、Docker镜像讲解

六、 容器数据卷

使用数据卷

实战测试

具名和匿名挂载

初识Dockerfile

数据卷容器

七、DockerFile

DockerFile介绍

DockerFile的构造过程

dockerfile的指令

实战测试

实战：Tomcat镜像

小结

八、Docker网络

理解docker0

--link

自定义网络

网络联通

六、容器数据卷