menu 我的书签 Docker
文章开始
文章结尾


镜像|容器|仓库

镜像就是集装箱,仓库就是超级码头,容器就是我们运行程序的地方.

docker运行程序的过程就是去仓库把镜像拉到本地,然后用一条命令把镜像运行起来变成容器

容器的实质是进程，运行在一个隔离的环境

镜像 ID 则是镜像的唯一标识，一个镜像可以对应多个标签 Docker 镜像是多层（分层）存储结构，并且可以继承、复用，因此不同镜像可能会因为使用相同的基础镜像，从而拥有共同的层。镜像的多层存储，每一层是在前一层的基础上进行的修改；而容器同样也是多层存储，是在以镜像为基础层，在其基础上加一层作为容器运行时的存储层。

docker system df 命令来查看镜像、容器、数据卷所占用的空间。 docker image ls 命令含了 仓库名、标签、镜像 ID、创建时间 以及所占用的空间。

镜像删除没有任何层依赖当前层时，才会真实的删除当前层。 镜像是容器的基础，每次执行 docker run 的时候都会指定哪个镜像作为容器运行的基础

镜像是一种轻量级的、可执行的独立软件包。用来打包软件运行环境和基于运行环境的开发软件，它包含运行某个软件所需要的内容，包括代码、运行时、库、环境变量和配置文件。

镜像就相当于打包好的版本，镜像启动之后运行在容器中，仓库就是装存储镜像的地方。

Client（客户端）：是Docker的用户端，可以接受用户命令和配置标识，并与Docker daemon通信。

Images（镜像）：是一个只读模板，含创建Docker容器的说明，它与操作系统的安装光盘有点像。

Containers（容器）：镜像的运行实例，镜像与容器的关系类比面向对象中的类和对象。

Registry（仓库）：是一个集中存储与分发镜像的服务。最常用的Registry是官方的Docker Hub 。


镜像一旦被创建就再也不能被修改了

一个运行着的Docker 容器是一个镜像的实例

每个运行着的容器都有一个可写层（ writable layer ，也成为容器层 container layer），它位于底下的若干只读层之上。

一个 Docker 镜像是基于基础镜像的多层叠加，最终构成和容器的 rootfs （根文件系统）。当 Docker 创建一个容器时，它会在基础镜像的容器层之上添加一层新的薄薄的可写容器层。

Docker 镜像原理

Docker镜像是由一层一层的文件系统叠加而成，最底端是 bootfs，并使用宿主机的bootfs ，第二层是 root文件系统rootfs，称为base image，然后再往上可以叠加其他的镜像文件，这种层级的文件系统被称之为UnionFS，统一文件系统（Union File System）技术能够将不同的层整合成一个文件系统，为这些层提供了一个统一的视角，这样就隐藏了多层的存在，在用户的角度看来，只存在一个文件系统一个镜像可以放在另一个镜像的上面。位于下面的镜像称为父镜像，最底部的镜像称为基础镜像，当从一个镜像启动容器时，Docker会在最顶层加载一个读写文件系统作为容器


Docker 镜像本质是一个分层文件系统

Docker 可以通过 Dockerfile 的内容来自动构建镜像。Dockerfile 是一个包含创建镜像所有命令的文本文件，通过docker build命令可以根据 Dockerfile 的内容构建镜像


容器

可以把容器想象成虚拟机,每个虚拟机都有自己的文件系统,与虚拟机系统的区别是文件系统是一层一层的，并且最下面的n层都是只读的，只有上面一层是可写的。程序运行起来，势必会要写一些日志，写一些文件，或者对系统的某一些文件做一些修改，所以容器在最上面一层创建了可读可写的文件系统。

在程序的运行过程中,如果要写镜像文件时,因为镜像的每一层都是只读的,它会把文件的每一层拷到文件的最上层,然后再对它进行修改,修改之后,当我们的应用读一个文件时会从顶层进行查找,如果没有才会找下一层.

由于容器的最上一层是可以修改的,镜像是不能修改的,这样就能保证镜像可以生成多个容器独立运行,没有任何干扰

容器的特点

因此，正确的流程是先构建镜像，然后在容器中运行该镜像。这样可以创建多个容器实例，每个实例都可以独立运行和管理应用程序。

容器存储层的生存周期和容器一样，容器消亡时，容器存储层也随之消亡。因此，任何保存于容器存储层的信息都会随容器删除而丢失。

数据卷的生存周期独立于容器，容器消亡，数据卷不会消亡。因此，使用数据卷后，容器可以随意删除、重新 run，数据却不会丢失。

一个 Docker Registry 中可以包含多个仓库（Repository）；每个仓库可以包含多个标签（Tag）；每个标签对应一个镜像。

由于 Docker 镜像是多层存储结构，并且可以继承、复用，因此不同镜像可能会因为使用相同的基础镜像，从而拥有共同的层。由于 Docker 使用 Union FS，相同的层只需要保存一份即可。

Docker安装：

1、yum -y install docker2、yum -y install docker-engine3、yum -y install docker-ce
docker pull centos  拉取镜像
docker run [可选参数] image 命令 #启动容器（无镜像会先下载镜像）#参数说明--name = "Name"   容器名字-c   后面跟待完成的命令-d   以后台方式运行并且返回ID，启动守护进程式容器-i   使用交互方式运行容器，通常与t同时使用-t   为容器重新分配一个伪输入终端。也即启动交互式容器-p   指定容器端口    -p 容器端口:物理机端口  映射端口-P   随机指定端口-v   给容器挂载存储卷

-i 、 -t 、 -d参数：一般it连用表示给一个可以操作的前台终端；id，以后台守护进程的方式运行容器。

第一种：交互方式创建容器，退出后容器关闭。docker run -it 镜像名称:标签 /bin/bash​第二种：守护进程方式创建容器。docker run -id 镜像名称:标签通过这种方式创建的容器，我们不会直接进入到容器界面，而是在后台运行了容器，如果我们需要进去，则还需要一个命令。docker exec -it  镜像名称:标签  /bin/bash通过这种方式运行的容器，就不会自动退出了。

Docker镜像加载原理

UnionFS（联合文件系统）

UnionFS（联合文件系统）：UnionFS文件系统是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层一层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下。Union文件系统是Docker镜像的基础。镜像可以通过分层来进行继承，基于基础镜像，可以制作各种各样的应用镜像。

特性：一次同时加载多个文件系统，但是从外面开起来，只能看一个文件系统，联合加载会把各层文件系统叠加起来，最终的文件系统会包含所有的底层文件和目录。

Docker镜像加载原理

docker的镜像实际上是由一层一层的文件系统组成，这种层级关系就叫UnionFS。 bootfs（boot file system）主要包括bootloader和kernel，bootloader主要是引导加载kernel，Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是bootfs。这一层与我们典型的Linux/Unix系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核就在内存中了，此时内存的使用权由bootfs转交给内核，此时系统会卸载bootfs。

rootfs（root file system），在bootfs之上。包含的就是典型Linux系统的/dev, /proc, /bin, /etc等等标准文件。rootfs就是各种不同的操作系统发行版本，比如Ubuntu、CentOS等。



镜像分层


所有的docker镜像都起始于一个基础镜像层，当进行修改或者增加新的内容时，就会在当前镜像层之上，创建新的镜像层。假如基于Ubuntu Linux 16.04创建一个新的镜像，这就是新镜像的第一层；如果在该镜像中添加Python包，就会在基础镜像之上创建第二个镜像层；如果继续添加安全补丁，就会创建第三个镜像层。

在添加额外的镜像的同时，镜像始终是当前所有镜像的组合。比如我们在添加第三层安全补丁的时候，Ubuntu和Python视为一个镜像层，在此基础上再添加安全补丁镜像层。 docker镜像都是只读的，当容器启动时，一个新的可写层被加载到镜像的顶部。这一层就是我们所说的容器层，容器之下都叫镜像层。

Docker容器数据卷

docker容器在产生数据的时候，如果不通过docker commit生成新的镜像，使得数据作为镜像的一部分保存下来，那么当容器删除之后，数据自然而然的也会消失。为了能保存数据，容器中引用了数据卷的概念。

卷就是目录或者文件，存在一个或者多个容器之中，由docker挂载到容器，但是不属于联合文件系统，因此能够绕过Union File System提供一些用于持续存储或者共享数据的特性。

卷的设计目的就是数据的持久化，完全独立于容器的生存周期，因此docker不会再容器删除时删除其挂载的数据卷。

1、数据卷可在容器之间共享或者重用数据。  2、卷中的更改可以直接生效。  3、数据卷中的更改不会包含在镜像的更新中。  4、数据卷的生命周期一直持续到没有容器使用它为止。


docker运行镜像流程


docker pull:首先docker pull向docker daemon发送了一条命令pull,告诉docker daemon要拉取某一个镜像,docker daemon会在本机检查镜像是否存在,如果存在且版本就是我们想要拉取的版本,它就不会做任何的操作.如果不存在下一步它会到docker的仓库中找我们要拉取的镜像名字,如果找到了就会有docker仓库传送到我们的本地,把我们要的镜像传送到我们的本地来.

docker run:首先把命令发送到我们的docker daemon,docker daemon会先检查镜像在本机是否存在,如果不存在相当于执行了一个docker pull的过程,下载回来之后会以一定方式把镜像运行起来变成docker容器

wget https://gitee.com/GalaIO/jpress/raw/master/wars/jpress-web-newest.war



常用命令

终端交互

runoob@runoob:~$ docker run -t -i ubuntu:15.10 /bin/bash root@d77ccb2e5cca:/#参数说明：    -i: 交互式操作。    -t: 终端。    ubuntu:15.10: 这是指用 ubuntu 15.10 版本镜像为基础来启动容器。    /bin/bash：放在镜像名后的是命令，这里我们希望有个交互式 Shell，因此用的是 /bin/bash。    $ docker run -it ubuntu /bin/bash参数说明：    -i: 交互式操作。    -t: 终端。    ubuntu: ubuntu 镜像。    /bin/bash：放在镜像名后的是命令，这里我们希望有个交互式 Shell，因此用的是 /bin/bash。要退出终端，直接输入 exit:

后台运行

$ docker run -itd --name ubuntu-test ubuntu /bin/bash注：加了 -d 参数默认不会进入容器，想要进入容器需要使用指令 docker exec

进入容器

在使用 -d 参数时，容器启动后会进入后台。此时想要进入容器，可以通过以下指令进入：    docker attach    docker exec：推荐使用 docker exec 命令，因为此命令会退出容器终端，但不会导致容器的停止。docker exec -it 243c32535da7 /bin/bash

拉取|搜索|删除镜像

docker pull | search | rmi

查看Docker状态

systemctl start docker.servicesystemctl enable docker.service

更新镜像

更新镜像之前，我们需要使用镜像来创建一个容器。

runoob@runoob:~$ docker run -t -i ubuntu:15.10 /bin/bashroot@e218edb10161:/#

在运行的容器内使用 apt-get update 命令进行更新。

在完成操作之后，输入 exit 命令来退出这个容器。

此时 ID 为 e218edb10161 的容器，是按我们的需求更改的容器。我们可以通过命令 docker commit 来提交容器副本。

runoob@runoob:~$ docker commit -m="has update" -a="runoob" e218edb10161 runoob/ubuntu:v2sha256:70bf1840fd7c0d2d8ef0a42a817eb29f854c1af8f7c59fc03ac7bdee9545aff8

各个参数说明：

docker port 命令可以让我们快捷地查看端口的绑定情况

docker network ls 查看网络

以特定格式显示

$ docker images -q5f515359c7f805a60462f8ba$ docker images --format "{{.ID}}: {{.Repository}}"5f515359c7f8: redis05a60462f8ba: nginxfe9198c04d62: mongo$ docker images --format "table {{.ID}}\t{{.Repository}}\t{{.Tag}}"IMAGE ID            REPOSITORY          TAG5f515359c7f8        redis               latest05a60462f8ba        nginx               latest

commit

镜像是容器的基础，每次执行 docker run 的时候都会指定哪个镜像作为容器运行的基础。

镜像是多层存储，每一层是在前一层的基础上进行的修改；而容器同样也是多层存储，是在以镜像为基础层，在其基础上加一层作为容器运行时的存储层。

docker run --name webserver -d -p 80:80 nginx这条命令会用 nginx 镜像启动一个容器，命名为 webserver，并且映射了 80 端口，这样我们可以用浏览器去访问这个 nginx 服务器。$ docker exec -it webserver bashroot@3729b97e8226:/# echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.htmlroot@3729b97e8226:/# exitexit以交互式终端方式进入 webserver 容器，并执行了 bash 命令，也就是获得一个可操作的 Shell。然后，我们用 <h1>Hello, Docker!</h1> 覆盖了 /usr/share/nginx/html/index.html 的内容。修改了容器的文件，也就是改动了容器的存储层。我们可以通过 docker diff 命令看到具体的改动。[root@localhost /]# docker diff websC /etcC /etc/nginxC /etc/nginx/conf.dC /etc/nginx/conf.d/default.conf......

当我们运行一个容器的时候（如果不使用卷的话），我们做的任何文件修改都会被记录于容器存储层里。而 Docker 提供了一个 docker commit 命令，可以将容器的存储层保存下来成为镜像。换句话说，就是在原有镜像的基础上，再叠加上容器的存储层，并构成新的镜像。以后我们运行这个新镜像的时候，就会拥有原有容器最后的文件变化。

docker commit 的语法格式为：

docker commit [选项] <容器ID或容器名> [<仓库名>[:<标签>]]$ docker commit \    --author "Tao Wang <twang2218@gmail.com>" \    --message "修改了默认网页" \    webserver \    nginx:v2sha256:07e33465974800ce65751acc279adc6ed2dc5ed4e0838f8b86f0c87aa1795214

docker history

查看镜像内的历史记录

$ docker history nginx:v2IMAGE               CREATED             CREATED BY                                      SIZE                COMMENT07e334659748        54 seconds ago      nginx -g daemon off;                            95 B                修改了默认网页e43d811ce2f4        4 weeks ago         /bin/sh -c #(nop)  CMD ["nginx" "-g" "daemon    0 B<missing>           4 weeks ago         /bin/sh -c #(nop)  EXPOSE 443/tcp 80/tcp        0 B.......

运行定制好的镜像

docker run --name web2 -d -p 81:80 nginx:v2

使用 docker commit 命令，手动操作给旧的镜像添加了新的一层，形成新的镜像

镜像所使用的分层存储的概念，除当前层外，之前的每一层都是不会发生改变的，换句话说，任何修改的结果仅仅是在当前层进行标记、添加、修改，而不会改动上一层。如果使用 docker commit 制作镜像，以及后期修改的话，每一次修改都会让镜像更加臃肿一次，所删除的上一层的东西并不会丢失，会一直如影随形的跟着这个镜像

使用 docker commit 意味着所有对镜像的操作都是黑箱操作，生成的镜像也被称为黑箱镜像，换句话说，就是除了制作镜像的人知道执行过什么命令、怎么生成的镜像，别人根本无从得知。

注：不要使用 docker commit 定制镜像，定制行为应该使用 Dockerfile 来完成。

删除容器

docker rm $(docker ps -aq)docker ps -aq：这部分命令列出所有容器的 ID，包括运行中的和已停止的容器。-a 选项表示列出所有容器，而 -q 选项表示仅显示容器的ID而不包括其他详细信息。docker rm：这个命令用于删除容器。docker rm 后面跟着一个或多个容器的ID，它将删除这些容器。


定制镜像

FROM nginxRUN echo '这是一个本地构建的nginx镜像' > /usr/share/nginx/html/index.html

FROM：定制的镜像都是基于FROM的镜像，基础镜像

RUN：用户执行后面的命令

&&符号链接命令，只会创建一层镜像

docker的运行模式为C/S

构建步骤

1、编写一个dockerfile文件

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

3、docker run 运行制作好的镜像

4、docker push 发布镜像（Docker Hub、阿里云镜像仓库）

推送到DockerHub

[root@localhost docker-admin]# docker push zhangcurry/ubuntu:18.04The push refers to repository [docker.io/zhangcurry/ubuntu]824bf068fd3d: Mounted from library/ubuntu 18.04: digest: sha256:fc0d6af5ab38dab33aa53643c4c4b312c6cd1f044c1a2229b2743b252b9689fc size: 529

docker commit 镜像提交到本地

docker push 镜像推送到dockerhub（docker login 登录到dockerhub）


Dockerfile

Dockerfile是一个创建镜像所有命令的文本文件，包含了一条条指令和说明, 每条指令构建一层,，通过docker build命令，根据Dockerfile的内容构建镜像，因此每一条指令的内容, 就是描述该层如何构建。有了Dockefile，就可以制定自己的docker镜像规则，只需要在Dockerfile上添加或者修改指令，就可生成docker 镜像。

dockerfile的关键字建议使用大写，它是从上往下按照循序执行的，在dockerfile中，#代表注释。




dockerfile是面向开发的，发布项目做镜像的时候就要编写dockerfile文件。 dockerfile：构建文件，定义了一切的步骤，源代码。 dockerImanges：通过dockerfile构建生成的镜像，最终发布和运行的产品。 docker容器：容器就是镜像运行起来提供服务的。

docker利用了分层的概念实现了镜像存储

docker镜像系统的每一层都是只读的,然后把每一层加载完成之后这些文件都会被看成是同一个目录,相当于只有一个文件系统.docker的这种文件系统被称之为镜像.



Dockerfile 常用指令

FROM			 指明构建的新镜像是来自于哪个基础镜像MAINTAINER  	 指明镜像维护者及其联系方式（姓名+邮箱）RUN				 制作镜像的时候需要运行的命令，RUN后面接linux里的命令，这个命令是在制作镜像的时候使用的WORKDIR			 镜像的工作目录，docker exec 命令执行的时候进入的目录VOLUME			 向镜像创建的容器中添加数据卷，数据卷可以在容器之间共享和重用EXPOSE			 指明容器运行的时候暴露的端口ONBUILD			 当构建一个被继承DockerFile的时候，就会运行ONBUILD指令，触发指令ENV				 设置镜像环境变量ADD       		 ADD和COPY作用相似，可以从一个URL地址下载内容复制到容器的文件系统中，还可以将压缩打包格式的文件解压后复制到指定位置COPY			 COPY指令用来将本地的文件或者文件夹复制到镜像的指定路径下# 文件复制均使用 COPY 指令,在需要自动解压缩的场合使用 ADD 指令CMD				 指定这个容器启动的时候要运行的命令				 Dockerfile只允许使用一次CMD指令，一般都是脚本中最后一条指令ENTRYPOINT		 指定这个容器启动的时候要运行的命令，可以追加命令# 如果docker run后面出现与CMD指定的相同的命令，那么CMD就会被覆盖。而ENTRYPOINT会把容器名后面的所有内容都当成参数传递给其指定的命令

在使用 Docker 构建镜像后，通常的流程是使用 docker run 命令在本地运行该镜像进行测试，然后使用 docker commit 命令将容器的状态保存为一个新的镜像，并最后使用 docker push 命令将构建的镜像推送到远程镜像仓库。

  1. docker build：该命令用于根据 Dockerfile 构建镜像，并在构建过程中执行一系列的操作，例如添加依赖、设置环境变量等。构建过程可以生成一个新的镜像。
  2. docker run：经过构建的镜像可以使用 docker run 命令在本地运行。这将创建一个容器，并在容器中运行该镜像。通过在容器中运行镜像，你可以测试镜像是否按预期工作，并进行调试和验证。
  3. docker commit：如果在测试期间对容器做了一些更改，并希望将这些更改保存为新的镜像，可以使用 docker commit 命令。该命令将容器的状态保存为新的镜像。但请注意，通常推荐使用 Dockerfile 和 docker build 命令来构建镜像，以便将构建过程纳入代码管理和自动化构建流程中。
  4. docker push：最后，如果要共享你的镜像或在其他环境中使用它，可以使用 docker push 命令将镜像推送到远程镜像仓库。远程镜像仓库可以是公共仓库（如 Docker Hub）或私有仓库（如 Docker Registry）。推送镜像之前，你通常需要进行身份验证，以确保对仓库的适当访问权限。

综上所述，一般的流程是：使用 docker build 构建镜像，然后使用 docker run 在本地测试镜像，根据需要使用 docker commit 将容器状态保存为新的镜像，最后使用 docker push 将镜像推送到远程仓库。具体操作根据你的需求和环境的要求可能会有所不同。

在Docker中，你是在容器中运行镜像，而不是在镜像中运行容器。

镜像是一个只读的模板，包含了构建一个完整应用程序所需的所有文件系统、依赖项、环境变量和默认执行命令等。镜像本身是静态的，不能直接运行或交互。

容器则是根据镜像创建的可运行的实例。容器是一个隔离的、可执行的环境，可以独立运行应用程序。当你在 Docker 中使用 docker run 命令时，实际上是基于选定的镜像创建了一个新的容器，并在容器中运行该镜像。


Dockerfile 定制镜像

Dockerfile定制镜像一定是以一个镜像为基础的；FROM指定基础镜像 且必须是第一条指令  scratch这个镜像是虚拟的概念，并不实际存在，它表示一个空白的镜像。不以任何镜像为基础，接下来所写的指令将作为镜像第一层开始存在。

FROM nginxRUN echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.html

镜像是多层存储，每一层的东西并不会在下一层被删除，会一直跟随着镜像。因此镜像构建时，一定要确保每一层只添加真正需要添加的东西，任何无关的东西都应该清理掉。

镜像的定制实际上就是定制每一层所添加的配置、文件。如果我们可以把每一层修改、安装、构建、操作的命令都写入一个脚本，用这个脚本来构建、定制镜像，那么之前提及的无法重复的问题、镜像构建透明性的问题、体积的问题就都会解决。这个脚本就是 Dockerfile。

FROM 指定基础镜像；scratch是虚拟镜像，并不实际存在，它表示一个空白的镜像。

Dockerfile 中每一个指令都会建立一层，RUN 也不例外。

FROM debian:jessieRUN apt-get updateRUN apt-get install -y gcc libc6-dev makeRUN wget -O redis.tar.gz "http://download.redis.io/releases/redis-3.2.5.tar.gz"RUN mkdir -p /usr/src/redisRUN tar -xzf redis.tar.gz -C /usr/src/redis --strip-components=1RUN make -C /usr/src/redisRUN make -C /usr/src/redis install创建了 7 层镜像，这是完全没有意义的！！！=========================================================================================FROM debian:jessieRUN buildDeps='gcc libc6-dev make' \    && apt-get update \    && apt-get install -y $buildDeps \    && wget -O redis.tar.gz "http://download.redis.io/releases/redis-3.2.5.tar.gz" \    && mkdir -p /usr/src/redis \    && tar -xzf redis.tar.gz -C /usr/src/redis --strip-components=1 \    && make -C /usr/src/redis \    && make -C /usr/src/redis install \    && rm -rf /var/lib/apt/lists/* \    && rm redis.tar.gz \    && rm -r /usr/src/redis \    && apt-get purge -y --auto-remove $buildDeps将之前的 7 层，简化为了 1 层。

镜像是多层存储，每一层的东西并不会在下一层被删除，会一直跟随着镜像。因此镜像构建时，一定要确保每一层只添加真正需要添加的东西，任何无关的东西都应该清理掉。


docker build镜像构建

docker build [选项] <上下文路径/URL/->

”.“点 代表上下文的目录

[root@localhost Docker]# docker build -t nginx:v3 .[+] Building 0.5s (6/6) FINISHED                                      docker:default => [internal] load build definition from Dockerfile                            0.0s => => transferring dockerfile: 175B                                            0.0s => [internal] load .dockerignore                                               0.0s => => transferring context: 2B                                                 0.0s => [internal] load metadata for docker.io/library/nginx:latest                 0.0s => [1/2] FROM docker.io/library/nginx                                          0.0s => [2/2] RUN echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.htm  0.3s => exporting to image                                                          0.1s => => exporting layers                                                         0.1s => => writing image sha256:0ae2e9031a917e2b96e453e9769fd139bfc8eb64a9b333806d  0.0s => => naming to docker.io/library/nginx:v3                                     0.0s

一般来说，应该会将 Dockerfile 置于一个空目录下，或者项目根目录下。如果该目录下没有所需文件，那么应该把所需文件复制一份过来。如果目录下有些东西确实不希望构建时传给 Docker 引擎，那么可以用 .gitignore 一样的语法写一个 .dockerignore，该文件是用于剔除不需要作为上下文传递给 Docker 引擎的。

容器的核心为所执行的应用程序，所需要的资源都是应用程序运行所必需的。除此之外，并没有其它的资源。可以在伪终端中利用 ps 或 top 来查看进程信息。

当Docker容器中指定的应用终结时，容器也自动终止。终止状态的容器可以用 docker ps -a 命令看到


虚悬镜像(dangling image)

无标签镜像也被称为 虚悬镜像(dangling image) docker image ls -f dangling=true 命令用来显示这些镜像

$ docker images -f dangling=true	查看REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE<none>              <none>              00285df0df87        5 days ago          342 MB$ docker rmi $(docker images -q -f dangling=true)	删除


删除容器

可以使用 docker rm 来删除一个处于终止状态的容器。 例如

$sudo docker rm  trusting_newtontrusting_newton

如果要删除一个运行中的容器，可以添加 -f 参数。Docker 会发送 SIGKILL 信号给容器。

清理所有处于终止状态的容器

用 docker ps -a 命令可以查看所有已经创建的包括终止状态的容器，如果数量太多要一个个删除可能会很麻烦，用 docker rm $(docker ps -a -q) 可以全部清理掉。

*注意：这个命令其实会试图删除所有的包括还在运行中的容器，不过就像上面提过的 docker rm 默认并不会删除运行中的容器。


数据卷

sudo docker run -d -P --name web -v /webapp training/webapp python app.py

在用 docker run 命令的时候，使用 -v 标记来创建一个数据卷并挂载到容器里。在一次 run 中多次使用可以挂载多个数据卷。也可以在 Dockerfile 中使用 VOLUME 来添加一个或者多个新的卷到由该镜像创建的任意容器。

数据卷是被设计用来持久化数据的，它的生命周期独立于容器，Docker不会在容器被删除后自动删除数据卷，并且也不存在垃圾回收这样的机制来处理没有任何容器引用的数据卷。如果需要在删除容器的同时移除数据卷。可以在删除容器的时候使用 docker rm -v 这个命令。

Docker的数据类型分为两种：

数据卷实际上就是宿主机上的目录或者是文件，可以直接被挂载到容器中使用。数据卷中的数据可以持久保存，对数据卷更改数据会在所有的容器中都生效。



docker-compose

docker-compose 是一个管理多个容器的工具，可以解决容器之间的依赖关系。比如启动一个nginx 前端服务的时候会调用后端的tomcat，那就得先启动tomcat，但是启动tomcat 容器还需要依赖数据库，那就还得先启动数据库，docker-compose 可以用来解决这样的嵌套依赖关系，并且可以替代docker命令对容器进行创建、启动和停止等手工的操作。

docker-compose 将所管理的容器分为三层，分别是工程（project），服务（service）以及容器（container）