Docker进阶

最新推荐文章于 2022-12-27 13:49:42 发布
最新推荐文章于 2022-12-27 13:49:42 发布
阅读量2.1k 收藏
点赞数
分类专栏： 软件开发 文章标签： docker
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44015043/article/details/112392909
版权

文章目录

Docker镜像加载原理与操作

其实就是层级的操作，最开始是只有一层的存在就是最基础的数据，在后面操作的过程中，就是会对层级进行不断地进行添加操作，我们最开始拉取下来的层级就是最基础的镜像，在使用到run命令的候，其实就是在新的层级上对其进行的系列的操作，并不会操作到最底层的数据，然后，就可以使用到commit命令来提交自己的镜像。

Commit

docker commit 提交容器成为一个新的副本

-m=“对提交的信息进行描述”

-a= “作者”

目标镜像的名字：[TAG]

我们下载下来的镜像是最基础的镜像版本，所以说我们若是想要每次都启动tomcat都需要下面的操作

docker run -d --name tomcat1 -p 8887:8080 tomcat # 表示后台启动，不会占用到当前的前台进程
docker exec -it tomcat1 /bin/bash    # 进入到docker里面进行系列的操作
cp -r ****         # 因为对于docker 安装的tomcat来说 是精简版本的，所以需要拷贝系列的东西，下面我们就可以发布一个自己的版本，然后后面运行自己的版本。
docker commit -m="add webapps" -a="Maycope" f3f1bd92b0ac tomcatF:1.0
# 进行查看
[root@yin ~]# docker images
REPOSITORY           TAG                 IMAGE ID            CREATED             SIZE
tomcatf              1.0                 d1ea0cf2c1cd        11 seconds ago      654MB
nginx                latest              bc9a0695f571        12 days ago         133MB
# 进行测试 先停掉当前的tomcat，然后启动自己新提交的docker，

容器数据卷

什么是容器数据卷

之前说的容器，例如我们的Mysql容器，数据都在里面，但是我们很多时候都是会对数据卷进行移除的处理，在这个时候，我们就需要将容器里面的数据持久化保存到我们容器的外面，使得在容器里面的操作不会影响到我们的基础数据。

容器的操作有一个叫做卷技术，就是目录的挂载的功能，将我们容器内的目录，挂载到我们的虚拟机上面。

使用数据卷

方法一：直接使用到命令来进行挂载 -v

docker run -it -v 外部目录：内部目录 容器名称 /bin/bash
docker run -it -v /home/test:/home  centos /bin/bash
# 可以进入到容器的home目录下面创建一个文件，然后在宿主机上进行系列的查看。
docker inspect 容器id     # 使用命令查看容器的基础信息。

image-20201208220613582

Mysql测试
docker run -d -p 3310:3306 -v /home/mysql/conf:/etc/mysql/conf -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7
-d 后台运行
-v 数据卷挂载
-e 配置数据库密码
--name 重新命名

**远程连接测试：**可以看到的是在本地连接到了远程服务器上的Mysql服务，此处可以对比自己的远程主机上面安装Mysql的复杂过程（注意对于Mysql与Redis来说，远程主机的服务的密码要经常进行更改，不然很有可能被挖矿软件攻击），这样我们在容器删除的时候，也就仍然能够将数据保存下来，而不会丢失。

image-20201208223605788

Docker的匿名挂载与具名挂载

#  匿名挂载
# -d 表示匿名 -P 表示端口号 -v 表示挂载的路径的信息。
docker run -d -P --name nginx1 -v /etc/nginx  nginx
# docker volume ls 查看我们所有卷的情况。会发现所有的vloume 都是没有命名的，就是所谓的匿名挂载
docker run -d -P --name nginx2 -v ju-nginx:/etc/nginx nginx 
# 此刻就是 具名挂载 通过 -v 名称:容器内的路径。  然后再使用到 docker volume ls 查看。
docker volume inspect ju-nginx   
# 来查看 对于这个容器的具体挂载到主机上的具体的路径信息。

image-20201211102341390

此刻进入到对应的目录下面，就可以看到挂载出来的目录信息
# 如何确定我们是具名，匿名 还是 指定路径挂载。
—v 容器内路径   # 匿名挂载
-v 卷名: 容器内路径   # 具名挂载
-v /宿主机路径: 容器内路径     #

拓展：

# 通过 -v 容器内路径： ro,rw 改变我们的读写权限。
ro   readonly   # 只能读
rw   readwrite  # 可读可写。

docker run -d -P --name nginx02 -v ju-nginx:/etc/nginx:ro nginx
docker run -d -P --name nginx03 -v ju-nginx:/etc/nginx:rw nginx
# ro 表示是只读信息，这个时候就只能够再宿主机上对信息进行修改，在容器里面不能够进行系列的修改，是只读的

Dockerfile

初始DockerFIle

Dockerfile 就是用来构建文件。

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

# 创建一个dockerfile 文件名字可以随机 
FROM centos
# 指令名字都是大写的。
VOLUME [“volume01","volume02"]

CMD echo "-----end----"
CMD /bin/bash
# 现在开始启动我们的镜像的创建。
# 执行这条语句之前，进入到对应的目录的下面。
docker build -f dockerfile -t maycope/centos .

image-20201211113219071

经过查看之后，发现我们自定义的镜像是存在的。此时我们就可以使用run命令来进行启动。

docker run -d -it maycope/centos  /bin/bash #运行
docker exec -it 7bee8331c3f3 /bin/bash     # 进行交互进入到容器里面。
# 退出来之后，使用到 inspect 之后 可以查看到挂载的地址信息。因为我们是么有指定挂载的其他具体信息，所以说是匿名挂载。可以查看到挂载的地址。
docker inspect 容器id。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oOQRL1sa-1610178887989)(C:\Users\ASUS\Desktop\upload\image-20201211133411350.png)]

在后面的使用的过程中，这种使用非常多，因为我们通常会构建属于自己的镜像。

构建

我们所谓的docker 核心上就是说可以用来构建docker镜像的核心的文件。我们可以对其进行内容的编写，然后 进行系列的生成，就可以完成我们制作精选的目的。

  1. 编写一个dockerFile 文件。
  2. docker build 构建成为一个镜像。
  3. docker run 来运行一个镜像。
  4. docker push 发布镜像（DockersHub，阿里云镜像仓库）

我们也可以去对应的centos（docker) docker 官网，然后点击对应的镜像信息，可以看到最基础的centos，其实是最基础的什么都没有，我们想要自己编写一个centos，带上我们想要的jdk,tomcat,mysql,redis,时候，就可以自己发布一个对应的centos。

指令

基础知识

  1. 每一个保留的关键字（指令）都必须是完全的大写字母。
  2. 执行从上到下顺序执行。
  3. “#” 表示的是注释信息。
  4. 每一个指令都会提交一个新的镜像层，并执行提交。
  5. 我们的dockerfile 是面向开发，在后面我们开发项目，都是直接编写dockerFile，然后添加上我们进行的更改，就可以将这个dockerFile修改之后，我们就可以这个dockerFile 进行交付就好了。‘

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

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

Docker容器： 容器就是镜像运行起来，然后提供服务的服务器系统。

FROM # 基础的镜像，一切都是从基础的镜像开始构建的。
maintainer  # 告诉别人，维护这个镜像的人是谁。
run   # 镜像构建的时候 会执行的命令。
add   # 步骤： tomcat 镜像  就是添加自己想要的内容
workid # 镜像的工作的目录。
volume # 挂载的目录。
expose # 暴露的端口。
cmd    # 指定这个容器启动的时候要运行的命令，只有最有一个会生效，可以被替代。
entrypoint # 指定这个容器要运行的命令，可以追加命令。
copy     # 类似于add 将我们文件拷贝到镜像中。
env      # 构建的时候设置环境变量。

image-20201211171157555

开始操作

创建一个属于自己的centos

# 1. 编写自己的dockerfile 配置文件。
FROM centos
MAINTAINER maycope<19129183@qq.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN  yum -y install vim
RUM yum -y install net-tools

EXPOSE 80

CMD echo $MYPATH
CMD echo "-----end----"
CMD /bin/bash

# 2.通过这个文件来构建一个镜像 -f 表示构建的文件，-t 版本号。
docker build -f mydoc-centos -t mycentos:0.1 .
 # 最后出现，表示构建成功。
Successfully built a70bf824d356
Successfully tagged mycentos:0.1
# 3. 测试运行。可以看到的是当前的目录就是我们设置的跟目录，并且，我们安装的一些其他的基础的信息也都存在。而我们之前的centos，默认的根目录，并且其他我们所谓的命令也都是不存在的。
[root@yin dockerfile]# docker run -it mycentos:0.1
[root@101f2a753ed8 local]# pwd
/usr/local
# 4. 使用到docker history 来查看历史是如何做出来的。平时也可以使用到history 来查看别人的镜像是如何做的。

image-20201211203007305

比较重要的命令
CMD与ENTRYPOINT
[root@yin dockerfile]# vim mydoc-cmd

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

[root@yin dockerfile]# docker build -f mydoc-cmd -t cmdtest .
[root@yin dockerfile]# docker run cmdtest
.
..
.dockerenv
bin
dev
etc

# 以上就是自己构建容器的三部过程。通过执行我的cmd命令，来获取到我们执行的命令。

# 思考 上面我们简单的镜像实现的功能是ls -a 我们想要进行命令的追加功能
# 使用到 docker run cmdtest -l 就是实现命令的追加发现并不成功，这个时候就引出来了 entrypoint。


# 我们重复上面的操作过程，只不过将命令行里面的
FROM centos
ENTRYPOINT ["ls","-a"]
docker build -f mydoc-entry -t entrytest.
# 没有使用 -l
[root@yin dockerfile]# docker run entrytest
.
..
.dockerenv
bin
dev
etc

# 追加 -l 的时候。

[root@yin dockerfile]# docker run entrytest -l
total 56
drwxr-xr-x   1 root root 4096 Dec 11 13:01 .
drwxr-xr-x   1 root root 4096 Dec 11 13:01 ..
-rwxr-xr-x   1 root root    0 Dec 11 13:01 .dockerenv

实战通过 DockerFile 制作Tomcat 镜像

这一节也就主要是利用我们现有的基础的信息来构建一个自己的tomcat镜像，利用基础的命令，挂载。

  1. 准备我们的镜像文件，需要tomcat压缩包，jdk 压缩包。

    把东西都传递到tomcat里面，然后vim

  2. 编写Dockerfile 文件，这个文件（名字是通用的）

关于这个如何制作的问题，前提准备工作：新建立一个tomcat的文件，里面存放上我们必须要的tar.gz包，就是两个jdk和tomcat，然后在这个tomcat下面使用到vim Dockerfile来建立dockerfile文件。

FROM centos
MAINTAINER    maycope<99876@qq.com>

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

ADD  资源（）   /usr/local
ADD  资源（）   /usr/local

RUN yum -y install vim
ENV MYPATH  /usr/local
WORKDIR  $MYPATH

ENV JAVA_HOME /usr/local/jdk.1.8.0_11
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/toos.jar

ENV CATALINA_HOME /usr/local/apache
ENV CATALINA_BATH /usr/local/apache

ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 8080

# 日志输出。
CMD /usr/local/apache/bin/startup.sh && tail -F /usr/local/apache/bin/logs/catalina.out


# 构建   -f 表示配置文件，这里，我们配置文件的名称就是Dockerfile，所以不需要指定-f。
docker build -t divtomcat 
# 启动
docker run -d -p 8090:8080 --name maycopetomcat -v /home/maycope/build/tomcat/test:/url/apache/webapps/test -v /home/maycope/build/tomcat/logs:/url/apache/logs divtomcat

数据卷容器

理解起来就是利用这个容器去给其他的容器共享数据。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y41481Cp-1610178887992)(C:\Users\ASUS\Desktop\upload\image-20201211140354298.png)]

# 启动三个容器，通过我们自己写的镜像启动。
docker run -d -it --name centos01 /bin/bash maycope/centos
# 进行挂载
docker run -it --name centos02 --volumes-from docker01 maycope/centos
# 挂载完成值后，我们想要进入到容器里面进行查看
docker exec -it 容器id /bin/bash
docker attach 容器id
# 进入到数据卷里面 在卷一里面修改一些配置，对应查看在另外一个数据卷里面能否进行展示。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0kBCUHGt-1610178887993)(upload\image-20201211150642670.png)]

同步的数据信息，是我们两个volume下面的文件信息。因为我们在创建镜像的时候，就是这两个文件目录下面的具体信息。

思考

若是说我们的docker01删除之后，我们的docker02和docker03里面的内容并不会删除，还是会存在。

实现多个Mysql数据的共享

docker run -d -p 3310:3306 -v /etc/mysql/conf.d /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 

# 在这个时候，我们两个数据库之间的数据就能够进行互相的通信处理。

结论：

容器之间信息的互相传递，就像是之前我们多个服务器之间的配置要兼顾的时候，可以把所有服务器的配置都放置在一起。并且对于数据卷来说，数据卷容器的生命周期，会一直持续倒没有容器使用为止。但是当我们在使用到-v保存到本地时候，就永远不会删除。

发布自己的镜像

  1. 首先是需要登录到dockerbub上面，注册一个属于自己的账号。
docker login -u maycope
password:password。
docker tag 916af5c4122a entrytest:1.0
docker push 镜像
# 提交的时候也是一层一层进行提交。

Docker 基础总结

image-20201214171651931

Docker 网络

首先是来查看网络的大体都有哪些：

image-20201214174041882

现在我有三个网络，但是docker又是如何处理容器之间的网络请求于访问的。
# 有一个容器是tomcat，有一个是mysql容器，但是对于两个容器之间的网络是如何进行请求与转发的？

# 表示后台启动，下载最新的tomcat。
docker run -d -P --name tomcat01 tomcat

# 表示交互获取到当前
docker exec -it tomcat01 ip addr

原理

  1. 我们每次启动一个容器的时候，docker 就会给docker容器分配一个ip地址，我们只要安装了docker，就会有一个网卡docker0，使用到的是 evth-pair 技术，此时我们可以通过在docker宿主机来ping容器的ip地址，发现是可以进行互通的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6p3lcSwT-1610178887995)(upload\image-20201215095755828.png)]

我们可以发现的是，对于这个容器所带来的网卡都是一对一对存在的。
evth-pair 就是一对虚拟设备接口，他们都是成对出现的，一端是连着协议，一端是彼此相连接，就是因为有这个特性，evth-pair 充当着一个桥梁，连接着各种虚拟网络设备。
# 如下图所示，本来我们的宿主机到容器里面是不能够进行互通的，但是通过evth-pair，两个里面都会有一个对接的地方，在两边对接完成之后，就可以进行互相的通信了。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qan2j9PQ-1610178887996)(upload\image-20201215100540497.png)]

多个容器进行测试时候：

可以发现的是对于ip都是成对存在的，我们的tomcat01，要和02进行通信的时候，并不是直接进行通信的，而是先通过我们的docker0 网络路由，来进行网络请求的转发，对于路由器里面的可以通过直接注册将所有的路由信息都存放在里面，或者通过广播的方式来进行路由的请求转发接收。

image-20201215101605862

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

思考一个场景，我们在编写了一个微服务的时候，我们指定了对应的数据库地址，但是在项目进行重启时候，数据库的地址在变更之后，我们就需要重新变更数据库的连接地址，所以想要解决这个问题，通过服务名称来访问对应的容器。

容器互联

–link

我们想要实现上面的需求，就需要使用到 –link,来实现

docker run -d -P --name tomcat003 --link tomcat002 tomcat
docker exec -it tomcat003 ping tomcat002
# 就可以实现具体的网络的联通。不需要通过具体的ip，但是弊端在于容器创建时候，不是双向的，是单向的，就是启动哪个容器和对应的容器进行连接时候，是一对一的
自定义网络

查看所有的docker网络

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dZSvq5Bd-1610178887998)(upload\image-20201216102446804.png)]

基本的网络的模式

bridge : 桥接模式（默认）

none ： 不配置网络

host ： 主机模式 和宿主机一起来共享网络

测试

# 第一条 我们不带网络执行的命令，执行的就是docker0 
docker run -d -P --name tomcat001 tomcat 
= docker run -d -P --name tomcat001 --net bridge tomcat 

# bridge0 默认 域名不能访问 --link 能够通 但是不方便


# 自定义网络 
# --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
8bbe2c13b2180ad08fd8281a51dcb5f0e5cdb5adeccb074e03ea340f85ef51bb
[root@yin ~]# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
2e8a058516bd        bridge              bridge              local
8af4b107b451        host                host                local
8bbe2c13b218        mynet               bridge              local
96610e843152        net1                bridge              local
# 使用 inspect 查看。
[root@yin ~]# docker network inspect mynet
[
    {
        "Name": "mynet",
        "Id": "8bbe2c13b2180ad08fd8281a51dcb5f0e5cdb5adeccb074e03ea340f85ef51bb",
        "Created": "2020-12-16T10:55:43.466196107+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/16",
                    "Gateway": "192.168.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,

将自己的服务放在自己的网络上

# 首先是部署
docker run -d -P --name tomcat01 --net mynet tomcat
docker run -d -P --name tomcat02 --net mynet tomcat 
docker network inspect mynet

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QV699A9z-1610178887998)(upload\image-20201216110606897.png)]

# 好处： 还记得之前我们提出的问题是，对于容器与容器之间绑定ip地址时候，出现ip地址变化问题，想要通过 --link来建立连接，但是通过 --link进行连接时候，是单向的，而且不方便操作。所以我们通过上面的 create 来创建自己的网络，然后将容器发布到自己的网络里面，下面就是可见的好处
# 现在不但可以通过ip地址进行连接，还能够通过容器的名称进行连接的建立，这里就可以看到我们自定义网络的好处，可以自定义很多的网络，然后将那些需要建立连接的容器再启动的时候，启动在我们的自定义网络里面。
# 这个时候 我们若是想要在运行redis和mysql两个集群的时候，并且不想要两个网络混杂在一起的时候，就会需要建立两个自己的网络

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ktDzcI8h-1610178887999)(upload\image-20201216111530845.png)]

网络连通
[root@yin ~]# docker run -d -P --name tomcat-bri-01 tomcat
5549f684f066186804cadb86ebf1975ed1396ea860da64ef223a3114654b325d
[root@yin ~]# docker run -d -P --name tomcat-bri-02 tomcat
2a9459a040dfa3c89ced5d291b94c2f47a54d2f5117f5172eadee2ea88bb4fc1
[root@yin ~]# docker exec -it ping tomcat01
Error: No such container: ping
[root@yin ~]# docker exec -it tomcat-bri-01  ping tomcat01
ping: tomcat01: Name or service not known
# 网络连通，利用到 docker network connnet 将一个容器联通到一个网络，我们这里就是将上面创建的tomcat-bri-01 联通到我们的 192.168.0.1 网络，就是所谓的网络连通。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3cqeSqFv-1610178888000)(upload\image-20201216134315116.png)]

# 具体使用（见下图），我们的网络192.168.0.1网络名称是mynet，连通到我们新创建的容器（其网络就是我们基本的网络），然后连通之后，使用的ping信息时候，就可以正常的展示。
[root@yin ~]# docker network connect mynet tomcat-bri-01
[root@yin ~]# docker exec -it tomcat-bri-01 ping tomcat01
PING tomcat01 (192.168.0.2) 56(84) bytes of data.
64 bytes from tomcat01.mynet (192.168.0.2): icmp_seq=1 ttl=64 time=0.060 ms
64 bytes from tomcat01.mynet (192.168.0.2): icmp_seq=2 ttl=64 time=0.062 ms

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1W1b2b5W-1610178888001)(upload\image-20201216135350766.png)]

具体的流程图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zXZSjr7X-1610178888001)(upload\image-20201216140627669.png)]

部署redis集群

  1. 对于redis集群来说，是偶数存在的。是三个从，三个主，所以最低需要启动六个redis单点容器。

  2. 既然我们是自己的redis集群，就需要有自己的网络。建立自己的网络信息。

    docker network create --driver bridge --subnet 192.169.0.0/16 --gateway 192.169.0.1 redisnet

# 具体的配置信息。这里就不具体配置出来。

SpringBoot微服务打包Docker镜像

1、构建一个SpringBoot项目

就是我们最基础的SpringBoot项目，定义一个接口，使用到对应的注解。

2、打包应用

启动能够正常进行访问之后，打包起来。

3、 编写对应的dockerfile

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eM1dx0r1-1610178888002)(upload\image-20201216154725754.png)]

4、构建镜像

将对应的jar包和对应的Dockerfile文件拷贝到服务器上对应的一个文件夹下面。

# 按理来说应该还会有对应的 文件信息，但是文件名称是标准的文件名称，所以可以不用指定对应的文件名。
docker build -t maycopeweb .

5、发布运行

# 不指定端口，后台启动服务。
docker run -d -P --name maycopes maycopeweb 
# 查看启动的容器,为了能够获取到对应的映射出来的端口。
docker ps
#  curl localhost:端口号/hello
conds       0.0.0.0:32779->8080/tcp   maycopeweb
[root@yin idea]# curl localhost:32779/hello
Hello,Maycope[root@yin idea]# 
# 可以查看到自己发布的接口信息。

Docker 高级部分

Docker Compose

网址

之前我们讲到我们发布的一个微服务的镜像，就是先创建一个SpringBoot项目，然后，打包起来成为一个jar包，编写Dockerfile文件，上传上去之后先进行一个build，创建完成之后，进行系列的run，才算是一个完整的微服务，但是有很多容器时候，我们不可能启动100个对应的微服务。所以需要进行系列的判断。

所以对于Docker Compose来说 可以来轻松高效的管理容器，定义运行多个容器。

使用：

  1. 还是需要我们定义对应的Dockerfile来保证我们的环境再任何地方运行。
  2. 定义对应的servies通过docker-compose-yml,然后运行环境。
  3. 运行docker-compose up命令就可以运行我们的对应App。

**作用：**批量对容器进行操作。

自己的理解：

  1. 只是一个Docker的开源的项目，需要安装。
  2. Dockerfile 让程序再任何地方运行。web服务，可能还会有redis，mysql，nginx等等。下面就是配置文件如何控制处理。
  3. 重要概念
    1. 服务 service就是我们的应用。
    2. 最终打包起来就是 项目 project。就是我们很多容器的集合体。

步骤

快速开始

1、应用app.py。

2、Dockerfile 应用打包为镜像

3、Docker-compose yaml 文件（定义整个服务，需要的环境，web，redis）。

4、启动compose。

5、启动起来之后我们可以发现是启动起来一个叫做web_1,和一个redis_2。

关于这个文件名字的问题默认的服务名字： 文件名 _ 服务名 _ num，在多个服务器时候，也就是集群的时候，若是我们的集群服务有两个服务器，现在有一个应用，既要在A服务器上运行，也要在B服务器上运行，对应的num就是副本的数量。现在我们有一个集群里面有四个服务器，需要部署四台redis，此时对应的就是 四个副本。在集群的状态下面，也不可能只会有一个运行的实例，就会有很多的实例，可以实现高可用。

image-20201221112319681

6、 网络规则，记得之前网络相关的具体信息，有关于网络访问的问题，现在情况就是若是我们将所有服务都部署在同一个网络下面，这样就可以不通过ip地址来访问到对应的服务，可以通过对应的服务的名称来对应访问。

image-20201221113737315

7、 停止docker 服务 docker-compose down ctrl+c。

**总结：**所谓的docker-compose 就是 能够通过配置文件的编写，通过compose

来一键启动所有的服务。

  1. 首先是我们通过了解Docker 镜像，run=> 容器。
  2. Dockerfile 构建镜像（服务打包）
  3. docker-compose up 启动项目（编排，多个微服务/环境）
  4. docker 网络，通过 inspect 进行查看网络之间的关系。

yaml配置

黛色翩翩
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【docker实战教程】基础、进阶，从入门到高级全面覆盖！
04-08
本系列讲解细致且深度，并包含进阶篇，技术点从入门到高级全面覆盖！教程也适用于零基础小白和已熟悉Docker的使用者。
Docker进阶教程
小Y先生的博客
08-26 581
这篇文章讲解Docker的高级用法，不适合丝毫不懂Docker的小白。如果你对于Docker没有任何了解，请移步至我的另一篇文章Docker零基础教程，待了解了Docker基础，再来学习这篇文章。FROM基础镜像，当前新镜像是基于那个镜像的，指定一个已经存在的镜像作为模板，第一条必须是fromMAINTAINER镜像维护者的姓名和邮箱地址RUN容器构建时需要执行的命令EXPOSE当前容器对外暴露的端口WORKDIR指定在创建容器后，终端默认登陆的进来工作目录，一个落脚点USER。..............
docker进阶
梦想是很难很难的，所以先勇敢一点
03-05 3821
容器数据卷 什么是容器数据卷 docker的理念回顾 将应用和环境打包成一个镜像！ 数据。如果数据都在容器中，那么我们容器删除，数据就会丢失！ 需求：数据可以持久化 MySQL，容器删了，相当于删库跑路！ 需求：mysql数据可以存储在本地！ 容器有一个数据共享的技术！Docker容器中产生的数据，同步到本地！这就是卷技术！相当于目录的挂载，将容器内的目录。挂载到linux上面。 总结：容器的持久化和同步操作！容器间也是可以数据共享的！即使容器没有运行，当然容器被干掉就不行了 面试可能会问的小问题：
Docker 进阶篇
凭心而动
07-25 896
Docker安装MySQL主从复制、redis三主三从集群配置及其常用分布式存储算法、Dockerfile发布微服务、Docker网络及网络模式、Docker-compose容器编排、Portainer轻量级可视化工具、CIG重量级监控等
Docker 的进阶操作
wenqi1992的博客
12-27 196
本文是关于 Docker 的进阶操作，介绍如何通过 Dockerfile 文件构建镜像、如何搭建私人镜像仓库、Docker 网络通信。
Docker的基本使用
山丘i
11-18 934
相应的资料 链接：https://pan.baidu.com/s/1rXqV2xWSkx7S8dEKQd63mQ 提取码：1211 1.初识Docker 1.1.什么是Docker 微服务虽然具备各种各样的优势，但服务的拆分通用给部署带来了很大的麻烦。 分布式系统中，依赖的组件非常多，不同组件之间部署时往往会产生一些冲突。 在数百上千台服务中重复部署，环境不一定一致，会遇到各种问题 1.1....
Docker入门与进阶（基础+实战+进阶+Compose+Swarm）超详细版
weixin_45698637的博客
04-08 4357
Docker入门与进阶 Docker入门 Docker 使用流程 Docker 访问原理 Docker 常用命令 容器数据卷 Dockerfile Docker总结 Docker网络 Docker Compose单机部署 Docker Swarm集群部署 Docker 其他命令
docker进阶与实战
qzcsu的博客
03-03 679
环境说明 本文是紧接着上一节 docker入门与实战 docker的网络模式 host 主机模式。该网络模式下容器不会拥有自己的ip地址，而是使用宿主机的ip地址和端口，因此不存在宿主机与容器端口映射。 bridge 桥接模式(默认)。桥接模式是，当Docker服务启动时，会在主机上创建一个名为docker0的虚拟网桥，并选择一个和宿主机不同的IP地址和子网分配给docker0网桥。后续启动...
docker整理进阶篇
xiaofang2015的博客
05-29 869
docker进阶篇：转自https://www.cnblogs.com/sparkdev/p/9092082.html 整理的笔记：镜像方面的： registry保存docker镜像，其中还包含镜像层次结构和关于镜像的元数据。 repository 是镜像组，是镜像集合，里面含有不同版本，版本之间用tag区分。 manifest(描述文件)是存在于Registry中作为docker镜像的元数据文件...
docker进阶教程-----概念理解
qq_39874538的博客
08-06 147
docker概念理解docker概念Docker的应用场景Docker 的优点1、快速，一致地交付您的应用程序2、响应式部署和扩展3、在同一硬件上运行更多工作负载Docker 包括三个基本概念如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 docker概念 docker里
docker从入门到入土（进阶篇）
qq_54502707的博客
02-24 365
Hello~大家好，这里是KOKO！ 之前我们学习了docker的基础篇内容，今天我们来深入了解进阶篇的内容。 在学习进阶篇之前，请大家务必保证基础篇的那些常用命令都进行了练习并且已经熟练掌握！ docker复杂安装详说 安装mysql主从复制 主从复制原理 日志的互相读写； 此处不详细讲解原理，可自行查阅相关资料。 主从搭建步骤 新建主服务器3307(3306为docker实例里的端口) docker run -p 3307:3306 --name mysql-master -v /mydata/m
docker进阶之路-基础篇 | 二：portainer安装与基本使用
银河架构师的博客
12-18 2039
转载请注明作者及出处： 作者：银河架构师 原文链接：https://blog.csdn.net/liuminglei1987/article/details/103603512 ​简介 Portainer 是轻量级，跨平台，开源的管理Docker的UI。Portainer提供了Docker的详细概述，并允许通过基于Web的简单仪表板管理容器、镜像、网络和卷，且支持GNU /...
《 Docker 进阶与实战 》 读书笔记
愿我如星君如月 ... 夜夜流光相皎洁 ...
02-23 3637
以下内容全文出自书目：《 Docker 进阶与实战 》 1. Docker 定义：一个开源的容器引擎，可以方便地对容器进行管理，不同容器可以共享底层的只读镜像。 2. Docker 是一个典型的 C/S 架构的应用。 3.Docker deamon 可以被理解成Docker Server ，也常常用Docker Engine 来描述它。 4. 容器以镜像为基础，同时又为镜像提...
【狂神说】Docker【进阶篇】
weixin_46703850的博客
02-07 2567
[【狂神说Java】Docker进阶篇超详细版教程通俗易懂_哔哩哔哩_bilibili](https://www.bilibili.com/video/BV1kv411q7Qc/?spm_id_from=autoNext) 官网：https://www.docker.com/ 文档地址： https://docs.docker.com/ （Docker 官网文档超级详细） 仓库地址：https://hub.docker.com/ 容器单独没有什么意义，有意义的是容器编排
docker从容器中拷贝文件到宿主机
zhaoyajie1011的博客
08-06 4195
docker 从容器中拷贝文件到宿主机 作者：YoungJ 进入容器 docker ps docker exec -it cf92087e9e9c bin/bash 找到docker容器中的文件，如果不知道路径，可以使用find ./ -name 'wh.sql' 退出容器Ctrl + D 使用docker cp 【CONTAINER ID】:【路径】文件名 【宿主机的绝...
docker 进阶安装
最新发布
09-13
以下是一些关于 Docker 进阶学习的建议： 1. 学习容器编排工具：Docker Compose 和 Kubernetes 是两个常用的容器编排工具。通过学习它们，您可以更好地管理和编排多个容器，构建复杂的应用架构。 2. 持续集成与...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值