docker学习笔记二
笔记整理来源 B站UP主 “遇见狂神说” https://space.bilibili.com/95256449/
参考文章 CSDN博主「兴趣使然的草帽路飞」
https://blog.csdn.net/weixin_43591980/article/details/106316094
一、容器数据卷
1.什么是容器数据卷
数据?如果数据都在容器中,那么我们容器删除,数据就会丢失!需求:数据可以持久化
MySQL,容器删除了,删库跑路!需求:MySQL数据可以存储在本地!
容器之间可以有一个数据共享的技术!Docker容器中产生的数据,同步到本地!
这就是卷技术!目录的挂载,将我们容器内的目录,挂载到Linux上面!
使用数据卷
方式一 :直接使用命令挂载 -v
-v, --volume list Bind mount a volume
docker run -it -v 主机目录:容器内目录 -p 主机端口:容器内端口
# /home/ceshi:主机home目录下的ceshi文件夹 映射:centos容器中的/home
[root@fanb home]# docker run -it -v /home/ceshi/:/home centos /bin/bash
[root@5c72c48e3085 /]#
[root@fanb ~]# cd /home
[root@fanb home]# ls -a
. .. ceshi
#这时候主机的/home/ceshi文件夹就和容器的/home文件夹关联了,二者可以实现文件或数据同步了
#通过 docker inspect 容器id 查看
[root@fanb home]# docker inspect 5c72c48e3085
#找到 "Mounts"
"Mounts": [
{
"Type": "bind",
"Source": "/home/ceshi", #主机内地址
"Destination": "/home", #docker容器内地址
"Mode": "",
"RW": true,
"Propagation": "rprivate"
}
],
测试文件的同步
- 测试一
先在容器内创建test.c文件
[root@5c72c48e3085 home]# touch test.c
[root@5c72c48e3085 home]# ls
test.c
在主机内查看
[root@fanb home]# cd ceshi
[root@fanb ceshi]# ls
test.c
- 测试二
先停止容器,再在宿主机修改文件
[root@fanb ceshi]# docker stop 5c72c48e3085
5c72c48e3085
[root@fanb ceshi]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
[root@fanb ceshi]#
[root@fanb ceshi]# vim test.c
启动容器查看
[root@fanb home]# docker start 5c72c48e3085
5c72c48e3085
[root@fanb home]# docker exec -it 5c72c48e3085 /bin/bash
[root@5c72c48e3085 /]# cd /home
[root@5c72c48e3085 home]# ls
test.c
[root@5c72c48e3085 home]# cat test.c
test #这里是我们刚才在宿主机vim修改的内容
好处:我们以后修改只需要在本地修改即可,容器内会自动同步!
2.实战:安装MySQL
[root@fanb ~]# docker pull mysql
# 运行容器,需要做数据挂载 #安装启动mysql,需要配置密码的,这是要注意点!
# 参考官网hub
docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag
[root@fanb ~]# 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
# 启动成功之后,我们在本地使用sqlyog来测试一下
# sqlyog-连接到服务器的3306--和容器内的3306映射
#在本地测试创建一个数据库,查看一下我们映射的路径是否ok!
**测试连接:**注意3310端口要在阿里云服务器的安全组中打开,否则无法连接。
当我们在本地用SQLyog新建名称为test的数据库时候,容器容器也会创建
[root@fanb ~]# cd /home/mysql/data/
[root@fanb data]# ls
auto.cnf binlog.index client-cert.pem #ib_16384_1.dblwr ib_logfile0 mysql private_key.pem server-key.pem undo_002
binlog.000001 ca-key.pem client-key.pem ib_buffer_pool ib_logfile1 mysql.ibd public_key.pem sys
binlog.000002 ca.pem #ib_16384_0.dblwr ibdata1 #innodb_temp performance_schema server-cert.pem undo_001
假设我们将包含mysql的容器删除时,发现,我们挂载到本地的数据卷依旧没有丢失,这就实现了容器数据持久化功能。
3.具名挂载和匿名挂载
匿名挂载
-v 容器内路径
[root@fanb ~]# docker run -d -P --name nginx01 -v /etc/nginx nginx
566cba37aa1aa43b906c06be154a1c9da221d3d5677e02c78d96fa0e6c684e59
# 查看所有的volume(卷)的情况
[root@fanb ~]# docker volume ls
DRIVER VOLUME NAME
local 1fdcce5df0f8193980b49dfef6801649ba1a20a7d83ffaf524c4808e95385756
local 9c7361c7fe76ac588e0b75110e6a48fba5475c59f1e535279d335fcb6475a733
local 0734c92ee8a1a5a40769abb0839e3980faa4b64bfa6b410d44de8a040a6000f2
local 9261b1e047da0c52ab7a41006e5d296705d4b215e804168d79602b1bbea6b201
这种就是匿名挂载,我们在 -v只写了容器内的路径,没有写容器外的路径!
剧名挂载
-v 卷名:查看容器内路径
[root@fanb ~]# docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx
7aa99889cc2e319e68dff2177d947cb1ca3b86585f77fb4989458e629b0f0c53
#查看所有的volume(卷)的情况
[root@fanb ~]# docker volume ls
DRIVER VOLUME NAME
local 1fdcce5df0f8193980b49dfef6801649ba1a20a7d83ffaf524c4808e95385756
local 9c7361c7fe76ac588e0b75110e6a48fba5475c59f1e535279d335fcb6475a733
local 0734c92ee8a1a5a40769abb0839e3980faa4b64bfa6b410d44de8a040a6000f2
local 9261b1e047da0c52ab7a41006e5d296705d4b215e804168d79602b1bbea6b201
local 353098ef7fb7ea83bb17c5101c5612a01a48a79e3a7d60ffb258834c5f84c769
local juming-nginx #多了一个名字
# 查看一下这个卷
[root@fanb ~]# docker volume inspect juming-nginx
[
{
"CreatedAt": "2021-07-16T10:28:25+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/自定义的卷名/_data下
如果指定了目录,docker volume ls 是查看不到的。
区分三种挂载方式
三种挂载: 匿名挂载、具名挂载、指定路径挂载
-v 容器内路径 #匿名挂载
-v 卷名:容器内路径 #具名挂载
-v /宿主机路径:容器内路径 #指定路径挂载 docker volume ls 是查看不到的
拓展:
# 通过 -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就说明这个路径只能通过宿主机来操作,容器内部是无法操作!
4.初识Dockerfile
Dockerfile 就是用来构建docker镜像的构建文件!命令脚本!先体验一下!
通过这个脚本可以生成镜像,镜像是一层一层的,脚本是一个个的命令,每个命令都是一层!
创建一个dockerfile文件,名字可以随便 建议Dockerfile
文件中的内容: 指令(大写) + 参数
[root@fanb home]# mkdir dockerfile
[root@fanb home]# cd dockerfile
[root@fanb dockerfile]# vim dockerfile01
FROM centos #当前镜像是基于centos的
VOLUME ["volume01","volume02"] #挂载卷的卷目录列表(多个目录)
CMD echo "-------end-------" #输出一下用于测试
CMD /bin/bash #默认走bash控制台
构建镜像docker build
[root@fanb dockerfile]# docker build -f dockerfile01 -t fanb/centos .
Sending build context to Docker daemon 2.048kB
Step 1/4 : FROM centos
---> 300e315adb2f
Step 2/4 : VOLUME ["volume01","volume02"] # 卷名列表
---> Running in 51b57f585168
Removing intermediate container 51b57f585168
---> 93b35296d609
Step 3/4 : CMD echo "-------end-------"
---> Running in 380578afbc24
Removing intermediate container 380578afbc24
---> 7d42a5b72229
Step 4/4 : CMD /bin/bash
---> Running in 2fefbe937ff0
Removing intermediate container 2fefbe937ff0
---> 408fb30988e3
Successfully built 408fb30988e3
Successfully tagged fanb/centos:latest
查看构建的镜像
[root@fanb dockerfile]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
fanb/centos latest 408fb30988e3 About a minute ago 209MB
启动自己写的镜像
[root@fanb dockerfile]# docker run -it fanb/centos
查看目录 ls -l
这个目录就是生成镜像时自动挂载的数据卷目录
这个卷和外部一定有一个同步的目录
[root@fanb dockerfile]# docker inspect 52e8cf78bf5e
5.数据卷容器
多个MySQL同步数据!
docker run -it --name docker01 fanb/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
$ docker run -it --name docker02 --volumes-from docker01 fanb/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
# 再新建一个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
# 这个时候,可以实现两个容器数据同步!
结论
容器之间的配置信息的传递,数据卷容器的生命周期一直持续到没有容器使用为止。
但是一旦你持久化到了本地,这个时候,本地的数据是不会删除的!
二、Dockerfile
1.DockerFile介绍
dockerfile是用来构建docker镜像的文件!命令参数脚本!
构建步骤:
1、 编写一个dockerfile文件
2、 docker build 构建称为一个镜像
3、 docker run运行镜像
4、 docker push发布镜像(DockerHub 、阿里云仓库)
点击后跳到一个Dockerfile
很多官方镜像都是基础包,很多功能没有,我们通常会自己搭建自己的镜像!
官方既然可以制作镜像,那我们也可以!
2.DockerFile构建过程
基础知识:
1、每个保留关键字(指令)都是必须是大写字母
2、执行从上到下顺序
3、#表示注释
4、每一个指令都会创建提交一个新的镜像曾,并提交!
- Dockerfile是面向开发的,我们以后要发布项目,做镜像,就需要编写dockerfile文件,这个文件十分简单!
- Docker镜像逐渐成企业交付的标准,必须要掌握!
- DockerFile:构建文件,定义了一切的步骤,源代码
- DockerImages:通过DockerFile构建生成的镜像,最终发布和运行产品。
- Docker容器:容器就是镜像运行起来提供服务。
3.DockerFile的指令
FROM # from:基础镜像,一切从这里开始构建
MAINTAINER # maintainer:镜像是谁写的, 姓名+邮箱
RUN # run:镜像构建的时候需要运行的命令
ADD # add:步骤,tomcat镜像,这个tomcat压缩包!添加内容 添加同目录
WORKDIR # workdir:镜像的工作目录
VOLUME # volume:挂载的目录
EXPOSE # expose:保留端口配置
CMD # cmd:指定这个容器启动的时候要运行的命令,只有最后一个会生效,可被替代
ENTRYPOINT # entrypoint:指定这个容器启动的时候要运行的命令,可以追加命令
ONBUILD # onbuild:当构建一个被继承DockerFile这个时候就会运行onbuild的指令,触发指令
COPY # copy:类似ADD,将我们文件拷贝到镜像中
ENV # env:构建的时候设置环境变量!
4.实战测试
Docker Hub 中 99%的镜像都是从这个基础镜像过来的 FROM scratch,然后配置需要的软件和配置来进行构建。
创建一个自己的centos
创建dockerfile-centos文件
[root@fanb dockerfile]# vim dockerfile-centos
编写dockerfile配置文件
FROM centos # 基础镜像是官方原生的centos
MAINTAINER fanb<1916861581@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
通过这个文件构建镜像
[root@fanb dockerfile]# docker build -f dockerfile-centos -t mycentos .
查看所构建的镜像
[root@fanb dockerfile]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
mycentos latest 668fc8f7bcca 2 minutes ago 299MB
测试运行
[root@fanb dockerfile]# docker run -it mycentos
[root@f2d61329cc8b local]# pwd
/usr/local #与Dockerfile文件中 WORKDIR 设置的 MYPATH 一致
$ vim # vim 指令可以使用
$ ifconfig # ifconfig 指令可以使用
docker history 镜像id
查看镜像构建历史步骤
[root@fanb dockerfile]# docker history 668fc8f7bcca
IMAGE CREATED CREATED BY SIZE COMMENT
668fc8f7bcca 6 minutes ago /bin/sh -c #(nop) CMD ["/bin/sh" "-c" "/bin… 0B
06f49deb46de 6 minutes ago /bin/sh -c #(nop) CMD ["/bin/sh" "-c" "echo… 0B
5ac05901a66a 6 minutes ago /bin/sh -c #(nop) CMD ["/bin/sh" "-c" "echo… 0B
6417f62f1c8e 6 minutes ago /bin/sh -c #(nop) EXPOSE 80 0B
97bf92409165 6 minutes ago /bin/sh -c yum -y install net-tools 26.6MB
2ea4ffe02184 6 minutes ago /bin/sh -c yum -y install vim 63.4MB
6e508a664cee 7 minutes ago /bin/sh -c #(nop) WORKDIR /usr/local 0B
96d9b53f6318 7 minutes ago /bin/sh -c #(nop) ENV MYPATH=/usr/local 0B
582bb2b05d8d 7 minutes ago /bin/sh -c #(nop) MAINTAINER fanb<191686158… 0B
300e315adb2f 7 months ago /bin/sh -c #(nop) CMD ["/bin/bash"] 0B
<missing> 7 months ago /bin/sh -c #(nop) LABEL org.label-schema.sc… 0B
我们平时拿到一个镜像,可以用 “docker history 镜像id” 研究一下是什么做的
CMD 和 ENTRYPOINT区别
CMD # 指定这个容器启动的时候要运行的命令,只有最后一个会生效,可被替代。
ENTRYPOINT # 指定这个容器启动的时候要运行的命令,可以追加命令
5.实战:tomcat镜像
1)准备镜像文件
准备tomcat 和 jdk 到当前目录,编写好README
2)编写dockerfile
$ vim dockerfile
FROM centos # 基础镜像centos
MAINTAINER fanb<1916861581@qq.com> # 作者
COPY README /usr/local/README # 复制README文件
ADD jdk-8u231-linux-x64.tar.gz /usr/local/ # 添加jdk,ADD 命令会自动解压
ADD apache-tomcat-9.0.35.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_231 # 环境变量: JAVA_HOME环境变量
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.35 # 环境变量: tomcat环境变量
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.35
# 设置环境变量 分隔符是:
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
EXPOSE 8080 # 设置暴露的端口
CMD /usr/local/apache-tomcat-9.0.35/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.35/logs/catalina.out # 设置默认命令
3)构建镜像
# 因为dockerfile命名使用默认命名 因此不用使用-f 指定文件
$ docker build -t mytomcat:0.1 .
4)运行镜像
$ docker run -d -p 8080:8080 --name tomcat01
-v /home/kuangshen/build/tomcat/test:/usr/local/apache-tomcat-9.0.35/webapps/test
-v /home/kuangshen/build/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.35/logs mytomcat:0.1
5)访问测试
$ docker exec -it 自定义容器的id /bin/bash
$ curl localhost:8080
6)发布项目
(由于做了卷挂载,我们直接在本地编写项目就可以发布了!)
发现:项目部署成功,可以直接访问!
我们以后开发的步骤:需要掌握Dockerfile的编写!我们之后的一切都是使用docker镜像来发布运行!
6.发布自己的镜像
发布到Docker Hub
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镜像
# 会发现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
发布到阿里云镜像服务上
看官网 很详细
https://cr.console.aliyun.com/repository/
$ sudo docker login --username=zchengx registry.cn-shenzhen.aliyuncs.com
$ sudo docker tag [ImageId] registry.cn-shenzhen.aliyuncs.com/dsadxzc/cheng:[镜像版本号]
# 修改id 和 版本
sudo docker tag a5ef1f32aaae registry.cn-shenzhen.aliyuncs.com/dsadxzc/cheng:1.0
# 修改版本
$ sudo docker push registry.cn-shenzhen.aliyuncs.com/dsadxzc/cheng:[镜像版本号]
7.小结
三、Docker网络
1.理解docker0
学习之前清空下前面的docker 镜像、容器
# 删除全部容器
$ docker rm -f $(docker ps -aq)
# 删除全部镜像
$ docker rmi -f $(docker images -aq)
测试
三个网络
问题: docker 是如果处理容器网络访问的?
# 测试 运行一个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技术!https://www.cnblogs.com/bakari/p/10613710.html
再次测试 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中所有网络接口都是虚拟的,虚拟的转发效率高(内网传递文件)
只要容器删除,对应的网桥一对就没了!
2.–link
思考一个场景:我们编写了一个微服务,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问题:不支持容器名连接访问!
3.自定义网络
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网络
网络模式
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.0.0/16 --gateway 192.168.0.1 mynet
$ docker network inspect mynet
启动两个tomcat,再次查看网络情况
在自定义的网络下,服务可以互相ping通,不用使用–link
我们自定义的网络docker当我们维护好了对应的关系,推荐我们平时这样使用网络!
好处:
redis -不同的集群使用不同的网络,保证集群是安全和健康的
mysql-不同的集群使用不同的网络,保证集群是安全和健康的
4.网络连通
# 测试两个不同的网络连通 再启动两个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 连通!
四、实战
1.部署Redis集群
# 创建网卡
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集群完成!
我们使用docker之后,所有的技术都会慢慢变得简单起来!
2.SpringBoot微服务打包Docker镜像
1、构建SpringBoot项目
2、打包运行
mvn package
3、编写dockerfile
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之后,给别人交付就是一个镜像即可!