安装
一些概念
基本命令
Dockerfile
网络
分区挂载和数据卷
镜像服务器
参考

1. 安装

照着官方文档 https://docs.docker.com/install/linux/docker-ce/ubuntu/ 做吧.

删除旧的包，如果有的话：

sudo apt-get remove docker docker-engine docker.io containerd runc

更新源，并安装依赖的工具：

sudo apt-get update
sudo apt-get install \
     apt-transport-https \
     ca-certificates \
     curl \
     gnupg-agent \
     software-properties-common

添加 Docker 的源：

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo apt-get update
sudo add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
   $(lsb_release -cs) \
   stable"

安装：

sudo apt-get install docker-ce docker-ce-cli containerd.io

安装完成之后, 有一个 docker 命令可供使用. 同时, docker 的服务默认监听在一个 sock 文件上(这样除了命令行工具, 各语言的 API 都很容易实现了).

权限方面, docker 的功能限制于 root 用户, docker 用户组. 所以, 你要么带着 sudo 用, 要么把当前用户加入到 docker 组:

$ sudo groupadd docker
$ sudo gpasswd -a zys docker

重启一下系统吧.

最后, 先安装一个可用的"镜像":

docker pull ubuntu:18.04

这可能需要一点时间, 也可能因为 GFW 的影响而不容易安装成功.

然后作一个 Hello World :

docker run ubuntu:18.04 echo "Hello World"

安装成功.

2. 一些概念

docker 是一套 Linux 的 LXC 管理工具.

LXC (Linux Containers) 的概念类似于虚拟机, 但是形式上有区别. 虚拟机更像是提供"机器环境", 而 LXC 则是提供"运行环境". 单看概念它们的区别有些微妙, 但是 LXC 的特点就是, 同样是提供一套完全隔离的操作系统环境, 它很快, 超级快.

在使用上, 概念上的区别就是, 用虚拟机, 可能更多是想, 做一个电脑, 让它跑起来, 然后再说让这台电脑干什么事.

而 docker 的使用, 则是做一个环境(一组进程, 还有虚拟的设备等), 用环境来运行一个命令. 环境-命令 是一体的(一个容器), 命令一旦执行完成, 那么一个容器实例的任务就结束了. 所以如果我们想让一个容器像一台电脑那样, 通常我们给它一个像 /usr/bin/sshd -D 这样的命令, 这个容器像一台电脑, 是因为这个命令一直"没有执行完成"的效果.

虚拟机的使用, 一个镜像就是一个安装好的系统. 而 docker 中, 镜像更像是一张安装光盘(刻盘后不能更改), 容器才是安装好的系统. 这种两层式结构相较于传统的"快照"机制, 要好用得多. (如何从真正的系统安装 ISO 镜像得到 docker 镜像, 我现在也不清楚怎么做)

更具体一些, 使用 docker , 就是在指定的环境中执行一条命令, 比如:

docker run ubuntu:14.04 /bin/bash

意思就是, 在 ubuntu:14.04 这个环境中, 执行 /bin/bash 这条命令. 当然, 这条命令显然是瞬间就执行完了的. 如果和这个命令立即有交互, 那么需要一些参数:

docker run -t -i ubuntu:14.04 /bin/bash

-t 是分配一个虚拟终端, -i 是获取当前的输入. 这样你可以立即使用一个终端来和这个环境交互了.

虽然终端是正常使用电脑最常用的交互方式, 不过真实使用 docker 的场景中, 会这样用的机会不会很多的. 通常是直接执行我们要做的事, 比如运行一个服务, 或者执行一系列的计算.

使用 nc 来作一个例子:

docker run -t ubuntu:14.04 nc -l 8000

加上 -t 是因为需要一个终端来显示输出, 否则 nc 的标准输出就没地方去了.

docker 安装之后, 会自动在系统中作一个网桥配置, run 出来的每个容器实例, 都会分配一个桥接的 IP 地址. 上面的命令执行之后, 已经有容器在运行了, 并且在其中, nc 正监听着 8000 端口. 我们要接上去试试, 首先需要找到这个容器实例的 IP 地址.

先看当前运行着的实例列表:

docker ps

你先看到下面的信息:

CONTAINER ID  IMAGE         COMMAND     CREATED        STATUS        PORTS  NAMES
e1d0c9193025  ubuntu:14.04  nc -l 8000  5 seconds ago  Up 4 seconds         silly_curie

记下 ID , 不需要全部, 前面几位就可以了, 然后查看指定容器实例的细节:

docker inspect e1d0

会输出一串 json 字符串, 里面会有这样一节:

"NetworkSettings": {
    "Bridge": "docker0",
    "Gateway": "172.17.42.1",
    "IPAddress": "172.17.0.82",
    "IPPrefixLen": 16,
    "PortMapping": null,
    "Ports": {}
},

可以看到, 容器的 IP 是 172.17.0.82 , 上面的网关 IP 172.17.42.1 就是你"实体机"的.

在实体机使用 telnet 连上去:

telnet 172.17.0.82 8000

现在能看到效果了.

^] 然后 quit 退出, nc 那边结束执行, 命令执行完, 之前的那个容器实例也就关闭了. 你使用 docker ps 看不到. 但是使用:

docker ps -a

就能看到所有的容器实例. 在这里列出的实例是真实存在的, 只是当前并没有运行起来而已. 你可以随时让其中的实例再运行起来:

docker start e1d0c9193025

这样你又可以 telnet , 只是没地方看输出.

回顾上面的过程, 提出两个概念, 镜像和容器 .

镜像指上面的 ubuntu:14.04 这种, 嗯, 这种环境, 这种系统. 后面会讲如何做一个自己的镜像 .

容器是在具体的镜像上 run 具体的命令, 得到的一个"绑定状态". run 命令执行时的一些参数(比如和实体机的端口映射), 也是"状态"的一部分, run 过之后就不能更改了.

它们的关系, 有些像编程语言中的类和实例 . run 时的命令就像是类实例化时的参数. 后面会提到, 你可以删除容器 , 也可以删除镜像 . 当你想删除镜像 , 但是使用它的容器还存在时, 你会得到操作失败的提示.

类有继承关系, 得利于 AUFS 这些的层级文件系统, 镜像的构建也是这种层层封装的结果.

3. 基本命令

docker images: 显示镜像列表
docker ps: 显示容器列表
docker run IMAGE_ID: 指定镜像, 运行一个容器
docker start/stop/pause/unpause/kill/restart CONTAINER_ID: 操作容器状态
docker tag IMAGE_ID [REGISTRYHOST/][USERNAME/]NAME[:TAG]: 给指定镜像命名
docker pull/push NAME:TAG: 下载, 推送镜像到 Docker registry server , NAME 部分包括了服务地址
docker rm/rmi CONTAINER_ID/IMAGE_ID: 删除容器, 镜像
docker inspect CONTAINER_ID/IMAGE_ID: 查看细节信息
docker top CONTAINER_ID: 查看指定的运行容器的进程情况
docker info: 查看系统配置信息
docker save/load: 保存, 恢复镜像信息
docker commit CONTAINER_ID: 从容器创建镜像
docker export > xxx.tar: 保存一个容器
docker import - < xxx.tar: 恢复一个容器
docker cp CONTAINER_ID:PATH HOSTPATH: 从镜像复制文件到实体机
docker diff CONTAINER_ID: 查看容器相对于镜像的文件变化
docker logs CONTAINER_ID: 查看容器日志
docker build: 从 Dockerfile 构建镜像
docker history IMAGE_ID: 查看镜像的构建历史

4. Dockerfile

Dockerfile 是记录了镜像是如何被构建出来的配置文件, 可以被 docker 直接执行以创建一个镜像. 它的样子:

FROM ubuntu:14.04
MAINTAINER YS.Zou <>

ADD run /root/run
ADD sources.list /etc/apt/sources.list
ADD id_rsa.pub /tmp/pubkey
ADD requirements /root/requirements

RUN mkdir -p /root/.ssh && \
    cat /tmp/pubkey >> /root/.ssh/authorized_keys && \
    rm -rf /tmp/pubkey
...

CMD ["bash", "/root/run"]

把文件命名为 Dockerfile , 进入文件所在目录, 输入:

docker build .

就可以开始构建过程, 并且得到一个新的镜像了.

Dockerfile 支持一些很简单的命令:

FROM: 以哪个镜像为基础开始构建.
MAINTAINER: 作者信息.
RUN: 运行一条命令.
CMD: docker run IMAGE_ID cmd 这里的默认命令.
ENTRYPOINT: docker run IMAGE_ID cmd 这里的默认命令的前面部分, run 中 cmd 可以作为后续参数.
EXPOSE: 声明会用到的端口.
ENV: 设置环境变量
ADD: 从当前目录复制文件到容器. 会自动处理目录, 压缩包等情况.
COPY: 从当前目录复制文件到容器. 只是单纯地复制文件.
VOLUME: 声明一个数据卷, 可用于挂载.
USER: RUN 命令执行时的用户.
WORKDIR: RUN, CMD, ENTRYPOINT 这些命令执行时的当前目录.
ONBUILD: 前缀命令, 放在上面这些命令前面, 表示生成的镜像再次作为"基础镜像"被用于构建时, 要执行的命令.

build 的过程, 会依次执行上面的命令, 实际上, docker 做的事, 也就是从基础镜像启一个容器, 然后执行一条命令, 修改之后提交此容器为新镜像. 以此类推, 直到所有命令都执行完. 所以在得到最终构建的镜像时, 会生成很多"中间镜像". 而如果 Dockerfile 中某条命令有错, 也是在当前中止, 过程中的"中间镜像"及"当前构建用的容器"仍然存在的.

5. 网络

docker 安装后, 会自动在系统做一个网桥配置 docker0 . 其容器都会分配到此网桥配置下的独立, 私有 IP 地址.

如果你要自己配置桥接, 也可以把 docker0 删除掉. docker run 的时候使用参数 -b 指定你自己配置的网桥.

docker 容器的网络, 是相对于实体机的私有网络. 在网桥配置下, 只要知道 IP 地址, 各容器, 及实体机本身都可以自由通信.

但是在实体机的网卡网络下, docker 容器就不可见了. 要让容器被外界访问到, 最简单的一个方法就是直接做端口映射, 把容器的端口和实体机端口成对连通. docker run 的时候使用 -p 参数就可以指定一对端口映射:

docker run -d -p 5000:22 -p 18888:8888 zys:common

上面的命令, 在启动容器时, 指定的端口映射表示实体机 5000 端口映射到容器 22 端口, 同时 18888 端口映射到容器 8888 端口. 这样做之后, 就可以通过实体机的 5000 端口 ssh 登录到容器了:

ssh root@localhost -p5000
ssh root@realip -p5000

docker run 时还有其它参数可用到控制容器的网络配置:

-p: 端口映射
-h: 设置主机名, 这个主机名是仅容器自己可见的.
--link=CONTAINER_NAME:ALIAS: 把另一个容器的地址配置成一个 ALIAS 主机名.
--dns: 配置 DNS 服务器.

6. 分区挂载和数据卷

容器中的文件系统是独立的, 一旦容器被删除, 则文件系统也会被删除. 如果想容器和实体机在文件系统层面打通, 可以把指定目录挂载到容器当中:

docker run -d -p 5000:22 -v /home/zys/temp:/root/volumn zys:common

使用 -v 参数, 就可以把多个实体机目录挂载到容器的文件系统中.

上面是直观的目录挂载. docker 还有自己的一个 数据卷 的概念. 它可以在容器中定义一些目录, 这些目录不使用层级的 AUFS 文件系统, 并且这些目录独立于容器而存在:

docker run -d -p 5000:22 -v /root/a --name=test zys:common

这样, 其 /root/a 目录就是一个数据卷, 如果使用 docker inspect 查看容器, 可以看到类似下面的信息:

"Volumes": {
    "/root/a": "/var/lib/docker/vfs/dir/xxx"
},
"VolumesRW": {
    "/root/a": true
}

其它的容器可以重用这个数据卷:

docker run -d -p 5000:22 --volumes-from=test zys:common

这里的形式有些别扭啊, 数据卷本来是独立于容器, 但是要想重用它, 又必须基于容器的名字.

当所有容器被删除后, 数据卷本身是还存在的, 但是这时好像没办法再去直接使用它了, 不过里面的数据你可以想办法弄到容器里去再作下一步处理.

7. 镜像服务器

docker 的镜像服务器 docker-registry 是 docker 项目的组成部分. 前面在谈 docker 的命令时, 它的 pull/push 命令就是和镜像服务器打交道. 并且, docker 的设计之中, 服务器地址不是单独配置的, 而是作为镜像名称的一部分.

镜像的完整名称是:

127.0.0.1:5000/zephyr/common:latest

各部分的意思:

127.0.0.1:5000 就是服务器地址
zephyr 是名字空间
common 是镜像名
latest 是版本

docker-registry 的实现也是开源的, 在 github https://github.com/dotcloud/docker-registry 上拿下源码就可以跑起来.

拿下源码之后, 项目中有一个 Dockerfile 文件, 我们可以开始构建镜像了. build 之前, 因为 GFW 的原因, 我们可以先把 Dockerfile 调整一下, 包括两部分:

把 ubuntu 的软件源改成国内的.
把 pip 的源改成国内的.

然后开始构建:

docker build -rm -t registry .

完成之后, 你可以得到一个名为 registry 的镜像, 直接运行即可:

docker run -p 5000:5000 registry

访问 http://localhost:5000 能得到响应, 一个 docker-registry 服务就起来了.

现在你可以把镜像提交到上面去:

docker tag xxx 127.0.0.1:5000/zephyr/common
docker push 127.0.0.1:5000/zephyr/common

完成之后, 在浏览器中访问 http://localhost:5000/v1/search 可以看到列表.

获取镜像:

docker pull 127.0.0.1:5000/zephyr/common

docker-registry 本身是设计成一套 Web API 的, 具体文档在 http://docs.docker.com/reference/api/registry_api/ .

docker 本身的服务, 也是有一套基于网络的 API 可供使用的, 文档在 http://docs.docker.com/reference/api/docker_remote_api/ .

8. 参考

Docker简单使用