docker 最初是dotCloud公司创始人 Solomon Hykes 在法国期间发起的一个公司内部醒目,于 2013年 3 月以
Apache 2.0  授权协议开源, 主要项目代码在 GitHub上进行维护
Docker是linux容器的一种封装, 提供简易的容器使用接口,它是流行的Linux容器解决方案
docker 的接口相当简单, 用户可以方便的创建,销毁容器
docker 将应用程序和程序的依赖, 打包在一个文里面, 运行这个文件就会生成一个虚拟容器
程序运行在虚拟容器里, 如同在真实物理机上运行一样, 有了docker, 就不用担心环境问题了

web应用的自动化打包和发布
自动化测试和持续集成,发布
在服务型环境中部署和调整数据库或其他应用

但是虚拟机也是有局限性的,每一个虚拟机都是一个完整的操作系统,要分配系统资源,
虚拟机多到一定程度的时候,操作系统本身资源也就爱消耗殆尽,或者说必须扩展

更高效的利用系统资源
由于容器不需要进行硬件虚拟以及运行完整操作系统额外开销, Docker对系统资源利用率更高
无论是应用执行速度,内存损耗或者文件存储速度,都要比传统虚拟技术更高效,
因此,相比虚拟技术,一个配置的主机,往往可以运行更多数量的应用

更快速的启动时间
传统的虚拟技术启动应用服务往往需要数分钟,而docker容器应用.由于直接运行宿主机内核,
无需启动完整的操作系统,因此可以做到秒级,甚至毫秒级别的启动时间,
大大节约了开发,测试,部署的时间

一致的运行环境
开发过程中一个常见问题是环境一致性问题,
由于开发环境,测试环境,生产环境不一致,导致有些bug并未在开发过程中被发现
而docker的镜像提供了除内核外完整的运行环境,确保了应用运行环境一致性,从而不会再出现代码在本地测试没问题,测试有问题

持续交付和部署
对开发和运维(DevOps)人员来说，最希望的就是一次创建或配置，可以在任意 地方正常运行。
使用 Docker 可以通过定制应用镜像来实现持续集成、持续交付、部署。开发人员 可以通过 Dockerfile 来进行镜像构建，
并结合 持续集成(Continuous Integration) 系 统进行集成测试，
而运维人员则可以直接在生产环境中快速部署该镜像，甚至结合 持续部署(Continuous Delivery/Deployment) 系统进行自动部署。
而且使用 Dockerfile 使镜像构建透明化，不仅仅开发团队可以理解应用运行环 境，
也方便运维团队理解应用运行所需条件，帮助更好的生产环境中部署该镜像

更轻松的迁移
由于 Docker 确保了执行环境的一致性，使得应用的迁移更加容易。Docker 可以在 很多平台上运行，无
论是物理机、虚拟机、公有云、私有云，甚至是笔记本，其运 行结果是一致的。
因此用户可以很轻易的将在一个平台上运行的应用，迁移到另一 个平台上，而不用担心运行环境的变化导致应用无法正常运行的情况。

容器的三大概念:
镜像 image
容器 container
仓库 repository
docker整个生命周期就是这三个概念

Docker镜像就是一个只读的模板
例如:一个镜像可以包含一个完整的Centos操作系统环境,里面不仅安装了Apache或用户需要的其他应用程序
镜像可以用来创建Docker容器
Docker提供了一个简单的机制来创建镜像或者更新现有的镜像,用户甚至可以直接从其他人哪里
下载一个已经做好的镜像来直接使用

因为镜像包含完整的root文件系统,体积是非常庞大,因此docker在设计是按照Union FS的技术
将其设计为分层存储的架构
镜像不是IOS那种完整的打包文件,镜像只是一个虚拟概念,他不是一个完整的文件,
而是有由一组文件组成,或者多组文件西永联合组成

image和container的关系,就像面向对象编程中的类和实例一样, 镜像的静态的定义(class),
容器是镜像运行时的实体(object)
容器可以被创建,启动,停止,删除,暂停.
Docker利用容器来运行应用
容器是从镜像创建的运行实例,它可以被启动,开始,停止,删除,每个容器都是相互隔离的,
保证安全的平台
可以把容器看做是一个减一半的Linux环境(包括rroot用户权限,进程空间和网络空间等)
和运行在其中的应用程序
注意:镜像是只读的,容器在启动的时候创建一层可写层作为最上层

仓库是集中存放文件的场所,有时候把仓库和仓库注册服务器混为一谈
并不严格区分,实际上,仓库注册服务器上往往存放着多个镜像,每个镜像有不同的标签
仓库的公开仓库是(Public)和私有仓库(Private)两种形式
最大的公开仓库是Docker Hub ,存放了数量庞大的镜像功用户下载,国内的公开仓库包括Docker Pool等,可以提供大陆用户更稳定快读的访问
当用户创建了自己的镜像之后就可以使用push命令将它上传到公有或者私有仓库,这样下载在另外一态机器上使用这个镜像的时候,只需要从仓库中pul下来就可以了
注意:Docker仓库的概念跟Git类似,注册服务器可以理解为GitHub这样的托管服务

Docker Registry 公开服务是开放给用户使用,允许用户管理镜像的Registry服务, 一般这类服务允许用户免费上传,下载公开的镜像,并可能提供收费服务,功用户管理私有镜像
最常使用的Registey 公开服务是官方的Docker Hub,这也是默认的registry,并拥有哦大量高质量的官方镜像
出息之外,还有coreOS的Quay.ioCore相关的镜像存储在这里;Google的Google Container Registry.Ruberenetes 的镜像 使用的就是这个服务
由于某些原因,在国内访问这些服务可能会比较慢
国内的一些云服务商提供了针 对 Docker Hub 的镜像服务(Registry Mirror)，这些镜像服务被称为加速器。常见 的有 阿里云加速器、DaoCloud 加速器、灵雀云加速器等。
使用加速器会直接从国内的地址下载 Docker Hub 的镜像，比直接从官方网站下载速度会提高很多。在后 面的章节中会有进一步如何配置加速器的讲解。
国内也有一些云服务商提供类似于 Docker Hub 的公开服务。比如 时速云镜像仓 库、网易云镜像服务、DaoCloud 镜像市场、阿里云镜像库等。

1,写在旧版本
sudo yum remove docker\
                           docker-client\
                           docker-client-latest\
                           docker-common\
                           docker-latest\
                           docker-latest-logrotate\
                           docker-logrotate\
                           docker-selinux\
                           docker-engine-selinux\
                           docker-engine
2设置存储库
sudo yum install -y yum-utils\
   device-mapper-persistent-data\
   1vm2
sudo yum-config-manage\
        --add-repo\
       https://download.docker.com/linux/centos/docker-ce.repo
3,安装社区版
sudo yum install docker-ce
4,启动关闭docker
systemctl start docker

Docker 是一个开源的商业产品，有两个版本：社区版（Community Edition，缩写为 CE）和企业版（Enterprise Edition，缩写为 EE）。
企业版包含了一些收费服务，个人开发者一般用不到。本文的介绍都针对社区版。

docker最低支持centos7且在64位平台上，内核版本在3.10以上
[root@localhost ~ ]#uname -r
3.10.0-693.el7.x86_64

https"//www.daocloud.io/mirror # accelerator-doc
 
# 一条加速命令
curl -sSL https://get.daocoud.io/daotools/set_mirror.sh | sh -s https://95822026.m.daocloud.io

[root@docker ~]# docker --help
Usage:
docker [OPTIONS] COMMAND [arg...]
       docker daemon [ --help | ... ]
       docker [ --help | -v | --version ]
 
A
self-sufficient runtime for containers.
 
Options:
 
  --config=~/.docker              Location of client config files  #客户端配置文件的位置
  -D, --debug=false               Enable debug mode  #启用Debug调试模式
  -H, --host=[]                   Daemon socket(s) to connect to  #守护进程的套接字（Socket）连接
  -h, --help=false                Print usage  #打印使用
  -l, --log-level=info            Set the logging level  #设置日志级别
  --tls=false                     Use TLS; implied by--tlsverify  #
  --tlscacert=~/.docker/ca.pem    Trust certs signed only by this CA  #信任证书签名CA
  --tlscert=~/.docker/cert.pem    Path to TLS certificate file  #TLS证书文件路径
  --tlskey=~/.docker/key.pem      Path to TLS key file  #TLS密钥文件路径
  --tlsverify=false               Use TLS and verify the remote  #使用TLS验证远程
  -v, --version=false             Print version information and quit  #打印版本信息并退出
 
Commands:
    attach    Attach to a running container  #当前shell下attach连接指定运行镜像
    build     Build an image from a Dockerfile  #通过Dockerfile定制镜像
    commit    Create a new image from a container\'s changes  #提交当前容器为新的镜像
    cp    Copy files/folders from a container to a HOSTDIR or to STDOUT  #从容器中拷贝指定文件或者目录到宿主机中
    create    Create a new container  #创建一个新的容器，同run 但不启动容器
    diff    Inspect changes on a container\'s filesystem  #查看docker容器变化
    events    Get real time events from the server#从docker服务获取容器实时事件
    exec    Run a command in a running container#在已存在的容器上运行命令
    export    Export a container\'s filesystem as a tar archive  #导出容器的内容流作为一个tar归档文件(对应import)
    history    Show the history of an image  #展示一个镜像形成历史
    images    List images  #列出系统当前镜像
    import    Import the contents from a tarball to create a filesystem image  #从tar包中的内容创建一个新的文件系统映像(对应export)
    info    Display system-wide information  #显示系统相关信息
    inspect    Return low-level information on a container or image  #查看容器详细信息
    kill    Kill a running container  #kill指定docker容器
    load    Load an image from a tar archive or STDIN  #从一个tar包中加载一个镜像(对应save)
    login    Register or log in to a Docker registry#注册或者登陆一个docker源服务器
    logout    Log out from a Docker registry  #从当前Docker registry退出
    logs    Fetch the logs of a container  #输出当前容器日志信息
    pause    Pause all processes within a container#暂停容器
    port    List port mappings or a specific mapping for the CONTAINER  #查看映射端口对应的容器内部源端口
    ps    List containers  #列出容器列表
    pull    Pull an image or a repository from a registry  #从docker镜像源服务器拉取指定镜像或者库镜像
    push    Push an image or a repository to a registry  #推送指定镜像或者库镜像至docker源服务器
    rename    Rename a container  #重命名容器
    restart    Restart a running container  #重启运行的容器
    rm    Remove one or more containers  #移除一个或者多个容器
    rmi    Remove one or more images  #移除一个或多个镜像(无容器使用该镜像才可以删除，否则需要删除相关容器才可以继续或者-f强制删除)
    run    Run a command in a new container  #创建一个新的容器并运行一个命令
    save    Save an image(s) to a tar archive#保存一个镜像为一个tar包(对应load)
    search    Search the Docker Hub for images  #在docker
hub中搜索镜像
    start    Start one or more stopped containers#启动容器
    stats    Display a live stream of container(s) resource usage statistics  #统计容器使用资源
    stop    Stop a running container  #停止容器
    tag         Tag an image into a repository  #给源中镜像打标签
    top       Display the running processes of a container #查看容器中运行的进程信息
    unpause    Unpause all processes within a container  #取消暂停容器
    version    Show the Docker version information#查看容器版本号
    wait         Block until a container stops, then print its exit code  #截取容器停止时的退出状态值
 
Run \'docker COMMAND --help\' for more information on a command.  #运行docker命令在帮助可以获取更多信息

从仓库中获取镜像
管理本地主机的景象

从docker registry获取镜像的命令是docker pull。命令格式是：
docker pull [选项][docker registry地址] 仓库名:标签
docker register地址：地址的格式一般是 域名:端口，默认地址是docker hub
仓库名：仓库名是两段格式，用户名/软件名，如果不写用户，默认docker hub用户名是library，也就是官方镜像

docker是把应用程序和其依赖打包在image文件里面，只有通过这个镜像文件才能生成docker容器。
一个image文件可以生成多个容器实例。
image文件是通用，可以共享的，为了节省时间，我们尽量

# 列出所有image文件
docker image ls
# 删除image文件
docker image rm 镜像名

docker search centos   # 搜索所有的centos的docker镜像
INDEX                NAME(名称)                  DESCRIPTION(描述)                    STARS(下载次数)OFFICIAL(官方)        AUTOMATED(自动化)
docker.io           docker.io/centos         The official build of CentOS.        1781               [OK]
docker.io   docker.io/jdeathe/centos-ssh     CentOS-6 6.7 x86_64 /             14                                               [OK]

可以使用docker pull命令来从仓库获取所需要的镜像。下面的例子将从Docker Hub仓库下载一个Centos操作系统的镜像。
[root@docker ~]# docker pull centos  #获取centos镜像
[root@docker ~]# docker run -it centos /bin/bash  #完成后可以使用该镜像创建一个容器

镜像的ID唯一标识了镜像，如果ID相同,说明是同一镜像。
TAG信息来区分不同发行版本，如果不指定具体标记,默认使用latest标记信息。
[root@docker ~]# docker images  #查看docker镜像
REPOSITORY(来自那个仓库)       TAG(标签)            IMAGE ID(唯一ID)         CREATED(创建时间)         VIRTUAL SIZE(大小)
docker.io/centos                   latest              60e65a8e4030           5
days ago              196.6 MB
docker.io/nginx             latest              813e3731b203             13
days ago 

如果要移除本地的镜像,可以使用docker rmi命令(在删除镜像之前先用docker rm删除依赖于这个镜像的所有容器)。
注意docker rm 命令是移除容器。
[root@docker ~]# docker rmi imageID  #删除docker镜像

如果要导出镜像到本地文件,可以使用docker save命令。
[root@docker ~]# docker save centos > /opt/centos.tar.gz  #导出docker镜像至本地
[root@docker ~]# ll /opt/
-rw-r--r--.1 root root 204205056 12月 30 09:53 centos.tar.gz

可以使用docker load从本地文件中导入到本地docker镜像库
[root@docker ~]# docker load < /opt/centos.tar.gz   #导入本地镜像到docker镜像库
[root@docker~]# docker images  #查看镜像导入情况
REPOSITORY           TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
docker.io/centos     latest              60e65a8e4030        5 days ago          196.6 MB

启动容器有两种方式，一种是基于镜像新建一个容器并启动，另外一个是将在终止状态(stopped)的容器重新启动。
因为Docker的容器实在太轻量级了，很多时候用户都是随时删除和新创建容器。

所需要的命令主要为docker run
例如,下面的命令输出一个hehe,之后终止容器。
[root@docker ~]# docker run centos /bin/echo "hehe"  #这跟在本地直接执行 /bin/echo\'hehe\' 
hehe
 
[root@docker ~]# docker run --name mydocker -it centos /bin/bash#启动一个bash终端,允许用户进行交互。
[root@1c6c3f38ea07 /]# pwd
/
[root@1c6c3f38ea07 /]# ls
anaconda-post.log  bindev  etc  homelib  lib64  lost+foundmedia  mnt  optproc  root  runsbin  srv  systmp  usr  var
 
--name:给容器定义一个名称
-i:则让容器的标准输入保持打开。
-t:让Docker分配一个伪终端,并绑定到容器的标准输入上
/bin/bash:执行一个命令

检查本地是否存在指定的镜像，不存在就从公有仓库下载
利用镜像创建并启动一个容器
分配一个文件系统，并在只读的镜像层外面挂在一层可读写层
从宿主主机配置的网桥接口中桥接一个虚拟接口到容器中去
从地址池配置一个ip地址给容器
执行用户指定的应用程序
执行完毕后容器被终止

# 获取镜像 hello-world
docker pull hello-world
# 检查镜像
docker images
# 运行image文件,可以用容器id
docker run hello-world
# 检查docker容器进程
docker ps
# 检查所有运行的容器
docker ps -a 

[root@localhost ~ 15:58:14]#docker run -d centos /bin/sh -c "while true;do echo hello centos; sleep 1;done"
c0283f1077d16a2bf2597e269d51a02815334f7390f18a62ed7a4ba07f351b65
#检查容器进程
[root@oldboy_python ~ 15:58:22]#docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
c0283f1077d1        centos              "/bin/sh -c \'while..."   6 seconds ago       Up 5 seconds                            fervent_turing
[root@localhost ~ 15:58:28]#

1,我们进入交互式的centos容器中,发现没有vim命令
docker run -it centos
2, 在容器中,安装一个vim
yum install -y vim
3, 安装好vim以后,exit退出容器
exit
4, 查看刚才安装好vim的容器记录
docker container ls -a
5,提交这个容器,创建新的image
docker commit 059fdea031ba xuexue/centos-vim
6,查看镜像文件
docker images

#宿主机ip:32768 映射容器的5000端口
[root@localhost ~ 16:34:02]#docker ps -l
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS                     NAMES
cfd632821d7a        training/webapp     "python app.py"     21 seconds ago      Up 20 seconds       0.0.0.0:32768->5000/tcp   brave_fermi

#指定服务器的9000端口，映射到容器内的5000端口
[root@localhost ~ 16:46:13]#docker run -d -p 9000:5000 training/webapp python app.py
c0b5a6278d0f4f2e9b9eba8680451111d8b911b61de0c37ea64cb337aefb854e

[root@localhost ~ 16:49:05]#docker top c0b
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                3926                3912                0                   16:46               ?                   00:00:00            python app.py

镜像的定制就是定制每一层所添加的配置、文件。如果可以吧每一层修改、安装、构建、操作的命令都写入到一个脚本，用脚本来构建、定制镜像，这个脚本就是dockerfile。
Dockerfile 是一个文本文件，其内包含了一条条的指令(Instruction)，每一条指令 构建一层，因此每一条指令的内容，就是描述该层应当如何构建。

FROM scratch #制作base image 基础镜像，尽量使用官方的image作为base image
FROM centos #使用base image
FROM ubuntu:14.04 #带有tag的base image
LABEL version=“1.0” #容器元信息，帮助信息，Metadata，类似于代码注释
LABEL maintainer=“yc_uuu@163.com"
#对于复杂的RUN命令，避免无用的分层，多条命令用反斜线换行，合成一条命令！
RUN yum update && yum install -y vim \
    Python-dev #反斜线换行
RUN /bin/bash -c "source $HOME/.bashrc;echo $HOME”
WORKDIR /root #相当于linux的cd命令，改变目录，尽量使用绝对路径！！！不要用RUN cd
WORKDIR /test #如果没有就自动创建
WORKDIR demo #再进入demo文件夹
RUN pwd     #打印结果应该是/test/demo
ADD and COPY 
ADD hello /  #把本地文件添加到镜像中，吧本地的hello可执行文件拷贝到镜像的/目录
ADD test.tar.gz /  #添加到根目录并解压
WORKDIR /root
ADD hello test/  #进入/root/ 添加hello可执行命令到test目录下，也就是/root/test/hello 一个绝对路径
COPY hello test/  #等同于上述ADD效果
ADD与COPY
   - 优先使用COPY命令
    -ADD除了COPY功能还有解压功能
添加远程文件/目录使用curl或wget
ENV #环境变量，尽可能使用ENV增加可维护性
ENV MYSQL_VERSION 5.6 #设置一个mysql常量
RUN yum install -y mysql-server=“${MYSQL_VERSION}” 
------这里需要稍微理解一下了-------中级知识---先不讲
VOLUME and EXPOSE 
存储和网络
RUN and CMD and ENTRYPOINT
RUN：执行命令并创建新的Image Layer
CMD：设置容器启动后默认执行的命令和参数
ENTRYPOINT：设置容器启动时运行的命令
Shell格式和Exec格式
RUN yum install -y vim
CMD echo ”hello docker”
ENTRYPOINT echo “hello docker”
Exec格式
RUN [“apt-get”,”install”,”-y”,”vim”]
CMD [“/bin/echo”,”hello docker”]
ENTRYPOINT [“/bin/echo”,”hello docker”]
通过shell格式去运行命令，会读取$name指令，而exec格式是仅仅的执行一个命令，而不是shell指令
cat Dockerfile
    FROM centos
    ENV name Docker
    ENTRYPOINT [“/bin/echo”,”hello $name”]#这个仅仅是执行echo命令，读取不了shell变量
    ENTRYPOINT  [“/bin/bash”,”-c”,”echo hello $name"]
CMD
容器启动时默认执行的命令
如果docker run指定了其他命令(docker run -it [image] /bin/bash )，CMD命令被忽略
如果定义多个CMD，只有最后一个执行
ENTRYPOINT
让容器以应用程序或服务形式运行
不会被忽略，一定会执行
最佳实践：写一个shell脚本作为entrypoint
COPY docker-entrypoint.sh /usr/local/bin
ENTRYPOINT [“docker-entrypoint.sh]
EXPOSE 27017
CMD [“mongod”]
[root@master home]# more Dockerfile
FROm centos
ENV name Docker
#CMD ["/bin/bash","-c","echo hello $name"]
ENTRYPOINT ["/bin/bash","-c","echo hello $name”]

1.docker提供了一个类似于github的仓库dockerhub,
网址https://hub.docker.com/需要注册使用
2.注册docker id后，在linux中登录dockerhub
docker login
注意要保证image的tag是账户名，如果镜像名字不对，需要改一下tag
docker tag chaoyu/centos-vim yuchao163/centos-vim
语法是：  docker tag   仓库名   yuchao163/仓库名
3.推送docker image到dockerhub
docker push yuchao163/centps-cmd-exec:latest
4.在dockerhub中检查镜像
https://hub.docker.com/
5.删除本地镜像，测试下载pull 镜像文件
docker pull yuchao163/centos-entrypoint-exec

1.官方提供的私有仓库docker registry用法
https://yeasy.gitbooks.io/docker_practice/repository/registry.html
2.一条命令下载registry镜像并且启动私有仓库容器
私有仓库会被创建在容器的/var/lib/registry下，因此通过-v参数将镜像文件存储到本地的/opt/data/registry下
端口映射容器中的5000端口到宿主机的5000端口
docker run -d \
    -p 5000:5000 \
    -v /opt/data/registry:/var/lib/registry \
    registry
3.检查启动的registry容器
docker ps
4.测试连接容器
telnet 192.168.119.10 5000
5.修改镜像tag,以docker registry的地址端口开头
docker tag hello-world:latest 192.168.119.10:5000/hello-world:latest
6.查看docker镜像，找到registry的镜像
docker images
7.Docker 默认不允许非 HTTPS 方式推送镜像。我们可以通过 Docker 的配置选项来取消这个限制，这里必须写正确json数据
[root@master /]# cat /etc/docker/daemon.json
{"registry-mirrors": ["http://95822026.m.daocloud.io"],
"insecure-registries":["192.168.119.10:5000"]
}
写入到docker服务中，写入到[Service]配置块中，加载此配置文件
[root@master home]# grep \'EnvironmentFile=/etc/docker/daemon.json\' /lib/systemd/system/docker.service
EnvironmentFile=/etc/docker/daemon.json
8.修改了docker配置文件，重新加载docker
systemctl daemon-reload
9.重启docker
systemctl restart docker
10.重启了docker，刚才的registry容器进程挂掉了，因此重新启动它
docker ps -a
docker start 容器id
11.推送本地镜像
docker push 192.168.119.10:5000/hello-world
12.由于docker registry没有web节目，但是提供了API数据
官网教程：https://docs.docker.com/registry/spec/api/#listing-repositories
curl http://192.168.119.10:5000/v2/_catalog
或者浏览器访问http://192.168.119.10:5000/v2/_catalog
13.删除本地镜像，从私有仓库中下载
docker pull 192.168.119.10:5000/hello-world

确保app.py和dockerfile在同一个目录！
1.准备好app.py的flask程序
[root@master home]# cat app.py
from flask import Flask
app=Flask(__name__)
@app.route(\'/\')
def hello():
    return "hello docker"
if __name__=="__main__":
    app.run(host=\'0.0.0.0\',port=8080)
[root@master home]# ls
app.py  Dockerfile
2.编写dockerfile
[root@master home]# cat Dockerfile
FROM python:2.7
LABEL maintainer="Chao Yu<yc_uuu@163.com>"
RUN pip install flask
COPY app.py /app/
WORKDIR /app
EXPOSE 8080
CMD ["python","app.py"]
3.构建镜像image
docker build -t yuchao163/flask-hello-docker .
4.查看创建好的images
docker image ls
5.启动此flask-hello-docker容器，映射一个端口供外部访问
docker run -d -p 8080:8080 yuchao163/flask-hello-docker
6.检查运行的容器
docker container ls