docker实战

docker简介

尚硅谷

docker官网

docker-hub

docker是基于'go语言'实现的云开源项目，社区版免费，企业版收费
docker的主要目标是通过对应用软件的封装、分发、部署、运行等生命周期的管理，使用户的APP（可以是一个web应用或数据库应用等），及其运行环境能够做到'一次封装，到处运行'
docker
	解决了运行问题和配置问题的软件容器，方便做持续集成，并有助于整体发布的容器虚拟化技术

docker三要素

仓库：
	仓库是集中存放镜像文件的场所，
	仓库和仓库注册服务器是有区别的，仓库注册服务器上往往存放多个仓库，每个仓库中有包含了多个镜像，每个镜像有不同的'标签'
	仓库分为公开仓库和私有仓库，最大的仓库是docker hub，存放了数量庞大的镜像，供用户下载，国内的公开仓库有阿里云、网易云
	
镜像：
	就是一个只读的模板，镜像可以用来创建docker容器，一个镜像可以创建很多的容器
	
容器：
	容器（container）就是镜像的实例，可以被启动、开始、停止、删除，每个容器都是相互隔离的、保证安全的平台

	docker本身是一个容器运行载体或称为管理引擎，我们把应用程序和配置依赖打包好形成一个可交付的运行环境中，这个打包好的运行环境就是image镜像文件，只有通过镜像文件才能生成docker容器，image镜像文件可以看作是容器的模板，docker根据镜像文件生成容器实例，同一个image镜像文件可以生成多个'同时运行'的容器实例
一个容器运行一种服务，当我们需要的时候，就可以通过docker客户端创建一个对应的运行实例，也就是我们的容器

#容器可以看做是一个简易版的linux环境，有简易的linux命令
#不同的容器之间是进程的隔离
#容器和镜像类似，只不过容器是动态的运行的镜像，从层的角度来说，镜像是只读的，容器最上层是可读可写的
#docker是一个client/server结构的系统，docker守护进程运行在主机上，然后通过socket连接从客户端访问，守护进程从客户端接收命令并运行并管理运行在主机上的容器
#容器的id和镜像的id没有关系，并且独有

docker安装条件

1.centos6.5以上版本，64位系统（cat /etc/redhat-release）
2.系统内核版本大于2.6.32（uname -a）

虚拟机

	虚拟机就是带环境安装的一种解决方案，他可以在一种操作系统里面运行另一种操作系统，比如Windows里面运行linux系统，应用程序对此毫无感知，因为虚拟机跟真事系统一模一样，而对于底层系统来说，虚拟机就是一个普通文件，删除了也不会影响其他部分，这样，虚拟机完美的运行了另一种系统，使应用程序、操作系统和硬件三者之间的逻辑不变
	
虚拟机的缺点：资源占用多、冗余步骤多、启动慢

linux容器（linux container，缩写为LXC）
	linux不是模拟一个完整的操作系统，而是'对进程进行隔离'，有了容器，就可以将软件运行所需的所有资源打包到一个隔离的容器中，容器与虚拟机不同，不需要捆绑一整套操作系统，只需要软件工作所需的库资源和设置，系统因此变得高效轻量并保证部署在任何环境中的软件都能始终如一的运行
	
#docker和传统虚拟化方式的不同之处
1.传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整的操作系统，在系统上再运行所需应用的进程
2.容器内的应用进程直接运行在宿主的内核，容器内没有自己的内核，而且也没有进行硬件虚拟，因此容器要比传统的虚拟机更加轻便
3.每个容器之间相互隔离，每个容器有自己的文件系统，容器之间进程不会相互影响，能区分计算资源
	
更轻量：基于容器的虚拟化，仅包含业务运行所需的runtime环境，centos/ubantu基础镜像仅仅170M，宿主机可以部署100~1000个容器	

#为什么docker比VM快
1.docker有着比虚拟机更少的抽象层，由于docker不需要hypevisor实现硬件资源虚拟化，运行在docker容器上的程序直接使用的都是实际物理机的硬件资源，因此，CPU、内存利用率上docker将会在效率上有明显优势
2.docker利用的是宿主机的内核，而不需要Guest OS，因此，当新建一个容器时，docker不需要和虚拟机一样重新加载一个操作系统的内核，当新建一个虚拟机时，虚拟机软件需要加载Guest OS，返回新建内容是分钟级别的，而docker由于直接利用宿主机的操作系统，则省略了返回的过程，因此新建一个docker容器只需要几秒钟

mysql优化
	1.网络
		将请求分发到多台服务器
	2.IO
		SSD硬盘
		增加内存
		分库分表

docker安装

参考文档

镜像加速器

centos7

#本地安装
1.上传
rz
2.安装docker
yum localinstall -y

#下载安装
1.
~]# yum install -y docker-ce
2.配置文件
~]# ll /etc/sysconfig/docker
-rw-r--r-- 1 root root 1094 Dec  4  2019 /etc/sysconfig/docker
3.检测安装是否成功
~]# docker version
Client:
 Version:         1.13.1
 API version:     1.26

#配置镜像加速器，才能docker pull
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://toemxq46.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

#配置了镜像加速器之后，docker run的时候，先在https://hub.docker.com/查询镜像，再在阿里云下载镜像到本地

常用命令

[root@docker ~]# docker version
Client: Docker Engine - Community
 Version:           19.03.12
 API version:       1.40
 Go version:        go1.13.10
 Git commit:        48a66213fe
 Built:             Mon Jun 22 15:46:54 2020
 OS/Arch:           linux/amd64
 Experimental:      false

Server: Docker Engine - Community

[root@docker ~]# docker info
Client:
 Debug Mode: false

Server:

[root@docker ~]# docker --help
Usage:	docker [OPTIONS] COMMAND

#查看当前主机能够使用的镜像模板
[root@docker ~]# docker images
镜像仓库源		   镜像的标签            镜像id              镜像创建时间         镜像大小   
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
hello-world         latest              bf756fb1ae65        7 months ago        13.3kB

#同一个仓库源可以有多个TAG，代表这个仓库镜像的不同的版本，我们使用REPOSITORY:TAG来定义不同的镜像
#如果不指定一个镜像的版本标签，例如只使用ubantu，docker将默认使用ubantu:latest镜像
#镜像名和镜像id都是唯一的，容器名和容器id也是唯一的

查

#查看所有的本地镜像image，含中间映像层
[root@docker ~]# docker images -a
#查看镜像的image id
[root@docker ~]# docker images -q
bf756fb1ae65
#查看所有镜像的image id，运行或者停止
[root@docker ~]# docker images -qa
bf756fb1ae65
#查看镜像说明
[root@docker ~]# docker images --digests
#查看完整的镜像信息
[root@docker ~]# docker images --no-trunc

拉

#在hub.docker上查找镜像
[root@docker ~]# docker search tomcat
NAME                          DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
#拉取镜像到本地
[root@docker ~]# docker pull tomcat
#在hub.docker上查找镜像，只显示点赞数大于30的镜像
[root@docker ~]# docker search -s30 tomcat
#在hub.docker上查找镜像，只显示点赞数大于30的镜像，并显示完整的说明
[root@docker ~]# docker search -s30 --no-trunc tomcat 

#拉取镜像
[root@docker ~]# docker pull nginx
[root@docker ~]# docker pull nginx:latest
[root@docker ~]# docker pull nginx:7.1

#不标注版本号，默认下载最新版latest，标注版本号下载指定版本号

删除

#删除镜像
[root@docker ~]# docker rmi nginx
#强制删除正在运行容器的镜像
[root@docker ~]# docker rmi -f hello-world:latest
#删除多个镜像
[root@docker ~]# docker rmi hello-world:latest nginx:latest
#删除全部镜像
[root@docker ~]# docker rmi $(docker images -qa)

#拉取centos镜像
[root@docker ~]# docker pull centos
#查看本地的镜像
[root@docker ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
nginx               latest              4bb46517cac3        6 days ago          133MB
centos              latest              0d120b6ccaa8        9 days ago          215MB
tomcat              latest              2ae23eb477aa        2 weeks ago         647MB
hello-world         latest              bf756fb1ae65        7 months ago        13.3kB

#删除容器
[root@docer02 ~]# docker rm 0b34d7c2a37d	#删除已经停止的容器的记录
[root@docer02 ~]# docker rm -f 0b34d7c2a37d	#强制删除
[root@docer02 ~]# docker rm -f $(docker ps -aq)		#一次性删除所有的容器记录
[root@docer02 ~]# docker ps -a|xargs docker rm		#一次性删除所有的容器记录

容器

#运行镜像，生成容器，启动容器，进入容器
[root@docker ~]# docker run -it 0d120b6ccaa8
[root@0bb604397483 /]# pwd
/

--name="容器的名字" ：为容器指定一个名字
-d	：后台运行容器，并返回容器id，也就是'启动守护式容器'
-i	：以'交互模式运行容器'，通常与 -t同时使用
-t	：为容器重新分配一个伪输入终端，通常与 -i同时使用，/bin/bash
-P	：随机端口映射
-p	：指定端口映射，有以下四种格式
	ip:hostport:containerport
	ip:containerport
	hostport:containerport
	containerport
rm	删除容器记录（依赖于docker ps）
rmi	删除镜像 （依赖于docker images）

#使用镜像生成容器，指定容器名字
[root@docker ~]# docker run -it --name syy centos
	
#查看当前正在运行容器
[root@docker ~]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES


#退出容器
exit      关闭容器并退出
ctrl+P+Q  不停止退出
ctrl+C/D    关闭容器并退出

#docker支持linux命令，因为linux或者linux软件
[root@docker ~]# docker stop 078e6a64239f
[root@docker ~]# docker start 183709d7649a
[root@docker ~]# docker restart 183709d7649a
[root@docker ~]# docker kill 183709d7649a


#查看上一个容器（正在运行或退出）
[root@docker ~]# docker ps -l
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
#查看所有运行过的容器
[root@docker ~]# docker ps -a
#查看上n个运行过的容器
[root@docker ~]# docker ps -n3
#显示容器编号
[root@docker ~]# docker ps -q
078e6a64239f

#停止容器
[root@docker bin]# docker stop $(docker ps -qa)
[root@docer02 ~]# docker kill 77167e0c29c6
77167e0c29c6

#重启容器（依赖于docker ps）
[root@docker bin]# docker restart 77167e0c29c6
77167e0c29c6

docker运行的底层原理

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

docker 是进程的隔离，不是系统的隔离
虚拟机是系统的隔离

logs

docker容器后台运行，就必须有一个前台进程，容器的运行命令如果不是那些一直挂起的命令（top tail bash），就是会自动退出的
可以使用&，让非centos镜像生成的容器放在后台运行

#启动守护式容器，启动后立即被干掉
[root@docker ~]# docker run -d centos
b97105fef7c2b8e775a7aa769c2b0bd6ee6c4eb11e99cf10fbc758e6158cb09f
#查看容器运行记录
[root@docker ~]# docker ps -a

#启动守护式容器
[root@docker ~]# docker run -d centos /bin/sh -c "while true;do echo hello syy;sleep 3;done"
#查看当前正在运行的容器
[root@docker ~]# docker ps
#查看容器的运行日志
[root@docker ~]# docker logs -t -f --tail 3 8bd786412f2f
2020-08-21T09:51:53.387919937Z hello syy

-t	:添加时间段
-f	:持续监控
--tail	:初始显示几条日志

#查看运行的容器
[root@docker ~]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
8bd786412f2f        centos              "/bin/sh -c 'while t…"   5 minutes ago       Up 5 minutes                            magical_blackwell

#查看指定容器运行的进程
[root@docker ~]# docker top 8bd786412f2f
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD

#查看容器运行细节，-f指定关键字
[root@docker ~]# docker inspect 8bd786412f2f
#过滤出指定内容
[root@docker bin]# docker inspect -f {{.Id}} centos
sha256:0d120b6ccaa8c5e149176798b3501d4dd1885f961922497cd0abef155c869566

attach exec

#启动容器，不停机退出
[root@docker ~]# docker run -it centos /bin/bash
#查看当前运行的容器
[root@docker ~]# docker ps
#进入容器
[root@docker ~]# docker attach 7caec6b77e23
[root@7caec6b77e23 /]#

#命令行查看容器（-it 可以省略）
[root@docker ~]# docker exec -it 7caec6b77e23 ls /tmp
ks-script-2n9owwnh  ks-script-xm1o5azb
[root@docker bin]# docker exec centos ls /tmp

#进入容器（-it 必须）
[root@docker ~]# docker exec -it 7caec6b77e23 /bin/bash
[root@7caec6b77e23 /]# 

cp

#拷贝容器中的文件到宿主机
[root@docker ~]# docker cp 7caec6b77e23:/tmp/ks-script-2n9owwnh /root

#拷贝宿主机的文件到容器
[root@docker ~]# docker cp /root/1.txt 7caec6b77e23:/tmp/ks-script-2n9owwnh

docker镜像

#Tomcat镜像为什么那么大？

镜像：
	镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需的'所有内容'，包括代码、运行时、库、环境变量和配置文件
	
unionFS（联合文件系统）:
	union文件系统是是一种分层、轻量级并且高性能的文件系统，'它支持Udine文件系统的修改作为一次提交来一层层的叠加'，同时可以将不同的目录挂载到同一个虚拟文件系统下，union文件系统是docker镜像的基础，镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作具体的应用镜像
	
	docker镜像实际上有一层一层的文件系统组成，这种层级调度文件系统叫做unionFS
	bootfs主要包含bootloader和kernel,bootloader主要是引导加载kernel，linux刚启动的时候会加载bootfs文件系统，在docker镜像的最底层就是bootfs，这一层与我们典型的linux/unix系统是一样的，包含boot加载器和内核，当boot加载完之后整个内核就在内存中了，此时内存的使用权已由bootfs转交给'内核'，此时系统也会卸载bootfs
	在bootfs之上，包含的就是典型linux系统中的/dev /proc /bin /etc 等标准目录和文件，rootfs就是各种不同的操作系统发行版，比如ubantu centos等
	对于一个精简的os，rootfs可以很小，只需要包括最基本的命令、工具和程序库就可以了，因为底层直接用host的kernel，自己只需要提供rootfs就行了，右侧可见对于不同的linux发行版，bootfs基本是一致的，rootfs会有差别，因此不同的发行版'可以共用bootfs'

联合文件系统的优点：
	共享资源
	比如，有多个镜像都从相同的base镜像构建而来，那么宿主机只需要在磁盘上保存一份base镜像，同时内存中也需要加载一份base镜像，就可以为所有容器服务了，而且镜像的每一层都可以被共享
docker镜像都是只读的，当容器启动时，一个新的可写层被加载到镜像的顶部，这一层通常被称为容器层，容器层之下的都叫做镜像层

commit，打包镜像

#指定端口启动容器
[root@docker ~]# docker run -it -p 8888:8080 tomcat
[root@docker ~]# curl localhost:8888
#随机端口启动容器
[root@docker ~]# docker run -it -P tomcat
[root@docker ~]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS                     NAMES
fcb73a5e59f4        tomcat              "catalina.sh run"   16 seconds ago      Up 15 seconds       '0.0.0.0:32768->8080/tcp'   mystifying_elgamal
7caec6b77e23        centos              "/bin/bash"         About an hour ago   Up About an hour                              sweet_bartik

#后台启动容器(-it可以省略)
[root@docker ~]# docker run -it -P tomcat &
[root@docker ~]# docker ps
#进入容器
[root@docker ~]# docker exec -it 37e5743fff3d /bin/bash
root@37e5743fff3d:/usr/local/tomcat/webapps# mkdir ROOT
root@37e5743fff3d:/usr/local/tomcat/webapps/ROOT# echo 123 > ROOT/1.html
#访问容器
[root@docker ~]# curl localhost:32769/1.html
123
#打包容器，重做镜像，-a:作者、-m：注释、namspace/my_tomcat:1.1 镜像名
[root@docker ~]# docker commit -a="syy" -m="add 1.html" 37e5743fff3d namspace/my_tomcat:1.1
sha256:7ab32b6665a40fb005d6ac2af22f7462e9d34b2996af3dd3040952d191cfd2ee

[root@docker ~]# docker images
REPOSITORY           TAG                 IMAGE ID            CREATED              SIZE
'namspace/my_tomcat'   1.1                 7ab32b6665a4        About a minute ago   648MB
'tomcat '              latest              2ae23eb477aa        2 weeks ago          647MB

#使用镜像，生成容器（-p 必须要有端口映射）
[root@docker ~]# docker run -it -p 7777:8080 namspace/my_tomcat:1.1
#再次访问
[root@docker ~]# curl localhost:7777/1.html
123

#前台生成容器,交互式容器
[root@docker ~]# docker run -it -p 7777:8080 namspace/my_tomcat:1.1
#后台生成容器，守护式容器
[root@docker ~]# docker run -d -p 7777:8080 namspace/my_tomcat:1.1

#-d选项，不能直接后台运行centos镜像，后面必须接命令，但是可以直接后台运行Tomcat镜像

数据卷

#docker理念：
	1.将应用与运行的环境打包形成容器运行，运行可以伴随着容器，但是我们对数据的要求希望是持久化的
	2.容器之间尽量共享数据
	
docker容器产生的数据，如果不通过 docker commit 生成新的镜像，使得数据作为镜像的一部分保存下来，那么容器删除后，数据自然也就没有了，为了能保存数据在docker中，要使用'卷'

#卷
	就是命令或文件，存在于一个或多个容器中，由docker挂载到容器，但不属于联合文件系统，因此能够绕过unionFS，提供一些用于'持续存储或共享数据的特性'
	
卷的设计目的就是数据的'持久化'，完全独立于容器的生存周期，因此docker不会再容器删除时删除其挂载的数据卷

#特点：
	1.数据卷可以在容器之间共享并使用
	2.卷中的更改可以直接生效
	3.数据卷中的更改不会包含在镜像的更新中
	4.数据卷的生命周期一直持续到没有容器使用它为止
	
#dockerfile是镜像模板的描述文件，在github.com上可以参考

#添加数据卷
	直接在命令行添加
	dockerfile添加

-v

#命令行添加数据卷，--privileged=true（可解决cannot open directory:permission denied）
docker run -it -v /宿主机绝对路径目录:/容器内目录 镜像名

[root@docker ~]# docker run -it -v /dockerdata/:/syy 0d120b6ccaa8	#自动创建/syy

#容器和宿主机之间数据共享
[root@f55afa5c0e24 /]# echo 123 > /syy/test

#命令行查看宿主机
[root@docker ~]# cat /dockerdata/test 
123

#查看数据卷是否挂载成功
[root@docker ~]# docker inspect f55afa5c0e24|grep -C5 syy

#容器关闭、重启，不影响数据卷的数据同步
[root@docker ~]# docker stop f55afa5c0e24
[root@docker dockerdata]# vim haha
[root@docker ~]# docker start f55afa5c0e24
[root@docker ~]# docker attach f55afa5c0e24
[root@f55afa5c0e24 /]# cat /syy/haha 
hahaaaaaaaaaaaaaaaaaaaa

#命令行添加数据卷（只读），容器目录只读，主机命令可读可写
docker run -it -v /宿主机绝对路径目录:/容器内目录:ro 镜像名
[root@docker dockerdata]# docker run -it -v /dockerdata/:/syy:ro centos

#dockerfile中添加数据卷
1.dockerfile脚本
[root@docker ~]# vim /dockerfile
# volume test
FROM centos
VOLUME ["/dockerdata1","/dockerdata2"]
CMD echo success
CMD /bin/bash

2.build后生成镜像,-f指定dockerfile文件（可省略），-t指定镜像名
[root@docker ~]# docker build -f /dockerfile -t syy/centos .
[root@docker ~]# docker images
syy/centos           latest              9c7c1bfe80ab        11 minutes ago      215MB
3.run容器
[root@docker ~]# docker run -it syy/centos
[root@docker ~]# docker inspect f373ea11ac76|grep -C5 Volume

4.查看容器与宿主机之间的数据共享
[root@docker _data]# cd "/var/lib/docker/volumes/edacddbfa943550edacf2ac156ea879d62e55389dddc693f65a3a5656daedf97/_data"

#使用dockerfile可以制作（docker build）镜像，镜像生成(docker run)容器
#通过dockerfile做成的数据卷无法指定宿主机中的目录名，可以使用find命令查找
#使用dockerfile可以一次搭建多个数据卷
#容器卷相关目录可以自动创建

数据卷容器：
	命名的数据卷容器挂载数据卷主机，其他容器通过挂载这个（父容器）实现数据的共享，挂载数据卷的容器，称为数据卷容器
	挂载方式为：容器 => 主机， 容器 => 容器

#容器与主机
[root@docker ~]# docker build -f /dockerfile -t syy/centos .
[root@docker ~]# docker run -it --name docker1 syy/centos
#容器与容器
[root@docker ~]# docker run -it --name docker2 --volumes-from docker1 syy/centos
[root@docker dockerdata1]# docker ps
[root@aff37c2d14b0 dockerdata1]# touch eeeee
查看容器与容器的数据卷共享
[root@a7ad7f315aeb dockerdata1]# ls
eeeee
查看容器与主机的数据卷共享
[root@docker dockerdata1]# docker inspect a7ad7f315aeb|grep -C5 volume

#容器之间配置信息的传递，数据卷的生命周期一直持续到没有容器使用它为止
#数据卷就是容器的持久化
# -v、--volume-from参数实现了容器与宿主机、父容器到子容器，子容器到父容器数据的持久化
#卷是可以继承的

#阿里云镜像仓库
https://cr.console.aliyun.com/cn-huhehaote/instances/repositories

1.创建本地镜像仓库
2.
docker login
docker push

dockerfile

#dockerfile
	是用来构建docker镜像的构建文件，是由一系列命令和参数构成的脚本
	
[root@docker ~]# vim /dockerfile
# volume test
FROM centos
VOLUME ["/dockerdata1","/dockerdata2"]
CMD echo success
CMD /bin/bash
	
#基础知识：
	1.每条'保留字指令'都必须为大写字母且后面要跟随至少一个参数
	2.指令按照从上到下的顺序执行
	3.#号表示注释
	4.每条指令都会创建一个新的'镜像层'，并对镜像进行'提交'
	
#dockerfile的使用
1.编写，手动构建一个dockerfile文件，必须要符合file的规范
2.构建，使用docker build命令执行，获得一个自定义的镜像
3.执行，使用docker run命令，获得容器

#从应用角度来看，dockerfile、docker镜像与docker容器分别代表软件的三个不同的阶段
	1.dockerfile是软件的原材料
	2.docker镜像是软件的交付品
	3.docker容器可以认为是软件的运行态
	dockerfile面向开发，docker镜像成为交付标准，docker容器则涉及部署与运维，三者缺一不可，合力成为docker体系的基石
			  build          run
	dockerfile ==> docker镜像 ==>docker容器
	
#dockerfile保留字指令：
	FROM：	基础镜像，当前镜像是基于哪个镜像的
	MAINTAINER: 镜像维护者的姓名和邮箱地址
	RUN: 	容器'构建时'需要运行的命令
	EXPOSE: 该镜像启动后，暴露的端口号（80 443使用空格隔开）
	WORKDIR: 指定在创建容器后，终端默认登录的进来的工作目录。'默认' /
	ENV: 	用来在构建镜像的过程中设置环境变量，'键值对'
	ADD: 	将宿主机目录下的文件拷贝进镜像且ADD命令会去自动处理URL和解压tar包
	COPY: 	将宿主机目录下的文件拷贝进镜像
	VOLUME: 容器数据卷，用于数据保存和持久化工作
	CMD: 	指定容器'启动时'要运行的命令，'只有最后一个生效'，CMD会被docker run 之后的命令替换
	ENTRYPOINT: 指定容器'启动时'要运行的命令，支持追加该命令的参数，使用该参数将不能开启终端
	ONBUILD: 当构建一个被继承的dockerfile时运行命令，父镜像在被子镜像继承后，父镜像的 onbuild 被触发,'相当于触发器'
	
#scratch 是所有镜像的源镜像
#所有的镜像都是dockerfile文件
#CMD不会被别的镜像继承

案例一

用镜像做镜像

#编辑dockerfile文件
[root@docker ~]# vim /dockerfile 
FROM centos
MAINTAINER syy<123@qq.com>
ENV MYPATH /usr/local
WORKDIR $MYPATH
RUN yum install -y vim
RUN yum install -y net-tools
VOLUME ["/dockerdata1","/dockerdata2"]
CMD echo success----------------ok
#CMD /bin/bash

#生成镜像，-f可以省略
[root@docker ~]# docker build -f /dockerfile -t mycentos:1.0 .
#查看镜像
[root@docker ~]# docker images
mycentos             1.0                 d050fe0b5608        9 seconds ago       295MB
#生成容器
[root@docker ~]# docker run -it mycentos:1.0
[root@4dec8de00b8e local]# pwd
/usr/local

#列出镜像的变更历史
[root@docker ~]# docker images
[root@docker ~]# docker history d050fe0b5608

CMD的替换

[root@docker ~]# docker run -it -p 7777:8080 tomcat ls -l
[root@docker ~]# docker ps

#原理是后面的 ls -l 覆盖掉了dockerfile里面的 CMD ["catalina.sh", "run"]，导致Tomcat没有启动

案例二

#编辑
[root@docker ~]# vim /dockerfile 
FROM centos
RUN yum install -y curl
ENTRYPOINT [ "curl","-si","https://cip.cc" ]

#创建镜像
[root@docker ~]# docker build -f /dockerfile -t mycentos:1.1 .

#生成容器
[root@docker ~]# docker run mycentos:1.1
HTTP/2 200 
server: openresty
date: Fri, 09 Oct 2020 07:37:34 GMT
content-type: text/html; charset=UTF-8
vary: Accept-Encoding
x-cip-c: H

IP	: 139.227.12.100
地址	: 中国  上海
运营商	: 联通

数据二	: 上海市 | 联通

数据三	: 中国上海上海 | 联通

URL	: http://www.cip.cc/139.227.12.100

案例三

#编辑
[root@docker ~]# vim /dockerfile 
FROM centos
RUN yum install -y curl
ENTRYPOINT [ "curl","-s","http://ip.cn" ]
ONBUILD RUN echo "father image sonbuild ------- 666"

#构建镜像
[root@docker ~]# docker build -f /dockerfile -t father .

#编辑
[root@docker ~]# vim /dockerfile 
FROM father
RUN yum install -y curl
ENTRYPOINT [ "curl","-s","http://cip.cc" ]
ONBUILD RUN echo "father image sonbuild ------- 666"
#构建镜像
[root@docker ~]# docker build -f /dockerfile -t son .
Step 1/4 : FROM father
# Executing 1 build trigger		触发器被触发
 ---> Running in 6e00d9d6f733
father image sonbuild ------- 666
...

案例四

#编辑
FROM centos
MAINTAINER syy<123@qq.com>
#把宿主机当前目录的c.txt拷贝到容器 /usr/local 路径下
COPY c.txt /usr/local/cincontainer.txt
#把Java与Tomcat添加到容器中
ADD jdk-8u40-linux-x64.gz /usr/local
ADD tomcat.tar.gz /usr/local
#安装vim编辑器
RUN yum install -y vim
#设置工作路径
ENV MYPATH /usr/local
WORKDIR $MYPATH
#配置Java与Tomcat环境变量
ENV JAVA_HOME /usr/local/jdk-8u40-linux-x64.gz
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-000
ENV CATALINA_BASE /usr/local/apache-tomcat-000
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
#容器运行时监听的端口
EXPOSE 8080
#启动时运行Tomcat
#ENTRYPOINT ["/usr/local/apache-tomcat-000/bin/startup.sh"]
#CMD ["/usr/local/apache-tomcat-000/bin/catalina.sh","run"]
CMD /usr/local/apache-tomcat-000/bin/startup.sh && tailf -F /usr/local/apache-tomcat-000/bin/logs/catalina.out

网络

bridge

docker的四种网络模式

save、export

参考网站