zoukankan      html  css  js  c++  java
  • docker大全集

    1,什么是docker

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

    2,docker的应用场景

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

    3,为什么要用docker

    那我们先看以前是怎们部署项目的

    由于物理机的诸多问题,后来出现了虚拟机

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

    4,docker vs 传统虚拟机

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

    一般几十个

    5,环境配置的难题

    让开发人员最头疼的麻烦事之一就是环境配置,每台计算机的环境都不相同,应该如何确保自己的程序换一台机器能运行起来?

    用户必须确保的是:

    1. 操作系统的相同
    2. 各种平台库和组件的安装
    3. 例如python依赖包,环境变量等

    6,解决方案一 虚拟机

    虚拟机也可以制作模板,基于模板创建虚拟机,保证环境问题一致

    虚拟机(virtual machine) 就是带着环境安装的一种解决方案, 它可以在你一种操作系统里面运行另一种操作系统, 比如在Windows系统里面运行Linux系统,应用程序对此毫无感知,因为虚拟机看上去和真实系统一模一样, 而对于的底层来说,虚拟机就是一个普通文件,不需要了就删除掉, 对其他部分毫无影响.

    虽然用户可以通过虚拟机还原软件的原始环境,但是, 这个方案有几个缺点

    1. 资源占用多
      • 虚拟机会独占一部分内存和硬盘空间,它运行的时候,其他程序就不能使用这些资源了,哪怕虚拟机里面的应用程序,真正使用的内存只有1MB, 虚拟机依然需要几百MB的内存才能运行
    2. 冗余步骤多
      • 虚拟机是完整的操作系统,一些系统级别的操作步骤, 往往无法跳过.比如用户登录
    3. 启动慢
      • 启动操作系统需要多久, 虚拟机就急需要多久, 可能要等几分钟, 应用程序才能真正运行

    虚拟化的有点:

    1. 资源池-------一个物理机的资源分配到了不同的虚拟机里
    2. 很容易扩展------加物理机器or加虚拟机机
    3. 很容易云化--------亚马逊AWS, 阿里云等

    7,结觉方案二 Linux容器

    现在:自从用上docker容器后,可以实现开发,测试和生产环境的统一化和标准化

    镜像作为标准的交付件,可在开发,测试和生产环境上以容器来运行,最终实现三套环境上的应用以及运行所依赖内容的完全一致性

    Linux容器不是一个完整的操作系统,而是对进程进行隔离,在正常进程的外面套一个保护层,对于容器里面进程来说,它接触的资源都是虚拟的,从而实现底层系统的隔离

    Linux容器的优点:

    1. 启动快

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

    1. 资源占用少

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

    1. 体积下

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

    8,docker容器的优点:

    更高效的利用系统资源
    由于容器不需要进行硬件虚拟以及运行完整操作系统额外开销, Docker对系统资源利用率更高
    无论是应用执行速度,内存损耗或者文件存储速度,都要比传统虚拟技术更高效,
    因此,相比虚拟技术,一个配置的主机,往往可以运行更多数量的应用
    更快速的启动时间
    传统的虚拟技术启动应用服务往往需要数分钟,而docker容器应用.由于直接运行宿主机内核,
    无需启动完整的操作系统,因此可以做到秒级,甚至毫秒级别的启动时间,
    大大节约了开发,测试,部署的时间
    一致的运行环境
    开发过程中一个常见问题是环境一致性问题,
    由于开发环境,测试环境,生产环境不一致,导致有些bug并未在开发过程中被发现
    
    而docker的镜像提供了除内核外完整的运行环境,确保了应用运行环境一致性,从而不会再出现代码在本地测试没问题,测试有问题
    持续交付和部署
    对开发和运维(DevOps)人员来说,最希望的就是一次创建或配置,可以在任意 地方正常运行。
    使用 Docker 可以通过定制应用镜像来实现持续集成、持续交付、部署。开发人员 可以通过 Dockerfile 来进行镜像构建,
    并结合 持续集成(Continuous Integration) 系 统进行集成测试, 而运维人员则可以直接在生产环境中快速部署该镜像,甚至结合 持续部署(Continuous Delivery/Deployment) 系统进行自动部署。 而且使用 Dockerfile 使镜像构建透明化,不仅仅开发团队可以理解应用运行环 境,
    也方便运维团队理解应用运行所需条件,帮助更好的生产环境中部署该镜像
    更轻松的迁移
    由于 Docker 确保了执行环境的一致性,使得应用的迁移更加容易。Docker 可以在 很多平台上运行,无
    论是物理机、虚拟机、公有云、私有云,甚至是笔记本,其运 行结果是一致的。 因此用户可以很轻易的将在一个平台上运行的应用,迁移到另一 个平台上,而不用担心运行环境的变化导致应用无法正常运行的情况。

    docker得到视图

     9,docker的三大概念

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

    docker镜像

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

    image的分层存储

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

    docker容器

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

    docker仓库

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

    docker Registry

    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 镜像市场、阿里云镜像库等。

    10,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
    
       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版本

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

    docker系统环境准备

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

    docker镜像加速器

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

    docker基础命令注释

    [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镜像

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

    获取镜像

    从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镜像

    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镜像

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

    查看docker镜像

    镜像的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镜像

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

    导出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镜像

    可以使用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

    启动docker容器的方式

    启动容器有两种方式,一种是基于镜像新建一个容器并启动,另外一个是将在终止状态(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:执行一个命令

    当利用docker run来创建容器时,Docker在后台运行的标准操作包括

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

    docker与"hello docker"

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

    后台模式启动docker

    -d 参数:后台运行容器, 返回容器ID

    [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]#

    查看容器内的标准输出

    • docker logs c02

    停止容器

    • docker stop c02

    启动容器

    • docker start c02

    删除容器

    • docker rm c02

    Docker镜像常用命令

    • docker images  # 列出所有本级镜像
    • docker pull centos  # 获取新的centos镜像
    • docker search nginx  # 搜索新的nginx镜像

    构建镜像

    • 通过commit修改镜像
    • 编写dockerfile

    11,进入容器

    使用-d参数时,容器启动后,会进入后台,某些时候要进入容器进行操作,有很多种方法,包括使用docker attach命令或nsenter工具等

    docker -exec -it  容器id

    docker attach 容器id

    提交创建自定义的镜像

    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

    外部访问容器

    容器中可以运用网络应用,但是要让外部也可以访问这些应用,可以通过-p或-P参数指定端口映射

    • docker run -d -p training/webapp python app.py

    检查映射窗口的端口

    #宿主机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

    查看容器日志信息

    • docker logs -f cfd

    也可以通过-p参数指定映射端口

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

    通过浏览器去访问

    查看指定容器的端口映射

    • docker port c0b

    查看容器内的进程

    [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定制镜像

    镜像是容器的基础,每次执行docker run 的时候都会指定那个镜像作为容器运行的基础,之前都是使用docker hub的镜像,直接使用这些镜像只能满足一定的需求,当镜像无法满足我们的需求时,就得自定制这些镜像

    镜像的定制就是定制每一层所添加的配置、文件。如果可以吧每一层修改、安装、构建、操作的命令都写入到一个脚本,用脚本来构建、定制镜像,这个脚本就是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”]

    发布docker image到仓库

    第一种, docker hub公有镜像发布

    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

    打包flask程序与dockerfile

    确保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

    docker网络

    docker允许通过外部访问容器或容器互联的方式来提供农网络服务

    • 端口映射允许外部访问容器
    • --link容器互联
    • 容器桥接网络
    1.通过--link容器通信,给test2添加一个hosts解析记录
    docker run -d --name test2 --link test1 busybox /bin/sh -c "while true;do sleep 3600;done"
    test2可以ping通test1,反之不可以

    但是--link是不推荐使用,而是更强大的自定义docker网络连接容器

    1.新建一个docker网络
    docker network create -d bridge my-net
    -d 参数指定 Docker 网络类型,有 bridge overlay
    
    2.连接容器
    运行一个容器并连接到新建的 my-net 网络
    
    $ docker run -it --rm --name busybox1 --network my-net busybox sh
    打开新的终端,再运行一个容器并加入到 my-net 网络
    
    $ docker run -it --rm --name busybox2 --network my-net busybox sh
    再打开一个新的终端查看容器信息
    
    $ docker container ls
    
    CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
    b47060aca56b        busybox             "sh"                11 minutes ago      Up 11 minutes                           busybox2
    8720575823ec        busybox             "sh"                16 minutes ago      Up 16 minutes                           busybox1
    下面通过 ping 来证明 busybox1 容器和 busybox2 容器建立了互联关系。
    
    在 busybox1 容器输入以下命令
    
    / # ping busybox2
    PING busybox2 (172.19.0.3): 56 data bytes
    64 bytes from 172.19.0.3: seq=0 ttl=64 time=0.072 ms
    64 bytes from 172.19.0.3: seq=1 ttl=64 time=0.118 ms
    用 ping 来测试连接 busybox2 容器,它会解析成 172.19.0.3。
    
    同理在 busybox2 容器执行 ping busybox1,也会成功连接到。
    
    / # ping busybox1
    PING busybox1 (172.19.0.2): 56 data bytes
    64 bytes from 172.19.0.2: seq=0 ttl=64 time=0.064 ms
    64 bytes from 172.19.0.2: seq=1 ttl=64 time=0.143 ms
    这样,busybox1 容器和 busybox2 容器建立了互联关系。
    

    外部访问容器

    容器中 可以运行网络应用,但是要让外部可以访问这些应用,可以通过-p或 -P参数指定端口 映射

    • docker run -d -p training/wenapp python app.py

    检查映射的端口

    #宿主机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

    查看容器日志信息

    • docker logs -f cfd

    也可以指定--p参数指定 映射端口

    #指定服务器的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
  • 相关阅读:
    【读书笔记】iOS-照相机与摄像头
    【读书笔记】iOS-加速计与陀螺仪
    【读书笔记】iOS-手势识别
    【读书笔记】iOS-移动开发
    【读书笔记】iOS-配件
    iOS开发UI篇—核心动画(转场动画和组动画)
    iOS开发UI篇—核心动画(关键帧动画)
    iOS开发UI篇—核心动画(基础动画)
    iOS开发UI篇—核心动画简介
    iOS开发UI篇—CAlayer(自定义layer)
  • 原文地址:https://www.cnblogs.com/ljc-0923/p/10265332.html
Copyright © 2011-2022 走看看