狂神docker笔记md文件 docker 狂神说

容器数据卷

什么是容器数据卷

将应用和环境打包成一个镜像！

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

MySQL，容器删除了，删库跑路！需求：MySQL数据可以存储在本地！

容器之间可以有一个数据共享的技术！Docker容器中产生的数据，同步到本地！

这就是卷技术！目录的挂载，将我们容器内的目录，挂载到Linux上面！

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

使用数据卷

-v, --volume list                    Bind mount a volume

docker run -it -v 主机目录:容器内目录  -p 主机端口:容器内端口
# /home/ceshi：主机home目录下的ceshi文件夹  映射：centos容器中的/home
yons@yons-X10SRA:/home$ sudo docker run -it -v /home/ceshi:/home centos /bin/bash
#这时候主机的/home/ceshi文件夹就和容器的/home文件夹关联了,二者可以实现文件或数据同步了

#通过 docker inspect 容器id 查看
yons@yons-X10SRA:/home$ sudo docker inspect 6064c490c371

同步测试

再来测试！

1、停止容器

2、宿主机修改文件

3、启动容器

4、容器内的数据依旧是同步的

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

安装mysql

思考：MySQL的数据持久化的问题

#下载镜像（之前已经有了）
yons@yons-X10SRA:/$ sudo docker pull mysql:5.7
#查看镜像
yons@yons-X10SRA:/$ sudo docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
tomcat              latest              266d1269bb29        8 days ago          668MB
nginx               latest              dd34e67e3371        9 days ago          133MB
mysql               5.7                 6c20ffa54f86        9 days ago          448MB
rancher/rancher     latest              d7329a56a8e4        6 weeks ago         1.06GB
#容器名字已经存在要么更名要么先删除以前安装的容器
#-d 后台运行
#-p 端口映射
#-v 卷挂载
#-e 环境配置
#-- name 容器名字
yons@yons-X10SRA:/$ sudo docker run -d -p 3306: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
docker: Error response from daemon: Conflict. The container name "/mysql01" is already in use by container "58a8512336d2c9bc83d8404d85fa56d3cee18a7c1dce8193830905b7b8373792". You have to remove (or rename) that container to be able to reuse that name.
See 'docker run --help'.
#根据容器id删除容器
yons@yons-X10SRA:/$ sudo docker rm 58a8512336d2c9bc8
58a8512336d2c9bc8
#重新安装
yons@yons-X10SRA:/$ sudo docker run -d -p 3306: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
616bb0550099503223ba6e07088704a6cb2ef91719166411fd457df914214bcc
#查看正在运行的容器
yons@yons-X10SRA:/$ sudo docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                                      NAMES
616bb0550099        mysql:5.7           "docker-entrypoint.s…"   37 seconds ago      Up 36 seconds       0.0.0.0:3306->3306/tcp, 33060/tcp          mysql01
3df285ffe05f        tomcat              "catalina.sh run"        25 hours ago        Up 25 hours         0.0.0.0:8080->8080/tcp                     tomcat01
0db996879b02        rancher/rancher     "entrypoint.sh"          2 weeks ago         Up 3 minutes        0.0.0.0:80->80/tcp, 0.0.0.0:443->443/tcp   rancher
yons@yons-X10SRA:/$

连接测试

在连接成功后创建fod数据库及表

进入宿主机查看目录查看/home/mysql/data

进入容器目录查看 /var/lib/mysql

此时我们删除容器：发现挂载在主机上的还在

具名和匿名挂载

# 匿名挂载
-v 容器内路径!
yons@yons-X10SRA:/$ docker run -d -P --name nginx01 -v /etc/nginx nginx

# 查看所有的volume(卷)的情况
yons@yons-X10SRA:/$ sudo docker volume ls    
DRIVER              VOLUME NAME # 容器内的卷名(匿名卷挂载)
local               21159a8518abd468728cdbe8594a75b204a10c26be6c36090cde1ee88965f0d0
local               b17f52d38f528893dd5720899f555caf22b31bf50b0680e7c6d5431dbda2802c
         
# 这里发现，这种就是匿名挂载，我们在 -v只写了容器内的路径，没有写容器外的路径！

# 具名挂载 -P:表示随机映射端口
yons@yons-X10SRA:/$ sudo docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx
9663cfcb1e5a9a1548867481bfddab9fd7824a6dc4c778bf438a040fe891f0ee

# 查看所有的volume(卷)的情况
yons@yons-X10SRA:/$ sudo docker volume ls                  
DRIVER              VOLUME NAME
local               21159a8518abd468728cdbe8594a75b204a10c26be6c36090cde1ee88965f0d0
local               b17f52d38f528893dd5720899f555caf22b31bf50b0680e7c6d5431dbda2802c
local               juming-nginx #多了一个名字

# 通过 -v 卷名：查看容器内路径
# 查看一下这个卷
yons@yons-X10SRA:/$ sudo docker volume inspect juming-nginx
[
    {
        "CreatedAt": "2020-05-23T13:55:34+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/juming-nginx/_data", #默认目录
        "Name": "juming-nginx",
        "Options": null,
        "Scope": "local"
    }
]

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

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

挂载分类

-v 容器内路径   #匿名挂载
-v 卷名：容器内路径  #具名挂载
-v /宿主机路径：容器内路径  #指定路径挂载

拓展

# 通过 -v  容器内路径：ro rw 可以改变读写权限
ro readonly #只读
rw readwrite #可读可写

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

初识Dockerfile

dockerfile就是用来构建docker镜像的构建文件！命令脚本，先体验下
通过这个脚本可以生产镜像，镜像是一层一层的，脚本是一个个的命令，每个命令都是一层！

#创建一个dockerfile文件，名字可以随机建议Dokcerfile
#文件中的内容指令（大写） 参数
FROM centos
VOLUME ["volume01","volume02"]
CMD echo "---end---"
CMD /bin/bash
#这里的每个命令，就是镜像的一层！

#编写dockerfile
$ vim dockerfile1
    FROM centos 					# 当前这个镜像是以centos为基础的
    VOLUME ["volume01","volume02"] 	# 挂载卷的卷目录列表(多个目录)
    CMD echo "-----end-----"		# 输出一下用于测试
    CMD /bin/bash					# 默认走bash控制台
    
# 构建出这个镜像 
-f dockerfile1 			# f代表file，指这个当前文件的地址(这里是当前目录下的dockerfile1)
-t caoshipeng/centos 	# t就代表target，指目标目录(注意caoshipeng镜像名前不能加斜杠‘/’)
. 						# 表示生成在当前目录下 .点不能去掉
sudo docker build -f dockerfile1 -t damon/centos .
 ....
 
# 查看自己构建的镜像
sudo docker images

启动自己写的容器镜像

#命令
docker run -it 容器id /bin/bash
ls -l

我们定义的在dockerfile中的卷和外部一定有一个同步的目录

#命令
docker inspect 容器id

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

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

数据卷容器

多个MySQL同步数据！

命名的容器挂载数据卷 --volumes-from

# 测试 启动3个容器，通过刚才自己写的镜像启动
# 创建docker01：
$ sudo docker run -it --name docker01 damon/centos:latest

# 查看容器docekr01内容
$ ls
bin  home   lost+found	opt   run   sys  var
dev  lib    media	proc  sbin  tmp  volume01
etc  lib64  mnt		root  srv   usr  volume02

# 不关闭该容器退出
CTRL + Q + P  

# 创建docker02: 并且让docker02 继承 docker01
$ sudo docker run -it --name docker02 --volumes-from docker01 damon/centos:latest

# 查看容器docker02内容
$ ls
bin  home   lost+found	opt   run   sys  var
dev  lib    media	proc  sbin  tmp  volume01
etc  lib64  mnt		root  srv   usr  volume02

测试发现

docker02的volume01中同步到docker01创建的文件

docker01的volume01中同步到docker02创建的文件

# 再新建一个docker03同样继承docker01
$ docker run -it --name docker03 --volumes-from docker01 caoshipeng/centos:latest
$ cd volume01	#进入volume01 查看是否也同步docker01的数据
$ ls 
docker01.txt

# 测试：可以删除docker01，查看一下docker02和docker03是否可以访问这个文件
# 测试发现：数据依旧保留在docker02和docker03中没有被删除

多个MySQL实现数据共享

$ docker run -d -p 3306: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

$ docker run -d -p 3310:3306 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql01  mysql:5.7
# 这个时候，可以实现两个容器数据同步！

结论：
容器之间的配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止。
但是一旦你持久化到了本地，这个时候，本地的数据是不会删除的！

DockerfFile

DockerfFile介绍

dockerfile是用来构建docker镜像的文件！命令参数脚本！
构建步骤：
1、 编写一个dockerfile文件
2、 docker build 构建称为一个镜像
3、 docker run运行镜像
4、 docker push发布镜像（DockerHub 、阿里云仓库)

很多官方镜像都是基础包，很多功能没有，我们通常会自己搭建自己的镜像！官方既然可以制作镜像，那我们也可以！

DockerFile构建过程

基础知识：

• 每个保留关键字（指令）必须大写
• 执行从上到下顺序
• #表示注释
• 每个指令都会创建提交一个新的镜像层
  
  DockerFile是面向开发的，我们以后要发布项目，做镜像，就需要编写DockerFile文件
  DockerFile镜像逐渐成为交付标准，需要掌握
  DockerFile构建文件，定义一切的步骤，源代码
  DockerImages通过DockerFile构建生成的镜像，最终发布和运行产品
  DockerFile容器 容器就是镜像运行起来提供服务

DockerFile的指令

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

实战测试 创建一个自己的centos

在线下载的centos 是基础版本 没有vim命令 我创建一个自己的具有vim功能的镜像

# 1./home下新建dockerfile目录
$ mkdir dockerfile

# 2. dockerfile目录下新建mydockerfile-centos文件
$ vim mydockerfile-centos

# 3.编写Dockerfile配置文件
FROM centos							# 基础镜像是官方原生的centos
MAINTAINER damon<[e-mail]> 	# 作者

ENV MYPATH /usr/local				# 配置环境变量的目录 
WORKDIR $MYPATH						# 将工作目录设置为 MYPATH

RUN yum -y install vim				# 给官方原生的centos 增加 vim指令
RUN yum -y install net-tools		# 给官方原生的centos 增加 ifconfig命令

EXPOSE 80							# 暴露端口号为80

CMD echo $MYPATH					# 输出下 MYPATH 路径
CMD echo "-----end----"				
CMD /bin/bash						# 启动后进入 /bin/bash

# 4.通过这个文件构建镜像
# 命令： docker build -f 文件路径 -t 镜像名:[tag] .
$ docker build -f mydockerfile-centos -t mycentos:0.1 .

# 5.构建成功
Successfully built 8aa37fc5b6a9
Successfully tagged mycentos:0.1

$ docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
mycentos            0.1                 8aa37fc5b6a9      2 minutes ago       311MB

# 6.测试运行
$ docker run -it mycentos:0.1 		# 注意带上版本号，否则每次都回去找最新版latest

$ pwd	
/usr/local							# 与Dockerfile文件中 WORKDIR 设置的 MYPATH 一致
$ vim								# vim 指令可以使用
$ ifconfig     						# ifconfig 指令可以使用

# docker history 镜像id 查看镜像构建历史步骤
$ docker history 镜像id

[root@localhost dockerfile]# docker history mycentos:0.1
IMAGE               CREATED             CREATED BY                                      SIZE                COMMENT
8aa37fc5b6a9        6 minutes ago       /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "/b...   0 B
866bdee7f3af        6 minutes ago       /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "ec...   0 B
08c16af8ed43        6 minutes ago       /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "ec...   0 B
f3cc608b41c8        6 minutes ago       /bin/sh -c #(nop)  EXPOSE 80/tcp                0 B
7346919df188        6 minutes ago       /bin/sh -c yum -y install net-tools             28.4 MB
106905b0b7d1        6 minutes ago       /bin/sh -c yum -y install vim                   66.3 MB
3b5648db6137        7 minutes ago       /bin/sh -c #(nop) WORKDIR /usr/local            0 B
5ee5086be218        7 minutes ago       /bin/sh -c #(nop)  ENV MYPATH=/usr/local        0 B
6c4ca076a25b        7 minutes ago       /bin/sh -c #(nop)  MAINTAINER damon<100702...   0 B
5d0da3dc9764        4 months ago        /bin/sh -c #(nop)  CMD ["/bin/bash"]            0 B
<missing>           4 months ago        /bin/sh -c #(nop)  LABEL org.label-schema....   0 B
<missing>           4 months ago        /bin/sh -c #(nop) ADD file:805cb5e15fb6e0b...   231 MB
[root@localhost dockerfile]#

我们平时拿到一个镜像，可以用 “docker history 镜像id” 研究一下是什么做的

CMD 和 ENTRYPOINT区别

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

测CMD

# 编写dockerfile文件
$ vim dockerfile-test-cmd
FROM centos
CMD ["ls","-a"]					# 启动后执行 ls -a 命令

# 构建镜像
$ docker build  -f dockerfile-test-cmd -t cmd-test:0.1 .

# 运行镜像
$ docker run cmd-test:0.1		# 由结果可得，运行后就执行了 ls -a 命令
.
..
.dockerenv
bin
dev
etc
home

# 想追加一个命令  -l 成为ls -al：展示列表详细数据
$ docker run cmd-test:0.1 -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:349: starting container process caused "exec: \"-l\":
executable file not found in $PATH": unknown.
ERRO[0000] error waiting for container: context canceled 

# cmd的情况下 -l 替换了CMD["ls","-l"] 而 -l  不是命令所以报错

测试ENTRYPOINT

# 编写dockerfile文件
$ vim dockerfile-test-entrypoint
FROM centos
ENTRYPOINT ["ls","-a"]

# 构建镜像
$ docker build  -f dockerfile-test-entrypoint -t cmd-test:0.1 .

# 运行镜像
$ docker run entrypoint-test:0.1
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
lost+found ...

# 我们的命令，是直接拼接在我们得ENTRYPOINT命令后面的
$ docker run entrypoint-test:0.1 -l
total 56
drwxr-xr-x   1 root root 4096 May 16 06:32 .
drwxr-xr-x   1 root root 4096 May 16 06:32 ..
-rwxr-xr-x   1 root root    0 May 16 06:32 .dockerenv
lrwxrwxrwx   1 root root    7 May 11  2019 bin -> usr/bin
drwxr-xr-x   5 root root  340 May 16 06:32 dev
drwxr-xr-x   1 root root 4096 May 16 06:32 etc
drwxr-xr-x   2 root root 4096 May 11  2019 home
lrwxrwxrwx   1 root root    7 May 11  2019 lib -> usr/lib
lrwxrwxrwx   1 root root    9 May 11  2019 lib64 -> usr/lib64 ....

Dockerfile中很多命令都十分的相似，我们需要了解它们的区别，我们最好的学习就是对比他们然后测试效果

实战：创建一个Tomcat镜像

1、准备镜像文件
准备tomcat 和 jdk 到当前目录，编写好README

[root@localhost mytomcat]# ls
apache-tomcat-9.0.11.tar.gz  Dockerfile  jdk-8u192-linux-x64.tar.gz  README
[root@localhost mytomcat]#

2、编写dockerfile

# 2、编写dockerfile
$ vim Dockerfile
FROM centos 										# 基础镜像centos
MAINTAINER damon<[e-mail]>					# 作者
COPY README /usr/local/README 						# 复制README文件
ADD jdk-8u192-linux-x64.tar.gz /usr/local/ 			# 添加jdk，ADD 命令会自动解压
ADD apache-tomcat-9.0.11.tar.gz /usr/local/ 		# 添加tomcat，ADD 命令会自动解压
RUN yum -y install vim								# 安装 vim 命令
ENV MYPATH /usr/local 								# 环境变量设置 工作目录
WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_192 				# 环境变量： JAVA_HOME环境变量
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.11 	# 环境变量： tomcat环境变量
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.11

# 设置环境变量 分隔符是：
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin 	

EXPOSE 8085 										# 设置暴露的端口

CMD /usr/local/apache-tomcat-9.0.11/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.11/logs/catalina.out 					# 设置默认命令

#3、构建镜像
# 因为dockerfile命名使用默认命名 因此不用使用-f 指定文件
$ docker build -t mytomcat:0.1 .

#4 run镜像
# -d:后台运行 -p:暴露端口 --name:别名 -v:绑定路径 
$ docker run -d -p 8085:8085 --name tomcat01 -v /home/damon/build/tomcat/test:/usr/local/apache-tomcat-9.0.11/webapps/test -v /home/damon/build/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.11 -v/logs mytomcat:0.1

#5、访问测试
$ docker exec -it 容器的id /bin/bash
$ cul localhost:8085

6、发布项目
(由于做了卷挂载，我们直接在本地编写项目就可以发布了！)
发现：项目部署成功，可以直接访问！
我们以后开发的步骤：需要掌握Dockerfile的编写！我们之后的一切都是使用docker镜像来发布运行！

发布自己的镜像

发布到docker hub

1、地址 https://hub.docker.com/
2、确定这个账号可以登录
3、登录

$ docker login --help
Usage:  docker login [OPTIONS] [SERVER]

Log in to a Docker registry.
If no server is specified, the default is defined by the daemon.

Options:
  -p, --password string   Password
      --password-stdin    Take the password from stdin
  -u, --username string   Username

$ docker login -u 你的用户名 -p 你的密码

#4、提交 push镜像
$ docker push mytomcat

# 会发现push不上去，因为如果没有前缀的话默认是push到 官方的library
# 解决方法：
# 第一种 build的时候添加你的dockerhub用户名，然后在push就可以放到自己的仓库了
$ docker build -t kuangshen/mytomcat:0.1 .

# 第二种 使用docker tag #然后再次push
$ docker tag 容器id kuangshen/mytomcat:1.0 #然后再次push
$ docker push kuangshen/mytomcat:1.0

发布到阿里云镜像服务上

$ sudo docker login --username=damon registry.cn-shenzhen.aliyuncs.com
$ sudo docker tag [ImageId] registry.cn-shenzhen.aliyuncs.com/xxx/xxx:[镜像版本号]

# 修改id 和 版本
sudo docker tag id registry.cn-shenzhen.aliyuncs.com/xxx/xxx:1.0
# 修改版本
$ sudo docker push registry.cn-shenzhen.aliyuncs.com/xxx/xxx:[镜像版本号]

小结

Docker网络

理解Dokcer0

学习新知识前，清空docker镜像、容器；由于本人的是测试环境不能删除

# 删除全部容器
$ docker rm -f $(docker ps -aq)

# 删除全部镜像
$ docker rmi -f $(docker images -aq)

测试

三个网络

# 测试  运行一个tomcat
$ docker run -d -P --name tomcat01 tomcat

# 查看容器内部网络地址
$ docker exec -it 容器id ip addr

# 发现容器启动的时候会得到一个 eth0@if91 ip地址，docker分配！
$ ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
261: eth0@if91: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:12:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.18.0.2/16 brd 172.18.255.255 scope global eth0
       valid_lft forever preferred_lft forever
     
# 思考？ linux能不能ping通容器内部！ 可以 容器内部可以ping通外界吗？ 可以！
$ ping 172.18.0.2
PING 172.18.0.2 (172.18.0.2) 56(84) bytes of data.
64 bytes from 172.18.0.2: icmp_seq=1 ttl=64 time=0.069 ms
64 bytes from 172.18.0.2: icmp_seq=2 ttl=64 time=0.074 ms

原理

1、我们每启动一个docker容器，docker就会给docker容器分配一个ip，我们只要按照了docker，就会有一个docker0桥接模式，使用的技术是veth-pair技术！

veth-pair看这篇文章就够了 再次测试 ip addr

2、在启动一个容器测试，发现多了一对网络

总结

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

3、我们来测试下Tomcat01和Tomcat02是否可以ping通

# 获取tomcat01的ip 172.17.0.2
$ docker-tomcat docker exec -it tomcat01 ip addr  
550: eth0@if551: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever
       
# 让tomcat02 ping tomcat01       
$ docker-tomcat docker exec -it tomcat02 ping 172.17.0.2
PING 172.17.0.2 (172.17.0.2) 56(84) bytes of data.
64 bytes from 172.17.0.2: icmp_seq=1 ttl=64 time=0.098 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.071 ms
# 结论：容器和容器之间是可以互相ping通

网络模型图

结论：tomcat01和tomcat02公用一个路由器，docker0。

所有的容器不指定网络的情况下，都是docker0路由的，docker会给我们的容器分配一个默认的可用ip。小结

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

docker中所有网络接口都是虚拟的，虚拟的转发效率高（内网传输）

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

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

- -link

$ docker exec -it tomcat02 ping tomca01   # ping不通
ping: tomca01: Name or service not known

# 运行一个tomcat03 --link tomcat02 
$ docker run -d -P --name tomcat03 --link tomcat02 tomcat
5f9331566980a9e92bc54681caaac14e9fc993f14ad13d98534026c08c0a9aef

# 3连接2
# 用tomcat03 ping tomcat02 可以ping通
$ docker exec -it tomcat03 ping tomcat02
PING tomcat02 (172.17.0.3) 56(84) bytes of data.
64 bytes from tomcat02 (172.17.0.3): icmp_seq=1 ttl=64 time=0.115 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=2 ttl=64 time=0.080 ms

# 2连接3
# 用tomcat02 ping tomcat03 ping不通

探索

docker network inspect 网络id 网段相同

docker inspect tomcat03

查看tomcat03里面的/etc/hosts发现有tomcat02的配置

–link 本质就是在hosts配置中添加映射

现在使用Docker已经不建议使用–link了！

自定义网络，不适用docker0！

docker0问题：不支持容器名连接访问！

自定义网络

docker network
connect     -- Connect a container to a network
create      -- Creates a new network with a name specified by the
disconnect  -- Disconnects a container from a network
inspect     -- Displays detailed information on a network
ls          -- Lists all the networks created by the user
prune       -- Remove all unused networks
rm          -- Deletes one or more networks

查看所有的网络

#命令 
docker network ls

[root@localhost ~]# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
26b5f32f4a4a        bridge              bridge              local
95cee67739a4        host                host                local
bedd3d75aaf8        none                null                local
[root@localhost ~]#

网络模式
bridge ：桥接 docker（默认，自己创建也是用bridge模式）
none ：不配置网络，一般不用
host ：和所主机共享网络
container ：容器网络连通（用得少！局限很大）

测试

# 我们直接启动的命令 --net bridge,而这个就是我们得docker0
# 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.1.0/16 --gateway 192.168.1.1 mynet

$ docker network inspect mynet;


[root@localhost ~]# docker network inspect mynet
[
    {
        "Name": "mynet",
        "Id": "b5eb20a76f625b53d31c2078a7caa924fe18b84868f20a363fdd51c08bbe0469",
        "Created": "2022-01-20T09:22:45.842665335+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.1.0/16",
                    "Gateway": "192.168.1.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Containers": {},
        "Options": {},
        "Labels": {}
    }
]

启动两个tomcat,再次查看网络情况

在自定义的网络下，服务可以互相ping通，不用使用–link

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

好处：

redis -不同的集群使用不同的网络，保证集群是安全和健康的

mysql-不同的集群使用不同的网络，保证集群是安全和健康的

网络连通

# 测试两个不同的网络连通  再启动两个tomcat 使用默认网络，即docker0
$ docker run -d -P --name tomcat01 tomcat
$ docker run -d -P --name tomcat02 tomcat
# 此时ping不通

# 要将tomcat01 连通 tomcat—net-01 ，连通就是将 tomcat01加到 mynet网络
# 一个容器两个ip（tomcat01）

# 01连通 ，加入后此时，已经可以tomcat01 和 tomcat-01-net ping通了
# 02是依旧不通的

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

部署rides集群

# 创建网卡
docker network create redis --subnet 172.38.0.0/16
# 通过脚本创建六个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

# 通过脚本运行六个redis
for port in $(seq 1 6);\
docker run -p 637${port}:6379 -p 1667${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
docker exec -it redis-1 /bin/sh #redis默认没有bash
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

docker搭建redis集群完成！

SpringBoot微服务打包Docker镜像

1、构建SpringBoot项目
2、打包运行

mvn package

3、编写dokcerfile

FROM java:8
COPY *.jar /app.jar
CMD ["--server.port=8080"]
EXPOSE 8080
ENTRYPOINT ["java","-jar","app.jar"]

4、构建镜像

# 1.复制jar和DockerFIle到服务器
# 2.构建镜像
$ docker build -t xxxxx:xx  .

5、发布运行
以后我们使用了Docker之后，给别人交付就是一个镜像即可！