Docker 容器基础篇简介

Docker 容器基础篇

一、容器技术和Docker简介

1、虚拟化：

• 使用虚拟化的优点：
  • 1.资源池：一个物理的资源分配到了不同的虚拟机里
  • 2.很容易扩展：加物理机器或者加虚拟机
  • 3.很容易云化：亚马逊AWS，阿里云等
• 虚拟化的局限性：
  • 每一个虚拟机都是一个完整的操作系统，要给其分配资源，当虚拟机数量增多时，操作系统本身消耗的资源势必增多

2、容器解决了什么问题?

• 解决了开发和运维之间的矛盾
• 在开发和运维之间搭建了一个桥梁，是实现devops的最佳解决方案

3、什么是容器？

• 对软件和其依赖的标准化打包
• 应用之间相互隔离
• 共享同一个OS kernel
• 可以运行在很多主流操作系统上

4、什么是Docker CE与EE?

• 2017年的3月1号之后，Docker的版本命名开始发生变化，同时将CE版本和EE版本进行分开。
• 区别如下：
  • Docker社区版(CE)：
    • 为了开发人员或小团队创建基于容器的应用,与团队成员分享和自动化的开发管道。docker-ce提供了简单的安装和快速的安装，以便可以立即开始开发。docker-ce集成和优化，基础设施 (免费)
  • Docker企业版(EE):
    • 专为企业的发展和IT团队建立谁。docker-ee为企业提供最安全的容器平台，以应用为中心的平台。（付费）

5、容器和虚拟机的区别：

• 容器是App层面的隔离

• 虚拟化是物理资源层面的隔离：

• 虚拟化 + 容器：

6、什么是Docker?

• Docker 使用 Google 公司推出的 Go 语言 进行开发实现，基于 Linux 内核的 cgroup，namespace，以及AUFS 类的 Union FS 等技术，对进程进行封装隔离，属于 操作系统层面的虚拟化技术
• 由于隔离的进程独立于宿主和其它的隔离的进程，因此也称其为容器
• Docker 在容器的基础上，进行了进一步的封装，从文件系统、网络互联到进程隔离等等，极大的简化了容器的创建和维护。使得 Docker 技术比虚拟机技术更为轻便、快捷。

7、为什么要用Docker？

• 作为一种新兴的虚拟化方式，Docker 跟传统的虚拟化方式相比具有众多的优势。

  1：更高效的利用系统资源：

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

  2：更快速的启动时间:

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

  3：一致的运行环境：

  • 开发过程中一个常见的问题是环境一致性问题。由于开发环境、测试环境、生产环境不一致，导致有些 bug 并未在开发过程中被发现。而Docker 的镜像提供了除内核外完整的运行时环境，确保了应用运行环境一致性，从而不会再出现 「这段代码在我机器上没问题啊」 这类问题

  4：持续交付和部署：

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

  5：更轻松的迁移：

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

  6：更轻松的维护和扩展：

  • Docker 使用的分层存储以及镜像的技术，使得应用重复部分的复用更为容易，也使得应用的维护更新更加简单，基于基础镜像进一步扩展镜像也变得非常简单。此外，Docker 团队同各个开源项目团队一起维护了一大批高质量的 官方镜像，既可以直接在生产环境使用，又可以作为基础进一步定制，大大的降低了应用服务的镜像制作成本。

  7：对比传统虚拟机总结：

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

二、Docker环境的各种搭建方法

安装Docker：

系统要求：

• Docker CE 支持 64 位版本 CentOS 7，并且要求内核版本不低于 3.10。 CentOS 7 满足最低内核的要求，但由于内核版本比较低，部分功能（如 overlay2 存储层驱动）无法使用，并且部分功能可能不太稳定。

• 1.卸载旧版本：

  • 旧版本的 Docker 称为 docker 或者 docker-engine，使用以下命令卸载旧版本：

    $ 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.使用yum安装：

  • 执行以下命令安装依赖包：

    $ sudo yum install -y yum-utils \
               device-mapper-persistent-data \
               lvm2
    

  • 鉴于国内网络问题，强烈建议使用国内源，官方源请在注释中查看。

    执行下面的命令添加 yum 软件源：

    $ sudo yum-config-manager \
        --add-repo \
        https://mirrors.ustc.edu.cn/docker-ce/linux/centos/docker-ce.repo
    
    # 官方源
    # $ sudo yum-config-manager \
    #     --add-repo \
    #     https://download.docker.com/linux/centos/docker-ce.repo
    

  • 如果需要测试版本的 Docker CE 请使用以下命令(我没有安装)：

    sudo yum-config-manager --enable docker-ce-test
    

  • 如果需要每日构建版本的 Docker CE 请使用以下命令（我没有安装）：

    $ sudo yum-config-manager --enable docker-ce-nightly
    

• 3.安装 Docker CE:

  • 更新 yum 软件源缓存，并安装 docker-ce。

  $ sudo yum makecache fast
  $ sudo yum install docker-ce  # 执行的这条命令
  

• 4.使用脚本自动安装：

  • 在测试或开发环境中 Docker 官方为了简化安装流程，提供了一套便捷的安装脚本，CentOS 系统上可以使用这套脚本安装

    $ curl -fsSL get.docker.com -o get-docker.sh
    $ sudo sh get-docker.sh --mirror Aliyun
    

    • 执行这个命令后，脚本就会自动的将一切准备工作做好，并且把 Docker CE 的 Edge 版本安装在系统中

• 5.启动Docker CE：

  $ sudo systemctl enable docker
  $ sudo systemctl start docker
  

• 6.测试Docker是否安装正确：

  $ docker run hello-world
  
  Unable to find image 'hello-world:latest' locally
  latest: Pulling from library/hello-world
  d1725b59e92d: Pull complete
  Digest: sha256:0add3ace90ecb4adbf7777e9aacf18357296e799f81cabc9fde470971e499788
  Status: Downloaded newer image for hello-world:latest
  
  Hello from Docker!
  This message shows that your installation appears to be working correctly.
  
  To generate this message, Docker took the following steps:
   1. The Docker client contacted the Docker daemon.
   2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
      (amd64)
   3. The Docker daemon created a new container from that image which runs the
      executable that produces the output you are currently reading.
   4. The Docker daemon streamed that output to the Docker client, which sent it
      to your terminal.
  
  To try something more ambitious, you can run an Ubuntu container with:
   $ docker run -it ubuntu bash
  
  Share images, automate workflows, and more with a free Docker ID:
   https://hub.docker.com/
  
  For more examples and ideas, visit:
   https://docs.docker.com/get-started/
  

  • 若能正常输出以上信息，则说明安装成功。

三、Docker的镜像和容器

1、Docker的架构和底层技术：

1.1、Docker平台(platform):

• Docker 提供了一个开发，打包，运行app的平台

• 把app和底层infrastructure隔离开来

  • 如图：

• Docker Engine都有哪些东西呢 ?

  • 1.后台进程(dockerd)

  • 2.REST API Server

  • 3.CLI接口(docker)

  • 如图所示：

• 查看docker版本：

  $ sudo docker version
  
  Client:
   Version:           18.09.0
   API version:       1.39
   Go version:        go1.10.4
   Git commit:        4d60db4
   Built:             Wed Nov  7 00:48:22 2018
   OS/Arch:           linux/amd64
   Experimental:      false
  
  Server: Docker Engine - Community
   Engine:
    Version:          18.09.0
    API version:      1.39 (minimum version 1.12)
    Go version:       go1.10.4
    Git commit:       4d60db4
    Built:            Wed Nov  7 00:19:08 2018
    OS/Arch:          linux/amd64
    Experimental:     false
  
  

• 查看docker后台进程：

  $ps -ef | grep docker
  
  root      20450      1  0 15:16 ?        00:00:20 /usr/bin/dockerd -H unix://
  root      20464  20450  0 15:16 ?        00:00:27 containerd --config /var/run/docker/containerd/containerd.toml --log-level info
  root      20845  18781  0 20:36 pts/2    00:00:00 grep --color=auto docker
  
  

1.2、Docker架构原理(Architecture):

• 总体看一下docker的架构如图所示：

• Client里面：是一些常用的命令
• Docker_HOST：是docker启动的机器
• Registry：是一些镜像存储的服务器

1.3、Docker 底层技术支持：

• Namespaces：做隔离pid，net，ipc，mnt，uts
• Control groups：做资源限制
• Union file systems：Container和image的分层

2、Docker 镜像(image)概述:

2.1、什么是镜像？

• 我们都知道，操作系统分为内核和用户空间。

• 对于 Linux 而言，内核启动后，会挂载 root 文件系统为其提供用户空间支持

  • 而 Docker 镜像（Image），就相当于是一个root文件系统
  • 比如官方镜像 ubuntu:18.04 就包含了完整的一套 Ubuntu 18.04 最小系统的 root 文件系统。

• Docker 镜像是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数（如匿名卷、环境变量、用户等）。

  • **镜像不包含任何动态数据，其内容在构建之后也不会被改变。 **

• 查看本地已经有的docker 镜像命令：

  $ docker image ls
  
  REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
  hello-world         latest              4ab4c602aa5e        3 months ago        1.84kB
  

2.2、分层存储：

• 因为镜像包含操作系统完整的 root 文件系统，其体积往往是庞大的，因此在 Docker 设计时，就充分利用 Union FS 的技术，将其设计为分层存储的架构，镜像并非是像一个 ISO 那样的打包文件，镜像只是一个虚拟的概念，其实际体现并非由一个文件组成，而是由一组文件系统组成，或者说，由多层文件系统联合组成。
• **镜像构建时，会一层层构建，前一层是后一层的基础 **
  • 每一层构建完就不会再发生改变，后一层上的任何改变只发生在自己这一层。
    • 比如，删除前一层文件的操作，实际不是真的删除前一层的文件，而是仅在当前层标记为该文件已删除。
    • 在最终容器运行的时候，虽然不会看到这个文件，但是实际上该文件会一直跟随镜像。
    • 因此，在构建镜像的时候，需要额外小心，每一层尽量只包含该层需要添加的东西，任何额外的东西应该在该层构建结束前清理掉。
• 分层存储的特征还使得镜像的复用、定制变的更为容易。甚至可以用之前构建好的镜像作为基础层，然后进一步添加新的层，以定制自己所需的内容，构建新的镜像。

2.3、创建一个Base Image：

• docker 重启命令：service docker restart

• centos下安装vim，因为vi的功能没有vim丰富

  • 1.用yum查找源中的VIM包，不知安装哪个合适。

    yum search vim
    vim-X11.i386 : The VIM version of the vi editor for the X Window System.
    vim-common.i386 : The common files needed by any version of the VIM editor.
    vim-enhanced.i386 : A version of the VIM editor which includes recent enhancements.
    vim-minimal.i386 : A minimal version of the VIM editor
    
    

  • 2.到已安装VIM的系统中查看VIM属于哪个软件包

    which vim
    /usr/bin/vim
    rpm -qf /usr/bin/vim
    vim-enhanced-7.0.109-7.el5
    

  • 3、安装VIM:

    yum install vim-enhanced
    

• 安装c语言的编辑器：

  • 首先创建了一个c语言编写的模块

    • vim hello.c 里面输出内容如下：

      #include<stdio.h>
      
      int main()
      {
          printf("hello docker\n");
      }
      

  • 第一条命令：yum install gcc

  • 第二条命令：yum install glibc-static

  • 编译C语言成二进制文件命令:gcc -static hello.c -o hello

    • 该目录下会出现：

      总用量 844
      -rwxr-xr-x. 1 root root 856856 12月 16 21:43 hello
      -rw-r--r--. 1 root root     64 12月 16 21:43 hello.c
      
      [root@localhost hello-c]# ./hello   # 输入./hello 
      hello docker
      

• 创建一个Dockerfile：

  • vim Dockerfile：

    FROM scratch
    ADD hello /
    CMD ["/hello"]
    

  • 把这个Dockerfile文件进行镜像：docker build -t lh9 .

    • -t(–tag)：镜像的名字及标签，通常 name:tag 或者name格式，可以在一次构建中为一个镜像设置多个标签
    • lh9：是这次镜像仓库的名字(随意起)
    • .：代表执行的是当前文件夹中的Dockerfile文件

• 查看镜像：docker image ls:

• 可以简写为：docker images：

  REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
  lh9                 latest              f519dcbd86cb        9 minutes ago       857kB  
  hello-world         latest              4ab4c602aa5e        3 months ago        1.84kB
  

• 查看历史镜像时的操作：docker history f519dcbd86cb

  • f519dcbd86cb: 镜像ID ，通过docker image ls 可以查看到该IMAGE ID

    [root@localhost hello-c]# docker history f519dcbd86cb
    IMAGE               CREATED             CREATED BY                                      SIZE                COMMENT
    f519dcbd86cb  10 minutes ago  /bin/sh -c #(nop)  CMD ["/hello"]               0B                  
    14fd8dbe42ef  10 minutes ago /bin/sh -c #(nop) ADD file:59b137d2e449bd517…   857kB 
    

3、Docker容器(Container)概述：

• 镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的 类 和 实例 一样，镜像是静态的定义，容器是镜像运行时的实体。**容器可以被创建、启动、停止、删除、暂停等。 **
  • 简单说，Container是通过Image创建
• 容器的实质是进程，但与直接在宿主执行的进程不同，容器进程运行于属于自己的独立的 命名空间。
  • 因此容器可以拥有自己的 root 文件系统、自己的网络配置、自己的进程空间，甚至自己的用户 ID 空间。
  • 容器内的进程是运行在一个隔离的环境里，使用起来，就好像是在一个独立于宿主的系统下操作一样。
  • 这种特性使得容器封装的应用比直接在宿主运行更加安全。也因为这种隔离的特性，很多人初学 Docker 时常常会混淆容器和虚拟机。
• 镜像使用的是分层存储，容器也是如此。
  • 每一个容器运行时，是以镜像为基础层，在其上创建一个当前容器的存储层，我们可以称这个为容器运行时读写而准备的存储层为容器存储层。
• 容器存储层的生存周期和容器一样，容器消亡时，容器存储层也随之消亡。因此，任何保存于容器存储层的信息都会随容器删除而丢失。
• 按照 Docker 最佳实践的要求，容器不应该向其存储层内写入任何数据，容器存储层要保持无状态化。所有的文件写入操作，都应该使用 数据卷（Volume）、或者绑定宿主目录，在这些位置的读写会跳过容器存储层，直接对宿主（或网络存储）发生读写，其性能和稳定性更高
• 数据卷的生存周期独立于容器，容器消亡，数据卷不会消亡。因此，使用数据卷后，容器删除或者重新运行之后，数据却不会丢失。

4、Docker 基本命令：

• 查看当前镜像：docker image ls
  • 可以简写：docker images
• 删除当前镜像：docker image rm xxxxxID
  • 可以简写：docker rmi xxxxxID
• 查看当前本地正在运行的容器：docker container ls
• 查看当前所有容器包括退出的:docker container ls -a
  • 以上两个查看命令可以简写为:docker ps -a
• 删除容器:docker container rm xxxxxID
  • 删除容器可以简写:docker rm xxxxxID
• 创建容器并执行:docker run REPOSITORY
  • 比如：docker run lh9(镜像名)
• 创建容器并在后台执行：docker run -d REPOSITORY
• 查看所有容器的ID：docker container ls -aq
  • 此命令相当于：docker container ls -a | awk {'print$1'}
• 批量删除所有容器：docker rm $(docker container ls -aq)
• 仅想清除容器是退出的：docker rm $(docker container ls -f "status=exited" -q)

5、构建Docker镜像：

• 把容器(container)commit成镜像(image)：docker container commit
  • 简写为：docker commit

5.1、创建镜像方法一：

• 通过用docker commit 基于容器创建一个镜像：

  • 1.首先 查看容器 docker container ls -a:

    CONTAINER ID  IMAGE  COMMAND   CREATED       STATUS       PORTS     NAMES
    
    fdbd66aa1ed9  lh9   "/hello"   2 minutes ago  Exited (13)         awesome_aryabhata
    caa7fca0483d  lh9   "/hello"   2 minutes ago  Exited (13)         vibrant_mendeleev
    

  • 2.基于容器创建一个镜像：docker commit NAMES[容器的名字] IMAGENAME[镜像的名字]

    • 执行命令：docker commit awesome_aryabhata test/lh9

    • 创建成功会提示：

      sha256:08984f0d6a0be8823f465d782de3fdcd6ec7494a956d5c7659964cb33e2fad72
      

  • 3.查看当前镜像：docker images

    REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
    test/hl9            latest              08984f0d6a0b        15 seconds ago      857kB
    lh9                 latest              906e443f5915        16 hours ago        857kB
    hello-world         latest              4ab4c602aa5e        3 months ago        1.84kB
    

  • 4.test/lh9 就是上面基于容器创建出的镜像。(不提倡这种方式)

• 从Dockerfile文件中：创建一个镜像：docker image build

  • 简写为：docker build

5.2、创建镜像方法二：

• 通过使用Dockerfile来创建一个镜像方法：

  • 1.首先创建一个文件夹

    mkdir  docker-vim
    

  • 2.进入docker-vim文件夹中，创建一个Dockerfile文件：

    [root@localhost docker-centos-vim]# more Dockerfile 
    FROM centos:7.2.1511 (后面是7.2.1511 是我拉取centos镜像的版本号)
    RUN yum install -y vim
    

  • 3.执行命令：docker build -t centos-vim[镜像的名字] . [.点代表的是当前目录]

6、Dockerfile 基本语法：

6.1、常用语法：

• 1.FORM：在哪个Base Image 之上，构建自己的Image

  • FROM scratch :制作base image
  • FROM centos：使用 base image
  • FROM ubuntu:14.04 :使用 base image
  • 经量使用官方的image作为base image 为了安全

• 2.LABEL：包含一些信息

  • LABEL maintainer = '[email protected]' : 作者信息
  • LABEL version = '1.0'： 版本信息
  • LABEL description = 'This is description'：描述信息

• 3.RUN：运行命令

  Run yum update && yum install -y vim \
  	python-dev   # 反斜线换行 && 合并命令
  

  Run apt-get update && apt-get install -y perl \
  	pwgen --no-install-recommends && rm -rf \
  	/var/lib/apt/lists/*  # 注意清理cache
  

  Run /bin/bash -c 'source $HOME/.bashrc;echo
  $HOME'
  

  • 为了美观，复杂的RUN 请用反斜杠换行，避免无用分层，合并多条命令成一行

• 4.WORKDIR：进入目录(相当于Linux系统中的cd 命令)

  WORKDIR /test  # 如果没有就会自动创建test目录
  WORKDIR demo
  RUN pwd  # 输出结果是 /test/demo
  

  • 用WORKDIR，不要用RUN cd ，尽量使用绝对目录

• 5.ADD 和 COPY：把本地文件添加到根目录里面：

  ADD hello /  # 把本地hello 文件添加到/目录中
  ADD	test.tar.gz/  # ADD 根COPY区别，ADD 还可以解压缩，把test.tar.gz 压缩文件解压缩到/目录中
  

  WORKDIR /root
  ADD hello test/   # /root/test/hello
  

  WORKDIR /root
  COPY hello test/
  

  • COPY优于ADD，ADD除了COPY还有额外功能(解压)：适用于添加本地的文件
  • 添加远程文件/目录请使用curl或者wget

• 6.ENV：设置常量

  ENV MYSQL_VERSION 5.6 # 设置常量
  RUN age-get install -y mysql-server  = '${MYSQL_VERSION}'\
  	&& rm -rf /var/lib/apt/lists/*  # 引用常量
  

  • 尽量使用ENV增加可维护性

• 7.EXPOSE：设置端口

• 8.CMD：设置容器启动后默认执行的命令和参数

  • 1：容器启动时默认执行的命令

  • 2：如果docker run 指令了其他命令，CMD命令会被忽略

  • 3：如果定义了多个CMD，只有最后一行会执行

    FROM centos:7.2.1511
    ENV name Docker
    CMD echo "hello $name"
    CMD echo "hello lh9"  # 只会输出这条信息
    

• 9.ENTRYPOINT：设置容器启动时运行的命令

  • 1：让容器以应用程序或者服务的形式运行
  • 2：不会被忽略，一定会执行

6.2、Shell 格式 和 Exec格式：

• Shell格式：要运行的命令当作shell格式来执行

  RUN apt-get install -y vim
  CMD echo 'hello docker'
  ENTRYPOINT echo 'hello docker'
  

  • 创建一个Dockerfile 文件：

    FROM centos:7.2.1511
    ENV name Docker
    ENTRYPOINT echo "hello $name"
    

    • 创建镜像：docker build -t docker-shell[镜像的名字] .
    • 创建容器：docker run docker-shell[镜像的名字]
    • 输出结果：hello docker
    • 总结：在使用shell格式写Dockerfile文件的时候，ENV变量 name 可以使用

• Exec 格式：特定的格式指明要运行的命令，和命令所跟的参数

  RUN ['apt-get', 'install', '-y', 'vim']
  CMD ['/bin/echo', 'hello docker']
  ENTRYPOINT ['/bin/echo', 'hello docker']
  

  • 创建一个Dockerfile文件：

    FROM centos:7.2.1511
    ENV name Docker
    ENTRYPOINT ["/bin/bash", "-c", "echo hello $name"]
    

    • 创建镜像：docker build -t docker-exec .
    • 创建容器：docker run docker-exec
    • 输出结果：hello Docker
    • 总结：在使用exec格式的时候，需要在/bin/bash，增加参数"-c" 使用要打印的变量名

6.3、获取centos镜像:

• 第一步：获取centos镜像

  [root@VM_0_13_centos ~]# docker pull centos #获取centos镜像 (centos:7.2后面可以指定版本号)
  

• 第二步：确认镜像是否成功

  [root@VM_0_13_centos ~]# docker images #查看所有镜像
  REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
  centos              latest              49f7960eb7e4        8 hours ago         200MB
  ubuntu              latest              452a96d81c30        5 weeks ago         79.6MB
  hello-world         latest              e38bc07ac18e        7 weeks ago         1.85kB
  

• 第三步：运行centOS镜像

  [root@VM_0_13_centos ~]# docker run -d -i -t 49f7960eb7e4 /bin/bash #运行centos镜像
  c8fd9560e87fef4a36e3d92856467f76a5924b39253bedc1ddf2530bc7b18f7e
  

• 第四步：进入容器

  [root@VM_0_13_centos ~]# docker attach c8fd9560e87f
  

• 第五步：退出容器

  exit
  

• 以上第三、四步可以简写为：

  docker run -it 49f7960eb7e4 /bin/bash
  

7、镜像的发布(Dockerhub)：

• 第一步：
  • www.dockerhub.com 注册账号
• 第二步：
  • docker login 登录dockerhub
• 第三步：
  • docker push imagename[镜像的名字]
• 第四步：
  • 登录dockerhub 就能看到发布的镜像文件
  • 通过docker pull 镜像文件名就可以下载到本地

8、实践操作Dockerfile：

8.1、方式一：创建普通的Dockerfile文件

• 创建flask(python框架)应用：

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
	return 'hello docker'

if __name__ == '__main__':
	app.run()

• 创建Dockerfile文件：

FROM python2.7  # base image 是python2.7 
LABEL maintainer="Lv [email protected]"  # 作者的信息
RUN pip install flask  # 执行pip install 安装命令
COPY app.py /app/   #  将本地的app.py拷贝到/app/ 目录中
WORKDIR /app  # 进入/app 目录中
EXPOSE 5000  # 启动的端口
CMD ["python", "app.py"]  #  执行的命令是exec

• 创建容器并后台运行容器：

docker run -d  [imagename]

8.2、方式二：创建 ENTRYPOINT + CMD 用法的Dockerfile文件：

• 创建Dockerfile文件：

  FROM daocloud.io/ubuntu:14.04  # base image加版本号
  RUN apt-get update && apt-get install -y stress  # 安装stress测压工具
  ENTRYPOINT ["/usr/bin/stress"]  # 执行stress命令
  CMD []  #  stress命令后面有参数 创建容器时添加参数到CMD [] 中
  

• 创建镜像：docker build -t ubuntu-stress .

• 查看镜像：

  [root@localhost docker-file]# docker images 
  REPOSITORY           TAG                 IMAGE ID            CREATED             SIZE
  ubuntu-stress        latest              569223e973e1        9 minutes ago       204MB
  

• 创建容器并运行：--vm 1 --verbose 就是Dockerfile文件中的CMD[]里面的指定参数

  [root@localhost docker-file]# docker run -it ubuntu-stress --vm 1 --verbose  
  

9、容器的操作：

• 进入已经运行的容器中：

  docker exec -it [containerID] /bin/bash  # 进入交互式
  

• 打印容器内的ip 地址：

  docker exec -it[containerID] ip a  #  打印容器内的ip地址
  

• 停止正在运行的容器：

  docker stop [containerID]
  

• 创建容器并给容器自定义起名字：

  docker run -d --name=demo [REPOSITORY] 
  # 查看容器docker ps
  CONTAINER ID   IMAGE   COMMAND      STATUS                   PORTS  NAMES
  2d31d01f1b7b    cmd    "/bin/sh -c  Exited (0) 4 seconds ago        demo  # 看到自定义取的名
  468c2477f9e1    cmd    "/bin/sh -c  Exited (0) 37 seconds ago       elegant_diffie
  

  • 可以通过容器名字进行停止正在运行的容器：docker stop container[NAMES]

• 启动docker 容器命令：

  docker start demo
  

• 查看容器详细的信息：

  docker inspect  [containerID] 或[containerNAMES]
  

• 查看容器logs：

  docker logs [containerID]