9102 年了，学Docker

以你之姓@ 2022-03-01 02:08 224阅读 0赞

[什么是docker?][docker]

**一、概述**

1.1 基本概念：

Docker 是一个开源的应用容器引擎，基于 Go 语言 并遵从Apache2.0协议开源。Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）,更重要的是容器性能开销极低。

1.2 优势：

简化程序：  
Docker 让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的 Linux 机器上，便可以实现虚拟化。Docker改变了虚拟化的方式，使开发者可以直接将自己的成果放入Docker中进行管理。方便快捷已经是 Docker的最大优势，过去需要用数天乃至数周的 任务，在Docker容器的处理下，只需要数秒就能完成。

节省开支：  
一方面，云计算时代到来，使开发者不必为了追求效果而配置高额的硬件，Docker 改变了高性能必然高价格的思维定势。Docker 与云的结合，让云空间得到更充分的利用。不仅解决了硬件管理的问题，也改变了虚拟化的方式。

1.3 与传统VM特性对比：

作为一种轻量级的虚拟化方式，Docker在运行应用上跟传统的虚拟机方式相比具有显著优势：

Docker容器很快，启动和停止可以在秒级实现，这相比传统的虚拟机方式要快得多。

Docker容器对系统资源需求很少，一台主机上可以同时运行数千个Docker容器。

Docker通过类似Git的操作来方便用户获取、分发和更新应用镜像，指令简明，学习成本较低。

Docker通过Dockerfile配置文件来支持灵活的自动化创建和部署机制，提高工作效率。

Docker容器除了运行其中的应用之外，基本不消耗额外的系统资源，保证应用性能的同时，尽量减小系统开销。

Docker利用Linux系统上的多种防护机制实现了严格可靠的隔离。从1.3版本开始，Docker引入了安全选项和镜像签名机制，极大地提高了使用Docker的安全性。

<table> 
 <tbody> 
  <tr> 
   <td>特性</td> 
   <td>容器</td> 
   <td>虚拟机</td> 
  </tr> 
  <tr> 
   <td>启动速度</td> 
   <td>秒级</td> 
   <td>分钟级</td> 
  </tr> 
  <tr> 
   <td>硬盘使用</td> 
   <td>一般为MB</td> 
   <td>一般为GB</td> 
  </tr> 
  <tr> 
   <td>性能</td> 
   <td>接近原生</td> 
   <td>弱于原生</td> 
  </tr> 
  <tr> 
   <td>系统支持量</td> 
   <td>单机支持上千个容器</td> 
   <td>一般几十个</td> 
  </tr> 
  <tr> 
   <td>隔离性</td> 
   <td>安全隔离</td> 
   <td>完全隔离</td> 
  </tr> 
 </tbody> 
</table>

1.4 基础架构

Docker 使用客户端-服务器 (C/S) 架构模式，使用远程API来管理和创建Docker容器。

Docker 容器通过 Docker 镜像来创建。

容器与镜像的关系类似于面向对象编程中的对象与类。

<table> 
 <tbody> 
  <tr> 
   <th>Docker</th> 
   <th>面向对象</th> 
  </tr> 
  <tr> 
   <td>容器</td> 
   <td>对象</td> 
  </tr> 
  <tr> 
   <td>镜像</td> 
   <td>类</td> 
  </tr> 
 </tbody> 
</table>

1.5 Docker技术的基础：

*  namespace，容器隔离的基础，保证A容器看不到B容器. 6个名空间：User,Mnt,Network,UTS,IPC,Pid
 *  cgroups，容器资源统计和隔离。主要用到的cgroups子系统：cpu,blkio,device,freezer,memory
 *  unionfs，典型：aufs/overlayfs，分层镜像实现的基础

1.6 Docker组件：

*  docker Client客户端————>向docker服务器进程发起请求，如:创建、停止、销毁容器等操作
 *  docker Server服务器进程—–>处理所有docker的请求，管理所有容器
 *  docker Registry镜像仓库——>镜像存放的中央仓库，可看作是存放二进制的scm

**二、安装部署**

2.1 准备条件

目前，CentOS 仅发行版本中的内核支持 Docker。

Docker 运行在 CentOS 7 上，要求系统为64位、系统内核版本为 3.10 以上。

Docker 运行在 CentOS-6.5 或更高的版本的 CentOS 上，要求系统为64位、系统内核版本2.6.32-431 或者更高版本。

2.2 安装docker

yum install docker -y          #安装
    systemctl start docker         #启动    
    systemctl enable docker        #设置开机自启动
    复制代码

2.3 基本命令

docker search centos   #搜索镜像

2.4 命令整理：

容器操作：

docker create # 创建一个容器但是不启动它
    docker run # 创建并启动一个容器
    docker stop # 停止容器运行，发送信号SIGTERM
    docker start # 启动一个停止状态的容器
    docker restart # 重启一个容器
    docker rm # 删除一个容器
    docker kill # 发送信号给容器，默认SIGKILL
    docker attach # 连接(进入)到一个正在运行的容器
    docker wait # 阻塞一个容器，直到容器停止运行
    复制代码

获取容器信息：

docker ps # 显示状态为运行（Up）的容器
    docker ps -a # 显示所有容器,包括运行中（Up）的和退出的(Exited)
    docker inspect # 深入容器内部获取容器所有信息
    docker logs # 查看容器的日志(stdout/stderr)
    docker events # 得到docker服务器的实时的事件
    docker port # 显示容器的端口映射
    docker top # 显示容器的进程信息
    docker diff # 显示容器文件系统的前后变化
    复制代码

导出容器：

docker cp # 从容器里向外拷贝文件或目录
    docker export # 将容器整个文件系统导出为一个tar包，不带layers、tag等信息
    复制代码

执行：

docker exec # 在容器里执行一个命令，可以执行bash进入交互式
    复制代码

镜像操作：

docker images # 显示本地所有的镜像列表
    docker import # 从一个tar包创建一个镜像，往往和export结合使用
    docker build # 使用Dockerfile创建镜像（推荐）
    docker commit # 从容器创建镜像
    docker rmi # 删除一个镜像
    docker load # 从一个tar包创建一个镜像，和save配合使用
    docker save # 将一个镜像保存为一个tar包，带layers和tag信息
    docker history # 显示生成一个镜像的历史命令
    docker tag # 为镜像起一个别名
    复制代码

镜像仓库(registry)操作：

docker login # 登录到一个registry
    docker search # 从registry仓库搜索镜像
    docker pull # 从仓库下载镜像到本地
    docker push # 将一个镜像push到registry仓库中

2.5 使用 Dockerfile 定制镜像

在一个空白目录中，建立一个文本文件，并命名为 `Dockerfile`：

$ mkdir mynginx
    $ cd mynginx
    $ touch Dockerfile

其内容为：

FROM nginx
    RUN echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.html

这个 Dockerfile 很简单，一共就两行。涉及到了两条指令，`FROM` 和 `RUN`。

### FROM 指定基础镜像 ###

所谓定制镜像，那一定是以一个镜像为基础，在其上进行定制。就像我们之前运行了一个 `nginx` 镜像的容器，再进行修改一样，基础镜像是必须指定的。而 `FROM` 就是指定**基础镜像**，因此一个 `Dockerfile` 中 `FROM` 是必备的指令，并且必须是第一条指令。

在 [Docker Hub][] 上有非常多的高质量的官方镜像，有可以直接拿来使用的服务类的镜像，如 [`nginx`][nginx]、[`redis`][redis]、[`mongo`][mongo]、[`mysql`][mysql]、[`httpd`][httpd]、[`php`][php]、[`tomcat`][tomcat] 等；也有一些方便开发、构建、运行各种语言应用的镜像，如 [`node`][node]、[`openjdk`][openjdk]、[`python`][python]、[`ruby`][ruby]、[`golang`][golang] 等。可以在其中寻找一个最符合我们最终目标的镜像为基础镜像进行定制。

如果没有找到对应服务的镜像，官方镜像中还提供了一些更为基础的操作系统镜像，如 [`ubuntu`][ubuntu]、[`debian`][debian]、[`centos`][centos]、[`fedora`][fedora]、[`alpine`][alpine] 等，这些操作系统的软件库为我们提供了更广阔的扩展空间。

除了选择现有镜像为基础镜像外，Docker 还存在一个特殊的镜像，名为 `scratch`。这个镜像是虚拟的概念，并不实际存在，它表示一个空白的镜像。

FROM scratch
    ...

如果你以 `scratch` 为基础镜像的话，意味着你不以任何镜像为基础，接下来所写的指令将作为镜像第一层开始存在。

不以任何系统为基础，直接将可执行文件复制进镜像的做法并不罕见，比如 [`swarm`][swarm]、[`coreos/etcd`][coreos_etcd]。对于 Linux 下静态编译的程序来说，并不需要有操作系统提供运行时支持，所需的一切库都已经在可执行文件里了，因此直接 `FROM scratch` 会让镜像体积更加小巧。使用 [Go 语言][Go] 开发的应用很多会使用这种方式来制作镜像，这也是为什么有人认为 Go 是特别适合容器微服务架构的语言的原因之一。

### RUN 执行命令 ###

`RUN` 指令是用来执行命令行命令的。由于命令行的强大能力，`RUN` 指令在定制镜像时是最常用的指令之一。其格式有两种：

*  *shell* 格式：`RUN <命令>`，就像直接在命令行中输入的命令一样。刚才写的 Dockerfile 中的 `RUN` 指令就是这种格式。

RUN echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.html

*  *exec* 格式：`RUN ["可执行文件", "参数1", "参数2"]`，这更像是函数调用中的格式。

既然 `RUN` 就像 Shell 脚本一样可以执行命令，那么我们是否就可以像 Shell 脚本一样把每个命令对应一个 RUN 呢？比如这样：

FROM debian:stretch
    
    RUN apt-get update
    RUN apt-get install -y gcc libc6-dev make wget
    RUN wget -O redis.tar.gz "http://download.redis.io/releases/redis-5.0.3.tar.gz"
    RUN mkdir -p /usr/src/redis
    RUN tar -xzf redis.tar.gz -C /usr/src/redis --strip-components=1
    RUN make -C /usr/src/redis
    RUN make -C /usr/src/redis install

2.6 Dockerfile详解

Dockerfile的指令是忽略大小写的，建议使用大写，使用 \# 作为注释，每一行只支持一条指令，每条指令可以携带多个参数。

Dockerfile的指令根据作用可以分为两种，构建指令和设置指令。

构建指令：用于构建image，其指定的操作不会在运行image的容器上执行；

设置指令：用于设置image的属性，其指定的操作将在运行image的容器中执行。

*  FROM（指定基础image）

构建指令，必须指定且需要在Dockerfile其他指令的前面。后续的指令都依赖于该指令指定的image。FROM指令指定的基础image可以是官方远程仓库中的，也可以位于本地仓库。

该指令有两种格式：

FROM <image>                  #指定基础image为该image的最后修改的版本
    FROM <image>:<tag>              #指定基础image为该image的一个tag版本。
    复制代码

*  MAINTAINER（用来指定镜像创建者信息）

构建指令，用于将image的制作者相关的信息写入到image中。当我们对该image执行docker inspect命令时，输出中有相应的字段记录该信息。

MAINTAINER <name>
    复制代码

*  RUN（安装软件用）

构建指令，RUN可以运行任何被基础image支持的命令。如基础image选择了ubuntu，那么软件管理部分只能使用ubuntu的命令。

RUN <command> (the command is run in a shell - `/bin/sh -c`)  
    RUN ["executable", "param1", "param2" ... ]  (exec form)
    复制代码

*  CMD（设置container启动时执行的操作）

设置指令，用于container启动时指定的操作。该操作可以是执行自定义脚本，也可以是执行系统命令。该指令只能在文件中存在一次，如果有多个，则只执行最后一条。

CMD ["executable","param1","param2"] (like an exec, this is the preferred form)  
    CMD command param1 param2 (as a shell)
    复制代码

ENTRYPOINT指定的是一个可执行的脚本或者程序的路径，该指定的脚本或者程序将会以param1和param2作为参数执行。所以如果CMD指令使用上面的形式，那么Dockerfile中必须要有配套的ENTRYPOINT。当Dockerfile指定了ENTRYPOINT，那么使用下面的格式：

CMD ["param1","param2"] (as default parameters to ENTRYPOINT)
    复制代码

*  ENTRYPOINT（设置container启动时执行的操作）

设置指令，指定容器启动时执行的命令，可以多次设置，但是只有最后一个有效。

ENTRYPOINT ["executable", "param1", "param2"] (like an exec, the preferred form)  
    ENTRYPOINT command param1 param2 (as a shell)
    复制代码

该指令的使用分为两种情况，一种是独自使用，另一种和CMD指令配合使用。  
当独自使用时，如果你还使用了CMD命令且CMD是一个完整的可执行的命令，那么CMD指令和ENTRYPOINT会互相覆盖只有最后一个CMD或者ENTRYPOINT有效。

# CMD指令将不会被执行，只有ENTRYPOINT指令被执行  
    CMD echo “Hello, World!”  
    ENTRYPOINT ls -l
    复制代码

另一种用法和CMD指令配合使用来指定ENTRYPOINT的默认参数，这时CMD指令不是一个完整的可执行命令，仅仅是参数部分；ENTRYPOINT指令只能使用JSON方式指定执行命令，而不能指定参数。

FROM ubuntu  
    CMD ["-l"]  
    ENTRYPOINT ["/usr/bin/ls"]
    复制代码

*  USER（设置container容器的用户）

设置指令，设置启动容器的用户，默认是root用户

# 指定memcached的运行用户  
    ENTRYPOINT ["memcached"]  
    USER daemon  
    或  
    ENTRYPOINT ["memcached", "-u", "daemon"]
    复制代码

*  EXPOSE（指定容器需要映射到宿主机器的端口）

设置指令，该指令会将容器中的端口映射成宿主机器中的某个端口。当你需要访问容器的时候，可以不是用容器的IP地址而是使用宿主机器的IP地址和映射后的端口。要完成整个操作需要两个步骤，首先在Dockerfile使用EXPOSE设置需要映射的容器端口，然后在运行容器的时候指定-p选项加上EXPOSE设置的端口，这样EXPOSE设置的端口号会被随机映射成宿主机器中的一个端口号。也可以指定需要映射到宿主机器的那个端口，这时要确保宿主机器上的端口号没有被使用。EXPOSE指令可以一次设置多个端口号，相应的运行容器的时候，可以配套的多次使用-p选项。

# 映射一个端口  
    EXPOSE port1  
    # 相应的运行容器使用的命令  (主机(宿主)端口:容器端口)
    docker run -p port1 image  
      
    # 映射多个端口  
    EXPOSE port1 port2 port3  
    # 相应的运行容器使用的命令  
    docker run -p port1 -p port2 -p port3 image  
    # 还可以指定需要映射到宿主机器上的某个端口号  
    docker run -p host_port1:port1 -p host_port2:port2 -p host_port3:port3 image
    复制代码

端口映射是docker比较重要的一个功能，原因在于我们每次运行容器的时候容器的IP地址不能指定而是在桥接网卡的地址范围内随机生成的。宿主机器的IP地址是固定的，我们可以将容器的端口的映射到宿主机器上的一个端口，免去每次访问容器中的某个服务时都要查看容器的IP的地址。对于一个运行的容器，可以使用docker port加上容器中需要映射的端口和容器的ID来查看该端口号在宿主机器上的映射端口。

*  ENV（用于设置环境变量）

构建指令，在image中设置一个环境变量。

ENV <key> <value>
    复制代码

设置了后，后续的RUN命令都可以使用，container启动后，可以通过docker inspect查看这个环境变量，也可以通过在docker run --env key=value时设置或修改环境变量。  
假如你安装了JAVA程序，需要设置JAVA\_HOME，那么可以在Dockerfile中这样写：

ENV JAVA_HOME /path/to/java/dirent
    复制代码

*  ADD（从src复制文件到container的dest路径）

构建指令，所有拷贝到container中的文件和文件夹权限为0755，uid和gid为0；如果是一个目录，那么会将该目录下的所有文件添加到container中，不包括目录；如果文件是可识别的压缩格式，则docker会帮忙解压缩（注意压缩格式）；如果<src>是文件且<dest>中不使用斜杠结束，则会将<dest>视为文件，<src>的内容会写入<dest>；如果<src>是文件且<dest>中使用斜杠结束，则会<src>文件拷贝到<dest>目录下。

ADD <src> <dest>
    复制代码

<src> 是相对被构建的源目录的相对路径，可以是文件或目录的路径，也可以是一个远程的文件url;  
<dest> 是container中的绝对路径

*  VOLUME（指定挂载点)

设置指令，使容器中的一个目录具有持久化存储数据的功能，该目录可以被容器本身使用，也可以共享给其他容器使用。我们知道容器使用的是AUFS，这种文件系统不能持久化数据，当容器关闭后，所有的更改都会丢失。当容器中的应用有持久化数据的需求时可以在Dockerfile中使用该指令。

FROM base  
    VOLUME ["/tmp/data"]
    复制代码

*  WORKDIR（切换目录）

设置指令，可以多次切换(相当于cd命令)，对RUN,CMD,ENTRYPOINT生效。

# 在 /p1/p2 下执行 vim a.txt  
    WORKDIR /p1 WORKDIR p2 RUN vim a.txt

[docker]: https://yeasy.gitbooks.io/docker_practice/introduction/what.html
[Docker Hub]: https://hub.docker.com/search?q=&type=image&image_filter=official
[nginx]: https://hub.docker.com/_/nginx/
[redis]: https://hub.docker.com/_/redis/
[mongo]: https://hub.docker.com/_/mongo/
[mysql]: https://hub.docker.com/_/mysql/
[httpd]: https://hub.docker.com/_/httpd/
[php]: https://hub.docker.com/_/php/
[tomcat]: https://hub.docker.com/_/tomcat/
[node]: https://hub.docker.com/_/node
[openjdk]: https://hub.docker.com/_/openjdk/
[python]: https://hub.docker.com/_/python/
[ruby]: https://hub.docker.com/_/ruby/
[golang]: https://hub.docker.com/_/golang/
[ubuntu]: https://hub.docker.com/_/ubuntu/
[debian]: https://hub.docker.com/_/debian/
[centos]: https://hub.docker.com/_/centos/
[fedora]: https://hub.docker.com/_/fedora/
[alpine]: https://hub.docker.com/_/alpine/
[swarm]: https://hub.docker.com/_/swarm/
[coreos_etcd]: https://quay.io/repository/coreos/etcd
[Go]: https://golang.org/