一，docker 三要素

1.镜像/容器

  1. Person person = new Person();
  2. Person person2 = new Person();

Docker镜像就是一个只读的模板，镜像可以创建Docker容器，一个镜像可以创建很多容器。

镜像：java类 ||| 容器：java对象

Docker是利用容器运行的一个或者一组应用。容器是使用镜像创建的运行实例。

他可以被启动，开始，停止，删除。每个容器都是相互隔离的，保障安全的平台。

可以把容器看作是一个简易版的linux环境和运行在其中的应用程序。

2.仓库

集中存放镜像文件的场所。

仓库和仓库注册服务器是有区别的。仓库注册服务器上往往存放着多个仓库，每个仓库有很多的镜像。

每个镜像有不同的标签。

仓库分为公开库和私有库。

最大的公开库是docker Hub。

国内公开库包括阿里云，网易云。

3.总结

Docker本身是一个容器运行载体或称为管理引擎。把应用程序和配置依赖打包好形成一个可以交付的运行环境，这个打包好 的运行环境就是一个image镜像文件。只有通过这个镜像文件才能生成Docker容器，image文件可以看做是容器模板，Docker根据image文件生成容器的实例。同一个image文件，可以生成多个同时运行的容器实例。

一个容器运行一种服务，需要的时候，就可以通过docker客户端创建一个对应的运行实例，也就是容器。

至于仓储，也就是存了一堆镜像的地方，可以把镜像发布到仓储中，需要的时候从仓储中拉下来就可以了。

二，docker-hello

1.查看docker 运行状态

  1. ps -ef |grep docker
  2. docker run helloworld

2.docker-helloworld

执行流程

  1. 先在本机寻找该镜像

  2. 如果有，以镜像为模板生产容器实例运行

  3. 如果本机没有，去阿里云上查找该镜像

  4. 如果找到了，下载这个镜像，以这个镜像为模板生产容器实例运行

  5. 如果没找到，返回失败错误，查找不到该镜像

3.docker 运行的底层原理

docker是怎么工作的？

docker 是一个cs架构的系统，docker守护进程运行在主机上，然后通过socket连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器。容器是一个运行时环境，就是logo的集装箱。

docker 为什么比vm快？

1）docker有着比虚拟机更少的抽象层。由于docker不需要硬件资源虚拟化，运行在docker容器上的程序实际上使用的都是实际物理机的硬件资源。因此在cpu，内存利用率上docker将会在效率上有明显优势。

2）docker利用的是宿主机的内核，因此当新建一个容器的时候，docker不需要像虚拟机一样，重新加载一个操作系统内核。docker直接利用宿主机的操作系统，省略了整个过程。

三，docker 帮助命令

  1.     docker info
  2.     docker --help
  3.     docker [option]  COMMAND [args]

四，docker 镜像命令

  1.     docker images 列出本地镜像模板
  2.     option：
  3.         -a：列出本地所有镜像（镜像分层概念）
  4.         -q：只显示镜像ID
  5.         --digests：显示镜像的摘要信息
  6.         --no-trunc：显示完整的镜像信息
  7.     docker search tomcat  |offcial：官方版
  8.     docker search  -s 30 tomcat (点赞数超过30的tomcat)
  9.     docker pull tomcat ==docker pull tomcat:latest
  10.     docker rmi -f centos 强制删除某个镜像
  11.     docker rmi -f centos nginx强制删除多个镜像
  12.     docker rmi -f $(docker images -qa) 删除所有镜像

五，docker容器命令

  1.     新建并启动容器 docker run [options] images [command]
  2.         -i:交互启动
  3.         -t:重新分配一个伪输入终端
  4.         -d:后台运行
  5.         --name：制定一个名字
  6.         docker run -it 831691599b88 执行完直接进入了容器，不信pwd
  7.     列出当前所有正在运行的容器
  8.             docker ps
  9.             -a：所有
  10.             -q：只显示容器编号
  11.     退出容器
  12.             exit 退出并关闭
  13.             ctrl+P+Q 容器不停止退出
  14.     启动容器
  15.         docker start 容器名
  16.     重启容器
  17.         docker restart 容器id
  18.     停止容器
  19.         docker stop
  20.     强制停止容器
  21.         docker kill
  22.     删除已经停止的容器
  23.         docker rm 容器id
  24.     启动守护式容器
  25.         docker run -d centos
  26.     查看容器日志
  27.         docker logs -f -t --tail 3 容器id
  28.         -t  假如时间戳
  29.         -f  跟随最新的日志打印
  30.         -tail   显示最后多少条
  31.     查看容器内运行的进程
  32.         docker top 30f00b23e1c5
  33.     查看容器内部细节
  34.         docker inspect 容器ID
  35.     进入正在运行的容器并以命令行交互
  36.         docker attach ID
  37.         docker exec -t ID 命令（不进入容器内部直接执行命令,相当于启动新的进程）
  38.     从容器内拷贝文件到主机上
  39.         docker cp 容器ID：容器内路径 目的主机路径
  40.         docker cp xxxxx:/tmp/yum.log /root

六，docker镜像原理

1.docker 的本质

union 联合文件系统：一种分层，轻量级并且高性能的文件系统，他支持对文件系统的修改作为一次提交 来一层层叠加，union文件系统是docker镜像的基础，镜像可以通过分层来继承，基于基础镜像，可以制作各种具体的应用镜像。

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

2.docker 镜像加载原理

  1. docker镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。

  2. bootfs（boot file system）主要包含bootloader和kerner，bootloader加载引导kerner，linux刚启动会加载bootfs，在docker镜像最底层就是bootfs。这一层与我们典型的Linux系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权由bootfs交给内核，系统卸载bootfs。

  3. rootfs在bootfs之上，rootfs就是linux各种不同操作系统的发行版。

  4. 对于一个精简的OS，rootfs很小，只需要包含最基本的命令，工具和程序库，底层直接用了宿主机的。

3.为什么这么设置docker

最大的一个好处就是资源共享。

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

七，docker镜像commit

  1.     docker commit 提交容器副本让他成为一个新的镜像。
  2.     docker commit - m="提交的信息" -a="作者" 容器ID 要创建的目标镜像名:[标签名]
  3.     docker run -it -p 8888:8080 tomcat (主机端口:容器端口)
  4.     docker run -d -p 8888:8080 tomcat 后台运行

本地镜像推送到阿里云

  1. 登录阿里云docker管理控制台：https://cr.console.aliyun.com/ 
  3. 创建命名空间（其实就是仓库）
  5. 1. 登录阿里云Docker Registry
  7. $ docker login --username=尹会东yhd registry.cn-hangzhou.aliyuncs.com
  9. 用于登录的用户名为阿里云账号全名，密码为开通服务时设置的密码。
  11. 2. 从Registry中拉取镜像
  13. $ docker pull registry.cn-hangzhou.aliyuncs.com/ershi-dev-tools-repository/ershi_rabbitmq:1.0
  15. 3. 将镜像推送到Registry
  16. # 登陆阿里云账户
  17. docker login --username=尹会东yhd registry.cn-hangzhou.aliyuncs.com
  18. # 将某个指定的镜像ID重命名为 阿里云网址/命名空间名/镜像的本地仓库名:tag
  19. docker tag ee70f97dd7fc registry.cn-hangzhou.aliyuncs.com/ershi-dev-tools-repository/ershi_rabbitmq:1.0
  20. # 推送 阿里云网址/命名空间名/镜像的本地仓库名:tag 到阿里云
  21. docker push registry.cn-hangzhou.aliyuncs.com/ershi-dev-tools-repository/ershi_rabbitmq:1.0

八，数据卷介绍

1.docker理念

将代码与运行环境打包形成容器运行，运行可以伴随着容器，但是我们对数据的要求是希望持久化

容器之间共享数据

docker容器产生的数据，如果不通过docker commit 生成新的镜像，使得数据作为镜像的一部分保存下来，那么当容器删除后，数据自然也就没有了，为了能保存数据，docker使用卷。

2.数据卷是什么

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

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

3.特点

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

4.容器数据卷用V命令添加

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

主机和容器在卷目录下数据共享

容器停止退出后，主机修改后，数据仍然同步

可以设置权限使容器只能读，不能修改或者新建

5.容器数据卷用dockerFile添加

1）是什么

JavaEE Hello.java ——>Hello.class

Docker images ——>DockerFile

镜像模板的描述文件

2）怎么做

  1. 根目录下新建mydocker文件夹并进入
  1. mkdir mydocker
  2. cd /mydocker
  1. 创建文件dockerFile
  1. vim Dockerfile
  2. ---------------------
  3. FROM centos
  4. VOLUME ["/dataVolumeContainer1","/dataVolumeContainer1"]
  5. CMD echo "fineshed,success!"
  6. CMD /bin/bash
  7. ----------------------

说明：出于可移植性和分享的考虑，用-v主机目录：容器目录这种方法不能够直接在Dokcerfile中实现。由于宿主机目录是依赖于特定宿主机的，并不能够保证在所有的宿主机上都存在这样的特定目录。

  1. build 生成镜像文件
  1. docker build -f /mydocker/Dockerfile -t zzyy/centos
  1. 启动容器
  1. docker run zzyy/centos
  1. 主机对应目录地址
  1. docker inspect 容器ID既可以查看

3）容器数据卷

命名的容器挂载数据卷，其他容器通过挂载这个容器实现数据共享，挂载数据卷的容器，称之为数据卷容器。