Docker原理及使用

　　

虚拟化系统：
　　1. Type-I： 此种虚拟化是Hypervisor直接运行在硬件之上,来创建虚拟机.
　　2. Type-II: 这种虚拟化类似与VMware Workstations。

　　

　　IPC: 在相同的名称空间中的进程才能通过IPC实现进程间通信。
　　PID: 在每个名称空间中必须有一个进程ID为1的进程，它是所有进程的父进程，即init进程,所以要实现用户空间隔离，就需要让每个用户空间中进程，以为自己是运行在init进程下的.
　　user: 要让每个用户空间中的进程以为自己是运行在独立的主机中，那就必须实现每个用户空间中都一个UID为0的用户, 但该用户在真实系统中,却是一个普通用户。

容器虚拟化:
　资源限制:
　　通常有两种,一种是弹性百分比限制能使用全部资源的百分比.另一种是决对资源限制.

　实现资源限制的是Cgroups(Control Groups):
　　1. blkio: 块设备IO
　　2. cpu: CPU
　　3. cpuacct: CPU资源使用报告
　　4. cpuset: 多处理器平台上的CPU集合
　　5. devices： 设备访问
　　6. freezer: 挂起 或 恢复任务
　　7. memory: 内存用量及报告
　　8. perf_event： 对cgroup中的任务进行统一性能测试
　　9. net_cls： cgroup中的任务创建的数据报文的类别标识符.

Docker、LXC、CNCF：
　　Docker是一家商业公司开发的容器技术，早期是容器内核是基于LXC(LinuX Container)，来实现容器的创建和管理的。
　　LXC: 早期有一种技术叫 jail(监狱，或叫沙盒)，这种技术可让一个应用程序运行在一个沙箱中,该应用程序无论做出任何对系统的破坏都不会影响到真实的系统，仅仅只是沙箱中的虚拟环境。后来这种技术在Linux也引入了，叫vserver,即现在我们比较熟悉的chroot功能。但是在Linux系统中早期内核支持名称空间,是需要通过自己编写代码,调用系统调用来创建出UTS，Network，IPC，等不同的名称空间，结合chroot实现在一个操作系统上创建出一个用户空间，但这对普通用户来说，是很困难的，而LXC则提供了一组工具,将这些功能整合成工具，用户若需要创建容器，只需要使用lxc-create等命令行工具，就可以很轻松的创建容器，但是LXC在创建容器时，它需要借助于template(模板)，当允许lxc-create来创建一个容器时，你可以在CentOS的系统上,创建一个Ubuntu的容器，或FreeBSD的容器等，都可以只有你提供相应的template和这些系统的软件包安装源即可； 但LXC这种方式带来的问题是使用上依然非常困难，应用模板的创建并不容易，而且又产生了很多冗余数据；如:我想创建两个Ubuntu的容器，我就需要安装两份相同的数据； 而且若我需要将一个容器
迁移到另一台主机上，怎么做？LXC没有提供相应的工具。所以它并不适合大规模使用。Docker：它早期创建容器的内核是LXC，但它使用了比LXC更高效，更精巧的方式来创建容器，它不在使用模板来安装容器，而是将容器制作成镜像，当需要使用容器时，直接从镜像仓库中下载之前制作好的镜像到本地，直接启动容器即可。并且它的镜像采用一种叫做叠加镜像的方式解决数据冗余的问题，实际上它采用一种叫三层叠加镜像的方式来实现数据的高效利用 和 容器私有数据的保存。借助于共享存储来将容器的私有数据保存在宿主机的外部，当宿主机宕机时，只要在新的宿主机上下载镜像，启动容器，挂载数据即可恢复服务。具体如下图:
　　注:
　　 Docker为了管理容器方便，它定义一个容器中只能运行一个进程, 但实际上容器跟虚拟机类似，它是可运行多个进程的，只是为了管理方便，限制容器中只能运行一个进程。

　　　　

容器这种技术带来好处:
　　对于开发人员来说，是天大的好处，因为Docker的出现真正解决代码一次编写到处运行，无论底层是什么系统，只要能运行docker,将镜像做好后，直接编排好，然后在宿主机上启动容器即可。对于运维人员来说，带来的问题是，系统构架更加复杂，原本的调试进程的方式，在容器时代变的异常困难，因为容器中很可能没有各种调试工具等。

容器部署上的问题:
　　如NMP环境的构建上, 通常我们需要先部署MySQL容器，接着是PHP容器，最后是Nginx容器，这样的顺序部署才能让环境都正常工作，否则可能出现Nginx代理PHP服务器，结果找不到PHP服务器,因为容器启动后，它的IP地址会改变，那通过DHCP根据MAC不是可以固定分配IP吗？但其实是不可以的，因为容器是没有固定MAC的，它的网卡是虚拟的，是通过Linux上的"虚拟网线”创建的两个虚拟网卡，一端接入容器，一端接入Docker0(默认桥)桥上，这样就实现了容器能接入网络中，因此每次启动容器时，是无法知道这一次创建的虚拟网卡的MAC地址是多少的，因此必须使用其它方法来获取启动完成后的容器的IP地址，这也就是为啥容器需要编排,对于LNMP环境，Nginx要依赖PHP，因为它要代理PHP，而PHP又依赖MySQL，因为PHP应用程序要从MySQL中获取数据，因此必须先启动MySQL容器，这样才能获取MySQL容器当前使用的IP，接着启动PHP容器，将MySQL容器的IP传入到PHP容器中，这样PHP容器就可以知道MySQL的IP，而Nginx也是一样，这样编排后，LNMP环境中每个容器就都能获取它所依赖的容器的IP，就可以正常通信了。

为了解决部署容器的顺序问题，容器技术，必须结合编排工具一起使用，才能实现大规模应用。
目前比较知名的编排工具:
　　Docker： machine+swarm+compose，这三个工具配合使用来实现编排。
　　第三方提供的编排工具: mesos+marathon
　　Google: kubernetes-->简称k8s

libcontainer:
　　又称为RunC，它是Docker官方提供的新Docker构建容器的核心程序，由于LXC在功能上，没有与时俱进，因此Docker官方，最终决定自己开发一个新的容器构建核心，它就是runC。

Docker，Moby，CNCF的历史故事:
　　Docker我们知道它是一家商业公司，早期Docker刚出现时，以下轰动世界，为了让Docker技术，能够有更大的发展，Docker将自己的产品分成商业版和社区开源版，但是Docker的商业版在商业领域上始终没能活动 大佬们的信赖，没能得到太多融资，但是社区开源版确始终火热的不行，Docker为了能获得更多商业利益，它最终决定将社区版的Docker更名为Moby，希望能吸引更多关注的目光到它的商业版上，但事与愿违。 而此时Google发现自己秘密使用了十几年的容器技术竟然被Docker给开源了，而且还发展的如此红火，尽人皆知，但Google不希望自己在容器技术上的话语权落到Docker手中，它决定扶持一家小容器公司，但这家公司的产品在Google大力扶植下，依然是名落孙山，不是Docker的对手，最后，Google发现Docker在编排工具的开发上，好无建树,而自己拥有十几年的容器使用经验(Google内部的容器叫Borg(博格))，因此就组织了工程师开发了Kubernetes,又鉴于Docker一家公司为了商业目的，随意更改Docker社区版,改变Docker的性质，因此Google将Kubernetes捐给了CNCF，而CNCF是容器标准化基金会组织，它是Google联合多家
知名公司,如:IBM,微软,Facebook等联合成立的组织。向世人表态为不会左右Kubernetes的发展进程,加上Kubernetes从其诞生就是站在Bong的肩膀上成立的，所以它一经发布就成为世人聚焦的目标，短短3年,就已经从0.1发展到1.1版本，以每年4个版本迭代，2018年为止，其市场占有率达到80%以上.

OCI(Open Container Initiative):
　　它由Linux基金会主导于2015年6月创立，皆在围绕容器格式和运行时制定了一个开放的工业标准.
　　它制定了两个规范标准:
　　　　1. 运行时标准(The Runtime Specifications (runtime-spec))
　　　　2. 镜像格式标准(The Image Specification (image-spec))

OCF(Open Container Format):
　　OCF开放容器格式就是OCI的倡导下产生的标准。

Docker的基本架构：

　　

注:
　Docker的镜像:
　　　Registry:在Docker中称为镜像仓库，Docker的镜像仓库有点类似与yum源仓库，但它的组织方式是这样的:
　　　　官方提供的Docker镜像仓库地址: hup.docker.org,当然国内也有很多docker镜像站.
　　　　Docker镜像仓库的组织格式为:
　　　　　　应用程序名:版本号
　　　　　　其中: 应用程序名为仓库名.
　　　　　　版本号: 为仓库中镜像名.也是它的tag标签号.
　　　　以Nginx为例:
　　　　　　Nginx：为仓库名.
　　　　　　nginx:1.15 这就是一个镜像名.同时一个镜像可能有多个名字,
　　　　　　　　比如: 1.15是Nginx的最新发行版,则还会给它提供一个名字叫: nginx:lasted 即最新版，
　　　　　　　　这个名字会随着Nginx发布的最新版而改变。
　　　　　　nginx:1.14 另外我们知道,Nginx的发行版中,次号码为偶数表示，此版本为稳定版,
　　　　　　　　为奇数则为开发版，所以这种版本通常也会有一个名字: nginx:stated 即稳定版的nginx镜像.

　　docker的下载站有很多:
　　　　若使用清华大学的repo仓库，下载其repo文件后，还需要修改其repo镜像的站点为清华大学的镜像站.
　　　　　　yum install docker-ce

　　　　安装完docker后，要下载其docker镜像，可使用国内的镜像加速器来下载:使用方式:
　　　　mkdir /etc/docker
　　　　vim /etc/docker/daemon.json
　　　　　　{  "registry-mirrors": ["https://registry.docker-cn.com"]  }

　　查看docker版本信息:
　　　　docker version
　　　　docker info

　　docker的常用操作:
　　　　docker search ：搜索docker镜像仓库中指定的镜像名.
　　　　docker pull : 下载指定镜像到本地.
　　　　docker images : 列出本地已有的镜像

　　下载docker镜像:
　　　　docker image pull nginx:1.14-alpine
　　　　注: alpine:这是一个小发行版的nginx,大小很小. 它仅集成了nginx运行所必须的环境,其它什么都没有,若你需要一些调试工具，它就不太适合了。
　　　　　　另外，一般官方发行的镜像，一般都很少会带调试工具。
　　　　　　另注: 我们搜索docker镜像时，会看到类似 tom/nginx 这类的镜像，它们是表示 tom这个人,在docker官方注册了账号，上传了自己制作的nginx镜像.

　　　　docker pull busybox

　　　　docker imgle ls --help 　　 #查看ls子命令的帮助.
　　　　docker imgle --help

　　创建容器:
　　　　docker container create 　　 #仅创建容器，但不运行.
　　　　docker container run 　　　 #创建容器，并运行。
　　　　docker container start 　　       #启动一个或多个已经创建好的容器。
　　　　docker container stop |kill 　　 #都可以停在一个或多个容器.
　　　　docker container top 　　　　 #查看那些容器最消耗资源.

　　docker container run [options] Image [Command] [参数...]
　　　options:
　　　　-t :启动镜像时,给其添加一个终端访问接口,以便能够启动后,连接登录.
　　　　-i :启动为交互模式.
　　　　--rm :停止后，直接删除该容器.
　　　　-d : 运行到后台.
　　　　--name <ImangeName> :为启动的容器名一个名字.
　　　　--network <NetName> :将容器加入一个指定的网络中.

　　docker network ls 　　 #可列出当前本机有多少网络可用.
　　ifconfig 　　 可查看到,当docker安装完成后,它会自动创建一个docker0的桥，这个桥是NAT桥.
　　　　　　　它是直接桥接在物理网卡上的，可直接和物理网络通信。

　　示例:
　　　docker pull busybox　　　　#下载一个busybox的镜像.
　　　docker container run -it --name b1 busybox:latest 　　 #这样就启动了一个叫b1的容器.
　　　　/ #ps 　　　　 #这样就启动了busybox，当前显示的是它的sh终端.
　　　　/ #mkdir /data/httpd
　　　　/ #vim /data/httpd/index.html
　　　　/ #httpd -f -h /data/httpd 　　　　 #在busybox中启动一个httpd进程，并指明其web根目录.
　　　　/ #exit 　　　　　　　　　　　　 #执行exit就退出了sh终端，也就终止了容器.

　　终端2:
　　　　docker ps
　　　　docker inspect b1　　  #可查看b1这个容器的详细信息.
　　　　curl http://1.1.1.1/ 　　 #这样就可以访问容器中的httpd服务了。

　　　　docker ps -a 　　 #可查看停止的容器.

　　示例2:
　　　　终端1:
　　　　　　docker start -a -i b1 #重新启动停止的容器b1

　　　　终端2:
　　　　　　docker ps
　　　　　　docker kill b1 　　 #可强制关闭b1容器. 正常情况下应该使用stop,可保障数据不丢失.
　　　　　　docker rm b1 　　 #删除停止的容器b1

　　示例3:
　　　　docker run --name nginx1 -d nginx:1.14-alpine #若本机能访问互联网,这里可直接运行,docker会自动下载镜像.
　　　　注:
　　　　    在容器中运行应用程序，它必须工作在前台，否则容器已启动就会关闭，因为在容器中只有一个进程，该进程是支撑容器的骨架
　　　　docker ps

　　　　docker run --name redis1 -d redis:4-alpine 　　 #启动一个redis容器,它将自动下载该镜像.并启动.

　　示例4：
　　　　docker exec -it redis1 /bin/sh 　　 #在指定容器redis1上运行一个命令,/bin/sh,并使用交互式登录.
　　　　/data # ps 　　　　　　　　　　  #这样就可以登录到redis1这个容器上了.

　　　　docker logs nginx1 　　 #查看容器nginx1的日志信息.

docker 所有状态转化示意

　　

  Docker的镜像:

　　

　　  Docker镜像包含了启动容器所需的文件系统及其内容,因此它用于创建并启动docker容器.
　　docker镜像采用分层构建的机制,最底层为bootfs，其上为rootfs.
　　bootfs: 用于系统引导文件系统,包括bootloader和kernel,容器启动完成后,bootfs会被卸载，以节省内存空间.
　　rootfs: 它在运行中的docker容器中变现为根文件系统.
　　如: docker exec -it nginx1 /bin/sh 　　#登录后, ls / 可以看到全部的根文件系统目录.
　　传统OS:
　　　　系统启动时,内核挂载rootfs时,为确保不会误删除文件,通常会先以只读模式挂载,完整性自检完成后,再重新以读写模式挂载rootfs.
　　　　docker: 它在启动内核,挂载rootfs时，始终是以只读模式挂载, 而后在通过联合挂载技术额外挂载一个可写层.实现读写操作。

Docker Image Layer

　　

　　

此镜像显示了Docker的镜像层级,从上到下分别为:
　　可写层
　　add Apache 和 add emacs(类似于vim的编辑器): 这两层为自己通过yum安装在镜像中的工具.
　　Debian: 这是为安装的工具提供的基本的最小安装的根文件系统已共Apache能运行起来.这里使用的是Debian.还可以使用CentOS等.
　　bootfs: 这一层则是启动Debian这个rootfs所需的bootloader和kernel，通常在将Debian启动起来后，它将自动被卸载.

Docker实现叠加挂载镜像的文件系统:
　　overlayfs： 从kernel3.18以后被整合到Linux内核中了. 它叫 叠加文件系统, 再早期Docker实现叠加挂载是使用Aufs(Advanced multi-layered unification filesystem:高级多层统一文件系统), 而此文件系统是2006年开发,但因代码质量问题，一直未被整合到kernel中; 据说它的代码有3万行，而ext4这种文件系统总代码量4千多行。所以早期要使用docker有两种方式 一种手动给内核打aufs的补丁，另一种就是使用Ubuntu系统，因为它比较早的将Aufs整合到它的kernel中了。不过现在目前 CentOS系统已经能支持overlayfs的第2版了，所以可以直接使用docker即可.
　　docker info
　　　　 #输出中Storage Driver: overlay2 ,overlay2是一种虚拟抽象层的文件系统，它是建构在Backing Filesystem： xfs ，即后端文件系统xfs之上的文件系统。

　　docker pull quay.io/coreos/flannel:v0.10.0-amd64
　　　　 #下载quay.io 这个网站的coreos名称空间下的flannel仓库中的tag为v0.10.0-amd64 的镜像。默认docker使用https去下载. quay.io是docker镜像很有名的第三方提供者.

　示例1:
　　#基于busybox创建一个测试镜像:
　　　　docker run --name bx1 -it busybox
　　　　/ #mkdir -p /data/html
　　　　/ #vi /data/html/index.html
　　　　　　<h1>Hello busybox HTTP Server</h1>

　　终端2:
　　　　docker commit -p bx1 　　 #-p是让bx1容器先暂停，避免有人访问镜像，导致镜像创建不完成.
　　　　docker image ls 　　　　  #可看到刚创建的镜像.
　　　　docker tag <IMAGE ID> tom/bbox:v0.1 　　     #这样就给指定的镜像打上了tom/bbox的标签，并且tag为v0.1s
　　　　docker tag tom/bbox:v0.1 tom/bbox:latest 　　 #在tom/bbox:v0.1上再给其创建一个标签名.
　　　　docker image rm tom/bbox:latest 　　 #删除一个标签名, 它只是删除标签,就像删除硬链接,文件是不会被删除的。

　示例2:
　　docker inspect nginx:v1.14 　　 #查看其CMD，可以看到的其被docker启动后，容器中将启动的第一个进程为nginx
　　docker inspect tom/bbox:latest

　示例3:
　　#基于busybox制作一个启动后运行busybox中的httpd的镜像.

　　终端1:
　　　　docker run --name bx1 -it tom/bbox:latest　　　　#注:这是基于示例1中的内容创建的.

　　终端2:
　　　　docker commit -a "tom <tom@test.com>" -c ‘CMD ["/bin/httpd","-f","-h","/data/html"]’ -p bx1 tom/bbox:v0.2
　　　　注:
　　　　　　CMD: 这是仅修改启动容器后,执行什么命令, 注意CMD必须大写！！ 其次参数的顺序不能乱.
　　　　　　-p : 制作时让容器处于暂停状态.
　　　　　　      制作完成后，直接给它加一个标签名为tom/bbox:v0.2
　　　　docker image ls　　#查看制作好的镜像
　　　　

　　　　docker  run  --name bx2  -d  tom/bbox:v02
　　终端3:
　　　　docker inspect bx2　　#查看bx2的定义，主要看CMD定义
　　　　curl http://1.1.1.3/ 　　 #这样就可以直接访问busybox启动的微型httpd了。

　　示例4：
　　#上传镜像到docker hup中的仓库中.
　　　　1. 要创建docker hup的登录账户，并登录到后台，创建一个仓库.
　　　　   如: 上面创建的镜像名为: tom/bbox:v0.1
　　　　  　　那创建的仓库就叫 tom/bbox
　　　　2. 上传镜像前，要先登录
　　　　　　docker login -u tom #然后要求输入密码，Login Succeeded表示登录成功.
　　　　3. 开始上传镜像:
　　　　　　docker push tom/bbox #不加tag则表示将本地所有镜像都推送上去。

　　示例5:
　　　　#导出已有镜像，并在其它主机上导入镜像:
　　　　docker image ls
　　　　docker save -o myimages.gz tom/bbox:v0.1 tom/bbox:v0.2 　　 #这样即可将两个镜像打包成myimages.gz。

　　　　#登录到另一台docker上就可以执行:
　　　　docker load -i myimages.gz #就可以导入镜像了
　　　　docker image ls

　　示例6：
　　　　docker exec -it --name bx1
　　　　/ #wget -O - -q http://1.1.1.2/ 　　# 假如Nginx容器启动后的地址为1.1.1.2,则通过wget测试访问.
　　　　　　     -O :加载完成页面后,不保存，直接输出当标准输出."-"

Docker的四种网络模型:
　　第一种是Closed Container(封闭式容器)： 它主要是用来处理一些Docker计算任务的，完成后就自动退出了，因此它无需网络协议栈.
　　第二种是Bridge Container(桥接式容器)： 它是通过创建一根虚拟网线，一头接入容器中，也就是Container Virtual interface,另一头接在Docker bridge Virtual Interface上.
　　第三种是Joined Container(联合容器)： 它是让A和B两个容器都共享一组Net,UTS,IPC名称空间，这样的好处是A和B可以直接通过lo接口通信，并且还可以桥接到Docker桥上，共享网络接口。
　　第四种是Open Container(开放容器)： 它是第三种的扩展，它直接与物理机共享了Net，UTS，IPC名称空间，因此物理机上的网络接口它都可以看到，并且可以直接管理。

　　　　

　　示例1:
　　　　#inspect 查看docker组件的详细信息.
　　　　docker network ls
　　　　docker network inspect bridge #查看bridge网络的详细信息。

　　示例2：
　　　　#创建网络模型3
　　　　终端1:
　　　　　　docker run --name bx1 -it --rm busybox
　　　　　　/ # wget -O - -q http://127.0.0.0.1/

　　　　终端2:
　　　　　　docker run --name bx2 -it --network container:bx1 --rm busybox
　　　　　　/ #echo "hello world." > /tmp/index.html
　　　　　　/ #httpd -f -h /tmp

　　示例2:
　　　　vim /etc/docker/daemon.json     #以下仅供参考,新版本有些参数以不支持!!
　　　　{
　　　　　　"bip": "1.1.1.1/24", #设置docker0的IP
　　　　　　“fixed-cidr”:"10.20.0.0/16",
　　　　　　"fixed-cidr-v6":"2001:db8::/64",
　　　　　　"mtu":"1500",
　　　　　　"default-gateway":"10.20.1.1",
　　　　　　"default-gateway-v6":"2001:db8:dbcd::89",
　　　　　　"dns":["10.20.1.2","8.8.8.8"],
　　　　　　"hosts":["tcp://0.0.0.0:2375","unix:///var/run/docker.sock"] #启动docker监听在2375端口上.
　　　　}

　　　　systemctl restart docker  　　　　#新版本建议直接修改启动脚本,已参数形式传入

　　在主机2:
　　　　docker -H 1.1.1.1:2375 image ls #这样就可以查看1.1.1.1这台主机上docker的是否有镜像了。

　　示例3：
　　　　#创建docker网络
　　　　docker network create -d bridge --subnet "1.1.1.0/16" --gateway "1.1.1.1" mybr0
　　　　docker run -it --name bx1 --net mybr0 busybox:v0.1

　　示例4:
　　　　#启动容器时传递参数:
　　　　docker run --name t1 -it --network bridge -h t1.test.com --rm busybox:latest

　　　　docker run --name t1 -it --network bridge -h t1.test.com --dns 114.114.114.114 --rm busybox:latest
　　　　docker run --name t1 -it --network bridge -h t1.test.com --dns 114.114.114.114 --add-host www.test.com:1.1.1.1 --rm busybox:latest

　　示例5:
　　　　docker run --name myweb --rm -p 80 tom/bbox:v0.2 #创建一个地址映射,允许外部访问此容器.
　　　　　　#注: -p 80 ,实际是创建了一条 iptables DNAT规则.
　　　　docker port myweb #查看docker创建的端口映射

　　　　docker run --name myweb --rm -p 1.1.1.1::80 tom/bbox:v0.2
　　　　docker run --name myweb --rm -p 80:80 tom/bbox:v0.2
　　　　docker run --name myweb --rm -p 1.1.1.1:80:80 tom/bbox:v0.2

Docker的数据卷(Data Volume):
　　为避免关闭再重启容器,其数据不受影响，但删除Docker容器,则其更改将会全部丢失.
　　存在的问题:
　　　　1. 存储于联合文件系统中的数据,宿主机不易访问.
　　　　2. 容器间数据共享不方便.
　　　　3. 删除容器其数据会丢失.
　　解决方案:"卷(Volume)":
　　　　卷是容器上的一个或多个目录(即:多个卷)，此类目录可绕过联合文件系统,与宿主机上的某目录绑定(即关联)

Docker有两种类型的卷:
　　1. Bind mount volume(绑定挂载卷)：这是有用户自定义指定docker中的某目录挂载到宿主机的某个指定目录.
　　2. Docker-managed volume(docker管理的卷): 这是由docker自己维护,用户需要在/etc/docker/daemon.json中指定启用docker自动启动容器时，关联宿主机上由docker默认自动创建一个目录，并与容器中指定目录关联的方式。

　　示例:
　　　　#由docker管理的卷:
　　　　docker run --rm --name b2 -it -v /data busybox:latest

　　　　终端2:
　　　　docker inspect b2　　 #可查看其“Mounts”段,其中有说明容器中/data 目录与宿主机上的那个目录建立的关联.
　　　　　　　　　　　　　　接着可测试在宿主机上目录中创建文件，在容器中编辑，是否可行。

　　示例2:
　　　　docker run --name b2 --rm -it -v /data/volumes/b2:/data busybox:latest

　　　　终端2:
　　　　echo “Hello Container busybox.” >> /data/volumes/b2/index.html
　　　　　　#接着在容器中查看.
　　　　　　# 再尝试删除容器，再关联相同目录，查看数据是否依然可访问。

　　　　docker inspect -f {{.Mounts}} b2 　　 #简单过滤.
　　　　　#注:
　　　　　　JSON中使用"[]": 表示这是一个列表， {}: 表示这是一个关联数组(也叫Hash映射)，它可嵌套.
　　　　　　在关联数组中的格式:
　　　　　　{
　　　　　　　　"Key":"Value", 　　 #每个键 值对要使用 逗号分隔.
　　　　　　　　"Key":"Value",
　　　　　　　　"key0": {
　　　　　　　　　　"key1":"Value1", 　　 #key1的上层是“key0”， 而key0上层是 根(通常用"."表示.)
　　　　　　　　　　..
　　　　　　　　},
　　　　　　..
　　　　　　}

　　docker inspect -f  {{.Mounts}}  b2
　　　　 #最外层{} 为引用格式, 内层{.Mounts} 为引用数组中.Mounts
　　　　　　. :表示根，.Mounts:表示根下的Mounts.
　　docker inspect -f {{.NetworkSettings.IPAddress}} b2 #这是简单的Go模板,go模板还支持循环,判断等.

　　示例3:
　　　#创建一个基础容器，让其它容器共享它的UTS，IPC，Network名称空间 已经它的卷映射.
　　终端1:
　　　　docker run --name infraCon -it -v /data/volumes/b2:/data/web/html busybox
　　　　/ #ifconfig

　　终端2:
　　　　docker run --name nginx --network container:infraCon --volumes-from infraCon -it busybox
　　　　/ #ifconfig

　　终端3:
　　　　docker inspect infraCon
　　　　docker inspect nginx 　　 #查看“Mounts” 和 Networks是否与上面的一样。

Dockerfile:
　格式:
　　# : #号开头为注释.
　　FROM : 第一个指令必须是FROM,它用来指明,依据那个基础镜像做镜像。
　　　　　　一般指令建议使用大写以区分参数, 但指令不区分大小写.
　　　　　格式:
　　　　　　FROM <仓库名>[:<tag>] 或 FROM <仓库名>@<Hash摘要值>

　　使用dockerfile制作镜像的注意事项:
　　　1. 必须把镜像文件都放到一个指定目录中, docker build在打包时，只打包该目录中的文件.超出此目录的文件将不会被打包到镜像中.
　　　2. .dockeringore : 这个隐藏文件在指定目录的中,用于设定打包时排除的文件列表,可使用通配符。
　　　3. docker build 在进行镜像打包时，它实际上类似于通过启动一个容器，然后，在容器中运行一些命令，创建一些文件，这些数据都保存在可写层中, 再将可写层打包到镜像中一样，不过，docker build是隐藏式启动基础镜像来自动完成这些操作,所以，需要知道你要使用某些命令，这些命令必须在基础镜像中存在才能使用。
　　　4. 变量替换:
　　　　变量格式: $VarName 或 ${VarName}
　　　　变量替换: ${VarName:-String} 　　 #若VarName为空或未定义,则使用String做为值. 否则使用VarName的值.
　　　　　　　　  ${VarName:+String}　　 #若VarName有值,则使用String替换该值.
　　    5. dockerfile中的指令:
　　　　1. copy <Src> <Dest> 或 COPY ["<Src>",..."<Dest>"] 　　 #注:Src若为目录,复制时,是仅复制目录中文件,而不复制目录本身的.

　　示例:
　　　　mkdir /dockerfile/
　　　　cd /dockerfile
　　　　vim Dockerfile 　　 #注: 文件名首字母必须大写.
　　　　　　#注: Dockerfile中的每条指令都是一层,层数越多挂载效率越差!!
　　　　　　#Description: test image
　　　　　　FROM busybox:latest
　　　　　　MAINTAINER "Tom <tom@test.com>"
　　　　　　# LABEL maintainer="Tom <tom@test.com>" 　 #功能和上面一样.
　　　　　　COPY index.html /data/web/html/ 　　　　　　 #需要将index.html放到/dockerfile中
　　　　　　COPY yum.repos.d /etc/yum.repos.d/ 　　　　 #注: 先将yum.repos.d 复制党/dcokerfile中, 然后在写此命令.
　　　　　　　　　　　　
　　　　　　ADD http://nginx.org/download/nginx-1.15.2.tar.gz /usr/local/src/ 　　 #它会自动在打包时下载该URL指定的文件.
　　　　　　ADD nginx-1.15.2.tar.gz /usr/local/src 　　　　 #打包时,会自动将tar.gz展开放入/usr/local/src/的文件.

　　　　　　WORKDIR /usr/local/src 　　 #将它做为工作目录.
　　　　　　ADD test.tar.gz ./ 　　　　　 #这里引用的相对路径就是WORRDIR所设定的目录.

　　　　　　WORKDIR /etc/yum.repos.d/
　　　　　　ADD yum.repos.d.tar.gz ./ 　　　　 #这里的相对路径就是/etc/yum.repos.d/了。

　　　　　　#VOLUME ["/dir_1", "/dir_2" ..] 　　 #设置容器挂载主机目录
　　　　　　VOLUME /data/mysql/ 　　　　　　 #指定Docker自动管理的卷。

　　　　　　#EXPOSE <Port>/<Protocol>
　　　　　　EXPOSE 80/tcp 　　　　
　　　　　　　 #指定要对外暴露TCP的80端口,但这里指定暴露,实际并不会直接暴露,而是需要在启动容器时,使用 “-P” 才会真正暴露此端口给外部用户.
　　　　　　     # docker port 容器名 #在不加"-P"时，可使用它来验证是否暴露了80端口.
　　　　　　#ENV <KeyName> <Value> 　　　　　　 #此格式定义的变量,会将空格后面的所有字符串都当做keyname的值.
　　　　　　#ENV <Key>=<Value> <Key2>=<V2> ...    #此格式可创建多个环节变量. 若值中有空格,需要用"\"转义, 或用引号引起来.
　　　　　　ENV DOC_ROOT /data/web/html
　　　　　　COPY *.html $DOC_ROOT
　　　　　　COPY *.jsp ${JSP_ROOT:-/data/web/jsp/}  #注：这些环境变量,是可以在启动容器时,指定"-e JSP_ROOT=/data/jsp" 来修改的.

　　　　　　#RUN <Command1> && <Command2> ...      #RUN执行命令是在docker build时执行命令.
　　　　　　WORKDIR /usr/local/src
　　　　　　ADD http://test.org/test.tar.gz ./
　　　　　　RUN cd ./ && \
　　　　　　tar xf test.tar.gz　　　　 #仅做多行写命令的测试

　　　　 #RUN ["<Executable>","<Param1>",....]
　　　　 #RUN的第二种语法格式.它使用JSON数组,Executable为要运行的命令,后面为命令的参数,可有多个.此格式启动的命令不会以/bin/sh -c 的方式启动,因此它不能使用sh的命令语法,如:变量替换,通配符等. 若想使用shell特性的话,可用以下方式:
　　　　RUN ["/bin/sh","-c","<Executable>","Param1",...]
　　　　注:
　　　　　　RUN 和 CMD 及 ENTRYPOINT 若使用中括号来表示数组时,其中不能使用单引号.必须使用双引号.

　　　　docker build --tag tinyhttpd:v0.1 ./

　　测试:
　　　　docker run --name tinyweb1 --rm tinyhttpd:v0.1 cat /data/web/html/index.html
　　　　docker run --name tinyweb1 --rm tinyhttpd:v0.1 ls /etc/yum.repos.d/

　　#启动镜像时,传递参数:
　　　　Dockerfile:
　　　　FROM java:8
　　　　ADD microsoft.jar /root
　　　　ENV PARAMS=""
　　　　ENTRYPOINT ["sh","-c","java $PARAMS -jar /root/microsoft.jar"]

　　　　测试:
　　　　　　docker run -d -e PARAMS="-Dserver.port=8080" -p 2000:8080 镜像名称

Docker私有仓库的构建:
　　1. 安装docker的仓库构建程序包.
　　　　yum install docker-distribution
　　2. vim /etc/docker-distribution/registry/config.yml
　　　　services: registry #表示运行的服务为registry
　　　　layerinfo: inmemory #表示缓存在内存中.
　　　　addr: :5000 #没有指定地址,表示使用0.0.0.0:5000

　　3.启动服务:
　　　　systemctl start docker-distribution

　　4. 给自己做的镜像打上自己的仓库地址的标签.
　　　　docker tag myweb:v0.3.11 node2.test.com:5000/myweb:v0.3.11

　　5. 将自己打好标签的镜像push上去.
　　　　docker push node2.test.com:5000/myweb:v0.3.11 　　 #这里会报错,说我们使用了不安全的http.

　　6. 若我们是内网使用, 不想使用HTTPS,可修改配置文件为:
　　　　vim /etc/docker/daemon.conf
　　　　　　{
　　　　　　...
　　　　　　"insecure-registries": ["node2.test.com:5000"]
　　　　　　}

　　　　systemctl restart docker

　　7. 再次push

　　8. 可到其它节点上测试下载.
　　　　docker pull node2.test.com:5000/myweb:v0.3.11

Docker的资源限制:
　　Linux Capabilities: Linux Kernel相关的知识

　　Memory:
　　OOM: 对于比较重要的容器，在启动时就要调整其OOM_adj, 其值调整越小, OOM_score的评分就越低,当内核发现内存不足,发生OOM时,就优先将OOM_score得分高的优先kill掉.
　　默认: docker daemon会自动将自己的OOM_adj调整很低,避免内核发生OOM时,被内核kill掉.

可调整容器使用内存的限制:
　　-m | --memory= 　　 #限制容器能使用的物理内存大小.单位:k, m, g; 若设置一个容器可用内存为4m,若容器使用超过,将被kill掉.
　　--memory-swap= 　  #要使用它,必须先使用 -m 选项,否则它不生效.
　　　　若设置: -m 7G --memory-swap=10G， 则表示Swap+Ram=10G, Swap=10-7=3G,即可使用3G的Swap内存.
　　　　若设置: -m 7G --memory-swap=7G， 则表示不使用Swap内存.即 若设置这两个参数值相同,表示禁用SWAP.
　　　　若设置: -m 7G --memory-swap=0, 则表示SWAP未设置, 则若DockerHost启用了SWAP,则表示容器可用的SWAP大小=2*RAM的大小.
　　　　若设置: -m 7G --memory-swap=-1, 则表示DockerHost上启用了Swap,则容器可使用的全部的SWAP大小.
　　　注:
　　　　free : 在容器中使用free看到的swap空间使用情况并非上面这些参数计算出来的实际情况, 也就是说free查看容器使用的内存空间是非常不准确的。
　　　　--memory-swappiness： 设置容器使用SWAP内存的倾向性. 值的范围: 0~100, 0:能不用就不用, 100:只要能需要就使用.
　　　　--memory-reservation: 设置要预留多少内存空间。
　　　　--oom-kill-disable 设置当发生OOM时，是否禁止此容器被kill掉，它要可-m一起使用.

CPU:
　　默认所有容器使用CPU资源都没有限制。
　　--cpu-shares  #CPU是可压缩性资源,若当前有A,B,C三个容器, 假如分配给他们CPU占用的比例为:1024:512:2048.
　　　　　　　　则表示,将CPU资源分2+1+4，即分成7份, 三个容器都需要CPU,则A使用2份CPU时间, B使用1份
　　　　　　　　CPU时间, C使用4份CPU时间, 若B和C当前都空闲,则A可使用全部CPU资源; 若此时A和B都需要
　　　　　　　　用CPU资源,则按照A使用2份CPU资源, B使用1份CPU时间, 若又新加了D,则再重新分割CPU时间片.
　　--cpus=　　 #限制单个容器最多可使用几核CPU, 即: 假如有4个核心, 还是A,B,C, 若此时B和C都不使用CPU
　　　　　　　　在不限制的情况下，A可使用4个核心,即最大可使用400%的计算能力.若设置了单个容器的
　　　　　　　　最多可使用CPU核心数,则基本当前所有容器都不用CPU，你也只能使用限制个数的核心数.
　　--cpus=1.5 #表示最多可用150%，注意容器最多可使用150%的CPU计算能力，指的是
　　　　　　　　只有能限制它最多使用这么多计算能力即可，至于容器在那个CPU核心上
　　　　　　　　运行无所谓，随机分配，分到那个核心上就在那个核心上运行。但总量是不会超过150%的。
　　--cpuset-cpus=     #这是限制容器能够运行在那个CPU核心上的, 假如:有4核心, 则用0~3来表示4个核心的编号.
　　--cpuset-cpus=0,1 　　# 则表示容器只能运行在核心0和1上，其它上面不行。
　　--cpu-period= 　　　    #限制最多可用CPU的时间.
　　--cpu-quota=

以上这些选项在docker run 时可以设置。

docker压测工具:
　　docker pull lorel/docker-stress-ng
　　docker run --name stress -it --rm -m 256m lorel/docker-stress-ng:latest stress --help #可查看帮助.
　　docker run --name stress -it --rm -m 256m lorel/docker-stress-ng:latest stress --vm 2 #限制其最多使用256M内存.
　　docker run --name stress -it --rm --cpus 2 lorel/docker-stress-ng:latest stress --cpu 8 #限制最多使用2个CPU核心的计算资源.

　　终端1:
　　　　docker run --name stress -it --rm --cpu-shares 1024 lorel/docker-stress-ng:latest stress --cpu 8

　　终端3:
　　　　docker run --name stress -it --rm --cpu-shares 512 lorel/docker-stress-ng:latest stress --cpu 8

　　终端2:
　　　　docker top stress #查看容器进程数
　　　　docker stats #查看docker资源的消耗情况。