Docker学习——docker高级

最新推荐文章于 2024-05-11 09:16:09 发布
最新推荐文章于 2024-05-11 09:16:09 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： 中间件/工具 文章标签： docker 容器 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44227063/article/details/122709794
版权

Docker高级

前言

上一篇文章，我们学习了docker的基础操作，还是那句话，渴望升职加薪的我们怎么可能仅仅停留在基础上，那就来继续学习下docker的数据卷、DockerFile和Docker网络吧。文章课程链接：【狂神说Java】Docker最新超详细版教程通俗易懂

一、Docker数据卷

（一）什么是容器数据卷

前面我们知道，我们启动一个镜像，就会生成一个容器，容器与外界隔离，我们的数据也在容器中，如果我们的容器是mysql，它将存储大量重要的数据，一不小心将mysql容器删除了，那我们的数据也将被一起被删除，因此，我们要解决删除容器时将数据一并删除的问题，而卷技术就能帮助我们解决这个问题，它将我们容器内的目录挂载到linux上，mysql容器中的数据就会自动同步到本地。
数据卷的功能包括

容器的数据持久化、数据同步、数据共享，数据同步可用于在linux主机修改容器内的配置文件（难得进到容器内修改），如nginx

使用数据卷

命令行挂载

# -v 挂载
# docker run -it -v 主机目录:容器目录
docker run -it -v /home/cs:/home centos /bin/bash # 服务器的/home/cs目录挂载centos容器的/home目录

挂载后，两个目录就会相互同步了，可以通过命令查看是否挂载成功

# docker inspect 容器id

如图
在这里插入图片描述
配置好后，可以进行测试，在容器内相应目录添加内容或者在主机上相应目录添加内容，然后在对应的目录下查看是否同步

（二）实践-安装Mysql

1、下载mysql镜像

docker pull mysql:5.7
docker images # 查看一下

2、运行容器（做数据挂载）

docker run -d -p 3310:3306 	# -d：后台运行，-p：映射端口
-v /home/mysql/config:/etc/mysql/my.conf	# -v：数据卷挂载
-v /home/mysql/data:/var/lib/mysql
-e MYSQL_ROOT_PASSWORD=123456		# -e 环境配置（mysql要设置密码）
--name mysql01		# --name 名字
mysql:5.7

3、测试
我们输入上述一串命令后，可以通过可视化工具连接mysql，看看是否成功，注意暴露的端口是3310，连接完成后，我们在工具上创建一个数据库test，然后到服务器相应的挂载目录，看下是否做到了同步

（三）具名挂载和匿名挂载

匿名挂载

docker run -d -P --name nginx01 -v /etc/nginx nginx

可以通过命令查看卷，匿名卷会自动生成一个字符串作为名字

docker volume ls

具名挂载

# 注意 juming-nginx前没有/，这是卷的名称
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx

区别如图
在这里插入图片描述
匿名卷的名字是自动生成的一串字符，具名卷则是取的名字，如红框

查看卷的具体信息

#docker volume inspect 卷名称
docker volume inspect juming-nginx

效果如图，Mountpoint为卷的路径。所有docker容器内的卷，不指定目录时，就默认放到/var/lib/docker/volumes下
在这里插入图片描述
可以自己cd到这个目录下去看看，里面有许多的卷，然后继续cd到/juming-nginx/_data下，这里面就有我们前面挂载的nginx配置文件
小结

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

扩展
可以使用 ro/rw改变读写权限，ro代表只读，rw可读写，默认为rw，当为ro时，只运行宿主机操作，容器内只可读

docker run -d -P --name nginx01 -v juming-nginx:/etc/nginx:ro nginx
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:rw nginx

（四）数据卷—DockerFile

DockerFile是用来构建docker镜像的构建文件，前面我们用commit的方式生成过镜像，DockerFile也是一种生成镜像的方式，这里只简单谈谈，后续进行学习
1、创建一个DockerFile

  • 创建目录 mkdir docker-test-volume
  • 创建文件 vim dockerfile1，写入内容保存退出，注意都为大写

FROM centos
VOLUME [“volume01”,“volume02”]
CMD echo “-----end-----”
CMD /bin/bash

2、执行命令

docker build -f dockerfile1 -t kuangshen-centos:1.0 .

注意：命令后有一个点，名称叫 kuangshen-centos，视频教程的截图为kuangshen/centos
执行这个命令后，出现这个界面，分别对应dockerfile1的四行命令，获取centos基础容器，挂载两个卷，输出–end–，进入到bin bash
在这里插入图片描述
执行完毕后可以通过docker images 查看下是否生成镜像

3、测试

  • 启动镜像

docker run -it 5fe09wju23 /bin/bash

然后会发现，我们前面挂载的两个卷会生成进来，如图
在这里插入图片描述
也可以通过 docker inspect 容器id 查看，如图
在这里插入图片描述

  • 测试卷同步
    这里跟前面的方式一样，不再记录

（五）、数据卷容器

前面，我们讲到了数据卷可用于容器间数据的同步，下面就开始学习
我们会启动三个容器，以达到测试数据同步的目的，其中，被挂载的容器称为父容器（数据卷容器），其他容器通过挂载它，进行数据间的同步

  1. 启动三个容器
# 这里启动的是 “（四）数据卷—DockerFile ”中构建的镜像
docker run -it --name docker01 fs88ewj43e09
# 容器启动后都查看下是否有数据卷
ls -l
# 退出当前容器 ctrl + p + Q
# 通过 --volumes-from 容器名称，挂载父容器，这里是docker01 
docker run -it --name docker02 --volumes-from docker01 fs88ewj43e09
# 创建第三个
docker run -it --name docker03 --volumes-from docker01 fs88ewj43e09
  1. 测试

新增文件：我们在docker01的数据卷中创建一个文件，然后在docker02和03查看是否同步，相同的，也在docker02/03操作，看是否在另外两个容器中同步
删除容器：我们删除docker01，查看docker02/03数据卷中的数据是否正常，答案是肯定的，这里不记录演示过程

  1. 总结

通过删除docker01，我们发现docker02/03的数据还存在，这说明容器卷之间的数据同步是拷贝的方式（双向），而不是同一个，就像java对象，是新new出来的
使用场景：容器间配置文件或者数据文件的同步

二、DockerFile制作镜像

（一）、DockerFile介绍

前面，我们接触了DockerFile，知道它是构建镜像的文件，是一个命令参数脚本，其构建步骤为

  • 编写一个dockerFile文件
  • docker build 构建成为一个镜像
  • docker run 运行镜像
  • docker push 发布镜像，可发布到DockerHub、阿里云镜像仓库

首先，我们看看官方是怎么做的，我们进入DockerHub，然后搜索一个镜像，这里，我搜索的是centos，如图
在这里插入图片描述
随便点击一个版本进入，比如centos7，然后我们就会进入到github了，这里给我们提供了一个DockerFile文件（官方提供的大多是基础包），如图
在这里插入图片描述
代码如下

FROM scratch # DockerHub 99%的镜像都从这个基础镜像过来的
ADD centos-7-x86_64-docker.tar.xz / # 添加一个centos7

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="20201113" \
    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-11-13 00:00:00+00:00"

CMD ["/bin/bash"] # 运行

（二）、DockerFile基础

在构建前，我们先学习下构建基础

  1. 保留关键字（指令），都是大写字母
  2. 执行从上到下顺序执行
  3. #为注释
  4. 每一个指令都会创建提交一个新的镜像层

DockerFile是面向开发的，发布一个项目，做镜像，就需要编写DockerFile文件

DockerFile指令

这里先贴张图
在这里插入图片描述

FROM 基础镜像，一切从这里开始构建
MAINTAINER 镜像是谁写的，国际常用：姓名+邮箱
RUN 镜像构建时需要执行的命令
ADD 加点东西，比如我们构建的是centos，给它加个mysql镜像啥的
WORKDIR 镜像的工作目录
VOLUME 挂载的目录
EXPOSE 指定暴露的端口
CMD 指定这个容器启动的时候要运行的命令，只有最后一个生效，可被替代
ENTRYPOINT 指定这个容器启动的时候要运行的命令，可以追加命令
ONBUILD 当构建一个被继承 DockerFile，这个时候会执行ONBUILD命令
COPY 类型ADD，将文件拷贝到镜像中
ENV 构建镜像时设置环境变量，前面mysql需密码有使用

CMD和ENTRYPOINT的区别

前面我们说到他们的区别

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

这里，我们来实际演示下，加深理解，首先构建CMD的DockerFile

  1. 创建文件 vim dockerfile-cmd-test 写入内容
FROM centos
CMD ["ls","-a"]
  1. 执行构建
docker build -f dockerfile-cmd-test -t cmdtest .
  1. 运行
docker run 66rwrh3d3rs

你会发现，执行了ls -a，展示了所有的目录
而当我们这样操作时，就会报错了，这里就不记录过程了

docker run 66rwrh3d3rs -l

这是由于CMD下 -l 替换了ls -a，-l 不是命令，因此报错了，这样才不会错

docker run 66rwrh3d3rs ls -al

看到这里，你已经能够理解他们的区别了，我们在写一个ENTRYPOINT的，步骤跟前面的一样，细节不在记录

FROM centos
ENTRYPOINT ["ls","-a"]

然后直接执行，

docker run 7fsh6wgded -l

你会发现不报错，这就很直观的展示了他们之前的区别

（三）、构建DockerFile实例

构建centos

官方的都是阉割版，我们来构建一个相对完整的，加上vim命令和ifconfig等命令

  1. 创建一个DockerFile，取名mydockerfile-centos，写入以下内容
FROM centos
MAINTAINER zx<8208820@qq.com>
ENV MYPATH /usr/local
WORKDIR $MYPATH
RUN yum -y install vim
RUN yum -y install net-tools
EXPOSE 80
CMD echo SMYPATH
CMD echo "---end---"
CMD /bin/bash
  1. 构建DockerFile，执行命令
# 注意，后面有个点
docker build -f mydockerfile-centos -t mycentos:0.1 .

然后就会一步一步执行了，具体可查看 “（四）数据卷—DockerFile”
执行完成后，也可以通过如下命令查看构建过程

docker history 镜像id

  1. 运行容器
docker run -it mycentos:0.1

然后执行pwd、vim、ifconfig等命令，发现能够执行

构建Tomcat

  1. 准备镜像文件 tomcat的压缩包和jdk的压缩包
  2. 在同级目录创建一个DockerFile，取名Dockerfile，这是官方推荐的名称，build构建时就不需要写 -f 了，然后写入内容
FROM centos
MAINTAINER zx<8208820@qq.com>

COPY readme.txt /usr/local/readme.txt

ADD jdk-8ull-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.22.tar.gz /usr/local/

RUN yum -y install vim

ENV MYPATH /usr/local
WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_11
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.22
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.22
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 8080

CMD /usr/local/apache-tomcat-9.0.22/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.22/bin/logs/catalina.out
  1. 构建镜像
    由于我们的Dockerfile的名字为官方定义（默认的），这里可以不用写名字
docker build -t diytomcat .
  1. 运行容器
docker run -d -p 9090:8080 --name mytomcat 
-v /home/mytomcat/test:/usr/local/apache-tomcat-9.0.22/webapps/test
-v /home/mytomcat/logs:/usr/local/apache-tomcat-9.0.22/logs 
diytomcat
# 进入容器
docker exec -it 6fsj3jrwda78 /bin/bash
# 进来就是工作目录，然后查看下是否有tomcat等
ls
  1. 访问测试
    在浏览器访问tomcat地址，进入到tomcat页面表示成功

http://ip:9090

然后我们可以写一个jsp放到webapps的test下，查看能否访问页面，由于我们已经挂载好，因此可以在容器外对应的目录编写，具体测试过程就不记录了

  1. 发布镜像（dockerHub）
    注册账号，网站地址：https://hub.docker.com/，并登录
    发布我们的镜像
# docker login -u 账号
# 根据提示输入密码
# 登录后，输入命令
docker push zx/diytomcat:1.0

这样就可以完成发布了，阿里云发布就不记录了

（四）、总结

贴张百度的图，图片内容包含了我们前面学习的所有内容，生动展示了他们之间的转换关系
在这里插入图片描述

三、Docker网络

（一）、基础原理

在这部分我们只做简单了解，不记录详细过程，由于计算机网络知识不扎实，可能存在错误 >_<
我们前面讲到，docker容器是独立的，当我们两个容器间需要通信时，比如tomcat中的java应用要使用数据库，我们的tomcat和mysql又是独立的两个容器，他们之间是如何通讯的呐，这就是docker的网络
通过测试，我们得出两个结论

1、主机能够ping通主机内的容器
2、同一主机内的两个容器之间能够相互ping通

这是如何做到的，如图
在这里插入图片描述
当我们启动容器时，docker会自动帮我们生成一对网卡（veth-pair技术），如图，261和262，容器间不直接通信，而是通过网卡连接路由器docker0，docker0充当桥梁，将它们连接起来，所有的容器不指定网络的情况下，都是docker0路由的，docker会给我们的容器分配一个默认的可用ip

（二）、–link

什么是–link，在我们启动一个容器时，docker会给我们自动分配可用ip，如果我们在项目中配置了数据库的dataSource（ip:端口 库名等），现在我们不用以前的数据库了，重新启动一个mysql容器，那么ip就换了，我们需要在项目中去改动，就很麻烦，因此，我们需要一种机制帮我们解决这个问题，就是将ip改成容器名称来进行连接（其本质为hosts映射），因为名字我们可以固定
我们启动两个容器，用docker分配的ip是能ping通的，但直接使用容器名称是不通的，我们需要在启动容器时加上–link，如下

docker run -d -P --name tomcat03 --link tomcat02 mysql

这样通过名称就能ping通了，他是如何实现的，如图
在这里插入图片描述
在docker03的hosts文件中，看到了如下配置 172.18.0.3 tomcat02 31285***，这就是我们能够ping通的原因了
注意，这只能实现tomcat03到tomcat02，tomcat02 ping tomcat03是不通的，我们要想ping通还得在02的hosts加上03的映射地址，当然–link的方式是不建议使用的，我们需要的是自义定网络

（三）、自定义网络

首先我们查看下docker的网络信息
在这里插入图片描述

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

创建自定义网络

在创建前，我们要保证环境干净，删除掉前面测试的网络等

docker rm -f $(docker ps -aq)

删除后，查看下网卡，初始的话只有三个网卡 ip addr
在这里插入图片描述
前面我们在启动容器时，我们省略了网络配置，网络配置命令如下

# --net bridge为配置网络，bridge就是前面我们说到的默认网络：docker0，
docker run -d -P --name tomcat01 --net bridge tomcat

docker0的特点是：默认，域名不能访问，需要–link打通
因此，我们需要自定义一个网络，可以通过 docker network create --help 查看创建网络相关命令，创建网络

# --driver bridge 桥接 默认
# --subnet 192.168.0.0/16 子网地址
# --gateway 192.168.0.1 网关地址
docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

然后就可以通过 docker network ps 查看到我们配置的网络了

测试

我们需要启动两个容器，并配置我们自定义的网络

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

查看自定义网络的详细信息

docker network inspect mynet

发现我们的两个容器已经配置好了
在这里插入图片描述
然后测试两个容器的网络

docker exec -it tomcat-net-01 ping 192.168.0.3
docker exec -it tomcat-net-01 ping tomcat-net-02

发现两个都能够ping通，而不是我们前面的要使用–link才能通了，这是因为自定义网络，docker都已经帮我们维护好了对应的关系，推荐使用自定义网络
自定义网络的好处有：当我们搭建redis集群和mysql集群时，使用不同的网络，保证集群的安全和健康

网络连通

前面我们讲到同一网络间的容器是能通的，但是不同网络间的容器呐，答案肯定是不通，因为他们之间的网段都是不一致的，如图，下面我们将学习怎样把docker0和mynet打通，开始前先在docker0下启动两个容器
docker run -d -P --name tomcat01 tomcat / docker run -d -P --name tomcat02 tomcat
在这里插入图片描述
打通的命令为 connet，可以通过 docker network connect --help 查看详细，连通命令

docker network connect mynet tomcat01
# 连通后，其实就是将 tomcat01放到了mynet下（一个容器，两个ip）

然后，我们的tomcat01 就能 ping 通tomcat-net-01了，假设我们要跨网络操作别人，就需要使用 docker network connect 连通了

四、Docker实战

Redis集群部署实战

部署如图所示的Redis集群
在这里插入图片描述

  1. 首先创建Redis集群的网络
docker network create redis --subnet 172.38.0.0/16
  1. 使用脚本创建6个redis配置
    在这里插入图片描述
    这里只简单记录下过程，直接粘贴如图脚本然后回车执行即可，执行完后，可以通过这个步骤查看是否成功
    在这里插入图片描述
  2. 启动redis
    在这里插入图片描述
    然后依次启动剩下的五个redis，注意对外端口、名称、ip都要改变，依次为

6372:6379 16372:16379 redis-2 172.38.0.12
6373:6379 16373:16379 redis-3 172.38.0.13
…

创建6个redis后，使用docker ps查看下

  1. 创建集群
    先进入到redis-1中
# 和其他不一样，redis没有bash，对应的是sh
docker exec -it redis-1 /bin/sh

配置

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

然后根据提示输入yes即可，可以通过如下命令查看是否配置成功

redis-cli -c
cluster info
cluster nodes

如图
在这里插入图片描述

  1. 测试集群
    过程：先往redis中设置一个值，然后将存储节点容器给删除，然后看能否正常取到该值，如图
    在这里插入图片描述
    先设置一个值，set a b，工作的redis为14这个，然后我们在另外一个主机窗口将此容器删除，然后再获取值，发现能够正常获取到，说明我们的集群是部署成功的，我们通过 cluster nodes也可以看到这个过程，13出问题了，然后14成为了master

SpringBoot微服务打包Docker镜像

  1. 在IDEA上创建一个springboot项目
    自己创建一个，然后写个controller接口，能够测试访问即可
  2. 打包应用
    maven -> package 打包即可，然后在cmd中看下能不能运行，java -jar xxx.jar
  3. 编写dockerfile
FROM java:8

COPY *.jar /app.jar

CMD ["--server.port=8080"]

EXPOSE 8080

ENTRYPOINT ["java","-jar","/app.jar"]
  1. 构建镜像
    先在服务器上创建一个目录：idea，将我们的jar包和dockerfile上传到目录中，然后执行
docker build -t springboot_test .

执行完毕后，docker images，就出现了springboot_test这个镜像

  1. 发布运行
docker run -d -P --name springboot_docker springboot_test
# 执行完毕看看是否成功
docker ps
  1. 测试
    访问我们设计好的controller接口，如果正确返回则成功，当然浏览器访问也可以
# curl localhost:端口/api

补充

前面的知识，我们只是做了简单的应用和测试，真正的企业运用，我们还需要继续学习
Docker Compose
Docker Swarm
CI/CD之Jenkins
这些内容等到需要的时候在进行学习啦

end…

**如果总结的还行，就点个赞呗 @_@ 如有错误，欢迎指点！

鑫！
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Docker学习笔记 —— Docker 安装
橘子上树丶的博客
09-28 515
一、 安装包下载 Mac 安装包：https://docs.docker.com/desktop/mac/install/ Windows 安装包：https://docs.docker.com/desktop/windows/install/ Linux 安装包: https://docs.docker.com/engine/install/ 二、CentOS 安装Docker 以CentOS为例，更多安装方式参考：https://docs.docker.com/engine/install/
docker学习至docker-compose
mofeng24的博客
07-02 562
docker安装 #系统内核 3.10 [fengge@localhost ~]$ uname -r 3.10.0-957.el7.x86_64 #系统版本 [fengge@localhost ~]$ cat /etc/os-release NAME="CentOS Linux" VERSION="7 (Core)" ID="centos" ID_LIKE="rhel fedora" VERSION_ID="7" PRETTY_NAME="CentOS Linux 7 (Core)" ANSI_COLOR=
《Docker极简教程》--Docker的高级特性--Docker Swarm的使用
喵叔
03-03 1288
Docker Swarm是一个强大的工具，可用于管理容器化应用程序。它提供了集群管理、服务发现、负载均衡等功能，通过Swarm模式实现高可用性和弹性伸缩。我们学习了如何创建和管理Swarm服务、网络和节点，以及部署策略和故障恢复机制。通过这些功能和实践，我们可以更轻松地在生产环境中部署和管理容器化应用程序，提高应用程序的可靠性和可扩展性。
《Docker极简教程》--Docker的高级特性--Docker Compose的使用
喵叔
03-02 1341
YAML（YAML Ain’t Markup Language）是一种人类友好的数据序列化格式，常用于配置文件和数据交换。在Docker Compose中，使用YAML语法来编写Compose文件来定义多容器应用程序的服务、网络、卷等配置。缩进YAML使用缩进来表示数据结构的层次关系，而不是使用花括号或其他符号。缩进一般是两个空格或一个制表符。子项的缩进必须严格地相对于其父项。键值对YAML使用键值对的形式来表示数据，格式为key: value。键和值之间用冒号分隔，且冒号后面必须有一个空格。列表。
Docker尚硅谷_高级篇
qq_43070052的博客
05-11 545
容器间的互联和通信以及端口映射。容器 IP 变动时候可以通过服务名直接网络通信而不受影响。（类似Eureka，通过服务名直接互相通信，而不是写死IP地址）。docker中还有一个--link进行容器网络互联，但是已经被标记为过时的，可能会在将来的版本中移除这个功能。推荐使用自定义网络替换link。自定义桥接网络（自定义网络默认使用的是桥接网络bridge）：新建自定义网络查看网络列表创建容器时，指定加入我们自定义的网络中此时进入tomcat1中，使用ping命令测试连接tomcat2。
docker 高级篇
qq_47848696的博客
01-30 487
docker高级篇-java.jar包构建镜像并运行
docker高级
qq_51274370的博客
05-03 1036
DockerFile DockerFile是什么？ Dockerfile是用来构建Docker镜像的文本文件，是由一条条构建镜像所需的指令和参数构成的脚本。 镜像构建三大步： ​ 编写DockerFile文件 执行docker build 命令构建镜像 docker run 运行容器。 DockerFile构建过程解析 Dockerfile内容基础知识 每条保留字指令都必须为大写字母且后面要跟随至少一个参数 指令按照从上到下，顺序执行 #表示注释 每条指令都会创建一个新的镜像层并对镜像进行提交
Docker高级篇
YZG ' BLOG
08-01 2638
Docker 高级篇优点：缺点：总结：官网：https://docs.docker.com/engine/reference/builder/简单来说，dockerfile 每执行一条指令都会提交新的镜像层，执行完得到最终的镜像层是什么？
Docker —— 从入门到实践 epub
12-06
Docker — 从入门到实践 0.9-rc1(2017-11-29) 修订说明：本书内容将基于 Docker CE v17.x 进行重新修订，计划...11、12 章介绍关于 Docker 安全和实现技术等高级话题。后续章节则分别介绍一些相关的热门开源项目。
docker的概要介绍与分析
最新发布
06-12
2. **《Docker —— 从入门到实践》**（电子书）：这本书由国内Docker社区撰写，内容从Docker安装到进阶使用，再到Docker Compose、Docker Swarm等高级话题，循序渐进，适合零基础学习者系统学习。 ### 实战课程 -...
详解Docker三剑客
12-24
在现代的云计算和DevOps领域，Docker已经成为了容器化技术的代名词，而“Docker三剑客”——Docker Swarm、Docker Machine和Docker Compose，则是Docker生态系统中的三个核心工具，它们分别负责了不同的任务，旨在...
Docker高级管理——网络通信、compose容器编排、consul、consul-template
01-09
在Docker的世界里，网络通信和容器编排是两个至关重要的概念。首先，我们要理解Docker的网络通信机制。默认情况下，Docker容器之间是相互隔离的，它们有自己的网络栈，不能直接相互通信。然而，为了实现服务间的通信...
GUI中常见事件和事件监听器
ruan_luqingnian的博客
02-02 3261
事件处理 前面介绍了如何放置各种组件，从而得到了丰富多彩的图形界面，但这些界面还不能响应用户的任何操作。比如单击前面所有窗口右上角的“X”按钮，但窗口依然不会关闭。因为在 AWT 编程中 ，所有用户的操作，都必须都需要经过一套事件处理机制来完成，而 Frame 和组件本身并没有事件处理能力 。 GUI事件处理机制 定义： ​ 当在某个组件上发生某些操作的时候，会自动的触发一段代码的执行。 在GUI事件处理机制中涉及到4个重要的概念需要理解： 事件源(Event Source)：操作发生的场所，通常指某个组件
Docker内容分享（三）：Docker 高级教程
之乎者也·的博客
12-10 946
Docker Compose 是 Docker 的一个子项目，可以帮助用户定义和运行多容器 Docker 应用程序。例如要实现一个Web微服务项目，除了Web服务容器本身，往往还需要再加上后端的数据库mysql服务容器，redis服务器，注册中心eureka，甚至还包括负载均衡容器等等。有关更详细的信息，请参阅 Docker Compose 的官方文档。Dockerfile面向开发，Docker镜像成为交付标准，Docker容器则涉及部署与运维，三者缺一不可，合力充当Docker体系的基石。
Docker高级
qq_45752401的博客
05-01 606
Docker1，docker网络管理 1，docker网络管理 默认网络 1，查看docker网络 docker network ls Docker中默认的三种网络分别为bridge、host和none，其中名为bridge的网络就是默认的bridge驱动网络，也是容器创建时默认的网络管理方式，配置后可以与宿主机通信从而实现与互联网通信功能，而host和none属于无网络，容器添加到这两个网络时不能与外界网络通信。 这里介绍的三种网络bridge、host和none都是在非集群环境下Docker提
docker部署--高级篇【运维开发】
qq_46955316的博客
03-17 403
docker常用的高级知识点。可以不看
docker高级篇
weixin_46018506的博客
01-28 2291
M S 1 5 2 6 3 4
Docker深度学习：从入门到实践
"这是一本全面介绍Docker的入门教程，...本书《Docker——从入门到实践》是学习Docker的全面教程，从基础概念到实际操作，再到高级应用场景和安全措施，覆盖了Docker的各个方面，适合想要深入了解和运用Docker的读者。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值