docker介绍和安装以及常用命令

介绍

Docker是基于Go语言实现的云开源项目。

一次镜像，处处运行

传统的部署项目环境配置相当麻烦，换一台机器，就要重来一次，费力费时。
Docker的主要目标是“一次镜像，随处运行”。只需要一次配置好环境，打包成镜像，换到别的主机上可以一键部署好，大大简化了操作。

传统的部署项目环境配置相当麻烦，换一台机器，就要重来一次，费力费时。利用docker可以把原始环境一模一样地复制过来。开发人员利用Docke可以消除协作编码时“在我的机器上可正常工作”的问题。

快速扩容

随着微服务架构和Docker的发展，大量的应用会通过微服务方式架构，应用的开发构建将变成搭乐高积木一样，每个Docker容器将变成一块“积木”，应用的升级将变得非常容易。当现有的容器不足以支撑业务处理时，可通过镜像运行新的容器进行快速扩容，使应用系统的扩容从原先的天级变成分钟级甚至秒级。

方便开发、测试、运维统一管理运行环境

生产环境运行的应用可与开发、测试环境的应用高度一致，容器会将应用程序相关的环境和状态完全封装起来,不会因为底层基础架构和操作系统的不一致性给应用带来影响，产生新的BUG。
利用docker可以把原始环境一模一样地复制过来。开发人员利用Docke可以消除协作编码时“在我的机器上可正常工作”的问题。
当出现程序异常时，也可以通过测试环境的相同容器进行快速定位和修复。

比虚拟机更快也更节省硬件资源

Docker是内核级虚拟化，其不像传统的虚拟化技术一样需要额外的Hypervisor支持，所以在一台物理机上可以运行很多个容器实例，可大大提升物理服务器的CPU和内存的利用率。
和传统虚拟机相比：

更轻量：

基于容器的虚拟化，仅包含业务运行所需的runtime环境，
CentOS/Ubuntu基础镜像仅170M;宿主机可部署100~1000个容器。

Docker不是模拟一个完整的操作系统，而是对进程进行隔离。有了容器，就可以将软件运行所需的所有资源打包到一个隔离的容器
中。容器与虚拟机不同，不需要捆绑一整套操作系统，只需要软件工作所需的库资源和设置。系统因此而变得高效轻量并保证部署在
任何环境中的软件都能始终如一地运行。

更高效：

无操作系统虚拟化开销
计算：轻量，无额外开销。
存储：系统盘aufs/dm/overlayfs，数据盘volume
网络：宿主机网络，NS隔离。

更敏捷、更灵活：

分层的存储和包管理，devops理念，支持多种网络配置

架构与流程

Docker是一个Client-Server结构的系统，Docker守护进程运行在主机上，然后通过Socket连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器。和mysql的架构是一样的，一个mysql服务器，可以连接多个mysql客户端，通过从mysql客户端接收命令，来操作数据库。

Docker运行的基本流程为：
1、用户是使用Docker Client.与Docker Daemon建立通信，并发送请求给后者。

2、Docker Daemon作为Docker:架构中的主体部分，首先提供Docker Server的功能使其可以接受Docker Client的请求。

3、Docker Engine执行Docker内部的一系列工作，每一项工作都是以一个Job的形式的存在。

4、Job的运行过程中，当需要容器镜像时，则从Docker Registry中下载镜像，并通过镜像管理驱动Graph driver将下载镜像以Graphl的形式存储。

5、当需要为Docker创建网络环境时，通过网络管理驱动Network driver创建并配置Docker容器网络环境。

6、当需要限制Docker:容器运行资源或执行用户指令等操作时，则通过Exec driver来完成。

7、Libcontainer是一项独立的容器管理包，Network driverl以及Exec driver都是通过Libcontainer来实现具体对容器进行的操作。

安装

https://docs.docker.com/engine/reference/builder/

Docker并非是一个通用的容器工具，它依赖于已存在并运行的Linux内核环境。
Docker实质上是在已经运行的Linux下制造了一个隔离的文件环境，因此它执行的效率几乎等同于所部署的Linux主机。
因此，Docker必须部署在Linux内核的系统上。如果其他系统想部署Docker就必须安装一个虚拟Linux环境。
在Windows上部署Docker的方法都是先安装一个虚拟机，并在安装Linux系统的的虚拟机中运行Docker。
哪怕是不安装VMware的windows版本的docker，也是基于windows自带的hyper-v加上wsl组合构建了一个GNU/Linux虚拟机，只是这个虚拟机对我们隐藏了，进入docker实例后用uname -a命令可以看到。

windows版本的安装：

第一步，打开官网https://www.docker.com/get-started/下载exe

第二步，安装wsl。
win10及以上打开PowerShell，输入wsl --install并回车，其他版本参阅微软官网：https://docs.microsoft.com/zh-cn/windows/wsl/install
第三步，开启虚拟机平台。

第四步，开启hyper-v

没有hyper-v的，随便新建一个bat或cmd文件，文件内容如下：

pushd "%~dp0"
dir /b %SystemRoot%\servicing\Packages\*Hyper-V*.mum >hyper-v.txt
for /f %%i in ('findstr /i . hyper-v.txt 2^>nul') do dism /online /norestart /add-package:"%SystemRoot%\servicing\Packages\%%i"
del hyper-v.txt
Dism /online /enable-feature /featurename:Microsoft-Hyper-V-All /LimitAccess /ALL

然后运行你新建的bat或cmd文件即可。然后再去windows功能里开启hyper-v。

第五步，双击下载的Docker Desktop Installer.exe安装。

centos7安装docker：

sudo yum install -y yum-utils
sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

sudo yum install docker-ce docker-ce-cli containerd.io docker-compose-plugin
sudo systemctl start docker
sudo docker run hello-world

官网安装教程：https://docs.docker.com/engine/install/centos/

修改公有库镜像

打开：https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://qg9o8o3o.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

三大概念

仓库，类似于maven仓库

仓库(Repository)是集中存放镜像文件的场所。类似于Maven仓库，存放各种jar包的地方；github仓库，存放各种git项目的地方；
Docker公司提供的官方registry被称为Docker Hub,存放各种镜像模板的地方。
仓库分为公开仓库(Public)和私有仓库(Private)两种形式。
最大的公开仓库是Docker Hub(https:/hub.docker.com/),存放了数量庞大的镜像供用户下载。国内的公开仓库包括阿里云、网易云等。

镜像 ，类似于java类

Docker镜像(Image)就是一个只读的模板。镜像可以用来创建Docker容器，一个镜像可以创建很多容器。
它也相当于是一个root文件系统。比如官方镜像centos:7就包含了完整的一套centos:7最小系统的root文件系统。
相当于容器的“源代码”，docker镜像文件类似于Java的类模板，而docker容器实例类似于java中new出来的实例对象。

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

UnionFS

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

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

Docker镜像加载原理

docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统 UnionFS。
bootfs( boot file system)主要包含 bootloader和 kernel, bootloader主要是引导加载 kernel, Linuxl刚启动时会加载 oootfs文件系统，在
Docker镜像的最底层是 bootfs。这一层与我们典型的 Linux/Unix系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核
就都在内存中了，此时内存的使用权已由 bootfs:转交给内核，此时系统也会卸载 bootfs。
rootfs( root file system),在 bootfs.之上。包含的就是典型 Linux系统中的/dev,/proc,/bin,/etc等标准目录和文件。 rootfs就是各种不
同的操作系统发行版，比如 Ubuntu, Centos等等。

对于一个精简的OS, rootfs可以很小，只需要包括最基本的命令、工具和程序库就可以了，因为底层直接用Host的 kernel,自己只需要提供 rootfs就行了，这就是为什么docker上安装一个linux只需要200MB。由此可见对于不同的 linux发行版， bootfs基本是一致的， rootfs会有差别，因此不同的发行版可以公用 bootfs。

镜像就像千层饼

镜像就像一个运维版本的pom文件，记住pom可以继承，也可以依赖别的pom，最底层都依赖jdk的rt.jar，对docker来说也一样，底层依赖的都是linux内核。

Docker镜像都是只读的（就像我们不能改别人的jar代码），当容器启动时，一个新的可写层被加载到镜像的顶部。这一层通常被称作“容器”（类似新建了一个maven项目，定义好了pom依赖），“容器层”之下的都叫“镜像层”。

容器 ，类似于java对象

1从面向对象角度
Docker利用容器(Container)独立运行的一个或一组应用，应用程序或服务运行在容器里面，容器就类似于一个虚拟化的运行环境，容器是用镜像创建的运行实例。就像是Java中的类和实例对象一样，镜像是静态的定义，容器是镜像运行时的实体。容器为镜像提供了一个标准的和隔离的运行环境，它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台。

2从镜像容器角度
可以把容器看做是一个简易版的Linux环境（包括root用户权限、进程空间、用户空间和网络空间等）和运行在其中的应用程序。

常用命令

镜像相关命令

docker search

从镜像仓库（Docker Hub）中查找镜像。

#查找镜像名或描述里包含java并且收藏数大于10的镜像
docker search -f stars=10 java

docker pull

pull Pull an image or a repository from the docker registry server#从 docker镜像源服务器拉取指定镜像或者库镜像。
从镜像仓库（Docker Hub）中拉取或者更新指定镜像，类似于npm的install、git的pull。

#拉取最新的mysql镜像
docker pull mysql:latest
#拉取5.6版本的mysql镜像
docker pull mysql:5.6

镜像查找顺序

docker run或者docker pull 命令首先查找本地的镜像，然后查找公有库的镜像。

docker images

images List images #列出当前所有镜像

参数说明：
-a :列出本地所有的镜像（含中间映像层，默认情况下，过滤掉中间映像层）；
--digests :显示镜像的摘要信息；
-f :显示满足条件的镜像；
--format :指定返回值的模板文件；
--no-trunc :显示完整的镜像信息；
-q :只显示镜像ID。

docker images
docker images --digests
docker images -q
docker images ls

容器相关命令

docker run

run Run a command in a new container#创建一个新的容器并运行一个命令
格式

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

使用镜像生产容器实例。
OPTIONS参数说明：
-a: 指定标准输入输出内容类型，可选 STDIN/STDOUT/STDERR 三项；

-d: 后台运行容器，并返回容器ID，即启动守护式容器

-i: 以交互模式运行容器，通常与 -t 同时使用；

-P: 随机端口映射，容器内部端口随机映射到主机的端口

-p: 指定端口映射，格式为：主机(宿主)端口:容器端口
一共有以下四种格式：
ip:hostPort:containerPort
ip::containerPort
hostPort: containerPort
containerPort

-t: 为容器重新分配一个伪输入终端，通常与 -i 同时使用；

--name: 为容器指定一个名称；

--dns: 指定容器使用的DNS服务器，默认和宿主一致；

--dns-search : 指定容器DNS搜索域名，默认和宿主一致；

-h: 指定容器的主机名；

-e : 设置环境变量，如-e username="xxx"；

--env-file: 从指定文件读入环境变量；

--cpuset: 绑定容器到指定CPU运行，如-cpuset="0-2" 或者--cpuset="0,1,2"；

-m :设置容器使用内存最大值；

--net: 指定容器的网络连接类型，支持 bridge/host/none/container: 四种类型；

--link: 添加链接到另一个容器；

--expose: 开放一个端口或一组端口；

--volume , -v: 绑定一个卷

#运行mysql容器简易格式
docker run -p 宿主机端口:容器内端口 -e MYSQL_ROOT_PASSWORD="密码" -d 镜像名
#运行mysql:5.6镜像，用宿主机3307端口绑定容器3306端口，传入环境变量MYSQL_ROOT_PASSWORD="123456"，并获取返回的容器ID
docker run -p 3307:3306 -e MYSQL_ROOT_PASSWORD="123456" -d mysql:5.6

#使用镜像nginx:latest以交互模式启动一个容器,在容器内执行/bin/bash命令。
docker run -it nginx:latest /bin/bash

#使用镜像tomcat:latest以daemon（后台）模式启动一个容器
docker run -d -p 8080:8080 tomcat:latest

docker exec

exec Run a command in an existing container#在已存在的容器上运行命令。

参数说明：
-d:分离模式: 在后台运行
-i:即使没有附加也保持STDIN 打开
-t:分配一个伪终端

#在容器中以交互模式执行容器内/root/mysh.sh脚本
docker exec -it 容器ID或者容器Name /bin/sh /root/mysh.sh
#在容器中开启一个交互模式的终端
docker exec -it 容器ID或者容器Name /bin/bash
#在容器中运行ls -l并返回结果，并不真的进入容器。
docker exec -t 容器ID或者容器Name ls -l /tmp

docker attach

attach Attach to a running container #当前 shell下 attach连接指定运行镜像
和docker exec类似。
区别：
attach
直接进入容器启动命令的终端，不会启动新的进程。
exec
是在容器中打开新的终端，并且可以启动新的进程。

docker start、docker stop、docker restart

start Start a stopped containers#启动一个或多个已经被停止的容器
stop Stop a running containers#停止一个运行中的容器
restart Restart a running container#重启运行的容器
pause Pause all processes within a container#暂停容器

数据卷相关命令

docker volume

管理容器数据卷。

#列出数据卷
docker volume ls

#只删除数据卷，如果还有容器引用该数据卷，则删除失败。
docker volume rm 数据卷名

#删除所有未被使用的数据卷，不指定名称。
docker volume prune

查询信息相关命令

docker system

管理docker

参数说明：
df 显示docker磁盘使用情况
events 从服务器获取实时事件
info 显示整个系统的信息
prune 删除未使用的数据

一般只用docker system df，其他都用不上。

docker system df

docker ps

ps List containers #列出容器列表
列出正在运行的容器（默认），加-a参数显示全部容器不管是否正在运行，加-q参数只显示容器ID。

docker ps 容器

用于查看容器的整体运行信息，和linux里的ps类似。
格式：

docker ps 容器ID

docker logs

logs Fetch the logs of a container#输出当前容器日志信息

docker logs -f -t -tail 显示的行数 容器ID

-t是加入时间戳
-f跟随最新的日志打印
-tail数字显示最后多少条

示例：

#查看容器最新的200行日志
docker logs -t -f --tail 200 3ba7fb9a7016

docker top

top Lookup the running processes of a container#查看容器中运行的进程信息，和linux里的top类似。
格式：

docker top 容器ID

docker inspect

inspect Return low- level information on a container#查看容器详细信息
查看容器内部结构信息，返回一个层级结构的json。

docker inspect 容器ID

管理镜像和容器相关命令

docker rm、docker rmi

docker rm：删除一个或多个容器
docker rmi：删除一个或多个镜像

docker cp

cpCopy files/ folders from the containers filesystem to the host path#从容器中拷贝指定文件或者目录到宿主机中

docker cp 容器ID:容器内路径  目的主机路径

#拷贝文件至文件夹中
docker cp 80b9a3588ab9: /tmp/yum.log /root
#拷贝文件内容至文件中
docker cp 80b9a3588ab9: /tmp/yum.log /root/backyum.log

cp命令还可以将宿主机的文件拷贝到容器中

docker cp 目的主机路径 容器ID:容器内路径

docker kill

kill Kill a running container#强行停止运行某个容器

docker kill 容器ID

docker build

build Build an image from a Dockerfile #使用 Dockerfile 创建镜像。

参数说明：
--build-arg:设置镜像创建时的变量；

--cpu-shares :设置 cpu 使用权重；

--cpu-period :限制 CPU CFS周期；

--cpu-quota :限制 CPU CFS配额；

--cpuset-cpus :指定使用的CPU id；

--cpuset-mems :指定使用的内存 id；

--disable-content-trust :忽略校验，默认开启；

-f :指定要使用的Dockerfile路径；

--force-rm :设置镜像过程中删除中间容器；

--isolation :使用容器隔离技术；

--label :设置镜像使用的元数据；

-m :设置内存最大值；

--memory-swap :设置Swap的最大值为内存+swap，"-1"表示不限swap；

--no-cache :创建镜像的过程不使用缓存；

--pull :尝试去更新镜像的新版本；

--quiet, -q :安静模式，成功后只输出镜像 ID；

--rm :设置镜像成功后删除中间容器；

--shm-size :设置/dev/shm的大小，默认值是64M；

--ulimit :Ulimit配置。

--squash :将 Dockerfile 中所有的操作压缩为一层。

--tag, -t: 镜像的名字及标签，通常 name:tag 或者 name 格式；可以在一次构建中为一个镜像设置多个标签。

--network: 默认 default。在构建期间设置RUN指令的网络模式

示例：
准备好Dockerfile文件：
文件名：Dockerfile和.dockerignore，内容如下：

FROM centos:latest
VOLUME ["/dataVolume1", "/dataVolume2"]
CMD echo "HelloWord, --------success1"
CMD /bin/bash

文件名：.dockerignore，内容如下：

*

将这两个文件用ssh上传到宿主机的某个目录，我是新建并丢到了/vmhost
然后运行：

docker build -f /vmhost/Dockerfile -t mytest/centos:latest .

不要落掉结尾的"."。
运行：

 docker run -it --privileged=true mytest/centos /bin/bash

docker commit

commit Create a new image from a container changes#提交当前容器为新的镜像

docker commit -m="提交的描述信息" -a="作者" 容器ID 要创建的目标镜像名:[标签名]

1.pulltomcat镜像到本地并成功运行
2.故意删除上一步镜像生产tomcat容器的文档
3.也即当前的tomcati运行实例是一个没有文档内容的容器，以它为模板commit一个没有doc的tomcat新镜像my/tomcat01

docker commit -m="tzc" -a="tzc" tomcat8000 test/tomcat:myfull

4.启动我们的新镜像并和原来的对比

其他命令

createCreate a new container #创建一个新的容器，同run,但不启动容器
diff Inspect changes on a container’’ s filesystem#查看 docker容器变化
events Get real time events from the server#从 docker服务获取容器实时事件
history Show the history of an image#展示一个镜像形成历史
info Display system-wide information#显示系统相关信息
export Stream the contents of a container as a tar archive#导出容器的内容流作为一个tar归档文件[对应 import]
import Create a new filesystem image from the contents of a tarball i#从tar包中的内容创建一个新的文件系统映像[对应 export]
load Load an image from a tar archive#从一个tar包中加载一个镜像[对应save]
login Register or Login to the docker registry server#注册或者登陆一个 docker源服务器
logout Log out from a Docker registry server#从当前 Docker registry退出
port Lookup the public.- facing port which is NAT- ed to PRIVATE_PORT#查看映射端口对应的容器内部源端口
push Push an image or a repository to the docker registry server#推送指定镜像或者库镜像至 docker源服务器
rm Remove one or more containers#移除一个或者多个容器
rmi Remove one or more images#移除一个或多个镜像[无容器使用该镜像才可删除，否则需删除相关容器才可继续或-f强制删除]
save Save an image to a tar archive#保存一个镜像为一个tar包[对应load]
search Search for an image on the Docker Hub#在 docker hub中搜索镜像
tag Tag an image into a repository#给源中镜像打标签
unpause Unpause a paused container #取消暂停容器
version Show the docker version informatior#査看 docker版本号
wait Block until a container stops, then print its exit code#截取容器停止时的退出状态值

更多的命令参见官方文档：
https://docs.docker.com/engine/reference/commandline/docker/
以及菜鸟教程：
https://www.runoob.com/docker/docker-command-manual.html

以后台模式运行容器会导致容器自杀

使用镜像 centos: latest以后台模式启动一个容器
docker run -d centos
问题：然后 docker ps-a进行查看，会发现容器已经退出
很重要的要说明的一点： Docker在容器后台运行，就必须有一个前台进程.
容器运行的命令如果不是那些一直挂起的命令（比如运行top,tail),就是会自动退出的。
这个是 dockerl的机制问题，比如你的web容器，我们以 nginx为例，正常情况下，我们配置启动服务只需要启动响应的 service即可。例如
service nginx start
但是，这样做， nginx为后台进程模式运行，就导致 dockeri前台没有运行的应用，
这样的容器后台启动后，会立即自杀因为他觉得他没事可做了.
所以，最佳的解决方案：
一、将你要运行的程序以前台进程的形式运行。
二、让容器持续性干活，让docker感知它还在工作。

docker run -d centos /bin/sh -c "while true; do echo hello zzyy; sleep 2; done"

容器数据卷

Docker容器产生的数据，如果不通过 docker commit生成新的镜像，使得数据做为镜像的一部分保存下来，那么当容器删除后，数据自然也就没有了。为了能保存数据在 docker中我们使用数据卷，有点像redis的rdb、aof持久化。

卷就是目录或文件，存在于一个或多个容器中，由 docker挂载到容器，但不属于联合文件系统，因此能够绕过 Union File System提供
一些用于持续存储或共享数据的特性：
卷的设计目的就是数据的持久化，完全独立于容器的生存周期，因此 Docker不会在容器删除时删除其挂载的数据卷。
特点：
1.数据卷独立于容器
2.数据卷的生命周期和容器无关，数据卷的生命周期一直持续到没有容器使用它为止
3.数据卷可在容器之间共享或重用数据
4:卷中的更改可以直接生效
5:数据卷中的更改不会包含在镜像的更新中
6.容器能完成主机到容器和容器到主机的文件共享

结论：容器之间配置信息的传递，数据卷的生命周期一直持续到没有容器使用它为止

一般配合docker run命令一起使用。

格式：

docker run -v 宿主机绝对路径:容器内绝对路径:读写模式（默认可读可写）

读写模式：

:ro只读，只允许主机的数据单向传输给容器，不允许容器内修改。
rw可读可写。

示例：

docker run -d -p 3306:3306 --privileged=true -v "C:/Users/tang8/.docker/mydata/mysql/log":"/var/log/mysql" -v "C:/Users/tang8/.docker/mydata/mysql/data":"/var/lib/mysql" -v "C:/Users/tang8/.docker/mydata/mysql/conf":"/etc/mysql/conf.d" -e MYSQL_ROOT_PASSWORD="123456" --name mysql mysql:latest

docker run -d -p 3306:3306 --privileged=true -v "C:/Users/tang8/.docker/mydata/mysql/log":"/var/log/mysql" -v "C:/Users/tang8/.docker/mydata/mysql/data":"/var/lib/mysql" -v "C:/Users/tang8/.docker/mydata/mysql/conf":"/etc/mysql/conf.d" -e MYSQL_ROOT_PASSWORD="123456" --name mysql mysql:latest

继承数据卷：
在docker run命令上增加参数--volumes-from 容器ID，那么此次运行的容器即可和volumes-from指定的容器共享所有数据卷。

--volumes-from 容器ID或容器名称

docker run -d -p 3306:3306 --privileged=true --volumes-from 000xxx --name mysql mysql:latest

如何删除数据卷：

删除容器时将数据卷一并删除，如果还有别的容器引用该数据卷，则删除失败。

docker rm -v 容器ID|数据卷名

只删除数据卷，如果还有容器引用该数据卷，则删除失败。

docker volume rm 数据卷名

删除所有未被使用的数据卷，不指定名称。

docker volume prune

DockerFile

dockerfile类似于maven的pom.xml，可以说是非常像。
镜像就是使用maven build指定的pom.xml文件生成的结果，一般是jar或者war。
容器就像运行的jar、war。

规则

1:每条保留字指令都必须为大写字母且后面要跟随至少一个参数
2:指令按照从上到下，顺序执行
3:#表示注释
4:每条指令都会创建一个新的镜像层，并对镜像进行提交

流程

(1) docker，从基础镜像运行一个容器
(2) 执行一条指令并对容器作出修改
(3) 执行类似docker commit的操作提交一个新的镜像层
(4) docker再基于刚提交的镜像运行一个新容器
(5) 执行 dockerfile中的下一条指令直到所有指令都执行完成

保留关键字

FROM

继承自哪个镜像。
docker提供了一下基础镜像（如scratch），类似于java的rt.jar.java.lang.Object.java。

MAINTAINER

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

RUN

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

EXPOSE

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

WORKDIR

指定在创建容器后，终端默认登陆的进来工作目录

ENV

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

ENV MY_PATH /usr/mytest
这个环境变量可以在后续的任何RUN指令中使用，这就如同在命令前面指定了环境变量前缀一样；
也可以在其它指令中直接使用这些环境变量，比如： WORKDIR$MY_PATH

ADD

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

COPY

将从构建上下文目录中<源路径>的文件/目录复制到新的一层的镜像内的<目标路径>位置

VOLUME

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

CMD

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

CMD指令
CMD容器启动命令
CMD指令的格式和RUN相似，也是两种格式：
shell格式：CMD<命令>
exec格式：CMD["可执行文件"，"参数1"，"参数2"…]
参数列表格式：CMD["参数1"，"参数2"…]。在指定了 ENTRYPOINT指令后，用CMD指定具体的参
数。

ENTRYPOINT

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

ONBUILD

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

案例

#配置默认进入的目录
ENV MYPATH /usr/local
WORKDIR SMYPATH

#配置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

推送镜像到阿里云

1.进入实例列表界面
https://cr.console.aliyun.com/cn-hangzhou/instances
点击创建个人实例
设置Registry登录密码

2.进入镜像列表
点击创建仓库镜像
选本地仓库

3.在创建好的镜像列表中，点击你刚刚创建的那个镜像的“镜像名称”或者“管理”进入基本信息页面。

4.在基本信息页面根据阿里云的操作说明进行操作即可。