Docker

虚拟化概念

传统的虚拟化技术

虚拟化，是指通过虚拟化技术将一台计算机虚拟为多台逻辑计算机。在一台计算机上同时运行多个逻辑计算机，每个逻辑计算机可运行不同的操作系统，并且应用程序都可以在相互独立的空间内运行而互不影响，从而显著提高计算机的工作效率。

随着硬件厂商的不断发展,很多在虚拟机里面的指令不需要通过虚拟的硬件层走到真正的硬件层.硬件厂商是支持直接在虚拟机里面实用指令操作硬件,这个技术我们就称为是硬件辅助的虚拟化.这种硬件的辅助虚拟化比起软件虚拟的硬件层来说,他不需要模拟所有的硬件.有些指令是直接运行在虚拟机上来操作硬件的.性能和效率比传统的虚拟化高更高些.

容器级别的虚拟化

特点: 1 不需要模拟硬件层 2共享同一个宿主机的内核

传统虚拟化和容器虚拟化的区别

	传统虚拟化	容器虚拟化
创建速度	很慢	非常快
性能消耗	通过对于硬件层模拟,增加了系统调用链的环节,有性能损耗	共享内核,几乎没有性能消耗
资源消耗	很大	很小,一台机器可以轻松创建多个容器
操作系统覆盖	支持Linux,Window,Mac等	仅仅是内核所支持的OS

初识Docker

Docker是什么

​ Docker是一个用来装应用的容器，就好比杯子用来装水，笔筒用来装笔，书包用来装书一样，你可以把hello world放到Docker里，你可以把网站放到Docker里，你可以把你想的到的任何程序放到Docker里。
Docker的思想

Docker 的思想来源于集装箱，集装箱最大的作用在于能够将货品标准化，在运输的过程中，不需要直接装载和卸载各种各样的商
品，而是统一标准的集装箱，这样装载和卸载的环节就可以实现流水线和自动化了，并且商品封装在集装箱中，没有暴露在外面，
提高安全性，集装箱与集装箱之间也是互相隔离，不会有任何相互影响的问题。我们也不再需要专门的船去运输专门的货品，只要
货品在集装箱内好好封存着，那就可以使用一艘大船将他们都运走。并且你可以很方便的将集装箱装载到飞机、轮船、货车、火
车，大大的提高了运输的便利性。

对于我们来说，Docker 也担任了集装箱类似的角色，我们的应用或者所依赖的第三方服务可以理解为货品，而 Docker 则是将我们的货品规范化管理起来，从而可以轻易的完成产品交付，环境转移等等诸多问题。还有我们的货品由Docker这个集中箱封装，对外隔离，提高安全性。并且 Docker 对于主机资源的消耗非常小，可以实现对服务器资源的最大利用!
Docker 解决了哪些问题？

1. 组织有序性
    以传统的方式部署你的应用，可能出现由于多个应用程序的依赖不同，导致应用之间的依赖变得非常混乱，若此时出现两个应
用依赖同一个程序但却依赖不同版本，便会出现让人比较头痛的问题，使用Docker便可以很方便的帮我们管理各个应用的依赖，
并以容器为基础将应用的运行环境独立开来，从而不会互相影响，还能提高资源利用率。

2. 便携性
    另一问题是，以传统的方式部署你的应用，如果我们的应用如果后期需要迁移（这里的迁移包括相同操作系统和不同操作系统
的迁移），还是需要做大规模的集群，都是一件工作量非常大的操作。而容器化了的应用，对这些操作都是非常方便的。

3. 安全性
    最后一个不得不提的问题就是安全，以传统的方式部署你的应用，如果该应用被攻击者攻击，或者因为程序自身的bug，又或
是运行环境多个应用间混乱的依赖关系导致的问题，这样的话，你的服务器系统安全危险级别会很高，因为这些问题将直接影响你
的系统安全。但如果你的应用是运行在Docker容器中，那么一切的危害都会被隔离在容器内，因为容器的资源跟系统是隔离的，
危害将被降到最低。

Docker VS VM
Docker 的核心是 基于 LXC（Liunx container） 技术的实现，可以理解为一个轻量级的虚拟机（实际上是容器的概念，Docker 不是虚拟机），Docker 使用 Linux 的 namespace 和 cgroups 技术实现容器隔离与资源限制。

类别	Docker	VM
操作系统	与宿主机共享 操作内核	在宿主机 OS 运行虚拟机 OS部署难度非常简单
启动速度	秒级	分钟级
部署难度	非常简单	组件多, 部署复杂
执行性能	和物理系统几乎一致	VM 会占用一些资源
镜像体积	镜像是 MB 级别	虚拟机镜像是 GB 级别
管理效率	管理简单	组件相互依赖, 管理复杂
隔离性	比较弱	彻底

Docker 的应用场景

面向产品：
    产品的交付模式改变
面向开发：
    个人开发环境发生改变
面向运维：
    获得比虚拟机性能损失更小的解决方案
    可以更快的进行自动化扩容（VM 是分钟级扩容，Docker 是秒级）
    Docker 适用于微服务架构
面向测试：
    同一环境下多版本测试

自动化、微服务、大规模集群（微博红包案例）百度的 Paas 平台、等等...
应用场景扩展：http://www.docker.org.cn/docker/151.html
docker中文学习网: http://www.docker.org.cn

Docker的基本概念

Docker 的基本概念：
​ Docker 有三大重要的概念：仓库、镜像、容器

仓库（Repository)

仓库是用于存放镜像的地方，类似于 Maven 仓库、Git 仓库等用途，仓库之上还有仓库注册服务器（Registry）的概念，上面存放着多个仓库，每个仓库中又有多个镜像，而每个镜像又可以有多个标签（tag）。目前最大的公开仓库是 Docker Hub，我们可以使用类似 Git 命令的方式去 pull/push 镜像

镜像（Image)

可以理解为一个只读的模板，镜像可以用来创建容器，一个镜像可以创建多个容器，你可以直接从官方仓库（docker hub）或者其他私服仓库拉取（pull）想要的镜像，或通过 Dockerfile 来构建属于你自己的镜像，这一切操作都非常的简单images:lastest

容器（Container)

容器是由镜像创建的实例，他可以被启动、停止、运行、删除。每个容器之间是互相隔离的、保证安全的平台。可以把容器看做为一个简单的 Linux 环境

安装Docker

Docker 的安装相对来说也算比较简单，咱们使用 CentOS7 来安装 Docker，不过 Docker 官方要求 CentOS 操作系统内核必须在 3.10 以上，所以我们这边使用 CentOS7 来安装；
PS：可以使用 uname -r 来查看当前系统的内核版本

基于 CentOS7 的安装步骤如下:
    1. 更新 yum 仓库，确保 yum 包都是最新版本
        yum update
    2. 查看是否有安装 docker，若有则将其删除
        yum list installed|grep docker
        yum remove docker...... # 如果有的话则删除对应的包
    3. 安装需要的软件包，yum-util 提供 yum-config-manager 功能，另外两个是 devicemapper 驱动依赖的
        yum install -y yum-utils device-mapper-persistent-data lvm2
    4. 设置 yum 源
        yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    5. 查看仓库中所有 docker 版本，选择你需要的版本安装
        yum list docker-ce --showduplicates | sort -r
    6. 安装 docker        
        ==================== 安装20版本
        yum install docker-ce-20.10.9-3.el7 docker-ce-cli-20.10.9-3.el7 containerd.io  -y
        
    7. 设置 docker 开机自动启动
        systemctl start docker # 启动 docker 服务端
        systemctl enable docker # 启用 docker 服务开机自启
    8. 校验 docker 是否启动成功
        docker version

配置容器加速工具
访问阿里云:https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

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

配置内容

{
    "registry-mirrors": [
        "https://docker.m.daocloud.io",
        "https://dockerproxy.com",
        "https://docker.mirrors.ustc.edu.cn",
        "https://docker.nju.edu.cn",
        "https://rbw25ox1.mirror.aliyuncs.com"
    ]
}

sudo systemctl daemon-reload
sudo systemctl restart docker

渡渡鸟
https://docker.aityp.com/

容器基本操作

启动一个新容器:
	docker run IMAGE [COMMAND] [ARGS...]
	run 命令解释.
	1. 命令会检测当前要运行的镜像在本地存不存在,若不存在他会自动 pull 下来再运行
  2. 运行后会启动一个容器, 并且开启一个文件系统, 你可以直接在容器内创建文件夹. 运行一个指定的程序, 当程序退出后, 容器也就退出了
  3. 运行时的容器无法删除, 只能停止后删除, 或者加上 -f 参数强制删除
  centos:版本
	示例: docker run centos echo 'hello docker'
	     docker run --name wolfcode-centos centos echo 'hello docker'

启动守护式容器:
	docker run -i -t IMAGE /bin/bash
		-i --interactive=true|false 默认是false:允许你对容器内的标准输入 (STDIN) 进行交互
		-t --tty=true|false 默认是false:在新容器内指定一个伪终端或终端
	示例: docker run -i -t centos /bin/bash
	使用exit退出守护式容器.

查看容器:
	docker ps [-a] [-l]
		-a:表示列举所有的容器
		-l :表示列举最近创建的容器.	
	默认情况容器在运行之后就停止了,ps只是显示正在运行的容器.

查看容器详细信息:
	docker inspect [容器名字|容器唯一标识]
	要查看容器详细信息,需要输入很长串的字母.
	docker允许用户自定义容器的名字:
		docker run --name=自定义名 -i -t IMAGE /bin/bash
	查看容器的ip地址
		docker inspect 27-web-03 | grep IPAddress

重新启动停止的容器:
	docker start [-i] 容器名

删除停止的容器:
	docker rm 容器名	
	只能删除停止的容器,但是不能删除正在运行中的容器.
	docker rm $(docker ps -aq)

守护式容器

我们之前的学习,大多是容器都是在创建好之后就关闭了.在真实的案例中,我们需要长期运行的容器提供服务.这就是docker的守护式容器.
特点:
​ 能长期运行
​ 没有交互式会话
​ 适合运行应用程序和服务.

以守护形式运行容器:
	启动容器:docker run -i -t IMAGE /bin/bash
	退出但不关闭容器:ctrl+p+q

附加到运行中的容器:
    进入到原来的容器的进程中,执行的还是原来的命令
	docker attach 容器名 

启动守护式容器:
    1 进入容器中
    2 在容器的内部去启动命令
    3 退出容器的时候要以守护式启动

	docker run -d 镜像名 [COMMAND] [ARG...]   
	示例:docker run --name dc1 -d centos /bin/sh -c "while true; do echo helloworld;sleep 1;done"

查看容器日志:
	docker logs [-f] [-t] [--tail] 容器名
		-f --follow=true|false 默认为false 一致跟踪日志的变化,并返回结果
		-t --timestamps=true|false 默认为false 在返回的结果上加上时间戳
		--tail = “all” 返回后几行的日志数据.
    案例:
      docker logs  -t 8fa19e27655
查看容器内进程:
	docker top 容器名

在运行中的容器内启动新进程:
	docker exec [-d] [-i] [-t] 容器名 [COMMAND] [ARG...]
	示例:docker exec -i -t dc1 /bin/bash

停止守护式容器:
	docker stop 容器名 :发送一个信号给容器,等待容器的关闭.
	docker kill 容器名 :直接停止容器.

部署静态网站

设置容器的端口映射:

run [-P] [-p]
	-P , --publish-all=true|false 默认为false :将为容器所有暴露的端口进行映射.
	      示例:docker run -P -i -t centos /bin/bash
	-p, --publish=[] :给指定的端口进行映射.
	     方式一:containerPort
	           示例:docker run -p 80 -i -t centos /bin/bash
	     方式二:hostPort:containerPort
	           示例:docker run -p 8080:80 -i -t centos /bin/bash

Nginx部署流程

Nginx部署流程
	创建映射80端口的交互式容器
	安装Nginx
	安装文本编辑器vim
	创建静态页面
	修改Nginx配置文件
	运行Nginx
	验证网站访问

步骤:
	1.创建一个守护式容器,并映射容器的80端口.
	    docker run -p 80 --name=nginx-demo -it centos /bin/bash
	2.进入容器后,需要安装nginx和vim,执行如下命令:
		# 1. 备份旧repo
        mv /etc/yum.repos.d /etc/yum.repos.d.bak
        mkdir -p /etc/yum.repos.d

        # 2. 下载阿里CentOS8 vault源
        curl -o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-vault-8.5.2111.repo

        # 3. 清理缓存，重建元数据
        yum clean all && yum makecache
	
	  3  安装ngin 依赖
	    yum install -y epel-release 
	  4 安装nginx
	    yum install -y nginx
	    
	  重要目录位置
	    /usr/sbin/nginx
	    /usr/share/nginx/html
	    /etc/nginx/nginx.conf
	    
	3.在容器内部,进入到/usr/share/nginx/html 目录,修改index.html文件
	    vi index.html
	    
	    配置文件位置 /etc/nginx/nginx.conf

	4.运行nginx命令,启动服务 /usr/sbin/nginx
	5.Ctrl+P和Ctrl+Q退出容器.
	6.在宿主机上使用curl命令查看是否能访问.
	    curl http://127.0.0.1:32769/index.html

其他问题:

其他问题:
	1.使用docker inspect 容器名可以查看容器的ip地址.
	2.在宿主机中使用容器的ip也是能访问到该静态页面的.
	3.使用docker stop 容器名 关闭容器.
	4.使用docker start 容器名 启动容器.
	5.使用docker top 容器名,发现重新启动容器后,nginx服务并没有重新启动.
	6.我们可以使用docker exec 容器名 nginx 来启动容器中的nginx服务. docker exec -it web1 /usr/sbin/nginx
	7.我们发现使用原来的端口映射已经访问不到了,当重新启动容器会重新给我们进行端口的映射.

Docker的镜像和仓库

Docker Image镜像:
​ 容器的基石

列出镜像:
	docker images [OPTIONS] [REPOSITORY]
	-a, --all=false :表示列举出所有的镜像.默认并不显示中间层的镜像.
	-f, --filter=[] :表示添加过滤条件.
	--no-trunc=false:表示对信息进行截断.默认情况是会截断镜像的唯一id的.
	-q, --quiet=false:表示值显示镜像的唯一id

REPOSITORY 仓库: 是一切镜像的集合.
REGISTRY 注册仓库:包含REPOSITORY 的仓库.
TAG 标签:我们之前运行的centos默认使用的是lastest的标签.仓库名+镜像名就能唯一确定一个镜像.
如果使用docker images -a 看到没有仓库名和标签名的其实是中间层镜像.
查看镜像:
	docker inspect [OPTIONS] CONTAINER|IMAGE [CONTAINER|IMAGE...]
	示例:docker inspect 49f796
删除镜像:
	docker rmi [OPTIONS] IMAGE [IMAGE...]
	-f, --force=false :表示强制删除镜像.
	--no-proune=false :会保留未被打标签的父镜像.
	删除对应仓库所有的镜像:docker rmi  $(docker images -q centos)

获取和推送镜像

Docker中REGISTER仓库有些类似Maven的中央仓库.我们通过类似Git中的pull和push命令从REGISTER仓库中拉取镜像和推送镜像.
查找镜像:
	方式一:
	              Docker Hub    https://hub.docker.com/
	方式二:
	              docker search [OPTIONS] TERM
                                          --no-trunc=false : 截断操作
                                          -s,--starts=0 : 每个镜像都会有star,我们可以通过-s操作来限定star数.
	             一次最多返回25条记录.
拉取镜像:
	docker pull [OPTIONS] NAME [:TAG]
	-a, --all-tags=false :会把所有仓库中标记的镜像下载到本地中
	示例:docker pull ubuntu:14.04

推送镜像:
	docker push 镜像名.
	步骤:
		1.注册hub的账号.
		2.登陆hub的账号.docker login
		3.使用push命令推送到hub中
		    docker push fjl0720/commit_test1

补充操作过程

1\登录阿里云网站 
2\个人实例的固定密码
   个人实例中-->访问凭证-->设置密码
3\登录后,点击控制台,进入容器镜像服务 -->实例列表 -->个人实例-->
4\新增命名空间
5\新增镜像仓库
6\点击 新建的仓库 --> 管理  12345abc
   找到推送脚本
   $ sudo docker login --username=linhaifengnih**** registry.cn-hangzhou.aliyuncs.com
    $ sudo docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/wolfcode-w/wolfcode-w:[镜像版本号]
    $ sudo docker push registry.cn-hangzhou.aliyuncs.com/wolfcode-w/wolfcode-w:[镜像版本号]
    注意: 这里面 linhaifengnih**** 改为用户名全称. 
         [ImageId] 这是要推送的镜像id
         [镜像版本号] 表示镜像版本号,可以自定义.如1.0
 7\执行三个脚本命令, 在仓库的镜像版本中查看上传的镜像.
 
 如果是拉取镜像 
 	docker pull registry.cn-hangzhou.aliyuncs.com/wolfcode-w/wolfcode-w:[镜像版本号]
 
 如果支付宝登录名是中文的处理方案:
    换一个方式登录就可以了. 如:淘宝,钉钉等.

构建镜像

构建镜像可以让我们保存对容器的修改,并再次使用.提供了自定义镜像的能力,以软件的形式打包并提供服务及其运行环境.
docker里面提供了两种方式来构建镜像:
	方式一:docker commit 通过容器构建
	方式二:docker build 通过Dockerfile文件构建.

使用commit构建镜像:
	docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]
	-a, --author=”” 指定镜像的作者.
	-m, --message=”” 提交信息,构建信息
	-p, --pause=true 默认情况在commit的时候会暂停容器,使用这个参数可以在构建的时候不暂停容器.
	步骤:
		1.创建一个容器并安装nginx服务
		docker run -it --name nginx-61  -p 80 centos /bin/bash
		2.在容器内部安装nginx,和之前步骤一样
		3.提交镜像.
		docker commit -a 'leo' 008654cb8501 nginx-68:404
		4.通过docker images命令可以看到我们刚构建的镜像.

		5.接下来我们就可以使用自己定义的镜像来启动容器.
		docker run -d  -p 80 wolfcode/nginx:v1.1 /usr/sbin/nginx -g "daemon off;"

使用DockerFile构建镜像

使用Dockerfile构建镜像:
	什么是Dockerfile文件呢?其实就是包含了一些执行命令的文本文件.

docker build [OPTIONS] PATH|URL|-
    --force-rm=false
    --no-cache=false
    --pull=false
    -q, --quiet=false
    -rm=true
    -t, --tag=””

步骤:
	1.在宿主机中,我们创建存放Dockerfile文件的目录和Dockerfile文件.
	    mkdir -p ~/65/01
	    cd ~/65/01
	    vi Dockerfile
	2.编写Dockfile文件
	    # First docker file for test
docker pull swr.cn-north-4.myhuaweicloud.com/ddn-k8s/docker.io/library/centos:centos7.9.2009

docker tag  swr.cn-north-4.myhuaweicloud.com/ddn-k8s/docker.io/library/centos:centos7.9.2009  docker.io/library/centos:centos7.9.2009


        FROM swr.cn-north-4.myhuaweicloud.com/ddn-k8s/docker.io/library/centos:latest
        MAINTAINER maomao "maomaocong@sy.wolfcode.cn"
        RUN mv /etc/yum.repos.d /etc/yum.repos.d.bak
        RUN mkdir -p /etc/yum.repos.d
        RUN curl -o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-vault-8.5.2111.repo
        RUN yum clean all && yum makecache
        RUN yum install -y epel-release
        RUN yum install -y nginx
        EXPOSE 80

	   
	3.使用build命令构建镜像.
	    docker build -t='镜像名称' Dockerfile 所在的目录
	    例如:
	    docker build -t='wolfcode/60-01:2.0' ~/60/01/
	4.通过我们构建好的镜像来创建容器.
	    docker run -d -p 80 581d1c49ab03 /usr/sbin/nginx -g "daemon off;"

DockerFile的指令

指令主要分为两种:
	注释 : # Comment
	指令 : INSTRUCTION argument

FROM:
	包含两种格式:
	1. FROM  <image>
	2. FROM  <image>:<tag>
	image要求是已经存在的镜像,我们也称为基础镜像.必须是第一条非注释指令

MAINTAINER:
	指定镜像的作者信息,包含镜像的所有者和联系信息.
RUN:
	指定当前镜像中运行的命令
	RUN  <command> (shell模式)
	        /bin/sh -c command
	        RUN echo hello

	RUN [“executable”,”param1”,”param2”] (exec模式)
                             RUN [“/bin/bash”,”-c”,”echo hello”]
                             /bin/bash -c echo hello
                             
	每个RUN命令都会在当前镜像的上层创建一个新的镜像来运行指令.
	
EXPOSE:
	指定运行该镜像的容器使用的端口.
	虽然我们在构建镜像的时候暴露了端口号,但是我们在运行容器的时候依然需要指定端口的映射.
	我们使用EXPOSE只是告诉Docker运行该镜像的容器会使用80端口,出于安全的考虑,docker并不会打开该端口.
	而是需要我们在使用该镜像运行容器的时候指定端口的映射.

CMD:
	CMD指令提供容器默认运行的命令,和之前讲的RUN指令类似.都是执行一个命令,但是RUN命令指定的命令是在镜像构建的过程运行的.
	CMD的命令是在容器运行的时候运行的.如果我们在docker run命令中指定运行的命令的时候,CMD的指令会被覆盖,默认命令就不会执行.
	CMD命令是指定容器启动的时候默认命令.
	两种模式.
	   CMD [“executable”,”param1”,”param2”] (exec模式)
	   CMD command param1 param2 (shell 模式)
 	   CMD [”param1”,”param2”] (作为ENTRYPOINT指令的默认参数.)

	通过构建的镜像来创建容器
	docker run -p 80 --name mao28-nginx -itd maomao/nginx-1  
	docker top cmd_test1
	发现已经启动nginx了.
	如果我们在启动的时候指定了参数,默认的CMD命令就会被覆盖了.
	
	
ENTRYPOINT:
	这个和我们刚刚讲的CMD指令非常相似,唯一的区别:不会给docker run的启动命令给覆盖.
	如果需要覆盖ENTRYPOINT的指令,需要在docker run使用docker run --entrypoint覆盖.
	ENTRYPOINT [“executable”,”param1”,”param2”] (exec模式)
	ENTRYPOINT command param1 param2 (shell 模式)
	docker build -t="fjl0720/df_test4" .
	docker run -p 80 --name ep_test1 -d lanxw0720/df_test4 
	docker ps -l
	可以发现,启动的容器依然使用的ENTRYPOINT指定的命令执行.

在宿主机中创建一个index.html文件 , 在构建镜像把我们宿主机的index.html文件把默认的首页文件替换掉
ADD:
    
	将文件和目录复制到使用dockerfile构建的镜像中.
	目标的来源可以本地的地址也可以是远程地址.
	如果是本地地址,本地地址必须是构建目录中的相对地址
	对于远程URL,docker并不推荐使用,更建议使用的是curl或者wget的命令来获取
	目标路径需要指定镜像中的绝对路径
	ADD <src>...<dest>
	ADD [“<src>”...”<dest>”](适用于文件路径有空格的情况)
	
COPY:	
	同上.
	COPY<src>...<dest>
	COPY[“<src>”...”<dest>”](适用于文件路径有空格的情况)
	
 	在Dockerfile所在目录添加index.html文件

	docker build -t="lanxw0720/df_test6" .
	docker run -p 80 --name add_test1 -d lanxw0720/df_test6
	curl http://127.0.0.1:32775

VOLUME:
	用于基于镜像创建的容器添加卷,一个卷可以存在一个或者多个容器的特定目录.这个目录可以绕过联合文件系统.提供共享数据和持久化数据的功能.(后面单独讲)
WORKDIR:
	WORKDIR /path/to/workdir
	这个指令从指令创建一个容器是,在容器内部设置工作目录.ENTRYPOINT和CMD的命令都会在这个目录下执行.
	我们也可以使用这个命令给后续的构建中指定工作目录.
	通常会使用绝对路径,如果使用了相对路径,那这个路径会一致传递下去.如下所示:
	WORKDIR /a
	WORKDIR b
	WORKDIR c
	RUN pwd
	结果====>/a/b/c

ENV:
	ENV <key>=<value>
	ENV <key>=<value>...
	这个指令主要是来设置环境变量,这个环境变量在构建过程中和运行过程中都有效.

USER:
	USER daemon
	指定镜像会以什么样的用户去运行.
	比如:USER nginx
	基于该镜像启动的容器就会以nginx的用户来运行.
	如果没有指定USER,容器会使用root用户来运行.
	
ONBUILD:
	ONBUILD [INSTRUCTION]
	镜像触发器.
	当一个镜像被其他镜像作为基础镜像时执行
	会在构建过程中插入指令
	示例:
	docker run -p 80 --name onbuild_test1 -d lanxw0720/df_test7
	curl http://127.0.0.1:32776
	发现在构建这个镜像的时候并没有执行COPY命令.
	接下来我们基于这个镜像来构建新的镜像.

	docker build -t="lanxw0720/df_test8" .
	docker run -p 80 --name onbuild_test2 -d lanxw0720/df_test8
	curl http://127.0.0.1:32777
	此时发现已经执行COPY命令了.

FROM swr.cn-north-4.myhuaweicloud.com/ddn-k8s/docker.io/library/centos:latest
MAINTAINER maomao "maomaocong@sy.wolfcode.cn"
RUN mv /etc/yum.repos.d /etc/yum.repos.d.bak
RUN mkdir -p /etc/yum.repos.d
RUN curl -o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-vault-8.5.2111.repo
RUN yum clean all && yum makecache
RUN yum install -y epel-release
RUN yum install -y nginx
ONBUILD RUN rm -rf /usr/share/nginx/html
ONBUILD ADD dist /usr/share/nginx/html
ENV username=maomao
ENV password=123321
ENTRYPOINT /usr/sbin/nginx -g "daemon off;"
EXPOSE 80

容器的数据管理

什么是数据卷(Data Volume):
​ 我们都知道Docker其中一个理念就是应用和环境打包.通常docker容器的生命周期都是和容器中的应用是一致的.而我们对数据的要求是持久化,另外docker容器之间也需要有一个共享数据的渠道.这些需求就催生了数据卷的需求.
​ 数据卷是经过特殊设计的目录,可以绕过联合文件系统(UFS),为一个或者多个容器提供访问.
​ 数据卷设计的目的,在于数据的永久化,它完全独立与容器的生命周期,因此Docker不会在容器删除的时候删除其关联的数据卷,也不会存在类似垃圾收集机制,对容器应用的数据卷进行处理.

通过上面这张图
​ 1.数据卷是独立于容器的存在,他存在于宿主机中.和容器是分离的.
​ 2.docker数据卷可以是文件或者目录.
​ 3.docker容器可以使用数据卷和宿主机进行数据的共享.
​ 4.同一个文件或者目录支持多个容器的访问.实现了容器间的数据共享和交换.
数据卷的特点:
​ 数据卷在容器启动时初始化,如果容器使用的镜像在挂载点包含了数据,这些数据会拷贝到新初始化的数据卷中.
​ 数据卷可以容器之间共享和重用.
​ 可以对数据卷里的内容直接进行修改.

为容器添加数据卷:
                       宿主机路径      容器内路径
       docker run -v ~/60/data:/data -it centos /bin/bash

为数据卷添加访问权限
       docker run -v  ~/datavolume:/data:ro -it centos /bin/bash

使用Dockerfile构建包含数据卷的镜像
Dockerfile指令:VOLUME[“/data”]
示例:
# Test

FROM centos
VOLUME ["/datavolume1"]
CMD /bin/bash

执行构建命令:docker build -t lanxw0720/dvt .
我们在容器启动的时候,我们在容器中指定的数据卷在容器中都会进行一次完整的初始化.根据镜像来创建的容器.使用的数据卷就没办法共享.当我们不能访问到本地目录时,我们怎么共享数据呢?

多容器管理（docker-compose）：

多容器管理（docker-compose）：
    前面讲了 Dockerfile 用来构建 Docker 镜像，那么 docker-compose 则是用来创建容器的。 Docker 有三个主要的功能：Build、Ship 和 Run，使用 docker-compose 可以帮我们在 Run 的层面解决很多实际问题。docker-compose 通过一个 yaml 模板文件来统一管理多个容器的配置，如网络、数据卷、执行指令、环境变量、资源限制等等。有了 docker-compose 我们便可以一键重启、关闭、删除、监控所有的 docker 服务，只需要一次配置，则可以对容器进行统一管理，那么此时我们则不必为了每次要运行一堆容器时写大量的命令而头疼。

    1. 安装 docker-compose：
    
    sudo curl -L "http://mirrors.aliyun.com/docker-toolbox/linux/compose/1.9.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
    
    要安装其他版本的 Compose，请替换 1.24.1。

	将可执行权限应用于二进制文件：
	sudo chmod +x /usr/local/bin/docker-compose
	创建软链：
	sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose
	测试是否安装成功：
    docker-compose --version

    2. 配置 docker-compose.yml 文件
        version: '2.1' # docker 的版本
        services: # 配置的容器列表
            CONTAINER_NAME: # 容器的名称
                image: BASE_IMAGE # 这个一个容器的基础镜像
                ports: # 你的容器需不需要做端口映射
                    - "host_port:container_port"
                volumes: # 数据卷配置
                    - host_dir:container_dir
                environment: # 环境变量（map 的配置方式 key: value）
                    PARAM: VALUE
                restart: always # 容器的重启策略
                dns: # dns 的配置
                    - "114.114.114.114"
    ------------------------------------------------------------------
                restart 容器的重启策略：
                    no：默认策略，在容器退出时不重启容器
                    on-failure：在容器非正常退出时（退出状态非0），才会重启容器
                    on-failure:3：在容器非正常退出时重启容器，最多重启3次
                    always：在容器退出时总是重启容器
                    unless-stopped：在容器退出时总是重启容器，但是不考虑在Docker守护进程启动时就已经停止了的容器

    3. 常用命令   必须在docker-compose.yml 文件所在的目录中
        docker-compose up -d # 启动所有服务并在后台运行
        docker-compose ps # 查看服务运行状态
        docker-compose restart # 重启所有服务
        docker-compose restart myApp # 重启 myApp 服务
        docker-compose start # 开启所有服务
        docker-compose start myApp # 开启 myApp 服务
        docker-compose stop # 停止所有服务
        docker-compose stop myApp # 停止 myApp 服务
        docker-compose rm # 删除所有服务
        docker-compose rm myApp # 删除 myApp fuwu