docker使用文档2

最新推荐文章于 2023-05-17 09:17:18 发布
最新推荐文章于 2023-05-17 09:17:18 发布
阅读量195 收藏
点赞数 1
分类专栏： docker
原文链接：https://blog.csdn.net/weixin_43591980/article/details/106316094
版权
什么是容器数据卷

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

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

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

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

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

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

使用数据卷

方式一 ：直接使用命令挂载 -v

-v, --volume list                    Bind mount a volume

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

#通过 docker inspect 容器id 查看
[root@iz2zeak7sgj6i7hrb2g862z home]# docker inspect 6064c490c371

测试文件的同步

再来测试！

1、停止容器

2、宿主机修改文件

3、启动容器

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

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

实战：安装MySQL

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

# 获取mysql镜像
[root@iz2zeak7sgj6i7hrb2g862z home]# docker pull mysql:5.7

# 运行容器,需要做数据挂载 #安装启动mysql，需要配置密码的，这是要注意点！
# 参考官网hub
docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

#启动我们得
-d 后台运行
-p 端口映射
-v 卷挂载
-e 环境配置
– name 容器名字
$ 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 mysql03 mysql:5.7

# 启动成功之后，我们在本地使用sqlyog来测试一下
# sqlyog-连接到服务器的3306–和容器内的3306映射

# 在本地测试创建一个数据库，查看一下我们映射的路径是否ok！

测试连接：注意3310端口要在阿里云服务器的安全组中打开，否则无法连接。

在这里插入图片描述

当我们在本地用SQLyog新建名称为test的数据库时候，容器容器也会创建

在这里插入图片描述

假设我们将包含mysql的容器删除时，

发现，我们挂载到本地的数据卷依旧没有丢失，这就实现了容器数据持久化功能。

具名和匿名挂载

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

# 查看所有的volume(卷)的情况
$ docker volume ls
DRIVER VOLUME NAME # 容器内的卷名(匿名卷挂载)
local 21159a8518abd468728cdbe8594a75b204a10c26be6c36090cde1ee88965f0d0
local b17f52d38f528893dd5720899f555caf22b31bf50b0680e7c6d5431dbda2802c

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

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

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

# 通过 -v 卷名：查看容器内路径
# 查看一下这个卷
$ 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/自定义的卷名/_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就说明这个路径只能通过宿主机来操作，容器内部是无法操作！

初始Dockerfile

Dockerfile 就是用来构建docker镜像的构建文件！命令脚本！先体验一下！

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

# 创建一个dockerfile文件，名字可以随便 建议Dockerfile
# 文件中的内容： 指令(大写) + 参数
$ vim dockerfile1
    FROM centos 					# 当前这个镜像是以centos为基础的

VOLUME <span class="token punctuation">[</span><span class="token string">"volume01"</span>,<span class="token string">"volume02"</span><span class="token punctuation">]</span> 	<span class="token comment"># 挂载卷的卷目录列表(多个目录)</span>

CMD <span class="token keyword">echo</span> <span class="token string">"-----end-----"</span>		<span class="token comment"># 输出一下用于测试</span>
CMD /bin/bash					<span class="token comment"># 默认走bash控制台</span>

# 这里的每个命令，就是镜像的一层！
# 构建出这个镜像
-f dockerfile1 # f代表file，指这个当前文件的地址(这里是当前目录下的dockerfile1)
-t caoshipeng/centos # t就代表target，指目标目录(注意caoshipeng镜像名前不能加斜杠‘/’)
. # 表示生成在当前目录下
$ docker build -f dockerfile1 -t caoshipeng/centos .
Sending build context to Docker daemon 2.56kB
Step 1/4 : FROM centos
latest: Pulling from library/centos
8a29a15cefae: Already exists
Digest: sha256:fe8d824220415eed5477b63addf40fb06c3b049404242b31982106ac204f6700
Status: Downloaded newer image for centos:latest
—> 470671670cac
Step 2/4 : VOLUME [“volume01”,“volume02”] # 卷名列表
—> Running in c18eefc2c233
Removing intermediate container c18eefc2c233
—> 623ae1d40fb8
Step 3/4 : CMD echo “-----end-----” # 输出 脚本命令
—> Running in 70e403669f3c
Removing intermediate container 70e403669f3c
—> 0eba1989c4e6
Step 4/4 : CMD /bin/bash
—> Running in 4342feb3a05b
Removing intermediate container 4342feb3a05b
—> f4a6b0d4d948
Successfully built f4a6b0d4d948
Successfully tagged caoshipeng/centos:latest

# 查看自己构建的镜像
$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
caoshipeng/centos latest f4a6b0d4d948 About a minute ago 237MB

启动自己写的容器镜像

$ docker run -it f4a6b0d4d948 /bin/bash	# 运行自己写的镜像
$ ls -l 								# 查看目录

这个卷和外部一定有一个同步的目录

查看一下卷挂载

# docker inspect 容器id
$ docker inspect ca3b45913df5

测试一下刚才的文件是否同步出去了！

在这里插入图片描述

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

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

数据卷容器

多个MySQL同步数据！

命名的容器挂载数据卷！

在这里插入图片描述

# 测试 启动3个容器，通过刚才自己写的镜像启动
# 创建docker01：因为我本机是最新版，故这里用latest，狂神老师用的是1.0如下图
$ docker run -it --name docker01 caoshipeng/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 caoshipeng/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

# 这个时候，可以实现两个容器数据同步！

  • 1
  • 2
  • 3
  • 4
  • 5

结论：

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

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

DockerFile

DockerFile介绍

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

构建步骤：

1、 编写一个dockerfile文件

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

3、 docker run运行镜像

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

点击后跳到一个Dockerfile

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

官方既然可以制作镜像，那我们也可以！

DockerFile构建过程

基础知识：

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

2、执行从上到下顺序

3、#表示注释

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

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

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

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

DockerImages：通过DockerFile构建生成的镜像，最终发布和运行产品。

Docker容器：容器就是镜像运行起来提供服务。

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:构建的时候设置环境变量！

在这里插入图片描述

实战测试

scratch 镜像

FROM scratch
ADD centos-7-x86_64-docker.tar.xz /

LABEL
org.label-schema.schema-version=“1.0”
org.label-schema.name=“CentOS Base Image”
org.label-schema.vendor=“CentOS”
org.label-schema.license=“GPLv2”
org.label-schema.build-date=“20200504”
org.opencontainers.image.title=“CentOS Base Image”
org.opencontainers.image.vendor=“CentOS”
org.opencontainers.image.licenses=“GPL-2.0-only”
org.opencontainers.image.created=“2020-05-04 00:00:00+01:00”

CMD ["/bin/bash"]

Docker Hub 中 99%的镜像都是从这个基础镜像过来的 FROM scratch，然后配置需要的软件和配置来进行构建。

在这里插入图片描述

创建一个自己的centos

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

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

# 3.编写Dockerfile配置文件
FROM centos # 基础镜像是官方原生的centos
MAINTAINER cao<1165680007@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.出现下图后则构建成功

$ docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
mycentos            0.1                 cbf5110a646d        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

我们可以列出本地进行的变更历史

我们平时拿到一个镜像，可以用 “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

2、编写dokerfile
$ vim dockerfile
FROM centos 										# 基础镜像centos
MAINTAINER cao<1165680007@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 J A V A H O M E < / s p a n > / l i b / d t . j a r : < s p a n c l a s s = " t o k e n v a r i a b l e " > JAVA_HOME</span>/lib/dt.jar:<span class="token variable"> JAVAH​OME</span>/lib/dt.jar:<spanclass="tokenvariable">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 P A T H < / s p a n > < s p a n c l a s s = " t o k e n k e y w o r d " > : < / s p a n > < s p a n c l a s s = " t o k e n v a r i a b l e " > PATH</span><span class="token keyword">:</span><span class="token variable"> PATH</span><spanclass="tokenkeyword">:</span><spanclass="tokenvariable">JAVA_HOME/bin: C A T A L I N A H O M E < / s p a n > / l i b : < s p a n c l a s s = " t o k e n v a r i a b l e " > CATALINA_HOME</span>/lib:<span class="token variable"> CATALINAH​OME</span>/lib:<spanclass="tokenvariable">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 .

 
 

 
 
  • 1
  • 2
4、run镜像
# -d:后台运行 -p:暴露端口 --name:别名 -v:绑定路径 
$ 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

$ cul localhost:8080

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镜像

# 会发现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:[镜像版本号]

小结

Docker 网络

理解Docker 0

学习之前清空下前面的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中所有网络接口都是虚拟的，虚拟的转发效率高（内网传递文件）

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

思考一个场景：我们编写了一个微服务，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网络

网络模式

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-不同的集群使用不同的网络，保证集群是安全和健康的

网络连通

# 测试两个不同的网络连通  再启动两个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 连通！

实战：部署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 KaTeX parse error: Undefined control sequence: \ at position 136: …ation">;</span>\̲ ̲docker run -p 6…{port}:6379 -p 1667 p o r t < / s p a n > : 16379 − − n a m e r e d i s − < s p a n c l a s s = " t o k e n v a r i a b l e " > {port}</span>:16379 --name redis-<span class="token variable"> port</span>:16379−−nameredis−<spanclass="tokenvariable">{port}
-v /mydata/redis/node-KaTeX parse error: Undefined control sequence: \ at position 26: …an>/data:/data \̲ ̲-v /mydata/redi…{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之后，所有的技术都会慢慢变得简单起来！

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之后，给别人交付就是一个镜像即可！

疯狂的布布
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
docker使用文档
08-12
docker的基本使用命令
docker使用文档1
u013177138的博客
08-13 6948
Docker 入门 笔记整理来源 B站UP主狂神说Javahttps://space.bilibili.com/95256449/ Docker概述 Docker为什么出现？ 一款产品： 开发–上线 两套环境！应用环境，应用配置！ 开发 — 运维。 问题：我在我的电脑上可以...
Docker 详细使用文档
qq_37480069的博客
05-15 919
Docker 是一个开源的容器化平台，可以让开发者将应用程序及其依赖项打包到一个可移植的容器中，从而实现快速部署、可移植性和可伸缩性。
docker命令文档
一个疯狂善良的程序员
05-17 823
这些命令可以帮助您更高效地管理和维护Docker容器、镜像和卷.
Docker使用文档
12-25
在计算机中，虚拟化（英语：Virtualization）是一种资源管理技术，是将计算机的各种实体资源，如服务器、网 络、内存及存储等，予以抽象、转换后呈现出来，打破实体结构间的不可切割的障碍，使用户可以比原本的组态...
docker配置使用（文档）
最新发布
07-09
docker配置使用（文档） 仅供学习交流！ 后续会持续分享相关资源，记得关注哦！ docker配置使用（文档） 仅供学习交流！ 后续会持续分享相关资源，记得关注哦！ docker配置使用（文档） 仅供学习交流！ 后续会...
Docker安装文档.docx
04-08
Docker安装文档
docker的文档，介绍docker以及如何使用
05-17
Docker 是一种工具，旨在通过使用容器更轻松地创建、部署和运行应用程序。 容器允许开发人员将应用程序及其所需的所有部分打包在一起，例如库和其他依赖项，并将其部署为一个包。 Docker 的主要优点是它允许应用程序...
Docker操作说明文档.doc
01-07
Docker从零开始操作文档，包含docker安装、防火墙操作、本地仓库registry、nginx安装使用、tomcat安装使用、mysql安装使用、ftp安装使用、zookeeper安装使用、oracle安装使用、redis安装使用、jdk安装使用、nexus安装使用、svn安装使用、jenkins安装使用、gitlab安装使用，及使用离线工具包打包封装自己的容器镜像说明。 文档由本人编写仅供学习，不做商用。
Docker文档
ks的博客
01-11 710
Docker文档 docker安装 sudo apt-get install docker-ce -y docker卸载 rm -rf /var/lib/docker/ rm -rf /etc/docker docker目录 /etc/docker/ docker的认证目录 /var/lib/docker/ docker的应用目录 /var/lib/docker/image/overlay2/imagedb/content/sha256 存放Docker镜像的目录 查看do
docker学习使用文档
车明强的博客
07-30 1447
学习途径 Docker官网： Docker中文网站： Docker Hub官网： （仓库） 安装 镜像image： docker镜像就好比是模板，可以通过这个模板创建容器服务，tomcat镜像=》run运行=》tomcat01容器（提供服务器），通过这个镜像可以创建多个容器（最终服务运行或者项目运行就是在容器中） 容器container：docker利用容器技术，独立运行一个或者一个组应用，通过·镜像来创建。 启动，停止，删除，基本命令 目前就可以理解为建议linux系统，项目 仓库rep
Docker使用手册
qq_29001173的博客
08-17 555
安装Docker
Docker 详细文档
yongyong169的博客
12-14 5010
Docker 文档 目录 ⒈ 简介... 2 1.1什么是容器？... 2 1.2 什么是Docker？... 3 1.3 Doceker的目标... 3 1.4 Docker 的使用场景... 3 ⒉ Docker 的基本组成... 3 2.1 Docker 客户端/守护进程... 3 2.2 Docker 镜像... 4 2.3 Doceker Contai...
docker 操作说明文档
dalter的博客
11-24 718
1 先删除旧的docker (如果有)5启动docker(记得关闭防火墙)6 docker -v 检查。docker 镜像命令操作。docker 容器命令操作。docker 数据卷。
docker 安装使用文档
小小的幸福
07-24 634
docker安装 安装前提 CentOS 7以上版本 https://docs.docker.com/engine/installation/linux/docker-ce/centos/#install-from-a-package https://www.digitalocean.com/community/tutorials/how-to-install-and-use-docker...
docker 文档
mixboot
06-13 387
Docker — 从入门到实践
Docker官方文档
05-29
Docker官方文档是由Docker公司编写和维护的一份文档，旨在提供关于Docker的详细信息、使用指南和最佳实践等方面的帮助。该文档涵盖了Docker引擎的各种方面，包括安装、配置、镜像、容器、网络等。此外，该文档还提供了与Docker相关的其他工具和服务的介绍，例如Docker Compose、Docker Swarm和Docker Hub等。 Docker官方文档的目录结构清晰，内容详实，非常适合新手和有经验的用户使用。用户可以通过文档的搜索功能快速查找到所需的内容，同时也可以根据自己的需求进行浏览和学习。 如果你需要更深入地学习Docker，建议先从官方文档入手，逐步掌握Docker的使用技巧和最佳实践。同时，你也可以加入Docker社区，与其他用户交流和分享经验。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值