docker之常用命令、自定制镜像、公(私)仓库的上传和下载

一、docker入门

1、介绍

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

KVM, Virtualbox, Vmware是虚拟出机器，让每个实例看到一个单独的机器；而Docker是虚拟出操作系统，实现应用之间的隔离，让各个应用觉得自己有一个自己的操作系统，而且彼此之间隔离。

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

 

2、为什么要用docker

首先要知道在实际中，我们如何解决项目部署的环境配置的问题呢？

1. 解决方案1,使用虚拟机
使用vmware的克隆功能，vmware支持一个模板克隆
首先准备一个vmware系统模板，装好一些必要的环境，例如：python3 mysql redis nginx等等，
然后基于这个模板，克隆生成新的系统，在新的系统上可以根据项目需要的继续配置不同的环境，
也就是，基于同一个镜像，同一个系统模板，可以生成 N 个系统实例。

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

虚拟机的缺点：
1,资源占用多
虚拟机会独占一部分内存和硬盘空间。它运行的时候，其他程序就不能使用这些资源了。哪怕虚拟机里面的应用程序，真正使用的内存只有 1MB，虚拟机依然需要几百 MB 的内存才能运行。

2,冗余步骤多
虚拟机是完整的操作系统，一些系统级别的操作步骤，往往无法跳过，比如用户登录。

3,启动慢
启动操作系统需要多久，启动虚拟机就需要多久。可能要等几分钟，应用程序才能真正运行。

 

2. 解决方案2，使用linux容器
Linux容器不是模拟一个完整的操作系统，而是对进程进行隔离。在正常进程的外面套了一个保护层，对于容器里面进程来说，它接触的资源都是虚拟的，从而实现和底层系统的隔离。

docker是linux的一种容器。

优点
1,启动快
容器里面的应用，直接就是底层系统的一个进程，而不是虚拟机内部的进程。所以，启动容器相当于启动本机的一个进程，而不是启动一个操作系统，速度就快很多。

2,资源占用少
容器只占用需要的资源，不占用那些没有用到的资源；虚拟机由于是完整的操作系统，不可避免要占用所有资源。另外，多个容器可以共享资源，虚拟机都是独享资源。

3,体积小
容器只要包含用到的组件即可，而虚拟机是整个操作系统的打包，所以容器文件比虚拟机文件要小很多。
总之，容器有点像轻量级的虚拟机，能够提供虚拟化的环境，但是成本开销小得多。

 

3、docker与传统虚拟机对比

特性	容器	虚拟机
启动	秒级	分钟级
硬盘使用	一般为MB	一般为GB
性能	接近原生	弱
系统支持量	单机支持上千个容器	一般几十个

 

4、虚拟机和docker容器的架构

1. 虚拟机

 

2. 容器

 

3. 虚拟机+容器

 

docker的每个容器都相当于一个微型的操作系统，它占用的资源非常少，
因此在一个系统上可以开启非常多的docker实例。

 

二、Docker的初步使用

1、docker三大概念

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

1. docker镜像(image)
Docker镜像就是一个只读的模板。
例如：一个镜像可以包含一个完整的CentOS操作系统环境，里面仅安装了Apache或用户需要的其他应用程序。
就相当于我们以前买的那些dvd装机的碟，你用这个碟可以给你的电脑装上win7 10 等系统，系统自带了一些软件，
暴风影音，QQ等，然后装好系统后，我们需要什么，我们还能自己下载，比如LOL、跑跑卡丁车之类的。

有了镜像后，就可以用镜像来创建Docker容器。
Docker提供了一个很简单的机制来创建镜像或者更新现有的镜像，用户甚至可以直接从其他人那里下载一个已经做好的镜像来直接使用。

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


2. docker容器(container)
image和container的关系，就像面向对象程序设计中的 类和实例一样，镜像是静态的类（class），容器是镜像运行时的实体（实例化的对象object）

Docker利用容器来运行应用。

容器是从镜像创建的运行实例。它可以被启动、开始、停止、删除。每个容器都是相互隔离的，保证安全的平台。

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

镜像
容器实例1=镜像()
容器实例2=镜像()
容器实例3=镜像()
容器实例4=镜像()
容器实例5=镜像()

注意：镜像是只读的，容器在启动的时候创建一层可写层作为最上层。


3. docker仓库(repository)
仓库是集中存放镜像文件的场所。有时候把仓库和仓库注册服务器（Registry）混为一谈，并不严格区分。
实际上，仓库注册服务器上往往存放着多个仓库，每个仓库中又包含了多个镜像，每个镜像有不同的标签(tag)。

仓库分为公开仓库(Public)和私有仓库(Private)两种形式。

最大的公开仓库是Docker Hub，存放了数量庞大的镜像供用户下载。国内的公开仓库包括Docker Pool等，可以提供大陆用户更稳定快读的访问。

当用户创建了自己的镜像之后就可以使用push命令将它上传到公有或者私有仓库，这样下载在另外一台机器上使用这个镜像时候，只需需要从仓库上pull下来就可以了。

注意：Docker仓库的概念跟Git类似，注册服务器可以理解为GitHub这样的托管服务。

 

2、CentOS安装docker

官方提供的安装方式：
https://docs.docker.com/install/linux/docker-ce/centos/#upgrade-docker-after-using-the-convenience-script

 

总结官方教程如下

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 \
  lvm2

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

3.安装docker社区版
sudo yum install docker-ce

4.启动关闭docker
systemctl start/stop/restart/status docker

5.查看docker版本
docker version 

 

3、Docker镜像加速器

修改docker的镜像加速器,daocloud公司推出的加速工具
1.一句命令生成docker加速地址
curl -sSL https://get.daocloud.io/daotools/set_mirror.sh | sh -s http://f1361db2.m.daocloud.io

2.好像有一个坑，请修改配置文件 /etc/docker/daemon.json
改成如下配置即可(默认在最后有个逗号，去掉即可，如果没有，请忽略以下步骤)
{"registry-mirrors": ["http://f1361db2.m.daocloud.io"]}

3.重启docker
systemctl restart docker 

 

4、注意

docker容器必须有后台进程在运行，如果docker容器内没有任务在运行中，容器就退出
docker容器必须有后台进程在运行，如果docker容器内没有任务在运行中，容器就退出
docker容器必须有后台进程在运行，如果docker容器内没有任务在运行中，容器就退出

 

5、docker run

docker run ：创建一个新的容器并运行一个命令

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

OPTIONS说明：

• -d: 后台运行容器，并返回容器ID；

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

• -t: 为容器重新分配一个伪输入终端，通常与 -i 同时使用；
• --name="zbj": 为容器指定一个名称；
• -a stdin: 指定标准输入输出内容类型，可选 STDIN/STDOUT/STDERR 三项；

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

• -p: 指定端口映射，格式为：主机(宿主)端口:容器端口

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

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

• -h "mars": 指定容器的hostname；

• -e username="ritchie": 设置环境变量；

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

• --cpuset="0-2" or --cpuset="0,1,2": 绑定容器到指定CPU运行；

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

• --net="bridge": 指定容器的网络连接类型，支持 bridge/host/none/container:<name|id> 四种类型；

• --link=[]: 添加链接到另一个容器；

• --expose=[]: 开放一个端口或一组端口；

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

实例
# 使用docker镜像centos以 后台模式 启动一个容器, 并将容器命名为mycentos。
docker run --name mycentos -d centos

# 使用镜像centos以 后台模式 启动一个容器,并将容器的80端口映射到主机随机端口。
docker run -P -d centos

# 使用镜像 centos，以 后台模式 启动一个容器,将容器的 80 端口映射到主机的 80 端口,主机的目录 /data 映射到容器的 /data。
docker run -p 80:80 -v /data:/data -d centos

# 绑定容器的 8080 端口，并将其映射到本地主机 127.0.0.1 的 80 端口上。
$ docker run -p 127.0.0.1:80:8080/tcp ubuntu bash

# 使用镜像centos以 交互模式启动一个容器,在容器内执行/bin/bash命令。
root@aliyunzbj:~$ docker run -it centos /bin/bash
[root@44026fe3420e /]# 

docker start 容器id  # 启动这个容器
docker stop  容器id  # 停止这个容器的运行
docker kill  容器id  # 停止这个容器的运行

docker rm 容器id  # 删除这个容器

 

6、docker的基本示例

1. 示例1

docker search  hello-docker  # 搜索docker镜像 ，就是去 docker hub搜索 hello-docker

docker pull hello-world        # 下载公网的，docker镜像

docker  image ls  # 查看本地的镜像有哪些
docker  images     # 这两条命令一样的,docker进行了很多的命令升级，不用慌

docker run  hello-world   # 运行一个docker镜像，产生一个容器实例

docker  container  ls  # 列出所有正在运行的容器(因为hello world一跑完就退出了，一退出，容器也就退出了)

docker  ps  -a    # 列出所有曾经运行过的容器记录，以及正在运行的容器记录
CONTAINER ID        IMAGE               COMMAND             CREATED              STATUS
容器ID                镜像                命令                创建时间                 状态

 

2. 示例2

创建一个可交互的容器

"""
docker run xxx : 创建一个新的容器
docker exec xxx : 进入一个已存在的容器
"""

# 查找centos仓库
docker search centos

# 下载cnetos镜像
docker pull  centos

# 创建一个新的容器，且以交互式的方式进入容器
docker run -itd centos /bin/bash

# 查看容器ID或者名字
docker ps -a
# 结果
CONTAINER ID        IMAGE               COMMAND             CREATED                STATUS                     NAMES
b367c2c29aac        centos            "/bin/bash"        6 seconds ago     Exited (0) 2 seconds ago     ecstatic_chebyshev

# 启动容器
docker start ecstatic_chebyshev
或者
docker start b367c2c29aac

# 容器是有自己的微型操作系统的。微型linux
docker exec -it  b367c2c29aac  /bin/bash
    exec  # 进入容器的参数
    -i    # 交互式的操作容器
    -t    # 开启一个terminel终端，用于和linux交互
    b367c2c29aac   # docker容器的id
    /bin/bash  # 指定docker容器，用shell解释器交互
    
或者
docker exec -it  ecstatic_chebyshev  /bin/bash

# 退出容器
exit

 

3.示例3

# 运行一个在后台的任务
docker run -d centos /bin/sh -c "while true;do echo hello-docker; sleep 1;done"
    -d        # 后台运行容器
    /bin/sh   # 指定使用centos的bash解释器
    -c        # 运行一段shell命令
    "while true;do echo hello-docker; sleep 1;done"   # 在linux后台，每秒中打印一个hello-docker

docker  ps  -a  # 列出所有曾经运行过的容器记录，以及正在运行的容器记录

docker  logs  -f  容器id  #不间断打印容器的日志信息 

 

三、docker命令详解

1、参数和命令汇总

1. 参数

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  #打印版本信息并退出

 

2. 命令

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  #截取容器停止时的退出状态值

 

 

2、一些常用的命令

0.启动关闭docker
# 开启/停止/重启/查看docker状态
systemctl start/stop/restart/status docker

# 查看docker版本
docker version 

1.搜索镜像
docker search  hello-docker  # 搜索docker镜像 ，就是去 docker hub搜索 hello-docker

2.下载镜像
docker pull hello-world        # 下载公网的，docker镜像

3.查看本地镜像
docker  image ls  # 查看本地的镜像有哪些
docker  images    # 这两条命令一样的,docker进行了很多的命令升级，不用慌

4.基于镜像开启新的容器
# 下载cnetos镜像
docker pull  centos

# 运行一个docker镜像，产生一个容器实例
docker run  hello-world
docker run  centos  # 注意：没有镜像的情况下，直接run，系统会自动帮我们去下载一个镜像

# 创建一个新的容器，并运行在在linux后台，每秒中打印一个hello-docker
docker run -d centos /bin/sh -c "while true;do echo hello-docker; sleep 1;done"
    -d        # 后台运行容器
    /bin/sh   # 指定使用centos的bash解释器
    -c        # 运行一段shell命令
    "while true;do echo hello-docker; sleep 1;done"

# 创建一个新的容器，且以交互式的方式进入容器
docker run  -it  centos  /bin/bash
    -i    # 交互式的操作容器
    -t    # 开启一个terminel终端，用于和linux交互

# 启动一个bash终端,允许用户进行交互
docker run --name mydocker -it centos /bin/bash

5.查看正在运行的容器
docker  container  ls  # 列出所有正在运行的容器(因为hello world一跑完就退出了，一退出，容器也就退出了)

6.查看所有运行过的容器
docker  ps  -a    # 列出所有曾经运行过的容器记录，以及正在运行的容器记录
CONTAINER ID        IMAGE               COMMAND             CREATED         STATUS     NAMES
容器ID              镜像                命令                创建时间         状态      容器名

7.查看容器日志
docker  logs  -f  容器id  #不间断打印容器的日志信息 

8.进入已有的容器
# 容器是有自己的微型操作系统的。微型linux
docker exec -it  ee0  /bin/bash
    exec  # 进入容器的参数
    -i    # 交互式的操作容器
    -t    # 开启一个terminel终端，用于和linux交互
    ee0   # docker容器的id
    /bin/bash  # 指定docker容器，用shell解释器交互

exit  # 退出容器terminel终端

9.开始/停止容器
docker start  容器id  # 开始运行这个容器
docker kill  容器id   # 停止这个容器的运行
docker stop  容器id   # 停止这个容器的运行
docker stop  `docker ps -aq`  # 停止所有正在运行的容器


10.删除容器记录
docker rm  容器id  # 删除这个容器
docker ps -aq  # 列出所有容器记录的id
docker rm `docker ps -aq`    #一次性删除所有容器记录

11.删除镜像(必须删除依赖这个镜像的容器记录)
docker rmi 镜像id/镜像名
docker rmi -f 镜像id/镜像名  # -f 强制删除
docker images -aq  # 列出所有本地镜像id
docker rmi  `docker images -aq`   #一次性删除所有本地的镜像记录

12.查看系统的版本信息
cat /etc/os-release  # 查看系统的版本信息(通用)
cat /etc/redhat-release  # 查看红帽系列的系统(不是红帽系列的系统查看不到信息)

 

四、docker一些操作

1、基于一个容器，自定制我们的镜像

就是你pull一个镜像到本地，新建一个容器后，你可以在容器内进行一些环境的配置，
然后根据这个容器，产生一个新的镜像，那么当你需要这套环境的时候就可以直接使用这个新的镜像创建容器了。

这里只是为了演示，下载官方的centos镜像，创建的容器默认是没有vim编辑器的，
我们就给这个容器下载vim编辑器，然后形成我们自己的镜像。

步骤如下：

1.基于centos镜像，创建一个容器，在容器安装一个vim工具
# 开启新容器，并以交互式的方式进入容器
docker run  -it  centos  /bin/bash
# 在容器空间内装vim
yum install vim -y 

2.退出当前容器，容器由于没有后台任务，立即挂掉，但是我们可以提交这个容器为新的镜像
# 退出容器
exit
# 查看之前运行的容器的id
docker -ps -a
# 提交当前容器为新的镜像
docker commit 容器id  形成的镜像名
docker commit f00d48 zbj/centos-vim

3.查看已提交的镜像记录
docker images

4.测试
# 基于这个拥有vim的镜像，创建新的容器
docker run -it 镜像名/镜像id  /bin/bash
docker run -it zbj/centos-vim /bin/bash
docker run -it 11c150 /bin/bash
# 看能否使用vim
vim
# 退出容器
exit

5.导出当前系统的镜像文件，可以传输给其他人
docker save zbj/centos-vim  > /opt/centos-vim.tar.gz

6.查看是否生成了镜像文件 
ls /opt

7.其他人或者自己可以导入这个镜像文件
# 导入镜像
docker load < /opt/centos-vim.tar.gz
# 查看镜像导入情况
docker images

 

2、让外部可以访问容器(暴露端口)

0.training/webapp 这个镜像文件生成的容器是什么
这个作者构建webapp镜像
    1.基于ubuntu 14.04的操作系统
    2.默认进入了/opt/webapp目录
    3.在这个目录下存放了Procfile  app.py  requirements.txt  tests.py
    4.通过容器内的命令，运行一个后台程序  python  app.py 
    5.最终这个镜像，生成了一个web容器
    6.数据挂载 
        -v  宿主机的文件夹:容器内的文件夹
        -p  端口映射  宿主机的端口:容器内的端口
    7.  docker port  82e  查看容器的端口映射关系

也就是说我们基于这个镜像，运行了一个flask web app


容器中可以运行网络应用，但是要让外部也可以访问这些应用，可以通过-p或-P参数指定端口映射。
-P  随机映射端口到容器开放的网络端口
-p  指定映射端口，格式：   物理机的端口:容器内暴露的端口
然后我们通过浏览器访问物理机的端口，就可以访问到 容器 开启的应用


1.下载一个web应用的镜像
docker pull training/webapp

2.随机映射端口到容器开放的网络端口
docker run -d -P training/webapp python app.py

3.查看物理机映射到容器的端口
docker ps -a
# 看PORTS这个参数
CONTAINER ID  ....             PORTS                  
d2bcc0c57ba1  ....   0.0.0.0:32768->5000/tcp

4. 用浏览器访问
你的ip:32768

5.指定服务器的9000端口，映射到容器内的5000端口
docker run -d -p 9000:5000 training/webapp python app.py

6.用浏览器访问
你的ip:9000

 

3、发布docker镜像到docker hub(公有的仓库)

1.登录docker hub仓库，注册一个用户，用于存放自己的docker镜像
网址：https://hub.docker.com/

2.在linux中登录docker
docker login  # 输入账号密码

3.修改本地镜像的tag，推送到docker hub
注意：
    要保证image的tag是 账户名/仓库名 的形式，如果镜像tag不对，需要改一下tag,不然会说你没有权限。

语法：
    docker tag 本地镜像名  账户名/仓库名[:TAG]

docker tag hello-world 573190041/docker-test  # 生成新的镜像

4.推送本地镜像到公有仓库
语法：
    docker push 账户名/仓库名:TAG  # TAG可不写,不写默认是latest

docker push 573190041/docker-test
docker push 573190041/docker-test:latest

5.任何人都可以随意下载这个镜像
# 删除本地的镜像，测试
docker rmi hello-world
docker rmi 573190041/docker-test
# 从公有仓库下载
docker pull 573190041/docker-test

 

4、搭建私有docker仓库，提交本地镜像

上面那种镜像仓库是公开的，其他人都是可以下载的，并不安全，因此还可以使用docker registry官方提供的私有仓库

1.下载一个docker官方私有仓库镜像
docker pull registry

2.运行一个docker私有容器仓库
# 私有仓库会被创建在容器的/var/lib/registry下

docker run -d -p 5000:5000 -v /opt/data/registry:/var/lib/registry  registry
    -d  后台运行 
    -p  端口映射  5000:5000
        把容器内的5000端口映射到物理机的5000端口
    -v  数据卷挂载  /opt/data/registry :/var/lib/registry 
        把容器内的私有仓库/var/lib/registry映射到物理机本地的/opt/data/registry
    registry  镜像名

3.检查启动的registry容器
docker ps

4.测试连接容器
# ping通常是用来检查网络是否通畅或者网络连接速度的命令，而telnet是用来探测指定ip是否开放指定端口的。
yum install telnet
telnet 192.168.3.16 5000

5.修改docker的配置文件，让他支持http方式，上传私有镜像
vim /etc/docker/daemon.json
写入如下内容
{
"registry-mirrors": ["http://f1361db2.m.daocloud.io"],
"insecure-registries":["192.168.3.16:5000"]
}

6.修改docker的服务配置文件
vim /lib/systemd/system/docker.service
# 找到[service]这一代码区域块，写入如下参数
[Service]
EnvironmentFile=-/etc/docker/daemon.json

7.重新加载docker服务
systemctl daemon-reload

8.重启docker服务
注意：
    重启docker服务，所有的容器都会挂掉
    重启docker服务，所有的容器都会挂掉
    重启docker服务，所有的容器都会挂掉
# 重启docker服务
systemctl restart docker
# 查看之前运行的容器，找到registry容器的ID，重启这个容器
docker ps -a
# 重启registry
docker start c25

9.修改本地镜像的tag标记，往自己的私有仓库推送
语法：
    docker tag 镜像名 私有仓库地址:端口/自定义tag名

# 修改tag
docker tag 573190041/docker-test  192.168.3.16:5000/zbj

# 推到私有仓库
docker push 192.168.3.16:5000/zbj

10.由于docker registry没有web项目，但是提供了API数据
官网教程：https://docs.docker.com/registry/spec/api/#listing-repositories

linux输入命令：curl http://192.168.3.16:5000/v2/_catalog
或者浏览器访问：http://192.168.3.16:5000/v2/_catalog
可查看到你上传的私有镜像

11.删除本地镜像，下载私有仓库的镜像
docker pull 192.168.3.16:5000/zbj

 

5、Dockerfile介绍

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

 1. 初级

FROM centos # 使用base image基础镜像，尽量使用官方的image作为base image
FROM ubuntu:14.04 # 带有tag的base image


LABEL version=“1.0” # 容器元信息，帮助信息，Metadata，类似于代码注释
LABEL maintainer=“zzz"


WORKDIR /root # 相当于linux的cd命令，改变目录，尽量使用绝对路径！！！不要用RUN cd
WORKDIR /test # 如果没有就自动创建

RUN touch a.txt  # RUN是万能命令，RUN后面跟你要操作的命令。创建a.txt文件
RUN pwd     # 打印当前绝对路径

ADD and COPY 
ADD hello /  # 把本地文件添加到镜像中，把本地的hello可执行文件拷贝到镜像的/目录
ADD test.tar.gz /  # ADD自带解压功能，添加到根目录并解压

WORKDIR /root
ADD test.tar.gz test/  # 进入/root/ 添加test.tar.gz压缩包到到test目录下，并解压
COPY test.tar.gz test/  # 等同于上述ADD效果，但是不会解压test.tar.gz

ADD与COPY
   -优先使用COPY命令
   -ADD除了COPY功能还有解压功能
添加远程文件/目录使用curl或wget

ENV # 环境变量，尽可能使用ENV增加可维护性
ENV MYSQL_VERSION 5.6 #设置一个mysql常量
RUN yum install -y mysql-server=“${MYSQL_VERSION}” 

 

2. 中级

VOLUME and EXPOSE 
存储和网络

RUN and CMD and ENTRYPOINT
RUN：执行命令并创建新的Image Layer
CMD：设置容器启动后默认执行的命令和参数
ENTRYPOINT：设置容器启动时运行的命令

Shell格式
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指令
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”]


FROm centos
ENV name Docker
#CMD ["/bin/bash","-c","echo hello $name"]
ENTRYPOINT ["/bin/bash","-c","echo hello $name”]

 

6、利用Dockerfile自定制镜像

1.创建工作目录，并准备一段flask代码
mkdir -p /opt/dockertest/
cd /opt/dockertest/

touch flasktest.py
# 内容如下
from flask import Flask
app=Flask(__name__)
@app.route('/')
def hello():
    return "you are a good 8"
if __name__=="__main__":
    app.run(host='0.0.0.0',port=8080)

 

2.构建Dockerfile的思路
    1,指引一个基础的系统镜像centos 
    2,定义作者标签
    3,解决环境依赖关系，安装python-setuptools  # 就是下载python的包管理工具
    4,安装flask模块  easy_install  flask 
    5,准备代码文件到容器中   COPY  flasktest.py   /opt/ 
    6,切换到/opt目录下 workdir  /opt 
    7,暴露端口
    8,运行代码  python flasktest.py 
    
3.Dockerfile内容如下
touch Dockerfile  # Dockerfile文件必须叫这个
内容如下：
FROM centos
LABEL maintainer="自定制我的镜像"
RUN yum install python-setuptools -y 
RUN  easy_install flask 
COPY  flasktest.py   /opt/
WORKDIR /opt
EXPOSE 8080  
CMD ["python","flasktest.py"]

4.构建镜像文件，找到当前目录的Dockerfile，开始构建
docker build -t  zbj/flask-web  /opt/dockertest
    
5.基于这个镜像，生成容器实例,映射一个端口供外部访问
docker images  # 查看生成了镜像没有
docker run -d -p  8888:8080  zbj/flask-web

6.测试
# 检查运行的容器
docker container ls

# 用浏览器访问 
你的服务器ip:8888

7.推送这个镜像到私有仓库
docker tag  zbj/flask-web  192.168.3.16:5000/zbj-flaskweb
docker push 192.168.3.16:5000/zbj-flaskweb