狂神说Docker学习笔记整理(二)

已于 2022-01-20 09:32:13 修改
阅读量162 收藏
点赞数
分类专栏： 个人成长记录 持续集成与容器管理 文章标签： docker centos 运维
于 2021-08-28 21:02:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45189427/article/details/119932913
版权

容器数据卷

什么是容器数据卷

将应用和环境打包成一个镜像！
数据？如果数据都在容器中，那么我们容器删除，数据就会丢失！需求：数据可以持久化
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<1007026004@qq.com> 	# 作者

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<1007026004@qq.com>					# 作者
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之后，给别人交付就是一个镜像即可！

指尖上的革新
关注
专栏目录
Docker进阶
super2feng博乐世界
08-04 175
Dockerfile docker-compose
狂神Docker学习笔记.pdf
03-10
学习docker时看到的学习笔记
斌哥的 Docker 进阶指南
weixin_33743703的博客
04-29 136
过去的一年中，关于 Docker 的话题从未断过，而如今，从尝试 Docker 到最终决定使用 Docker 的转化率依然在逐步升高，关于 Docker 的讨论更是有增无减。另一方面，大家的注意力也渐渐从 “Docker 是什么”转移到“实践 Docker”与“监控 Docker”上。 本文转自刘斌博文「如何选择 Docker 监控方案 ...
docker 进阶
热门推荐
不懂一休
06-17 1万+
一、提交镜像 1、docker commit 制作镜像，保留当前快照 ①、docker commit --help -a 作者 -c -m 提交信息 -p 提交期间暂停容器，默认为 true ②、docker commit -a=“admin” -m=“更新tomcat镜像” tomcat01 tomcat01:9.99 第一个 tomcat01 为需要提交的容器，第二个 tomcat01:9.99 为镜像的名字个版本（tag） 2、docker push 上传镜像到 仓库，以 dockerhu
狂神说Docker容器学习笔记全部.pdf
12-22
狂神说Docker容器学习笔记全
狂神 Docker学习笔记 超详细从开始到进阶到补充
04-01
狂神 Docker 学习笔记 超详细从开始到进阶到补充 Docker 概述 Docker 是一个开源的应用容器引擎，基于 Go 语言并遵从 Apache2.0 协议开源。Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的...
狂神docker笔记（超详细）.zip
08-09
狂神docker笔记（超详细） 1:docekr进阶 2: docker基础入门 都是自己亲自看着bilibili上学习敲打的，还标注了一些，然后还有一些自己的err的解决方法
Docker容器学习笔记全（狂神说Java）.pdf
07-10
B站狂神说java的docker笔记md转pdf版本，全部笔记
狂神docker笔记（超详细）.rar
06-14
狂神docker教学视频笔记，截图标注很全（本人增加了很多额外的标注），帮助更好理解，敲了很久，实在不易。上传来帮助大家学习，一方面攒点积分！
Docker 进阶篇
凭心而动
07-25 954
Docker安装MySQL主从复制、redis三主三从集群配置及其常用分布式存储算法、Dockerfile发布微服务、Docker网络及网络模式、Docker-compose容器编排、Portainer轻量级可视化工具、CIG重量级监控等
Docker进阶教程
小Y先生的博客
08-26 645
这篇文章讲解Docker的高级用法，不适合丝毫不懂Docker的小白。如果你对于Docker没有任何了解，请移步至我的另一篇文章Docker零基础教程，待了解了Docker基础，再来学习这篇文章。FROM基础镜像，当前新镜像是基于那个镜像的，指定一个已经存在的镜像作为模板，第一条必须是fromMAINTAINER镜像维护者的姓名和邮箱地址RUN容器构建时需要执行的命令EXPOSE当前容器对外暴露的端口WORKDIR指定在创建容器后，终端默认登陆的进来工作目录，一个落脚点USER。..............
【云原生 | Docker 高级篇】05、DockerFile 详解
Stars.Sky 的博客
10-10 608
DockerFile 详解！！！
Docker 的进阶操作
wenqi1992的博客
12-27 223
本文是关于 Docker 的进阶操作，介绍如何通过 Dockerfile 文件构建镜像、如何搭建私人镜像仓库、Docker 网络通信。
Docker进阶 — 一文掌握Docker 入门到精通
yxn4065的博客
12-30 964
Docker 是一个开源的应用容器引擎（是一个快速交付应用、运行应用的技术)Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的Linux 机器上。其启动、移除都可以通过一行命令完成，方便快捷.本文带你一篇文章彻底搞懂Docker并快速上手使用.实践涵盖了常用的部署操作,包括MySQL,tomcat,nginx,Redis等,图文并茂打造全文最快的上手教程
docker从入门到入土（进阶篇）
qq_54502707的博客
02-24 383
Hello~大家好，这里是KOKO！ 之前我们学习了docker的基础篇内容，今天我们来深入了解进阶篇的内容。 在学习进阶篇之前，请大家务必保证基础篇的那些常用命令都进行了练习并且已经熟练掌握！ docker复杂安装详说 安装mysql主从复制 主从复制原理 日志的互相读写； 此处不详细讲解原理，可自行查阅相关资料。 主从搭建步骤 新建主服务器3307(3306为docker实例里的端口) docker run -p 3307:3306 --name mysql-master -v /mydata/m
狂神说Docker进阶篇笔记
Java男朋友
01-02 2888
【狂神说Java】Docker进阶篇超详细版教程通俗易懂笔记
docker(进阶)
v5的博客
11-05 242
docker ubuntu 一键按照包已经上传到资源中，可以去下载哦！ docker-compose.yml docker run 起动一个容器或者多个容器有时候参数会很多，那么如果使用交互的命令行，不易管理和维护。 参数 version '2' services: severName(服务名字): restart: always （运行docker-compose 是否重启） ...
狂神说docker系列笔记
最新发布
06-16
"狂神说Docker系列笔记"通常指的是关于Docker容器技术的学习资料或教程，Docker是一个流行的开源平台，用于创建、部署和运行应用程序的轻量级容器。这个系列可能包括以下内容： 1. Docker基础概念：如Docker镜像...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值