容器（container）和镜像（image）

Posted 2023-05-05

参考技术A

镜像（Image）就是一堆只读层（read-only layer）的统一视角，也许这个定义有些难以理解，下面的这张图能够帮助读者理解镜像的定义。

从左边我们看到了多个只读层，它们重叠在一起。除了最下面一层，其它层都会有一个指针指向下一层。这些层是Docker内部的实现细节，并且能够 在主机（译者注：运行Docker的机器）的文件系统上访问到。统一文件系统（union file system）技术能够将不同的层整合成一个文件系统，为这些层提供了一个统一的视角，这样就隐藏了多层的存在，在用户的角度看来，只存在一个文件系统。 我们可以在图片的右边看到这个视角的形式。

你可以在你的主机文件系统上找到有关这些层的文件。需要注意的是，在一个运行中的容器内部，这些层是不可见的。

/var/lib/docker/
├── aufs
├── containers
├── graph
├── init
├── linkgraph.db
├── repositories-aufs
├── tmp
├── trust
└── volumes
7 directories, 2 files

容器（container）的定义和镜像（image）几乎一模一样，也是一堆层的统一视角，唯一区别在于容器的最上面那一层是可读可写的。

容器的定义并没有提及容器是否在运行
要点：容器 = 镜像 + 可读层。并且容器的定义并没有提及是否要运行容器

一个运行态容器（running container）被定义为一个可读写的统一文件系统加上隔离的进程空间和包含其中的进程。下面这张图片展示了一个运行中的容器。

正是文件系统隔离技术使得Docker成为了一个前途无量的技术。一个容器中的进程可能会对文件进行修改、删除、创建，这些改变都将作用于可读写层（read-write layer）。下面这张图展示了这个行为。

即便是这个ubuntu容器不再运行，依旧能够在主机的文件系统上找到这个新文件。

/var/lib/docker/aufs/diff/860a7b...889/happiness.txt

为了将零星的数据整合起来，我们提出了镜像层（image layer）这个概念。下面的这张图描述了一个镜像层，通过图片我们能够发现一个层并不仅仅包含文件系统的改变，它还能包含了其他重要信息。

元数据（metadata）就是关于这个层的额外信息，它不仅能够让Docker获取运行和构建时的信息，还包括父层的层次信息。需要注意，只读层和读写层都包含元数据。

除此之外，每一层都包括了一个指向父层的指针。如果一个层没有这个指针，说明它处于最底层。

Metadata Location:
在我自己的主机上，镜像层（image layer）的元数据被保存在名为”json”的文件中，比如说：
/var/lib/docker/graph/e809f156dc985.../json

e809f156dc985...就是这层的id

一个容器的元数据好像是被分成了很多文件，但或多或少能够在/var/lib/docker/containers/<id>目录下找到，<id>就是一个可读层的id。这个目录下的文件大多是运行时的数据，比如说网络，日志等等。

参考 docker容器和镜像区别

Docker

1、基本概念

Docker：打包应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化

• 镜像（Image）：Docker 镜像（Image），就相当于是一个 root 文件系统。比如官方镜像 ubuntu:16.04 就包含了完整的一套 Ubuntu16.04 最小系统的 root 文件系统
• 容器（Container）：镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的类和实例一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等
• 仓库（Repository）：仓库可看成一个代码控制中心，用来保存镜像

Docker 使用客户端-服务器 (C/S) 架构模式，使用远程API来管理和创建Docker容器，Docker守护进程运行在主机上，然后通过Socket连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器。容器，是一个运行时环境

Docker 容器通过 Docker 镜像来创建

为什么Docker比vm快：docker有着比虚拟机更少的抽象层

 

2、在容器内使用docker run命令在容器内运行一个应用程序

docker run hello-world  //run后面跟的是镜像，先在本地找hello-world镜像，没有就去docker hub里面拉取，run的是容器，容器是由镜像生成

docker run ubuntu:15.10 /bin/echo "Hello world"

-->Docker以ubuntu15.10镜像创建一个新容器，然后在容器里执行bin/echo "Hello world"，然后输出结果


//docker：Docker的二进制执行文件
//run:与前面的docker组合来运行一个容器
//ubuntu:15.10 指定要运行的镜像，Docker首先从本地主机上查找镜像是否存在，如果不存在，Docker就会从镜像仓库Docker Hub下载公共镜像
// /bin/echo "Hello world":在启动的容器里执行的命令

/**
运行交互式的容器：通过docker的两个参数-i -t，让docker运行的容器实现“对话”的能力

-t:在新容器内指定一个伪终端或终端
-i:允许对容器内的标准输入(STDIN)进行交互
*/

docker run -i -t ubuntu:15.10 /bin/bash
-->root@443ede1ec576:/#   此时已进入一个ubuntu15.10系统的容器

cat /proc/version和ls分别查看当前系统的版本信息和当前目录下的文件列表
exit命令或者使用CTRL+D来退出容器

/**
启动容器（后台模式）

*/

//创建一个以进程方式运行的容器
docker run -d ubuntu:15.10 /bin/sh -c "while true; do echo hello world; sleep 1; done"


docker ps

/**
CONTAINER ID: 容器 ID。
IMAGE: 使用的镜像。
COMMAND: 启动容器时运行的命令。
CREATED: 容器的创建时间。
STATUS: 容器状态。

状态有7种：
created、restarting、running、removing、paused、exited、dead

PORTS: 容器的端口信息和使用的连接类型（tcpudp）。
NAMES: 自动分配的容器名称。
*/

docker logs 容器ID  //查看容器内的标准输出
docker stop 容器ID  //停止容器

 

3、Docker容器使用

获取镜像：如果本地没有ubuntu镜像，可以使用docker pull命令来载入ubuntu镜像 

docker pull ubuntu

启动容器：使用ubuntu镜像启动一个容器，参数为以命令行模式进入该容器

//新建并启动容器
docker run -it ubuntu /bin/bash

docker run -it --names Mycentos centos
/**
-i：交互式操作
-t：伪终端
-d：后台运行容器
--names:起一个别名,若不指定则自动分配
ubuntu：ubuntu镜像
/bin/bash：放在镜像名后的是命令，交互式shell-->/bin/bash
*/

//列出当前所有在运行的容器
docker ps
//参数
-a:当前所有正在运行的容器+历史上运行过的
-l：显示最近创建的容器
-n：显示最近n个创建的容器
-q：静默模式，只显示容器编号
--no-trunc：不截断输出

//退出容器
exit：容器停止退出
ctrl+P+Q：容器不停止退出


//启动已停止运行的容器
docker start 容器ID

//重启容器
docker restart 容器ID

//停止容器
docker stop 容器ID
//强制关闭容器
docker kill 容器ID

//删除已经停止的容器
docker rm 容器ID

//一次性删除多个容器
docker rm -f $(docker ps -a -q)
docker ps -a -q | xargs docker rm

//后台运行，启动守护式容器
docker run -d centos
//docker ps查看容器退出
//Docker容器后台运行，就必须有一个前台进程。容器运行的命令如果不是那些一直挂起的命令（比如运行top、tail），就是会自动退出的
//解决方案：将要运行的程序以前台进程的形式运行
docker run -itd --name ubuntu-test ubuntu /bin/bash

//查看容器日志
docker logs -f -t --tail 容器ID
-t：加入时间戳
-f：跟随最新的日志打印
--tail数字：显示最后多少条

//查看容器内运行的进程
docker top 容器ID

//查看容器内部细节
docker inspect 容器ID

//进入正在运行的容器并以命令行交互
docker exec -it 容器ID bashShell
docker attach 容器ID
//attach：直接进入容器启动命令的终端，不会启动新的进程
//exec：在容器中打开新的终端，并且可以启动新的进程
docker exec -t 容器ID ls -l /tmp  //不进入容器，在外面执行命令并返回结果
docker exec -it 容器ID /bin/bash  //进入容器，类似attach

//从容器内拷贝文件到主机上-->持久化容器内容，stop容器后，容器内数据丢失
docker cp 容器ID:容器内路径 目的主机路径

//加了-d参数默认不会进入容器，想要进入容器需要使用指令docker exec
docker stop 容器ID
docker restart 容器ID

//进入容器
docker attach
docker exec：该命令退出容器终端不会导致容器的停止
docker exec -it 容器ID /bin/bash

//导出和导入容器
docker export 容器ID > ubuntu.tar
//导出容器快照到本地文件ubuntu.tar

//导入容器快照
cat docker /ubuntu.tar | docker import - test/ubuntu:v1

//删除容器
docker rm -f 容器ID

//清理掉所有处于终止状态的容器
docker container prune

 

4、docker镜像使用

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

UnionFS：联合文件系统

Docker镜像加载原理

分层的镜像

为什么Docker镜像要采用分层结构呢：共享资源。比如有多个镜像都从相同的base镜像构建而来，那么宿主机只需在磁盘上保存一份base镜像，同时内存中也只需加载一份base镜像，就可以为所有容器服务了。而且镜像的每一层都可以被共享

//列出本地主机上的镜像
docker images
//参数
-a  列出本地所有的镜像（含中间映像层）
-q  只显示镜像ID
--digests  显示摘要信息
----no-trunc  显示完整的镜像信息


//拖取（下载）镜像
docker pull 名字
docker pull tomcat  <==>  docker pull tomcat:latest

//删除镜像
docker rmi 名字
//删除全部
sudo docker rmi -f $(sudo docker images -qa)

//创建镜像
/**
当从docker镜像仓库中下载的镜像不能满足我们的需求时，可以通过以下两种方式对镜像进行更改
1、从已经创建的容器中更新镜像，并且提交这个镜像
2、使用Dockerfile指令来创建一个新的镜像
*/

/**
更新镜像：
更新镜像之前需要使用镜像来创建一个容器，在运行的容器内使用apt-get update命令进行更新
*/

//查找某个镜像
docker search 镜像名字  从docker hub中查找

//参数
-s：  stars数

//commit操作
docker commit //提交容器副本使之成为一个新的镜像
docker commit -m="提交的描述信息" -a="作者" 容器ID 要创建的目标镜像名：[标签名]

docker run -it -p
//-p 主机端口：docker容器端口

 

5、Docker容器数据卷

是什么：把docker容器运行产生的数据保存下来/持久化，因为docker关了数据会丢失

能干什么：容器的持久化；容器间继承+共享数据

数据卷：容器内添加  直接命令添加；DockerFile添加

数据卷容器

//添加数据卷
docker run -it -v /宿主机绝对路径目录：/容器内目录  镜像名

//查看数据卷挂载是否成功
docker inspect

//容器和宿主机之间数据共享

//容器停止退出后，主机修改后数据是否同步-->是  类似redis的全量同步

//命令（带权限）-->写保护
docker run -it -v /宿主机绝对路径目录：/容器内目录:ro 镜像名
//在主机上可以写并同步到容器中，在容器中不可写

//DockerFile添加
Docker images --> DockerFile

//根目录下新建mydocker文件夹并进入

//可在Dockerfile中使用VOLUME指令来给镜像添加一个或多个数据卷


//File构建
vim DockerFile
FROM centos
VOLUME ["/dataVolumeContainer1", "/dataVolumeContainer2"]
CMD echo "finished, ------success1"
CMD /bin/bash


//build后生成镜像
docker build
docker build -f /mydocker/Dockfile -t aaaa/centos .  //获得一个新的镜像 aaaa/centos

//run容器
docker run -it aaaa/centos 

//主机对应默认地址

//数据卷容器：命名的容器挂载数据卷，其它容器通过挂载这个（父容器）实现数据共享，挂载数据卷的容器，称之为数据卷容器



//容器间传递共享（--volumes-from）
//先启动一个父容器
docker run -it --names dc01 aaaa/centos
//继承容器，共享传递数据
docker run -it --name dc02 --volumes-form dc01 aaaa/centos
//dc02/dc03继承自dc01
//回到dc01可以看到02/03各自添加的都能共享了
//删除dc01，dc02修改后dc03可否访问  可以
//删除dc02后dc03可否访问
//新建dc04继承dc03后再删除dc03
//容器之间配置信息的传递，数据卷的生命周期一直持续到没有容器使用它为止

 

6、Docker Dockerfile

是什么：Dockerfile是用来构建Docker镜像的构建文件，是由一系列命令和参数构成的脚本

构建过程解析：每条指令都会创建一个新的镜像层，并对镜像进行提交

 

Docker执行Dockerfile的大致流程：

docker从基础镜像运行一个容器

执行一条指令并对容器作出修改

执行类似docker commit的操作提交一个新的镜像层

docker再基于刚提交的镜像运行一个新容器

执行dockerfile中的下一条指令直到所有指令都执行完成

 

体系结构：

FROM：基础镜像，当前新镜像是基于哪个镜像的

MAINTAINER：镜像维护者的姓名和邮箱地址

RUN：容器构建时需要运行的命令

EXPOSE：当前容器对外暴露出的端口

WORKDIR：指定在创建容器后，终端默认登陆的进来工作目录，一个落脚点

ENV：用来在构建镜像过程中设置环境变量

ADD：将宿主机目录下的文件拷贝进镜像且ADD命令会自动处理URL和解压tar压缩包

COPY：类似ADD，拷贝文件和目录到镜像中，将从构建上下文目录中<源文件>的文件/目录复制到新的一层的镜像内的<目标路径>位置

VOLUME：容器数据卷，用于数据保存和持久化工作

CMD：指定一个容器启动时要运行的命令；Dockerfile中可以有多个CMD指令，但只有最后一个生效，CMD会被docker run之后的参数替换

ENTRYPOINT：指定一个容器启动时要运行的命令；ENTRYPOINT的目的和CMD一样，都是在指定容器启动程序及参数

ONBUILD：当构建一个被继承的Dockerfile时运行命令，父镜像在被子继承后父镜像的onbuild被触发

/**
Dockerfile是一个用来构建镜像的文本文件，文本内容包含了一条条构建镜像所需的指令和说明

使用Dockerfile定制镜像
1、定制一个nginx镜像（构建好的镜像内会有一个/usr/share/nginx/html/index.html文件）
在一个空目录下，新建一个名为Dockerfile文件，并在文件内添加：
FROM nginx
RUN echo ‘这是一个本地构建的nginx镜像’ > /usr/share/nginx/html/index.html

2、FROM：定制的镜像都是基于FROM的镜像，这里的nginx就是定制需要的基础镜像。后续的操作都是基于nginx
RUN：用于执行后面跟着的命令行命令
*/

//手动编写一个dockerfile文件
//直接docker build命令执行，获得一个自定义的镜像

FROM scratch  所有镜像文件的祖先

 

案例

Base镜像（scratch）：Docker Hub中99%的镜像都是通过在base镜像中安装和配置需要的软件构建出来的

自定义镜像mycentos：

//1.编写Dockerfile
vim Dockerfile

FROM centos
MAINTAINER lsd<[e-mail]>

ENV MYPATH /usr/local
WORKDIR $MYPATH

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

EXPOSE 80

CMD echo $MYPATH
CMD echo "success--------------ok"
CMD /bin/bash

//2.build
sudo docker build -f /home/ubuntu/mydocker/Dockerfile -t mycentos:1.1 .

//3.run
docker run -it 新镜像名字：TAG

//4.列出镜像的变更历史
docker history 镜像名

 

CMD/ENTRYPOINT镜像案例

//docker run之后的参数会被当做参数传递给ENTRYPOINT，之后形成新的命令组合

//Case：
//制作CMD版可以查询IP信息的容器
//问题
//WHY
//制作ENTRYPOINT版查询IP信息的容器:把CMD改为ENTRYPOINT即可

 

ONBUILD镜像案例

vim Dockerfile

FROM centos
RUN yum install -y curl
ENTRYPOINT ["curl", "-s", "http://ip.cn"]
ONBUILD RUN echo "father image onbuild-------886"

 

自定义镜像Tomcat9

//1.mkdir -p /aa/mydockerfile/tomcat9

//2.在上述目录下touch c.txt

//3.将jdk和tomcat安装的压缩包拷贝进上一步目录
apache-tomcat-9.0.8.tar.gz
jdk-8u171-linux-x64.tar.gz

//4.在/aa/mydockerfile/tomcat9目录下新建Dockerfile文件
vim Dockerfile

FROM  centos
MAINTAINER. lsd<[e-mail]>
#把宿主机当前上下文的c.txt拷贝到容器/usr/local/路径下
COPY c.txt /usr/local/cincontainer.txt
#把java与tomcat添加到容器中
ADD jdk-8u171-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.8.tar.gz /usr/local/
#安装vim编辑器
RUN yum -y install vim
#设置工作访问时候的WORKDIR路径，登录落脚点
ENV MYPATH /usr/local
WORKDIR $MYPATH
#配置java与tomcat环境变量
ENV JAVA_HOME /usr/local/jdk1.8.0_171
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.8
ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.8
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
#容器运行时监听的端口
EXPOSE 8080
#启动时运行tomcat
#ENTRYPOINT ["/usr/local/apache-tomcat-9.0.8/bin/startup.sh"]
#CMD ["/usr/local/apache-tomcat-9.0.8/bin/catalina.sh", "run"]
CMD /usr/local/apache-tomcat-9.0.8/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.8/bin/logs/catalina.out

//5.构建
docker build -t aaaa .

//6.run
docker run -d -p 9080:8080 --name myt9
-v /zzyyuse/mydockerfile/tomcat9/test:/usr/local/apache-tomcat-9.0.8/webapps/test
-v /zzyyuse/mydockerfile/tomcat9/tomcat9logs/:/usr/local/apache-tomcat-9.0.8/logs
--privileged=true
aaaa
//7.验证

//8.结合容器卷将测试的web服务test发布