dunwu
/
linux-tutorial
mirror of https://github.com/dunwu/linux-tutorial.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

更新文档

pull/11/head
Zhang Peng 2019-02-21 19:26:15 +08:00
parent 4866bae6d3
commit 56d1c908a8
68 changed files with 2355 additions and 1253 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
README.md
View File

@ -1,4 +1,4 @@
# OS
# 操作系统指南
> 作为研发工程师，谁还没干过点运维的活？:joy:
>
@ -8,33 +8,35 @@
## :books: 内容
### [Linux](docs/linux/README.md)
### [Linux](docs/linux)
- [查看 Linux 命令帮助信息](docs/linux/01.查看Linux命令帮助信息.md) - 关键词：`help`, `whatis`, `info`, `which`, `whereis`, `man`
- [Linux 文件目录管理](docs/linux/02.Linux文件目录管理.md) - 关键词：`cd`, `ls`, `pwd`, `mkdir`, `rmdir`, `tree`, `touch`, `ln`, `rename`, `stat`, `file`, `chmod`, `chown`, `locate`, `find`, `cp`, `mv`, `rm`
- [Linux 文件内容查看命令](docs/linux/03.Linux文件内容查看编辑.md) - 关键词：`cat`, `head`, `tail`, `more`, `less`, `sed`, `vi`, `grep`
- [Linux 文件压缩和解压](docs/linux/04.Linux文件压缩和解压.md) - 关键词：`tar`, `gzip`, `zip`, `unzip`
- [Linux 用户管理](docs/linux/05.Linux用户管理.md) - 关键词：`groupadd`, `groupdel`, `groupmod`, `useradd`, `userdel`, `usermod`, `passwd`, `su`, `sudo`
- [Linux 系统管理](docs/linux/06.Linux系统管理.md) - 关键词：`reboot`, `exit`, `shutdown`, `date`, `mount`, `umount`, `ps`, `kill`, `systemctl`, `service`, `crontab`
- [Linux 网络管理](docs/linux/07.Linux网络管理.md) - 关键词：关键词：`curl`, `wget`, `telnet`, `ip`, `hostname`, `ifconfig`, `route`, `ssh`, `ssh-keygen`, `firewalld`, `iptables`, `host`, `nslookup`, `nc`/`netcat`, `ping`, `traceroute`, `netstat`
- [Linux 硬件管理](docs/linux/08.Linux硬件管理.md) - 关键词：`df`, `du`, `top`, `free`, `iotop`
- [Linux 软件管理](docs/linux/09.Linux软件管理.md) - 关键词：`rpm`, `yum`, `apt-get`
- [samba 使用详解](docs/linux/samba使用详解.md)
- [命令行的艺术（转载）](docs/linux/命令行的艺术.md)
#### [Linux 命令](docs/linux/cli)
### [Shell](docs/shell.md)
> 根据应用场景，将常见 Linux 命令分门别类的一一介绍。
>
> 如果想快速学习，推荐参考这篇文章：[命令行的艺术（转载）](docs/linux/cli/命令行的艺术.md)
### [Python](docs/python.md)
1. [查看 Linux 命令帮助信息](docs/linux/cli/01.查看Linux命令帮助信息.md) - 关键词：`help`, `whatis`, `info`, `which`, `whereis`, `man`
2. [Linux 文件目录管理](docs/linux/cli/02.Linux文件目录管理.md) - 关键词：`cd`, `ls`, `pwd`, `mkdir`, `rmdir`, `tree`, `touch`, `ln`, `rename`, `stat`, `file`, `chmod`, `chown`, `locate`, `find`, `cp`, `mv`, `rm`
3. [Linux 文件内容查看命令](docs/linux/cli/03.Linux文件内容查看编辑.md) - 关键词：`cat`, `head`, `tail`, `more`, `less`, `sed`, `vi`, `grep`
4. [Linux 文件压缩和解压](docs/linux/cli/04.Linux文件压缩和解压.md) - 关键词：`tar`, `gzip`, `zip`, `unzip`
5. [Linux 用户管理](docs/linux/cli/05.Linux用户管理.md) - 关键词：`groupadd`, `groupdel`, `groupmod`, `useradd`, `userdel`, `usermod`, `passwd`, `su`, `sudo`
6. [Linux 系统管理](docs/linux/cli/06.Linux系统管理.md) - 关键词：`reboot`, `exit`, `shutdown`, `date`, `mount`, `umount`, `ps`, `kill`, `systemctl`, `service`, `crontab`
7. [Linux 网络管理](docs/linux/cli/07.Linux网络管理.md) - 关键词：关键词：`curl`, `wget`, `telnet`, `ip`, `hostname`, `ifconfig`, `route`, `ssh`, `ssh-keygen`, `firewalld`, `iptables`, `host`, `nslookup`, `nc`/`netcat`, `ping`, `traceroute`, `netstat`
8. [Linux 硬件管理](docs/linux/cli/08.Linux硬件管理.md) - 关键词：`df`, `du`, `top`, `free`, `iotop`
9. [Linux 软件管理](docs/linux/cli/09.Linux软件管理.md) - 关键词：`rpm`, `yum`, `apt-get`
### [Vim](docs/vim.md)
#### [Linux 工具](docs/linux/tool)
### [Docker](docs/docker/README.md)
- [Git](docs/linux/tool/git)
- [Vim](docs/linux/tool/vim.md)
### Windows
#### [Linux 脚本编程](docs/linux/scripts)
- [Windows 工具](docs/windows/Windows工具.md)
- [Shell](docs/linux/scripts/shell.md)
- [Python](docs/linux/scripts/python.md)
## :hammer_and_pick: 常见软件安装/配置/使用指南
#### [Linux 运维](docs/linux/ops)
> :bulb: **说明**
>
@ -42,51 +44,41 @@
>
> [环境部署工具](codes/deploy/README.md) ：适合开发、运维人员，在 [CentOS](https://www.centos.org/) 机器上安装常用命令工具或开发软件。
>
> - *`Scripts`：安装配置脚本，按照说明安装使用即可。*
> - *`Docs`: 安装配置文档，说明安装的方法以及一些注意事项。*
> - *`Tutorial`: 教程文档。*
#### 研发环境
> - _`Scripts`：安装配置脚本，按照说明安装使用即可。_
> - _`Docs`: 安装配置文档，说明安装的方法以及一些注意事项。_
> - _`Tutorial`: 教程文档。_
- 研发环境
- JDK
- | [**`Scripts`**](codes/deploy/tool/jdk) | [**`Docs`**](docs/tool/jdk.md) |
- | [**`Scripts`**](codes/deploy/tool/jdk) | [**`Docs`**](docs/linux/ops/service/jdk.md) |
- Maven
- | [**`Scripts`**](codes/deploy/tool/maven) | [**`Tutorial`**](https://github.com/dunwu/javastack/tree/master/docs/javatool/build/maven) |
- Nginx
- | [**`Scripts`**](codes/deploy/tool/nginx) | [**`Tutorial`**](https://github.com/dunwu/nginx-tutorial) |
- Nodejs
- | [**`Scripts`**](codes/deploy/tool/nodejs) | [**`Docs`**](docs/tool/nodejs.md) |
- | [**`Scripts`**](codes/deploy/tool/nodejs) | [**`Docs`**](docs/linux/ops/service/nodejs.md) |
- Tomcat
- | [**`Scripts`**](codes/deploy/tool/tomcat) | [**`Docs`**](docs/tool/tomcat.md) |
- | [**`Scripts`**](codes/deploy/tool/tomcat) | [**`Docs`**](docs/linux/ops/service/tomcat.md) |
- Zookeeper
- | [**`Scripts`**](codes/deploy/tool/zookeeper) | [**`Docs`**](docs/tool/zookeeper.md) |
#### 研发工具
- | [**`Scripts`**](codes/deploy/tool/zookeeper) | [**`Docs`**](docs/linux/ops/service/zookeeper.md) |
- 研发工具
- Nexus - Maven 私服。
- | [**`Docs`**](docs/tool/nexus.md) |
- Gitlab - Git 代码管理平台。
- | [**`Docs`**](docs/linux/ops/service/nexus.md) |
。
- Jenkins - 持续集成和持续交付平台。
- | [**`Scripts`**](codes/deploy/tool/jenkins) | [**`Docs`**](docs/tool/jenkins.md) |
- | [**`Scripts`**](codes/deploy/tool/jenkins) | [**`Docs`**](docs/linux/ops/service/jenkins.md) |
- Elastic - 常被称为 `ELK` ，是 Java 世界最流行的分布式日志解决方案 。 `ELK` 是 Elastic 公司旗下三款产品 [ElasticSearch](https://www.elastic.co/products/elasticsearch) 、[Logstash](https://www.elastic.co/products/logstash) 、[Kibana](https://www.elastic.co/products/kibana) 的首字母组合。
- | [**`Tutorial`**](docs/tool/elastic/README.md) |
#### 版本控制
- Git
- | [**`Tutorial`**](docs/git/README.md) |
- | [**`Tutorial`**](docs/linux/ops/service/elastic/README.md) |
- 版本控制
- Gitlab - Git 代码管理平台
- Svn - Svn 是 Subversion 的简称，是一个开放源代码的版本控制系统，它采用了分支管理系统。
- | [**`Docs`**](docs/tool/svn.md) |
#### 消息中间件
- | [**`Docs`**](docs/linux/ops/service/svn.md) |
- 消息中间件
- Kafka - 应该是 Java 世界最流行的消息中间件了吧。
- | [**`Scripts`**](codes/deploy/tool/kafka) | [**`Docs`**](docs/tool/kafka.md) |
- | [**`Scripts`**](codes/deploy/tool/kafka) | [**`Docs`**](docs/linux/ops/service/kafka.md) |
- RocketMQ - 阿里巴巴开源的消息中间件。
- | [**`Scripts`**](codes/deploy/tool/rocketmq) | [**`Docs`**](docs/tool/rocketmq.md) |
#### 数据库
- | [**`Scripts`**](codes/deploy/tool/rocketmq) | [**`Docs`**](docs/linux/ops/service/rocketmq.md) |
- 数据库
- Mysql - 关系型数据库
- | [**`Docs`**](https://github.com/dunwu/database/blob/master/docs/mysql/install-mysql.md) |
- PostgreSQL - 关系型数据库
@ -95,3 +87,9 @@
- | [**`Scripts`**](codes/deploy/tool/mongodb) | [**`Docs`**](https://github.com/dunwu/database/blob/master/docs/mongodb/install-mongodb.md) |
- Redis - Nosql
- | [**`Scripts`**](codes/deploy/tool/redis) | [**`Docs`**](https://github.com/dunwu/database/blob/master/docs/redis/install-redis.md) |
### [Windows](docs/windows)
- [Windows 工具](docs/windows/Windows工具.md)
### [Docker](docs/docker)

15
docs/README.md 100644
View File

@ -0,0 +1,15 @@
# 操作系统
> :dart: 所有配套源码整理归档在 [**os-tutorial**](https://github.com/dunwu/os-tutorial) 项目中。
## :memo: 知识点
- [Linux](linux)
- [Windows](windows)
- [Docker](docker)
## :books: 学习资源
## :door: 传送门
| [回首頁](https://github.com/dunwu/os-tutorial) |

29
docs/docker/README.md
View File

@ -1,29 +0,0 @@
# Docker
> [Docker](https://www.docker.com/) 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。
>
> 容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）。几乎没有性能开销，可以很容易地在机器和数据中心中运行。最重要的是，他们不依赖于任何语言、框架或包装系统。
## 知识大纲
- [x] [Docker 快速指南](docker-quickstart.md)
- [x] [Docker Cheat Sheet](docker-cheat-sheet.md)
- [ ] 基础篇（basics）
- [x] [Docker 简介](basics/docker-introduction.md)
- [x] [Docker 安装](basics/docker-install.md)
- [x] [Docker 之 Hello World](basics/docker-helloworld.md)
- [ ] 配置（configuration）
- [ ] 进阶篇（advanced）
- [x] [Docker 的设计](advanced/docker-design.md)
- [x] 实践篇（practice）
- [x] [Docker 安装 MySQL](practice/docker-install-mysql.md)
- [x] [Docker 安装 Nginx](practice/docker-install-nginx.md)
- [ ] 常见问题（faq）
- [x] [附录](appendix/README.md)
- [x] [Docker 命令](appendix/docker-cli.md)
- [x] [Docker 资源](appendix/docker-resource.md)
- [x] [Docker 术语](appendix/docker-glossary.md)
- [x] [Docker 技巧](appendix/docker-recipe.md)
_知识点仍在完善中。。。_

8
docs/docker/appendix/README.md
View File

@ -1,8 +0,0 @@
# 附录
## 内容
* [Docker 命令](docker-cli.md)
* [Docker 资源](docker-resource.md)
* [Docker 术语](docker-glossary.md)
* [Docker 技巧](docker-recipe.md)

139
docs/docker/appendix/docker-cli.md
View File

@ -1,10 +1,139 @@
# Docker 命令
## 命令行大纲
<!-- TOC depthFrom:2 depthTo:3 -->
![docker-cli.png](images/docker-cli.png)
- [镜像(Images)](#镜像images)
- [容器(Container)](#容器container)
- [生命周期](#生命周期)
- [启动和停止](#启动和停止)
- [信息](#信息)
- [导入 / 导出](#导入--导出)
- [执行命令](#执行命令)
- [网络(Networks)](#网络networks)
- [生命周期](#生命周期-1)
- [信息](#信息-1)
- [链接](#链接)
- [仓管中心和仓库(Registry & Repository)](#仓管中心和仓库registry--repository)
- [Dockerfile](#dockerfile)
- [卷标(Volumes)](#卷标volumes)
- [生命周期](#生命周期-2)
- [信息](#信息-2)
- [引用和引申](#引用和引申)
## 资料
<!-- /TOC -->
* https://docs.docker.com/engine/reference/commandline/cli/
* http://www.runoob.com/docker/docker-command-manual.html
## 镜像(Images)
- [`docker image ls`](https://github.com/yeasy/docker_practice/blob/master/image/list.md) - 查看所有镜像。
- [`docker image rm`](https://github.com/yeasy/docker_practice/blob/master/image/rm.md) - 删除本地镜像。
- `docker import` - 从压缩文件中创建镜像。
- `docker export` - 导出既有容器。
- `docker build` - 从 Dockerfile 创建镜像。
- `docker commit` - 为容器创建镜像，如果容器正在运行则会临时暂停。
- `docker rmi` - 删除镜像。
- `docker load` - 通过 STDIN 从压缩包加载镜像，包括镜像和标签(images and tags) (0.7 起).
- `docker save` - 通过 STDOUT 保存镜像到压缩包，包括所有的父层，标签和版本(parent layers, tags & versions) (0.7 起).
- `docker history` - 查看镜像历史记录。
- `docker tag` - 给镜像命名打标(tags) (本地或者仓库)。
## 容器(Container)
### 生命周期
- `docker create` - 创建一个容器但是不启动。
- `docker rename` - 允许重命名容器。
- `docker run` - 在同一个操作中创建并启动一个容器。
- `docker rm` - 删除容器。
- `docker update` - 更新容器的资源限制。
### 启动和停止
- `docker start` - 启动容器。
- `docker stop` - 停止运行中的容器。
- `docker restart` - 停止之后再启动容器。
- `docker pause` - 暂停运行中的容器，将其 "冻结" 在当前状态。
- `docker unpause` - 结束容器暂停状态。
- `docker wait` - 阻塞，到运行中的容器停止为止。
- `docker kill` - 向运行中容器发送 SIGKILL 指令。
- `docker attach` - 链接到运行中容器。
### 信息
- `docker ps` - 查看运行中的所有容器。
- `docker logs` - 从容器中获取日志。(你也可以使用自定义日志驱动，不过在 1.10 中，它只支持 json-file 和 journald)
- `docker inspect` - 查看某个容器的所有信息(包括 IP 地址)。
- `docker events` - 从容器中获取事件(events)。
- `docker port` - 查看容器的公开端口。
- `docker top` - 查看容器中活动进程。
- `docker stats` - 查看容器的资源使用情况统计信息。
- `docker diff` - 查看容器的 FS 中有变化文件信息。
### 导入 / 导出
docker cp 在容器和本地文件系统之间复制文件或文件夹。
docker export 将容器的文件系统切换为压缩包(tarball archive stream)输出到 STDOUT。
### 执行命令
docker exec 在容器中执行命令。
## 网络(Networks)
### 生命周期
- `docker network create`
- `docker network rm`
### 信息
- `docker network ls`
- `docker network inspect`
### 链接
- `docker network connect`
- `docker network disconnect`
## 仓管中心和仓库(Registry & Repository)
- `docker login` - 登入仓管中心。
- `docker logout` - 登出仓管中心。
- `docker search` - 从仓管中心检索镜像。
- `docker pull` - 从仓管中心拉去镜像到本地。
- `docker push` - 从本地推送镜像到仓管中心。
## Dockerfile
- .dockerignore
- FROM 为其他指令设置基础镜像(Base Image)。
- MAINTAINER 为生成的镜像设置作者字段。
- RUN 在当前镜像的基础上生成一个新层并执行命令。
- CMD 设置容器默认执行命令。
- EXPOSE 告知 Docker 容器在运行时所要监听的网络端口。注意：并没有实际上将端口设置为可访问。
- ENV 设置环境变量。
- ADD 将文件，文件夹或者远程文件复制到容器中。缓存无效。尽量用 COPY 代替 ADD。
- COPY 将文件或文件夹复制到容器中。
- ENTRYPOINT 将一个容器设置为可执行。
- VOLUME 为外部挂载卷标或其他容器设置挂载点(mount point)。
- USER 设置执行 RUN / CMD / ENTRYPOINT 命令的用户名。
- WORKDIR 设置工作目录。
- ARG 定义编译时(build-time)变量。
- ONBUILD 添加触发指令，当该镜像被作为其他镜像的基础镜像时该指令会被触发。
- STOPSIGNAL 设置通过系统向容器发出退出指令。
- LABEL 将键值对元数据(key/value metadata)应用到你的镜像，容器，或者守护进程。
## 卷标(Volumes)
### 生命周期
- `docker volume create`
- `docker volume rm`
### 信息
- `docker volume ls`
- `docker volume inspect`
## 引用和引申
https://github.com/wsargent/docker-cheat-sheet/tree/master/zh-cn

30
docs/docker/appendix/docker-resource.md
View File

@ -1,30 +0,0 @@
# Docker 资源
## Docker 官方资源
* Docker 官网：http://www.docker.com
* Docker Github：https://github.com/moby/moby
* Docker 官方文档：https://docs.docker.com/
* Docker windows 入门：https://docs.docker.com/windows/
* Docker Linux 入门：https://docs.docker.com/linux/
* Docker mac 入门：https://docs.docker.com/mac/
* Docker 用户指引：https://docs.docker.com/engine/userguide/
* Docker 官方博客：http://blog.docker.com/
* Docker Hub: https://hub.docker.com/
* Docker 开源： https://www.docker.com/open-source
## 资源整理
* Awesome Docker： https://github.com/veggiemonk/awesome-docker
## Docker 中文资源
* Docker中文网站：https://www.docker-cn.com/
* Docker安装手册：https://docs.docker-cn.com/engine/installation/
## Docker 国内镜像
* 网易加速器：http://hub-mirror.c.163.com
* 官方中国加速器：https://registry.docker-cn.com
* ustc的镜像：https://docker.mirrors.ustc.edu.cn
* daocloud：https://www.daocloud.io/mirror#accelerator-doc（注册后使用）

30
docs/docker/appendix/docker-resources.md 100644
View File

@ -0,0 +1,30 @@
# Docker 资源
## Docker 官方资源
- Docker 官网：http://www.docker.com
- Docker Github：https://github.com/moby/moby
- Docker 官方文档：https://docs.docker.com/
- Docker windows 入门：https://docs.docker.com/windows/
- Docker Linux 入门：https://docs.docker.com/linux/
- Docker mac 入门：https://docs.docker.com/mac/
- Docker 用户指引：https://docs.docker.com/engine/userguide/
- Docker 官方博客：http://blog.docker.com/
- Docker Hub: https://hub.docker.com/
- Docker 开源： https://www.docker.com/open-source
## 资源整理
- Awesome Docker： https://github.com/veggiemonk/awesome-docker
## Docker 中文资源
- Docker 中文网站：https://www.docker-cn.com/
- Docker 安装手册：https://docs.docker-cn.com/engine/installation/
## Docker 国内镜像
- 网易加速器：http://hub-mirror.c.163.com
- 官方中国加速器：https://registry.docker-cn.com
- ustc 的镜像：https://docker.mirrors.ustc.edu.cn
- daocloud：https://www.daocloud.io/mirror#accelerator-doc（注册后使用）

BIN
docs/docker/appendix/images/docker-cli.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 62 KiB

261
docs/docker/basics/docker-container.md 100644
View File

@ -0,0 +1,261 @@
# Docker 容器
容器是独立运行的一个或一组应用，以及它们的运行态环境。对应的，虚拟机可以理解为模拟运行的一整套操作系统（提供了运行态环境和其他系统环境）和跑在上面的应用。
<!-- TOC depthFrom:2 depthTo:3 -->
- [启动容器](#启动容器)
- [新建并启动](#新建并启动)
- [启动已终止容器](#启动已终止容器)
- [后台运行](#后台运行)
- [终止容器](#终止容器)
- [进入容器](#进入容器)
- [`attach` 命令](#attach-命令)
- [`exec` 命令](#exec-命令)
- [导出和导入容器](#导出和导入容器)
- [导出容器](#导出容器)
- [导入容器快照](#导入容器快照)
- [删除容器](#删除容器)
- [清理所有处于终止状态的容器](#清理所有处于终止状态的容器)
<!-- /TOC -->
## 启动容器
启动容器有两种方式，一种是基于镜像新建一个容器并启动，另外一个是将在终止状态（`stopped`）的容器重新启动。
因为 Docker 的容器实在太轻量级了，很多时候用户都是随时删除和新创建容器。
### 新建并启动
所需要的命令主要为 `docker run`。
例如，下面的命令输出一个 “Hello World”，之后终止容器。
```bash
$ docker run ubuntu:14.04 /bin/echo 'Hello world'
Hello world
```
这跟在本地直接执行 `/bin/echo 'hello world'` 几乎感觉不出任何区别。
下面的命令则启动一个 bash 终端，允许用户进行交互。
```bash
$ docker run -t -i ubuntu:14.04 /bin/bash
root@af8bae53bdd3:/#
```
其中，`-t` 选项让 Docker 分配一个伪终端（pseudo-tty）并绑定到容器的标准输入上， `-i` 则让容器的标准输入保持打开。
在交互模式下，用户可以通过所创建的终端来输入命令，例如
```bash
root@af8bae53bdd3:/# pwd
/
root@af8bae53bdd3:/# ls
bin boot dev etc home lib lib64 media mnt opt proc root run sbin srv sys tmp usr var
```
当利用 `docker run` 来创建容器时，Docker 在后台运行的标准操作包括：
- 检查本地是否存在指定的镜像，不存在就从公有仓库下载
- 利用镜像创建并启动一个容器
- 分配一个文件系统，并在只读的镜像层外面挂载一层可读写层
- 从宿主主机配置的网桥接口中桥接一个虚拟接口到容器中去
- 从地址池配置一个 ip 地址给容器
- 执行用户指定的应用程序
- 执行完毕后容器被终止
### 启动已终止容器
可以利用 `docker container start` 命令，直接将一个已经终止的容器启动运行。
容器的核心为所执行的应用程序，所需要的资源都是应用程序运行所必需的。除此之外，并没有其它的资源。可以在伪终端中利用 `ps` 或 `top` 来查看进程信息。
```bash
root@ba267838cc1b:/# ps
PID TTY TIME CMD
1 ? 00:00:00 bash
11 ? 00:00:00 ps
```
可见，容器中仅运行了指定的 bash 应用。这种特点使得 Docker 对资源的利用率极高，是货真价实的轻量级虚拟化。
## 后台运行
更多的时候，需要让 Docker 在后台运行而不是直接把执行命令的结果输出在当前宿主机下。此时，可以通过添加 `-d` 参数来实现。
下面举两个例子来说明一下。
如果不使用 `-d` 参数运行容器。
```bash
$ docker run ubuntu:18.04 /bin/sh -c "while true; do echo hello world; sleep 1; done"
hello world
hello world
hello world
hello world
```
容器会把输出的结果 (STDOUT) 打印到宿主机上面
如果使用了 `-d` 参数运行容器。
```bash
$ docker run -d ubuntu:18.04 /bin/sh -c "while true; do echo hello world; sleep 1; done"
77b2dc01fe0f3f1265df143181e7b9af5e05279a884f4776ee75350ea9d8017a
```
此时容器会在后台运行并不会把输出的结果 (STDOUT) 打印到宿主机上面(输出结果可以用 `docker logs` 查看)。
**注：** 容器是否会长久运行，是和 `docker run` 指定的命令有关，和 `-d` 参数无关。
使用 `-d` 参数启动后会返回一个唯一的 id，也可以通过 `docker container ls` 命令来查看容器信息。
```
$ docker container ls
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
77b2dc01fe0f ubuntu:18.04 /bin/sh -c 'while tr 2 minutes ago Up 1 minute agitated_wright
```
要获取容器的输出信息，可以通过 `docker container logs` 命令。
```bash
$ docker container logs [container ID or NAMES]
hello world
hello world
hello world
. . .
```
## 终止容器
可以使用 `docker container stop` 来终止一个运行中的容器。
此外，当 Docker 容器中指定的应用终结时，容器也自动终止。
例如对于上一章节中只启动了一个终端的容器，用户通过 `exit` 命令或 `Ctrl+d` 来退出终端时，所创建的容器立刻终止。
终止状态的容器可以用 `docker container ls -a` 命令看到。例如
```bash
docker container ls -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
ba267838cc1b ubuntu:14.04 "/bin/bash" 30 minutes ago Exited (0) About a minute ago trusting_newton
98e5efa7d997 training/webapp:latest "python app.py" About an hour ago Exited (0) 34 minutes ago backstabbing_pike
```
处于终止状态的容器，可以通过 `docker container start` 命令来重新启动。
此外，`docker container restart` 命令会将一个运行态的容器终止，然后再重新启动它。
## 进入容器
在使用 `-d` 参数时，容器启动后会进入后台。
某些时候需要进入容器进行操作，包括使用 `docker attach` 命令或 `docker exec` 命令，推荐大家使用 `docker exec` 命令，原因会在下面说明。
### `attach` 命令
`docker attach` 是 Docker 自带的命令。下面示例如何使用该命令。
```bash
$ docker run -dit ubuntu
243c32535da7d142fb0e6df616a3c3ada0b8ab417937c853a9e1c251f499f550
$ docker container ls
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
243c32535da7 ubuntu:latest "/bin/bash" 18 seconds ago Up 17 seconds nostalgic_hypatia
$ docker attach 243c
root@243c32535da7:/#
```
_注意：_ 如果从这个 stdin 中 exit，会导致容器的停止。
### `exec` 命令
#### -i -t 参数
`docker exec` 后边可以跟多个参数，这里主要说明 `-i` `-t` 参数。
只用 `-i` 参数时，由于没有分配伪终端，界面没有我们熟悉的 Linux 命令提示符，但命令执行结果仍然可以返回。
当 `-i` `-t` 参数一起使用时，则可以看到我们熟悉的 Linux 命令提示符。
```bash
$ docker run -dit ubuntu
69d137adef7a8a689cbcb059e94da5489d3cddd240ff675c640c8d96e84fe1f6
$ docker container ls
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
69d137adef7a ubuntu:latest "/bin/bash" 18 seconds ago Up 17 seconds zealous_swirles
$ docker exec -i 69d1 bash
ls
bin
boot
dev
...
$ docker exec -it 69d1 bash
root@69d137adef7a:/#
```
如果从这个 stdin 中 exit，不会导致容器的停止。这就是为什么推荐大家使用 `docker exec` 的原因。
更多参数说明请使用 `docker exec --help` 查看。
## 导出和导入容器
### 导出容器
如果要导出本地某个容器，可以使用 `docker export` 命令。
```bash
$ docker container ls -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
7691a814370e ubuntu:14.04 "/bin/bash" 36 hours ago Exited (0) 21 hours ago test
$ docker export 7691a814370e > ubuntu.tar
```
这样将导出容器快照到本地文件。
### 导入容器快照
可以使用 `docker import` 从容器快照文件中再导入为镜像，例如
```bash
$ cat ubuntu.tar | docker import - test/ubuntu:v1.0
$ docker image ls
REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE
test/ubuntu v1.0 9d37a6082e97 About a minute ago 171.3 MB
```
此外，也可以通过指定 URL 或者某个目录来导入，例如
```bash
$ docker import http://example.com/exampleimage.tgz example/imagerepo
```
_注：用户既可以使用 docker load 来导入镜像存储文件到本地镜像库，也可以使用 docker import 来导入一个容器快照到本地镜像库。这两者的区别在于容器快照文件将丢弃所有的历史记录和元数据信息（即仅保存容器当时的快照状态），而镜像存储文件将保存完整记录，体积也要大。此外，从容器快照文件导入时可以重新指定标签等元数据信息。_
## 删除容器
可以使用 `docker container rm` 来删除一个处于终止状态的容器。例如
```bash
$ docker container rm trusting_newton
trusting_newton
```
如果要删除一个运行中的容器，可以添加 `-f` 参数。Docker 会发送 `SIGKILL` 信号给容器。
## 清理所有处于终止状态的容器
用 `docker container ls -a` 命令可以查看所有已经创建的包括终止状态的容器，如果数量太多要一个个删除可能会很麻烦，用下面的命令可以清理掉所有处于终止状态的容器。
```bash
$ docker container prune
```

1
docs/docker/basics/docker-containers.md
View File

@ -1 +0,0 @@
Docker 容器

667
docs/docker/basics/docker-dockerfile.md
View File

@ -1,86 +1,649 @@
# Dockerfile
## 格式
<!-- TOC depthFrom:2 depthTo:3 -->
Dockerfile 中，对于指令不区分大小写，但是推荐使用大写，来区别于参数。
- [Dockerfile 指令](#dockerfile-指令)
- [FROM(指定基础镜像)](#from指定基础镜像)
- [RUN(执行命令)](#run执行命令)
- [COPY(复制文件)](#copy复制文件)
- [ADD(更高级的复制文件)](#add更高级的复制文件)
- [CMD(容器启动命令)](#cmd容器启动命令)
- [ENTRYPOINT(入口点)](#entrypoint入口点)
- [ENV(设置环境变量)](#env设置环境变量)
- [ARG(构建参数)](#arg构建参数)
- [VOLUME(定义匿名卷)](#volume定义匿名卷)
- [EXPOSE(暴露端口)](#expose暴露端口)
- [WORKDIR(指定工作目录)](#workdir指定工作目录)
- [USER(指定当前用户)](#user指定当前用户)
- [HEALTHCHECK(健康检查)](#healthcheck健康检查)
- [ONBUILD(为他人作嫁衣裳)](#onbuild为他人作嫁衣裳)
- [引用和引申](#引用和引申)
Dockerfile 中，将按照指令（instruction）出现次序依次执行。**注意：Dockerfile 必须从 `FROM` 指令开始。**
<!-- /TOC -->
Dockerfile 中，将 `#` 开头的行作为注释，除非该行是有效的解析指令（parser directives）。一行中的 `#` 标记被视为参数。注释中不支持换行符。
## Dockerfile 指令
### FROM(指定基础镜像)
> 作用：
>
> `FROM` 指令用于指定基础镜像。
所谓定制镜像，那一定是以一个镜像为基础，在其上进行定制。就像我们之前运行了一个 `nginx` 镜像的容器，再进行修改一样，基础镜像是必须指定的。而 `FROM` 就是指定**基础镜像**，因此一个 `Dockerfile` 中 `FROM` 是必备的指令，并且必须是第一条指令。
在 [Docker Store](https://store.docker.com/) 上有非常多的高质量的官方镜像，有可以直接拿来使用的服务类的镜像，如 [`nginx`](https://store.docker.com/images/nginx/)、[`redis`](https://store.docker.com/images/redis/)、[`mongo`](https://store.docker.com/images/mongo/)、[`mysql`](https://store.docker.com/images/mysql/)、[`httpd`](https://store.docker.com/images/httpd/)、[`php`](https://store.docker.com/images/php/)、[`tomcat`](https://store.docker.com/images/tomcat/) 等；也有一些方便开发、构建、运行各种语言应用的镜像，如 [`node`](https://store.docker.com/images/node)、[`openjdk`](https://store.docker.com/images/openjdk/)、[`python`](https://store.docker.com/images/python/)、[`ruby`](https://store.docker.com/images/ruby/)、[`golang`](https://store.docker.com/images/golang/) 等。可以在其中寻找一个最符合我们最终目标的镜像为基础镜像进行定制。
如果没有找到对应服务的镜像，官方镜像中还提供了一些更为基础的操作系统镜像，如 [`ubuntu`](https://store.docker.com/images/ubuntu/)、[`debian`](https://store.docker.com/images/debian/)、[`centos`](https://store.docker.com/images/centos/)、[`fedora`](https://store.docker.com/images/fedora/)、[`alpine`](https://store.docker.com/images/alpine/) 等，这些操作系统的软件库为我们提供了更广阔的扩展空间。
除了选择现有镜像为基础镜像外，Docker 还存在一个特殊的镜像，名为 `scratch`。这个镜像是虚拟的概念，并不实际存在，它表示一个空白的镜像。
```dockerfile
FROM scratch
...
```
如果你以 `scratch` 为基础镜像的话，意味着你不以任何镜像为基础，接下来所写的指令将作为镜像第一层开始存在。
不以任何系统为基础，直接将可执行文件复制进镜像的做法并不罕见，比如 [`swarm`](https://hub.docker.com/_/swarm/)、[`coreos/etcd`](https://quay.io/repository/coreos/etcd)。对于 Linux 下静态编译的程序来说，并不需要有操作系统提供运行时支持，所需的一切库都已经在可执行文件里了，因此直接 `FROM scratch` 会让镜像体积更加小巧。使用 [Go 语言](https://golang.org/) 开发的应用很多会使用这种方式来制作镜像，这也是为什么有人认为 Go 是特别适合容器微服务架构的语言的原因之一。
### RUN(执行命令)
`RUN` 指令是用来执行命令行命令的。由于命令行的强大能力，`RUN` 指令在定制镜像时是最常用的指令之一。其格式有两种：
- _shell_ 格式：`RUN <命令>`，就像直接在命令行中输入的命令一样。刚才写的 Dockerfile 中的 `RUN` 指令就是这种格式。
```dockerfile
RUN echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.html
```
- _exec_ 格式：`RUN ["可执行文件", "参数1", "参数2"]`，这更像是函数调用中的格式。
既然 `RUN` 就像 Shell 脚本一样可以执行命令，那么我们是否就可以像 Shell 脚本一样把每个命令对应一个 RUN 呢？比如这样：
```dockerfile
FROM debian:jessie
RUN apt-get update
RUN apt-get install -y gcc libc6-dev make
RUN wget -O redis.tar.gz "http://download.redis.io/releases/redis-3.2.5.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
```
之前说过，Dockerfile 中每一个指令都会建立一层，`RUN` 也不例外。每一个 `RUN` 的行为，就和刚才我们手工建立镜像的过程一样：新建立一层，在其上执行这些命令，执行结束后，`commit` 这一层的修改，构成新的镜像。
而上面的这种写法，创建了 7 层镜像。这是完全没有意义的，而且很多运行时不需要的东西，都被装进了镜像里，比如编译环境、更新的软件包等等。结果就是产生非常臃肿、非常多层的镜像，不仅仅增加了构建部署的时间，也很容易出错。 这是很多初学 Docker 的人常犯的一个错误。
_Union FS 是有最大层数限制的，比如 AUFS，曾经是最大不得超过 42 层，现在是不得超过 127 层。_
上面的 `Dockerfile` 正确的写法应该是这样：
```dockerfile
FROM debian:jessie
RUN buildDeps='gcc libc6-dev make' \
&& apt-get update \
&& apt-get install -y $buildDeps \
&& wget -O redis.tar.gz "http://download.redis.io/releases/redis-3.2.5.tar.gz" \
&& mkdir -p /usr/src/redis \
&& tar -xzf redis.tar.gz -C /usr/src/redis --strip-components=1 \
&& make -C /usr/src/redis \
&& make -C /usr/src/redis install \
&& rm -rf /var/lib/apt/lists/* \
&& rm redis.tar.gz \
&& rm -r /usr/src/redis \
&& apt-get purge -y --auto-remove $buildDeps
```
首先，之前所有的命令只有一个目的，就是编译、安装 redis 可执行文件。因此没有必要建立很多层，这只是一层的事情。因此，这里没有使用很多个 `RUN` 对一一对应不同的命令，而是仅仅使用一个 `RUN` 指令，并使用 `&&` 将各个所需命令串联起来。将之前的 7 层，简化为了 1 层。在撰写 Dockerfile 的时候，要经常提醒自己，这并不是在写 Shell 脚本，而是在定义每一层该如何构建。
并且，这里为了格式化还进行了换行。Dockerfile 支持 Shell 类的行尾添加 `\` 的命令换行方式，以及行首 `#` 进行注释的格式。良好的格式，比如换行、缩进、注释等，会让维护、排障更为容易，这是一个比较好的习惯。
此外，还可以看到这一组命令的最后添加了清理工作的命令，删除了为了编译构建所需要的软件，清理了所有下载、展开的文件，并且还清理了 `apt` 缓存文件。这是很重要的一步，我们之前说过，镜像是多层存储，每一层的东西并不会在下一层被删除，会一直跟随着镜像。因此镜像构建时，一定要确保每一层只添加真正需要添加的东西，任何无关的东西都应该清理掉。
很多人初学 Docker 制作出了很臃肿的镜像的原因之一，就是忘记了每一层构建的最后一定要清理掉无关文件。
### COPY(复制文件)
> 作用：
>
> **`COPY` 指令将从构建上下文目录中 `<源路径>` 的文件/目录复制到新的一层的镜像内的 `<目标路径>` 位置。**
格式：
- `COPY [--chown=<user>:<group>] <源路径>... <目标路径>`
- `COPY [--chown=<user>:<group>] ["<源路径1>",... "<目标路径>"]`
示例：
```
# Comment
RUN echo 'we are running some # of cool things'
```dockerfile
COPY package.json /usr/src/app/
```
## 解析指令（parser directives）
`<源路径>` 可以是多个，甚至可以是通配符，其通配符规则要满足 Go 的 [`filepath.Match`](https://golang.org/pkg/path/filepath/#Match) 规则，如：
解析指令是可选的，并且会影响 Dockerfile 中后续行的处理方式。解析指令不会将图层添加到构建中，并且不会显示为构建步骤。解析指令以 `# directive=value` 的形式写入特殊类型的注释。单个指令只能使用一次。
一旦注释，空行或构建指令已被处理，Docker 不再查找解析指令。相反，它将任何符合解析指令格式的内容视为注释，不会尝试验证它是否可能是解析指令。因此，所有解析指令都必须位于Dockerfile 的最顶端。
解析指令不区分大小写。但是，约定是小写。约定还包括在任何解析指令之后的空白行。解析指令不支持续行符。
以下列举几个不合规范的示例。
因为续行符而无效：
```
# direc \
tive=value
```dockerfile
COPY hom* /mydir/
COPY hom?.txt /mydir/
```
因为出现两次解析指令而无效：
`<目标路径>` 可以是容器内的绝对路径，也可以是相对于工作目录的相对路径（工作目录可以用 `WORKDIR` 指令来指定）。目标路径不需要事先创建，如果目录不存在会在复制文件前先行创建缺失目录。
```
# directive=value1
# directive=value2
此外，还需要注意一点，使用 `COPY` 指令，源文件的各种元数据都会保留。比如读、写、执行权限、文件变更时间等。这个特性对于镜像定制很有用。特别是构建相关文件都在使用 Git 进行管理的时候。
FROM ImageName
在使用该指令的时候还可以加上 `--chown=<user>:<group>` 选项来改变文件的所属用户及所属组。
```dockerfile
COPY --chown=55:mygroup files* /mydir/
COPY --chown=bin files* /mydir/
COPY --chown=1 files* /mydir/
COPY --chown=10:11 files* /mydir/
```
解析指令由于出现在构建指令后，而被视为注释：
### ADD(更高级的复制文件)
```
FROM ImageName
# directive=value
> 作用：
>
> `ADD` 指令和 `COPY` 的格式和性质基本一致。但是在 `COPY` 基础上增加了一些功能。
>
> 比如 `<源路径>` 可以是一个 `URL`，这种情况下，Docker 引擎会试图去下载这个链接的文件放到 `<目标路径>`去。下载后的文件权限自动设置为 `600`，如果这并不是想要的权限，那么还需要增加额外的一层 `RUN` 进行权限调整，另外，如果下载的是个压缩包，需要解压缩，也一样还需要额外的一层 `RUN` 指令进行解压缩。所以不如直接使用 `RUN` 指令，然后使用 `wget` 或者 `curl` 工具下载，处理权限、解压缩、然后清理无用文件更合理。因此，这个功能其实并不实用，而且不推荐使用。
>
> 如果 `<源路径>` 为一个 `tar` 压缩文件的话，压缩格式为 `gzip`, `bzip2` 以及 `xz` 的情况下，`ADD` 指令将会自动解压缩这个压缩文件到 `<目标路径>` 去。
在某些情况下，这个自动解压缩的功能非常有用，比如官方镜像 `ubuntu` 中：
```dockerfile
FROM scratch
ADD ubuntu-xenial-core-cloudimg-amd64-root.tar.gz /
...
```
解析指令由于出现在注释后，而被视为注释：
但在某些情况下，如果我们真的是希望复制个压缩文件进去，而不解压缩，这时就不可以使用 `ADD` 命令了。
```
# About my dockerfile
# directive=value
FROM ImageName
在 Docker 官方的 [Dockerfile 最佳实践文档](https://yeasy.gitbooks.io/docker_practice/content/appendix/best_practices.html) 中要求，尽可能的使用 `COPY`，因为 `COPY` 的语义很明确，就是复制文件而已，而 `ADD` 则包含了更复杂的功能，其行为也不一定很清晰。最适合使用 `ADD` 的场合，就是所提及的需要自动解压缩的场合。
另外需要注意的是，`ADD` 指令会令镜像构建缓存失效，从而可能会令镜像构建变得比较缓慢。
因此在 `COPY` 和 `ADD` 指令中选择的时候，可以遵循这样的原则，所有的文件复制均使用 `COPY` 指令，仅在需要自动解压缩的场合使用 `ADD`。
在使用该指令的时候还可以加上 `--chown=<user>:<group>` 选项来改变文件的所属用户及所属组。
```dockerfile
ADD --chown=55:mygroup files* /mydir/
ADD --chown=bin files* /mydir/
ADD --chown=1 files* /mydir/
ADD --chown=10:11 files* /mydir/
```
因为无法识别，未知的指令被视为注释。此外，因为前一个未知指定被视为注释，后一个指令相当于出现在注释后，而也被视为了注释：
### CMD(容器启动命令)
```
# unknowndirective=value
# knowndirective=value
> 作用：
>
> 之前介绍容器的时候曾经说过，Docker 不是虚拟机，容器就是进程。既然是进程，那么在启动容器的时候，需要指定所运行的程序及参数。`CMD` 指令就是用于指定默认的容器主进程的启动命令的。
`CMD` 指令的格式和 `RUN` 相似，也是两种格式：
- `shell` 格式：`CMD <命令>`
- `exec` 格式：`CMD ["可执行文件", "参数1", "参数2"...]`
- 参数列表格式：`CMD ["参数1", "参数2"...]`。在指定了 `ENTRYPOINT` 指令后，用 `CMD` 指定具体的参数。
在运行时可以指定新的命令来替代镜像设置中的这个默认命令，比如，`ubuntu` 镜像默认的 `CMD` 是 `/bin/bash`，如果我们直接 `docker run -it ubuntu` 的话，会直接进入 `bash`。我们也可以在运行时指定运行别的命令，如 `docker run -it ubuntu cat /etc/os-release`。这就是用 `cat /etc/os-release` 命令替换了默认的 `/bin/bash` 命令了，输出了系统版本信息。
在指令格式上，一般推荐使用 `exec` 格式，这类格式在解析时会被解析为 JSON 数组，因此一定要使用双引号 `"`，而不要使用单引号。
如果使用 `shell` 格式的话，实际的命令会被包装为 `sh -c` 的参数的形式进行执行。比如：
```dockerfile
CMD echo $HOME
```
解析器指令中允许使用非分行空白。因此，以下几行都是一致对待的：
在实际执行中，会将其变更为：
```
#directive=value
# directive =value
# directive= value
# directive = value
# dIrEcTiVe=value
```dockerfile
CMD [ "sh", "-c", "echo $HOME" ]
```
### escape
这就是为什么我们可以使用环境变量的原因，因为这些环境变量会被 shell 进行解析处理。
```
# escape=\ (backslash)
提到 `CMD` 就不得不提容器中应用在前台执行和后台执行的问题。这是初学者常出现的一个混淆。
Docker 不是虚拟机，容器中的应用都应该以前台执行，而不是像虚拟机、物理机里面那样，用 upstart/systemd 去启动后台服务，容器内没有后台服务的概念。
一些初学者将 `CMD` 写为：
```dockerfile
CMD service nginx start
```
```
# escape=` (backtick)
然后发现容器执行后就立即退出了。甚至在容器内去使用 `systemctl` 命令结果却发现根本执行不了。这就是因为没有搞明白前台、后台的概念，没有区分容器和虚拟机的差异，依旧在以传统虚拟机的角度去理解容器。
对于容器而言，其启动程序就是容器应用进程，容器就是为了主进程而存在的，主进程退出，容器就失去了存在的意义，从而退出，其它辅助进程不是它需要关心的东西。
而使用 `service nginx start` 命令，则是希望 upstart 来以后台守护进程形式启动 `nginx` 服务。而刚才说了 `CMD service nginx start` 会被理解为 `CMD [ "sh", "-c", "service nginx start"]`，因此主进程实际上是 `sh`。那么当 `service nginx start` 命令结束后，`sh` 也就结束了，`sh` 作为主进程退出了，自然就会令容器退出。
正确的做法是直接执行 `nginx` 可执行文件，并且要求以前台形式运行。比如：
```dockerfile
CMD ["nginx", "-g", "daemon off;"]
```
在 Dockerfile 中，
### ENTRYPOINT(入口点)
`ENTRYPOINT` 的格式和 `RUN` 指令格式一样，分为 `exec` 格式和 `shell` 格式。
`ENTRYPOINT` 的目的和 `CMD` 一样，都是在指定容器启动程序及参数。`ENTRYPOINT` 在运行时也可以替代，不过比 `CMD` 要略显繁琐，需要通过 `docker run` 的参数 `--entrypoint` 来指定。
当指定了 `ENTRYPOINT` 后，`CMD` 的含义就发生了改变，不再是直接的运行其命令，而是将 `CMD` 的内容作为参数传给 `ENTRYPOINT` 指令，换句话说实际执行时，将变为：
```bash
<ENTRYPOINT> "<CMD>"
```
那么有了 `CMD` 后，为什么还要有 `ENTRYPOINT` 呢？这种 `<ENTRYPOINT> "<CMD>"` 有什么好处么？让我们来看几个场景。
#### 场景一：让镜像变成像命令一样使用
假设我们需要一个得知自己当前公网 IP 的镜像，那么可以先用 `CMD` 来实现：
```dockerfile
FROM ubuntu:18.04
RUN apt-get update \
&& apt-get install -y curl \
&& rm -rf /var/lib/apt/lists/*
CMD [ "curl", "-s", "https://ip.cn" ]
```
假如我们使用 `docker build -t myip .` 来构建镜像的话，如果我们需要查询当前公网 IP，只需要执行：
```bash
$ docker run myip
当前 IP：61.148.226.66 来自：北京市 联通
```
嗯，这么看起来好像可以直接把镜像当做命令使用了，不过命令总有参数，如果我们希望加参数呢？比如从上面的 `CMD` 中可以看到实质的命令是 `curl`，那么如果我们希望显示 HTTP 头信息，就需要加上 `-i` 参数。那么我们可以直接加 `-i` 参数给 `docker run myip` 么？
```bash
$ docker run myip -i
docker: Error response from daemon: invalid header field value "oci runtime error: container_linux.go:247: starting container process caused \"exec: \\\"-i\\\": executable file not found in $PATH\"\n".
```
我们可以看到可执行文件找不到的报错，`executable file not found`。之前我们说过，跟在镜像名后面的是 `command`，运行时会替换 `CMD` 的默认值。因此这里的 `-i` 替换了原来的 `CMD`，而不是添加在原来的 `curl -s https://ip.cn` 后面。而 `-i` 根本不是命令，所以自然找不到。
那么如果我们希望加入 `-i` 这参数，我们就必须重新完整的输入这个命令：
```bash
$ docker run myip curl -s https://ip.cn -i
```
这显然不是很好的解决方案，而使用 `ENTRYPOINT` 就可以解决这个问题。现在我们重新用 `ENTRYPOINT` 来实现这个镜像：
```dockerfile
FROM ubuntu:18.04
RUN apt-get update \
&& apt-get install -y curl \
&& rm -rf /var/lib/apt/lists/*
ENTRYPOINT [ "curl", "-s", "https://ip.cn" ]
```
这次我们再来尝试直接使用 `docker run myip -i`：
```bash
$ docker run myip
当前 IP：61.148.226.66 来自：北京市 联通
$ docker run myip -i
HTTP/1.1 200 OK
Server: nginx/1.8.0
Date: Tue, 22 Nov 2016 05:12:40 GMT
Content-Type: text/html; charset=UTF-8
Vary: Accept-Encoding
X-Powered-By: PHP/5.6.24-1~dotdeb+7.1
X-Cache: MISS from cache-2
X-Cache-Lookup: MISS from cache-2:80
X-Cache: MISS from proxy-2_6
Transfer-Encoding: chunked
Via: 1.1 cache-2:80, 1.1 proxy-2_6:8006
Connection: keep-alive
当前 IP：61.148.226.66 来自：北京市 联通
```
可以看到，这次成功了。这是因为当存在 `ENTRYPOINT` 后，`CMD` 的内容将会作为参数传给 `ENTRYPOINT`，而这里 `-i` 就是新的 `CMD`，因此会作为参数传给 `curl`，从而达到了我们预期的效果。
#### 场景二：应用运行前的准备工作
启动容器就是启动主进程，但有些时候，启动主进程前，需要一些准备工作。
比如 `mysql` 类的数据库，可能需要一些数据库配置、初始化的工作，这些工作要在最终的 mysql 服务器运行之前解决。
此外，可能希望避免使用 `root` 用户去启动服务，从而提高安全性，而在启动服务前还需要以 `root` 身份执行一些必要的准备工作，最后切换到服务用户身份启动服务。或者除了服务外，其它命令依旧可以使用 `root` 身份执行，方便调试等。
这些准备工作是和容器 `CMD` 无关的，无论 `CMD` 为什么，都需要事先进行一个预处理的工作。这种情况下，可以写一个脚本，然后放入 `ENTRYPOINT` 中去执行，而这个脚本会将接到的参数（也就是 `<CMD>`）作为命令，在脚本最后执行。比如官方镜像 `redis` 中就是这么做的：
```dockerfile
FROM alpine:3.4
...
RUN addgroup -S redis && adduser -S -G redis redis
...
ENTRYPOINT ["docker-entrypoint.sh"]
EXPOSE 6379
CMD [ "redis-server" ]
```
可以看到其中为了 redis 服务创建了 redis 用户，并在最后指定了 `ENTRYPOINT` 为 `docker-entrypoint.sh` 脚本。
```bash
#!/bin/sh
...
# allow the container to be started with `--user`
if [ "$1" = 'redis-server' -a "$(id -u)" = '0' ]; then
chown -R redis .
exec su-exec redis "$0" "$@"
fi
exec "$@"
```
该脚本的内容就是根据 `CMD` 的内容来判断，如果是 `redis-server` 的话，则切换到 `redis` 用户身份启动服务器，否则依旧使用 `root` 身份执行。比如：
```bash
$ docker run -it redis id
uid=0(root) gid=0(root) groups=0(root)
```
### ENV(设置环境变量)
> 作用：`ENV` 指令用于设置环境变量。无论是后面的其它指令，如 `RUN`，还是运行时的应用，都可以直接使用这里定义的环境变量。
格式：
- `ENV <key> <value>`
- `ENV <key1>=<value1> <key2>=<value2>...`
示例 1：
```dockerfile
ENV VERSION=1.0 DEBUG=on \
NAME="Happy Feet"
```
这个例子中演示了如何换行，以及对含有空格的值用双引号括起来的办法，这和 Shell 下的行为是一致的。
示例 2：
定义了环境变量，那么在后续的指令中，就可以使用这个环境变量。比如在官方 `node` 镜像 `Dockerfile` 中，就有类似这样的代码：
```dockerfile
ENV NODE_VERSION 7.2.0
RUN curl -SLO "https://nodejs.org/dist/v$NODE_VERSION/node-v$NODE_VERSION-linux-x64.tar.xz" \
&& curl -SLO "https://nodejs.org/dist/v$NODE_VERSION/SHASUMS256.txt.asc" \
&& gpg --batch --decrypt --output SHASUMS256.txt SHASUMS256.txt.asc \
&& grep " node-v$NODE_VERSION-linux-x64.tar.xz\$" SHASUMS256.txt | sha256sum -c - \
&& tar -xJf "node-v$NODE_VERSION-linux-x64.tar.xz" -C /usr/local --strip-components=1 \
&& rm "node-v$NODE_VERSION-linux-x64.tar.xz" SHASUMS256.txt.asc SHASUMS256.txt \
&& ln -s /usr/local/bin/node /usr/local/bin/nodejs
```
在这里先定义了环境变量 `NODE_VERSION`，其后的 `RUN` 这层里，多次使用 `$NODE_VERSION` 来进行操作定制。可以看到，将来升级镜像构建版本的时候，只需要更新 `7.2.0` 即可，`Dockerfile` 构建维护变得更轻松了。
下列指令可以支持环境变量展开： `ADD`、`COPY`、`ENV`、`EXPOSE`、`LABEL`、`USER`、`WORKDIR`、`VOLUME`、`STOPSIGNAL`、`ONBUILD`。
可以从这个指令列表里感觉到，环境变量可以使用的地方很多，很强大。通过环境变量，我们可以让一份 `Dockerfile` 制作更多的镜像，只需使用不同的环境变量即可。
### ARG(构建参数)
> 作用：
>
> `Dockerfile` 中的 `ARG` 指令是定义参数名称，以及定义其默认值。该默认值可以在构建命令 `docker build` 中用 `--build-arg <参数名>=<值>` 来覆盖。
>
> 构建参数和 `ENV` 的效果一样，都是设置环境变量。所不同的是，`ARG` 所设置的构建环境的环境变量，在将来容器运行时是不会存在这些环境变量的。但是不要因此就使用 `ARG` 保存密码之类的信息，因为 `docker history` 还是可以看到所有值的。
格式：`ARG <参数名>[=<默认值>]`
在 1.13 之前的版本，要求 `--build-arg` 中的参数名，必须在 `Dockerfile` 中用 `ARG` 定义过了，换句话说，就是 `--build-arg` 指定的参数，必须在 `Dockerfile` 中使用了。如果对应参数没有被使用，则会报错退出构建。从 1.13 开始，这种严格的限制被放开，不再报错退出，而是显示警告信息，并继续构建。这对于使用 CI 系统，用同样的构建流程构建不同的 `Dockerfile` 的时候比较有帮助，避免构建命令必须根据每个 Dockerfile 的内容修改。
### VOLUME(定义匿名卷)
格式：
- `VOLUME ["<路径1>", "<路径2>"...]`
- `VOLUME <路径>`
之前我们说过，容器运行时应该尽量保持容器存储层不发生写操作，对于数据库类需要保存动态数据的应用，其数据库文件应该保存于卷(volume)中，后面的章节我们会进一步介绍 Docker 卷的概念。为了防止运行时用户忘记将动态文件所保存目录挂载为卷，在 `Dockerfile` 中，我们可以事先指定某些目录挂载为匿名卷，这样在运行时如果用户不指定挂载，其应用也可以正常运行，不会向容器存储层写入大量数据。
```dockerfile
VOLUME /data
```
这里的 `/data` 目录就会在运行时自动挂载为匿名卷，任何向 `/data` 中写入的信息都不会记录进容器存储层，从而保证了容器存储层的无状态化。当然，运行时可以覆盖这个挂载设置。比如：
```dockerfile
docker run -d -v mydata:/data xxxx
```
在这行命令中，就使用了 `mydata` 这个命名卷挂载到了 `/data` 这个位置，替代了 `Dockerfile` 中定义的匿名卷的挂载配置。
### EXPOSE(暴露端口)
> 作用：
>
> `EXPOSE` 指令是声明运行时容器提供服务端口，这只是一个声明，在运行时并不会因为这个声明应用就会开启这个端口的服务。在 Dockerfile 中写入这样的声明有两个好处，一个是帮助镜像使用者理解这个镜像服务的守护端口，以方便配置映射；另一个用处则是在运行时使用随机端口映射时，也就是 `docker run -P` 时，会自动随机映射 `EXPOSE` 的端口。
>
> 要将 `EXPOSE` 和在运行时使用 `-p <宿主端口>:<容器端口>` 区分开来。`-p`，是映射宿主端口和容器端口，换句话说，就是将容器的对应端口服务公开给外界访问，而 `EXPOSE` 仅仅是声明容器打算使用什么端口而已，并不会自动在宿主进行端口映射。
格式：`EXPOSE <端口1> [<端口2>...]`。
### WORKDIR(指定工作目录)
> 作用：
>
> 使用 `WORKDIR` 指令可以来指定工作目录（或者称为当前目录），以后各层的当前目录就被改为指定的目录，如该目录不存在，`WORKDIR` 会帮你建立目录。
格式：`WORKDIR <工作目录路径>`。
示例 1：
之前提到一些初学者常犯的错误是把 `Dockerfile` 等同于 Shell 脚本来书写，这种错误的理解还可能会导致出现下面这样的错误：
```dockerfile
RUN cd /app
RUN echo "hello" > world.txt
```
如果将这个 `Dockerfile` 进行构建镜像运行后，会发现找不到 `/app/world.txt` 文件，或者其内容不是 `hello`。原因其实很简单，在 Shell 中，连续两行是同一个进程执行环境，因此前一个命令修改的内存状态，会直接影响后一个命令；而在 `Dockerfile` 中，这两行 `RUN` 命令的执行环境根本不同，是两个完全不同的容器。这就是对 `Dockerfile` 构建分层存储的概念不了解所导致的错误。
之前说过每一个 `RUN` 都是启动一个容器、执行命令、然后提交存储层文件变更。第一层 `RUN cd /app` 的执行仅仅是当前进程的工作目录变更，一个内存上的变化而已，其结果不会造成任何文件变更。而到第二层的时候，启动的是一个全新的容器，跟第一层的容器更完全没关系，自然不可能继承前一层构建过程中的内存变化。
因此如果需要改变以后各层的工作目录的位置，那么应该使用 `WORKDIR` 指令。
### USER(指定当前用户)
> 作用：
>
> `USER` 指令和 `WORKDIR` 相似，都是改变环境状态并影响以后的层。`WORKDIR` 是改变工作目录，`USER` 则是改变之后层的执行 `RUN`, `CMD` 以及 `ENTRYPOINT` 这类命令的身份。
>
> 当然，和 `WORKDIR` 一样，`USER` 只是帮助你切换到指定用户而已，这个用户必须是事先建立好的，否则无法切换。
格式：`USER <用户名>[:<用户组>]`
示例 1：
```dockerfile
RUN groupadd -r redis && useradd -r -g redis redis
USER redis
RUN [ "redis-server" ]
```
如果以 `root` 执行的脚本，在执行期间希望改变身份，比如希望以某个已经建立好的用户来运行某个服务进程，不要使用 `su`或者 `sudo`，这些都需要比较麻烦的配置，而且在 TTY 缺失的环境下经常出错。建议使用 [`gosu`](https://github.com/tianon/gosu)。
```dockerfile
# 建立 redis 用户，并使用 gosu 换另一个用户执行命令
RUN groupadd -r redis && useradd -r -g redis redis
# 下载 gosu
RUN wget -O /usr/local/bin/gosu "https://github.com/tianon/gosu/releases/download/1.7/gosu-amd64" \
&& chmod +x /usr/local/bin/gosu \
&& gosu nobody true
# 设置 CMD，并以另外的用户执行
CMD [ "exec", "gosu", "redis", "redis-server" ]
```
### HEALTHCHECK(健康检查)
格式：
- `HEALTHCHECK [选项] CMD <命令>`：设置检查容器健康状况的命令
- `HEALTHCHECK NONE`：如果基础镜像有健康检查指令，使用这行可以屏蔽掉其健康检查指令
`HEALTHCHECK` 指令是告诉 Docker 应该如何进行判断容器的状态是否正常，这是 Docker 1.12 引入的新指令。
在没有 `HEALTHCHECK` 指令前，Docker 引擎只可以通过容器内主进程是否退出来判断容器是否状态异常。很多情况下这没问题，但是如果程序进入死锁状态，或者死循环状态，应用进程并不退出，但是该容器已经无法提供服务了。在 1.12 以前，Docker 不会检测到容器的这种状态，从而不会重新调度，导致可能会有部分容器已经无法提供服务了却还在接受用户请求。
而自 1.12 之后，Docker 提供了 `HEALTHCHECK` 指令，通过该指令指定一行命令，用这行命令来判断容器主进程的服务状态是否还正常，从而比较真实的反应容器实际状态。
当在一个镜像指定了 `HEALTHCHECK` 指令后，用其启动容器，初始状态会为 `starting`，在 `HEALTHCHECK` 指令检查成功后变为 `healthy`，如果连续一定次数失败，则会变为 `unhealthy`。
`HEALTHCHECK` 支持下列选项：
- `--interval=<间隔>`：两次健康检查的间隔，默认为 30 秒；
- `--timeout=<时长>`：健康检查命令运行超时时间，如果超过这个时间，本次健康检查就被视为失败，默认 30 秒；
- `--retries=<次数>`：当连续失败指定次数后，则将容器状态视为 `unhealthy`，默认 3 次。
和 `CMD`, `ENTRYPOINT` 一样，`HEALTHCHECK` 只可以出现一次，如果写了多个，只有最后一个生效。
在 `HEALTHCHECK [选项] CMD` 后面的命令，格式和 `ENTRYPOINT` 一样，分为 `shell` 格式，和 `exec` 格式。命令的返回值决定了该次健康检查的成功与否：`0`：成功；`1`：失败；`2`：保留，不要使用这个值。
假设我们有个镜像是个最简单的 Web 服务，我们希望增加健康检查来判断其 Web 服务是否在正常工作，我们可以用 `curl` 来帮助判断，其 `Dockerfile` 的 `HEALTHCHECK` 可以这么写：
```dockerfile
FROM nginx
RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*
HEALTHCHECK --interval=5s --timeout=3s \
CMD curl -fs http://localhost/ || exit 1
```
这里我们设置了每 5 秒检查一次（这里为了试验所以间隔非常短，实际应该相对较长），如果健康检查命令超过 3 秒没响应就视为失败，并且使用 `curl -fs http://localhost/ || exit 1` 作为健康检查命令。
使用 `docker build` 来构建这个镜像：
```bash
$ docker build -t myweb:v1 .
```
构建好了后，我们启动一个容器：
```bash
$ docker run -d --name web -p 80:80 myweb:v1
```
当运行该镜像后，可以通过 `docker container ls` 看到最初的状态为 `(health: starting)`：
```bash
$ docker container ls
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
03e28eb00bd0 myweb:v1 "nginx -g 'daemon off" 3 seconds ago Up 2 seconds (health: starting) 80/tcp, 443/tcp web
```
在等待几秒钟后，再次 `docker container ls`，就会看到健康状态变化为了 `(healthy)`：
```bash
$ docker container ls
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
03e28eb00bd0 myweb:v1 "nginx -g 'daemon off" 18 seconds ago Up 16 seconds (healthy) 80/tcp, 443/tcp web
```
如果健康检查连续失败超过了重试次数，状态就会变为 `(unhealthy)`。
为了帮助排障，健康检查命令的输出（包括 `stdout` 以及 `stderr`）都会被存储于健康状态里，可以用 `docker inspect` 来查看。
```bash
$ docker inspect --format '{{json .State.Health}}' web | python -m json.tool
{
"FailingStreak": 0,
"Log": [
{
"End": "2016-11-25T14:35:37.940957051Z",
"ExitCode": 0,
"Output": "<!DOCTYPE html>\n<html>\n<head>\n<title>Welcome to nginx!</title>\n<style>\n body {\n width: 35em;\n margin: 0 auto;\n font-family: Tahoma, Verdana, Arial, sans-serif;\n }\n</style>\n</head>\n<body>\n<h1>Welcome to nginx!</h1>\n<p>If you see this page, the nginx web server is successfully installed and\nworking. Further configuration is required.</p>\n\n<p>For online documentation and support please refer to\n<a href=\"http://nginx.org/\">nginx.org</a>.<br/>\nCommercial support is available at\n<a href=\"http://nginx.com/\">nginx.com</a>.</p>\n\n<p><em>Thank you for using nginx.</em></p>\n</body>\n</html>\n",
"Start": "2016-11-25T14:35:37.780192565Z"
}
],
"Status": "healthy"
}
```
### ONBUILD(为他人作嫁衣裳)
格式：`ONBUILD <其它指令>`。
`ONBUILD` 是一个特殊的指令，它后面跟的是其它指令，比如 `RUN`, `COPY` 等，而这些指令，在当前镜像构建时并不会被执行。只有当以当前镜像为基础镜像，去构建下一级镜像的时候才会被执行。
`Dockerfile` 中的其它指令都是为了定制当前镜像而准备的，唯有 `ONBUILD` 是为了帮助别人定制自己而准备的。
假设我们要制作 Node.js 所写的应用的镜像。我们都知道 Node.js 使用 `npm` 进行包管理，所有依赖、配置、启动信息等会放到 `package.json` 文件里。在拿到程序代码后，需要先进行 `npm install` 才可以获得所有需要的依赖。然后就可以通过 `npm start`来启动应用。因此，一般来说会这样写 `Dockerfile`：
```dockerfile
FROM node:slim
RUN mkdir /app
WORKDIR /app
COPY ./package.json /app
RUN [ "npm", "install" ]
COPY . /app/
CMD [ "npm", "start" ]
```
把这个 `Dockerfile` 放到 Node.js 项目的根目录，构建好镜像后，就可以直接拿来启动容器运行。但是如果我们还有第二个 Node.js 项目也差不多呢？好吧，那就再把这个 `Dockerfile` 复制到第二个项目里。那如果有第三个项目呢？再复制么？文件的副本越多，版本控制就越困难，让我们继续看这样的场景维护的问题。
如果第一个 Node.js 项目在开发过程中，发现这个 `Dockerfile` 里存在问题，比如敲错字了、或者需要安装额外的包，然后开发人员修复了这个 `Dockerfile`，再次构建，问题解决。<EFBFBD> 第一个项目没问题了，但是第二个项目呢？虽然最初 `Dockerfile` 是复制、粘贴自第一个项目的，但是并不会因为第一个项目修复了他们的 `Dockerfile`，而第二个项目的 `Dockerfile` 就会被自动修复。
那么我们可不可以做一个基础镜像，然后各个项目使用这个基础镜像呢？这样基础镜像更新，各个项目不用同步 `Dockerfile`的变化，重新构建后就继承了基础镜像的更新？好吧，可以，让我们看看这样的结果。那么上面的这个 `Dockerfile` 就会变为：
```dockerfile
FROM node:slim
RUN mkdir /app
WORKDIR /app
CMD [ "npm", "start" ]
```
这里我们把项目相关的构建指令拿出来，放到子项目里去。假设这个基础镜像的名字为 `my-node` 的话，各个项目内的自己的 `Dockerfile` 就变为：
```dockerfile
FROM my-node
COPY ./package.json /app
RUN [ "npm", "install" ]
COPY . /app/
```
基础镜像变化后，各个项目都用这个 `Dockerfile` 重新构建镜像，会继承基础镜像的更新。
那么，问题解决了么？没有。准确说，只解决了一半。如果这个 `Dockerfile` 里面有些东西需要调整呢？比如 `npm install` 都需要加一些参数，那怎么办？这一行 `RUN` 是不可能放入基础镜像的，因为涉及到了当前项目的 `./package.json`，难道又要一个个修改么？所以说，这样制作基础镜像，只解决了原来的 `Dockerfile` 的前 4 条指令的变化问题，而后面三条指令的变化则完全没办法处理。
`ONBUILD` 可以解决这个问题。让我们用 `ONBUILD` 重新写一下基础镜像的 `Dockerfile`:
```dockerfile
FROM node:slim
RUN mkdir /app
WORKDIR /app
ONBUILD COPY ./package.json /app
ONBUILD RUN [ "npm", "install" ]
ONBUILD COPY . /app/
CMD [ "npm", "start" ]
```
这次我们回到原始的 `Dockerfile`，但是这次将项目相关的指令加上 `ONBUILD`，这样在构建基础镜像的时候，这三行并不会被执行。然后各个项目的 `Dockerfile` 就变成了简单地：
```dockerfile
FROM my-node
```
是的，只有这么一行。当在各个项目目录中，用这个只有一行的 `Dockerfile` 构建镜像时，之前基础镜像的那三行 `ONBUILD` 就会开始执行，成功的将当前项目的代码复制进镜像、并且针对本项目执行 `npm install`，生成应用镜像。
## 引用和引申
- [Dockerfie 官方文档](https://docs.docker.com/engine/reference/builder/)
- [Dockerfile 最佳实践文档](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/)
- [Docker 官方镜像 Dockerfile](https://github.com/docker-library/docs)
- [Dockerfile 指令详解](https://yeasy.gitbooks.io/docker_practice/content/image/dockerfile/)

491
docs/docker/basics/docker-image.md 100644
View File

@ -0,0 +1,491 @@
# Docker 镜像
<!-- TOC depthFrom:2 depthTo:3 -->
- [获取镜像](#获取镜像)
- [运行](#运行)
- [列出镜像](#列出镜像)
- [镜像体积](#镜像体积)
- [虚悬镜像](#虚悬镜像)
- [中间层镜像](#中间层镜像)
- [列出部分镜像](#列出部分镜像)
- [以特定格式显示](#以特定格式显示)
- [删除本地镜像](#删除本地镜像)
- [用 ID、镜像名、摘要删除镜像](#用-id镜像名摘要删除镜像)
- [Untagged 和 Deleted](#untagged-和-deleted)
- [用 docker image ls 命令来配合](#用-docker-image-ls-命令来配合)
- [CentOS/RHEL 的用户需要注意的事项](#centosrhel-的用户需要注意的事项)
- [使用 Dockerfile 定制镜像](#使用-dockerfile-定制镜像)
- [构建镜像](#构建镜像)
- [镜像构建上下文（Context）](#镜像构建上下文context)
- [其它 `docker build` 的用法](#其它-docker-build-的用法)
<!-- /TOC -->
## 获取镜像
之前提到过，[Docker Hub](https://hub.docker.com/explore/) 上有大量的高质量的镜像可以用，这里我们就说一下怎么获取这些镜像。
从 Docker 镜像仓库获取镜像的命令是 `docker pull`。其命令格式为：
```bash
docker pull [选项] [Docker Registry 地址[:端口号]/]仓库名[:标签]
```
具体的选项可以通过 `docker pull --help` 命令看到，这里我们说一下镜像名称的格式。
- Docker 镜像仓库地址：地址的格式一般是 `<域名/IP>[:端口号]`。默认地址是 Docker Hub。
- 仓库名：如之前所说，这里的仓库名是两段式名称，即 `<用户名>/<软件名>`。对于 Docker Hub，如果不给出用户名，则默认为 `library`，也就是官方镜像。
比如：
```bash
$ docker pull ubuntu:18.04
18.04: Pulling from library/ubuntu
bf5d46315322: Pull complete
9f13e0ac480c: Pull complete
e8988b5b3097: Pull complete
40af181810e7: Pull complete
e6f7c7e5c03e: Pull complete
Digest: sha256:147913621d9cdea08853f6ba9116c2e27a3ceffecf3b492983ae97c3d643fbbe
Status: Downloaded newer image for ubuntu:18.04
```
上面的命令中没有给出 Docker 镜像仓库地址，因此将会从 Docker Hub 获取镜像。而镜像名称是 `ubuntu:18.04`，因此将会获取官方镜像 `library/ubuntu` 仓库中标签为 `18.04` 的镜像。
从下载过程中可以看到我们之前提及的分层存储的概念，镜像是由多层存储所构成。下载也是一层层的去下载，并非单一文件。下载过程中给出了每一层的 ID 的前 12 位。并且下载结束后，给出该镜像完整的 `sha256` 的摘要，以确保下载一致性。
在使用上面命令的时候，你可能会发现，你所看到的层 ID 以及 `sha256` 的摘要和这里的不一样。这是因为官方镜像是一直在维护的，有任何新的 bug，或者版本更新，都会进行修复再以原来的标签发布，这样可以确保任何使用这个标签的用户可以获得更安全、更稳定的镜像。
*如果从 Docker Hub 下载镜像非常缓慢，可以参照 镜像加速器 一节配置加速器。*
### 运行
有了镜像后，我们就能够以这个镜像为基础启动并运行一个容器。以上面的 `ubuntu:18.04` 为例，如果我们打算启动里面的 `bash` 并且进行交互式操作的话，可以执行下面的命令。
```bash
$ docker run -it --rm \
ubuntu:18.04 \
bash
root@e7009c6ce357:/# cat /etc/os-release
NAME="Ubuntu"
VERSION="18.04.1 LTS (Bionic Beaver)"
ID=ubuntu
ID_LIKE=debian
PRETTY_NAME="Ubuntu 18.04.1 LTS"
VERSION_ID="18.04"
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
VERSION_CODENAME=bionic
UBUNTU_CODENAME=bionic
```
`docker run` 就是运行容器的命令，具体格式我们会在 [容器](https://yeasy.gitbooks.io/docker_practice/content/container) 一节进行详细讲解，我们这里简要的说明一下上面用到的参数。
- `-it`：这是两个参数，一个是 `-i`：交互式操作，一个是 `-t` 终端。我们这里打算进入 `bash` 执行一些命令并查看返回结果，因此我们需要交互式终端。
- `--rm`：这个参数是说容器退出后随之将其删除。默认情况下，为了排障需求，退出的容器并不会立即删除，除非手动 `docker rm`。我们这里只是随便执行个命令，看看结果，不需要排障和保留结果，因此使用 `--rm` 可以避免浪费空间。
- `ubuntu:18.04`：这是指用 `ubuntu:18.04` 镜像为基础来启动容器。
- `bash`：放在镜像名后的是**命令**，这里我们希望有个交互式 Shell，因此用的是 `bash`。
进入容器后，我们可以在 Shell 下操作，执行任何所需的命令。这里，我们执行了 `cat /etc/os-release`，这是 Linux 常用的查看当前系统版本的命令，从返回的结果可以看到容器内是 `Ubuntu 18.04.1 LTS` 系统。
最后我们通过 `exit` 退出了这个容器。
## 列出镜像
要想列出已经下载下来的镜像，可以使用 `docker image ls` 命令。
```bash
$ docker image ls
REPOSITORY TAG IMAGE ID CREATED SIZE
redis latest 5f515359c7f8 5 days ago 183 MB
nginx latest 05a60462f8ba 5 days ago 181 MB
mongo 3.2 fe9198c04d62 5 days ago 342 MB
<none> <none> 00285df0df87 5 days ago 342 MB
ubuntu 18.04 f753707788c5 4 weeks ago 127 MB
ubuntu latest f753707788c5 4 weeks ago 127 MB
ubuntu 14.04 1e0c3dd64ccd 4 weeks ago 188 MB
```
列表包含了 `仓库名`、`标签`、`镜像 ID`、`创建时间` 以及 `所占用的空间`。
其中仓库名、标签在之前的基础概念章节已经介绍过了。**镜像 ID** 则是镜像的唯一标识，一个镜像可以对应多个**标签**。因此，在上面的例子中，我们可以看到 `ubuntu:18.04` 和 `ubuntu:latest` 拥有相同的 ID，因为它们对应的是同一个镜像。
### 镜像体积
如果仔细观察，会注意到，这里标识的所占用空间和在 Docker Hub 上看到的镜像大小不同。比如，`ubuntu:18.04` 镜像大小，在这里是 `127 MB`，但是在 [Docker Hub](https://hub.docker.com/r/library/ubuntu/tags/) 显示的却是 `50 MB`。这是因为 Docker Hub 中显示的体积是压缩后的体积。在镜像下载和上传过程中镜像是保持着压缩状态的，因此 Docker Hub 所显示的大小是网络传输中更关心的流量大小。而 `docker image ls` 显示的是镜像下载到本地后，展开的大小，准确说，是展开后的各层所占空间的总和，因为镜像到本地后，查看空间的时候，更关心的是本地磁盘空间占用的大小。
另外一个需要注意的问题是，`docker image ls` 列表中的镜像体积总和并非是所有镜像实际硬盘消耗。由于 Docker 镜像是多层存储结构，并且可以继承、复用，因此不同镜像可能会因为使用相同的基础镜像，从而拥有共同的层。由于 Docker 使用 Union FS，相同的层只需要保存一份即可，因此实际镜像硬盘占用空间很可能要比这个列表镜像大小的总和要小的多。
你可以通过以下命令来便捷的查看镜像、容器、数据卷所占用的空间。
```bash
$ docker system df
TYPE TOTAL ACTIVE SIZE RECLAIMABLE
Images 24 0 1.992GB 1.992GB (100%)
Containers 1 0 62.82MB 62.82MB (100%)
Local Volumes 9 0 652.2MB 652.2MB (100%)
Build Cache 0B 0B
```
### 虚悬镜像
上面的镜像列表中，还可以看到一个特殊的镜像，这个镜像既没有仓库名，也没有标签，均为 `<none>`。：
```bash
<none> <none> 00285df0df87 5 days ago 342 MB
```
这个镜像原本是有镜像名和标签的，原来为 `mongo:3.2`，随着官方镜像维护，发布了新版本后，重新 `docker pull mongo:3.2` 时，`mongo:3.2` 这个镜像名被转移到了新下载的镜像身上，而旧的镜像上的这个名称则被取消，从而成为了 `<none>`。除了 `docker pull` 可能导致这种情况，`docker build` 也同样可以导致这种现象。由于新旧镜像同名，旧镜像名称被取消，从而出现仓库名、标签均为 `<none>` 的镜像。这类无标签镜像也被称为 **虚悬镜像(dangling image)** ，可以用下面的命令专门显示这类镜像：
```bash
$ docker image ls -f dangling=true
REPOSITORY TAG IMAGE ID CREATED SIZE
<none> <none> 00285df0df87 5 days ago 342 MB
```
一般来说，虚悬镜像已经失去了存在的价值，是可以随意删除的，可以用下面的命令删除。
```bash
$ docker image prune
```
### 中间层镜像
为了加速镜像构建、重复利用资源，Docker 会利用 **中间层镜像**。所以在使用一段时间后，可能会看到一些依赖的中间层镜像。默认的 `docker image ls` 列表中只会显示顶层镜像，如果希望显示包括中间层镜像在内的所有镜像的话，需要加 `-a` 参数。
```bash
$ docker image ls -a
```
这样会看到很多无标签的镜像，与之前的虚悬镜像不同，这些无标签的镜像很多都是中间层镜像，是其它镜像所依赖的镜像。这些无标签镜像不应该删除，否则会导致上层镜像因为依赖丢失而出错。实际上，这些镜像也没必要删除，因为之前说过，相同的层只会存一遍，而这些镜像是别的镜像的依赖，因此并不会因为它们被列出来而多存了一份，无论如何你也会需要它们。只要删除那些依赖它们的镜像后，这些依赖的中间层镜像也会被连带删除。
### 列出部分镜像
不加任何参数的情况下，`docker image ls` 会列出所有顶级镜像，但是有时候我们只希望列出部分镜像。`docker image ls` 有好几个参数可以帮助做到这个事情。
根据仓库名列出镜像
```bash
$ docker image ls ubuntu
REPOSITORY TAG IMAGE ID CREATED SIZE
ubuntu 18.04 f753707788c5 4 weeks ago 127 MB
ubuntu latest f753707788c5 4 weeks ago 127 MB
ubuntu 14.04 1e0c3dd64ccd 4 weeks ago 188 MB
```
列出特定的某个镜像，也就是说指定仓库名和标签
```bash
$ docker image ls ubuntu:18.04
REPOSITORY TAG IMAGE ID CREATED SIZE
ubuntu 18.04 f753707788c5 4 weeks ago 127 MB
```
除此以外，`docker image ls` 还支持强大的过滤器参数 `--filter`，或者简写 `-f`。之前我们已经看到了使用过滤器来列出虚悬镜像的用法，它还有更多的用法。比如，我们希望看到在 `mongo:3.2` 之后建立的镜像，可以用下面的命令：
```bash
$ docker image ls -f since=mongo:3.2
REPOSITORY TAG IMAGE ID CREATED SIZE
redis latest 5f515359c7f8 5 days ago 183 MB
nginx latest 05a60462f8ba 5 days ago 181 MB
```
想查看某个位置之前的镜像也可以，只需要把 `since` 换成 `before` 即可。
此外，如果镜像构建时，定义了 `LABEL`，还可以通过 `LABEL` 来过滤。
```bash
$ docker image ls -f label=com.example.version=0.1
...
```
### 以特定格式显示
默认情况下，`docker image ls` 会输出一个完整的表格，但是我们并非所有时候都会需要这些内容。比如，刚才删除虚悬镜像的时候，我们需要利用 `docker image ls` 把所有的虚悬镜像的 ID 列出来，然后才可以交给 `docker image rm` 命令作为参数来删除指定的这些镜像，这个时候就用到了 `-q` 参数。
```bash
$ docker image ls -q
5f515359c7f8
05a60462f8ba
fe9198c04d62
00285df0df87
f753707788c5
f753707788c5
1e0c3dd64ccd
```
`--filter` 配合 `-q` 产生出指定范围的 ID 列表，然后送给另一个 `docker` 命令作为参数，从而针对这组实体成批的进行某种操作的做法在 Docker 命令行使用过程中非常常见，不仅仅是镜像，将来我们会在各个命令中看到这类搭配以完成很强大的功能。因此每次在文档看到过滤器后，可以多注意一下它们的用法。
另外一些时候，我们可能只是对表格的结构不满意，希望自己组织列；或者不希望有标题，这样方便其它程序解析结果等，这就用到了 [Go 的模板语法](https://gohugo.io/templates/go-templates/)。
比如，下面的命令会直接列出镜像结果，并且只包含镜像ID和仓库名：
```bash
$ docker image ls --format "{{.ID}}: {{.Repository}}"
5f515359c7f8: redis
05a60462f8ba: nginx
fe9198c04d62: mongo
00285df0df87: <none>
f753707788c5: ubuntu
f753707788c5: ubuntu
1e0c3dd64ccd: ubuntu
```
或者打算以表格等距显示，并且有标题行，和默认一样，不过自己定义列：
```bash
$ docker image ls --format "table {{.ID}}\t{{.Repository}}\t{{.Tag}}"
IMAGE ID REPOSITORY TAG
5f515359c7f8 redis latest
05a60462f8ba nginx latest
fe9198c04d62 mongo 3.2
00285df0df87 <none> <none>
f753707788c5 ubuntu 18.04
f753707788c5 ubuntu latest
1e0c3dd64ccd ubuntu 14.04
```
## 删除本地镜像
如果要删除本地的镜像，可以使用 `docker image rm` 命令，其格式为：
```
$ docker image rm [选项] <镜像1> [<镜像2> ...]
```
### 用 ID、镜像名、摘要删除镜像
其中，`<镜像>` 可以是 `镜像短 ID`、`镜像长 ID`、`镜像名` 或者 `镜像摘要`。
比如我们有这么一些镜像：
```bash
$ docker image ls
REPOSITORY TAG IMAGE ID CREATED SIZE
centos latest 0584b3d2cf6d 3 weeks ago 196.5 MB
redis alpine 501ad78535f0 3 weeks ago 21.03 MB
docker latest cf693ec9b5c7 3 weeks ago 105.1 MB
nginx latest e43d811ce2f4 5 weeks ago 181.5 MB
```
我们可以用镜像的完整 ID，也称为 `长 ID`，来删除镜像。使用脚本的时候可能会用长 ID，但是人工输入就太累了，所以更多的时候是用 `短 ID` 来删除镜像。`docker image ls` 默认列出的就已经是短 ID 了，一般取前3个字符以上，只要足够区分于别的镜像就可以了。
比如这里，如果我们要删除 `redis:alpine` 镜像，可以执行：
```bash
$ docker image rm 501
Untagged: redis:alpine
Untagged: redis@sha256:f1ed3708f538b537eb9c2a7dd50dc90a706f7debd7e1196c9264edeea521a86d
Deleted: sha256:501ad78535f015d88872e13fa87a828425117e3d28075d0c117932b05bf189b7
Deleted: sha256:96167737e29ca8e9d74982ef2a0dda76ed7b430da55e321c071f0dbff8c2899b
Deleted: sha256:32770d1dcf835f192cafd6b9263b7b597a1778a403a109e2cc2ee866f74adf23
Deleted: sha256:127227698ad74a5846ff5153475e03439d96d4b1c7f2a449c7a826ef74a2d2fa
Deleted: sha256:1333ecc582459bac54e1437335c0816bc17634e131ea0cc48daa27d32c75eab3
Deleted: sha256:4fc455b921edf9c4aea207c51ab39b10b06540c8b4825ba57b3feed1668fa7c7
```
我们也可以用`镜像名`，也就是 `<仓库名>:<标签>`，来删除镜像。
```bash
$ docker image rm centos
Untagged: centos:latest
Untagged: centos@sha256:b2f9d1c0ff5f87a4743104d099a3d561002ac500db1b9bfa02a783a46e0d366c
Deleted: sha256:0584b3d2cf6d235ee310cf14b54667d889887b838d3f3d3033acd70fc3c48b8a
Deleted: sha256:97ca462ad9eeae25941546209454496e1d66749d53dfa2ee32bf1faabd239d38
```
当然，更精确的是使用 `镜像摘要` 删除镜像。
```bash
$ docker image ls --digests
REPOSITORY TAG DIGEST IMAGE ID CREATED SIZE
node slim sha256:b4f0e0bdeb578043c1ea6862f0d40cc4afe32a4a582f3be235a3b164422be228 6e0c4c8e3913 3 weeks ago 214 MB
$ docker image rm node@sha256:b4f0e0bdeb578043c1ea6862f0d40cc4afe32a4a582f3be235a3b164422be228
Untagged: node@sha256:b4f0e0bdeb578043c1ea6862f0d40cc4afe32a4a582f3be235a3b164422be228
```
### Untagged 和 Deleted
如果观察上面这几个命令的运行输出信息的话，你会注意到删除行为分为两类，一类是 `Untagged`，另一类是 `Deleted`。我们之前介绍过，镜像的唯一标识是其 ID 和摘要，而一个镜像可以有多个标签。
因此当我们使用上面命令删除镜像的时候，实际上是在要求删除某个标签的镜像。所以首先需要做的是将满足我们要求的所有镜像标签都取消，这就是我们看到的 `Untagged` 的信息。因为一个镜像可以对应多个标签，因此当我们删除了所指定的标签后，可能还有别的标签指向了这个镜像，如果是这种情况，那么 `Delete` 行为就不会发生。所以并非所有的 `docker image rm`都会产生删除镜像的行为，有可能仅仅是取消了某个标签而已。
当该镜像所有的标签都被取消了，该镜像很可能会失去了存在的意义，因此会触发删除行为。镜像是多层存储结构，因此在删除的时候也是从上层向基础层方向依次进行判断删除。镜像的多层结构让镜像复用变动非常容易，因此很有可能某个其它镜像正依赖于当前镜像的某一层。这种情况，依旧不会触发删除该层的行为。直到没有任何层依赖当前层时，才会真实的删除当前层。这就是为什么，有时候会奇怪，为什么明明没有别的标签指向这个镜像，但是它还是存在的原因，也是为什么有时候会发现所删除的层数和自己 `docker pull` 看到的层数不一样的源。
除了镜像依赖以外，还需要注意的是容器对镜像的依赖。如果有用这个镜像启动的容器存在（即使容器没有运行），那么同样不可以删除这个镜像。之前讲过，容器是以镜像为基础，再加一层容器存储层，组成这样的多层存储结构去运行的。因此该镜像如果被这个容器所依赖的，那么删除必然会导致故障。如果这些容器是不需要的，应该先将它们删除，然后再来删除镜像。
### 用 docker image ls 命令来配合
像其它可以承接多个实体的命令一样，可以使用 `docker image ls -q` 来配合使用 `docker image rm`，这样可以成批的删除希望删除的镜像。我们在“镜像列表”章节介绍过很多过滤镜像列表的方式都可以拿过来使用。
比如，我们需要删除所有仓库名为 `redis` 的镜像：
```bash
$ docker image rm $(docker image ls -q redis)
```
或者删除所有在 `mongo:3.2` 之前的镜像：
```bash
$ docker image rm $(docker image ls -q -f before=mongo:3.2)
```
充分利用你的想象力和 Linux 命令行的强大，你可以完成很多非常赞的功能。
### CentOS/RHEL 的用户需要注意的事项
在 Ubuntu/Debian 上有 `UnionFS` 可以使用，如 `aufs` 或者 `overlay2`，而 CentOS 和 RHEL 的内核中没有相关驱动。因此对于这类系统，一般使用 `devicemapper` 驱动利用 LVM 的一些机制来模拟分层存储。这样的做法除了性能比较差外，稳定性一般也不好，而且配置相对复杂。Docker 安装在 CentOS/RHEL 上后，会默认选择 `devicemapper`，但是为了简化配置，其 `devicemapper`是跑在一个稀疏文件模拟的块设备上，也被称为 `loop-lvm`。这样的选择是因为不需要额外配置就可以运行 Docker，这是自动配置唯一能做到的事情。但是 `loop-lvm` 的做法非常不好，其稳定性、性能更差，无论是日志还是 `docker info` 中都会看到警告信息。官方文档有明确的文章讲解了如何配置块设备给 `devicemapper` 驱动做存储层的做法，这类做法也被称为配置 `direct-lvm`。
除了前面说到的问题外，`devicemapper` + `loop-lvm` 还有一个缺陷，因为它是稀疏文件，所以它会不断增长。用户在使用过程中会注意到 `/var/lib/docker/devicemapper/devicemapper/data` 不断增长，而且无法控制。很多人会希望删除镜像或者可以解决这个问题，结果发现效果并不明显。原因就是这个稀疏文件的空间释放后基本不进行垃圾回收的问题。因此往往会出现即使删除了文件内容，空间却无法回收，随着使用这个稀疏文件一直在不断增长。
所以对于 CentOS/RHEL 的用户来说，在没有办法使用 `UnionFS` 的情况下，一定要配置 `direct-lvm` 给 `devicemapper`，无论是为了性能、稳定性还是空间利用率。
*或许有人注意到了 CentOS 7 中存在被 backports 回来的 overlay 驱动，不过 CentOS 里的这个驱动达不到生产环境使用的稳定程度，所以不推荐使用。*
## 使用 Dockerfile 定制镜像
从刚才的 `docker commit` 的学习中，我们可以了解到，镜像的定制实际上就是定制每一层所添加的配置、文件。如果我们可以把每一层修改、安装、构建、操作的命令都写入一个脚本，用这个脚本来构建、定制镜像，那么之前提及的无法重复的问题、镜像构建透明性的问题、体积的问题就都会解决。这个脚本就是 Dockerfile。
Dockerfile 是一个文本文件，其内包含了一条条的**指令(Instruction)**，每一条指令构建一层，因此每一条指令的内容，就是描述该层应当如何构建。
还以之前定制 `nginx` 镜像为例，这次我们使用 Dockerfile 来定制。
在一个空白目录中，建立一个文本文件，并命名为 `Dockerfile`：
```bash
$ mkdir mynginx
$ cd mynginx
$ touch Dockerfile
```
其内容为：
```dockerfile
FROM nginx
RUN echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.html
```
这个 Dockerfile 很简单，一共就两行。涉及到了两条指令，`FROM` 和 `RUN`。
### 构建镜像
好了，让我们再回到之前定制的 nginx 镜像的 Dockerfile 来。现在我们明白了这个 Dockerfile 的内容，那么让我们来构建这个镜像吧。
在 `Dockerfile` 文件所在目录执行：
```bash
$ docker build -t nginx:v3 .
Sending build context to Docker daemon 2.048 kB
Step 1 : FROM nginx
---> e43d811ce2f4
Step 2 : RUN echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.html
---> Running in 9cdc27646c7b
---> 44aa4490ce2c
Removing intermediate container 9cdc27646c7b
Successfully built 44aa4490ce2c
```
从命令的输出结果中，我们可以清晰的看到镜像的构建过程。在 `Step 2` 中，如同我们之前所说的那样，`RUN` 指令启动了一个容器 `9cdc27646c7b`，执行了所要求的命令，并最后提交了这一层 `44aa4490ce2c`，随后删除了所用到的这个容器 `9cdc27646c7b`。
这里我们使用了 `docker build` 命令进行镜像构建。其格式为：
```bash
docker build [选项] <上下文路径/URL/->
```
在这里我们指定了最终镜像的名称 `-t nginx:v3`，构建成功后，我们可以像之前运行 `nginx:v2` 那样来运行这个镜像，其结果会和 `nginx:v2` 一样。
### 镜像构建上下文（Context）
如果注意，会看到 `docker build` 命令最后有一个 `.`。`.` 表示当前目录，而 `Dockerfile` 就在当前目录，因此不少初学者以为这个路径是在指定 `Dockerfile` 所在路径，这么理解其实是不准确的。如果对应上面的命令格式，你可能会发现，这是在指定**上下文路径**。那么什么是上下文呢？
首先我们要理解 `docker build` 的工作原理。Docker 在运行时分为 Docker 引擎（也就是服务端守护进程）和客户端工具。Docker 的引擎提供了一组 REST API，被称为 [Docker Remote API](https://docs.docker.com/engine/reference/api/docker_remote_api/)，而如 `docker` 命令这样的客户端工具，则是通过这组 API 与 Docker 引擎交互，从而完成各种功能。因此，虽然表面上我们好像是在本机执行各种 `docker` 功能，但实际上，一切都是使用的远程调用形式在服务端（Docker 引擎）完成。也因为这种 C/S 设计，让我们操作远程服务器的 Docker 引擎变得轻而易举。
当我们进行镜像构建的时候，并非所有定制都会通过 `RUN` 指令完成，经常会需要将一些本地文件复制进镜像，比如通过 `COPY` 指令、`ADD` 指令等。而 `docker build` 命令构建镜像，其实并非在本地构建，而是在服务端，也就是 Docker 引擎中构建的。那么在这种客户端/服务端的架构中，如何才能让服务端获得本地文件呢？
这就引入了上下文的概念。当构建的时候，用户会指定构建镜像上下文的路径，`docker build` 命令得知这个路径后，会将路径下的所有内容打包，然后上传给 Docker 引擎。这样 Docker 引擎收到这个上下文包后，展开就会获得构建镜像所需的一切文件。
如果在 `Dockerfile` 中这么写：
```Dockerfile
COPY ./package.json /app/
```
这并不是要复制执行 `docker build` 命令所在的目录下的 `package.json`，也不是复制 `Dockerfile` 所在目录下的 `package.json`，而是复制 **上下文（context）** 目录下的 `package.json`。
因此，`COPY` 这类指令中的源文件的路径都是*相对路径*。这也是初学者经常会问的为什么 `COPY ../package.json /app` 或者 `COPY /opt/xxxx /app` 无法工作的原因，因为这些路径已经超出了上下文的范围，Docker 引擎无法获得这些位置的文件。如果真的需要那些文件，应该将它们复制到上下文目录中去。
现在就可以理解刚才的命令 `docker build -t nginx:v3 .` 中的这个 `.`，实际上是在指定上下文的目录，`docker build` 命令会将该目录下的内容打包交给 Docker 引擎以帮助构建镜像。
如果观察 `docker build` 输出，我们其实已经看到了这个发送上下文的过程：
```bash
$ docker build -t nginx:v3 .
Sending build context to Docker daemon 2.048 kB
...
```
理解构建上下文对于镜像构建是很重要的，避免犯一些不应该的错误。比如有些初学者在发现 `COPY /opt/xxxx /app` 不工作后，于是干脆将 `Dockerfile` 放到了硬盘根目录去构建，结果发现 `docker build` 执行后，在发送一个几十 GB 的东西，极为缓慢而且很容易构建失败。那是因为这种做法是在让 `docker build`打包整个硬盘，这显然是使用错误。
一般来说，应该会将 `Dockerfile` 置于一个空目录下，或者项目根目录下。如果该目录下没有所需文件，那么应该把所需文件复制一份过来。如果目录下有些东西确实不希望构建时传给 Docker 引擎，那么可以用 `.gitignore` 一样的语法写一个 `.dockerignore`，该文件是用于剔除不需要作为上下文传递给 Docker 引擎的。
那么为什么会有人误以为 `.` 是指定 `Dockerfile` 所在目录呢？这是因为在默认情况下，如果不额外指定 `Dockerfile` 的话，会将上下文目录下的名为 `Dockerfile` 的文件作为 Dockerfile。
这只是默认行为，实际上 `Dockerfile` 的文件名并不要求必须为 `Dockerfile`，而且并不要求必须位于上下文目录中，比如可以用 `-f ../Dockerfile.php` 参数指定某个文件作为 `Dockerfile`。
当然，一般大家习惯性的会使用默认的文件名 `Dockerfile`，以及会将其置于镜像构建上下文目录中。
### 其它 `docker build` 的用法
#### 直接用 Git repo 进行构建
或许你已经注意到了，`docker build` 还支持从 URL 构建，比如可以直接从 Git repo 中构建：
```bash
$ docker build https://github.com/twang2218/gitlab-ce-zh.git#:8.14
docker build https://github.com/twang2218/gitlab-ce-zh.git\#:8.14
Sending build context to Docker daemon 2.048 kB
Step 1 : FROM gitlab/gitlab-ce:8.14.0-ce.0
8.14.0-ce.0: Pulling from gitlab/gitlab-ce
aed15891ba52: Already exists
773ae8583d14: Already exists
...
```
这行命令指定了构建所需的 Git repo，并且指定默认的 `master` 分支，构建目录为 `/8.14/`，然后 Docker 就会自己去 `git clone` 这个项目、切换到指定分支、并进入到指定目录后开始构建。
#### 用给定的 tar 压缩包构建
```bash
$ docker build http://server/context.tar.gz
```
如果所给出的 URL 不是个 Git repo，而是个 `tar` 压缩包，那么 Docker 引擎会下载这个包，并自动解压缩，以其作为上下文，开始构建。
#### 从标准输入中读取 Dockerfile 进行构建
```bash
docker build - < Dockerfile
```
或
```bash
cat Dockerfile | docker build -
```
如果标准输入传入的是文本文件，则将其视为 `Dockerfile`，并开始构建。这种形式由于直接从标准输入中读取 Dockerfile 的内容，它没有上下文，因此不可以像其他方法那样可以将本地文件 `COPY` 进镜像之类的事情。
#### 从标准输入中读取上下文压缩包进行构建
```bash
$ docker build - < context.tar.gz
```
如果发现标准输入的文件格式是 `gzip`、`bzip2` 以及 `xz` 的话，将会使其为上下文压缩包，直接将其展开，将里面视为上下文，并开始构建。

66
docs/docker/basics/docker-images.md
View File

@ -1,66 +0,0 @@
# Docker 镜像使用
## 列出镜像列表
`docker images` 命令可用来列出本地主机上的镜像。
```
# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
docker.io/maven latest 76c9ab5df55b 7 days ago 737 MB
friendlyhello latest 0c6d91e71733 8 days ago 148 MB
<none> <none> d1eab98cf3bd 11 days ago 311 MB
docker.io/python 2.7-slim 5541369755c4 13 days ago 139 MB
docker.io/hello-world latest f2a91732366c 4 months ago 1.85 kB
docker.io/java 8-jre e44d62cf8862 14 months ago 311 MB
docker.io/training/webapp latest 6fae60ef3446 2 years ago 349 MB
```
选项说明：
* REPOSITORY：表示镜像的仓库源
* TAG：镜像的标签
* IMAGE ID：镜像ID
* CREATED：镜像创建时间
* SIZE：镜像大小
同一仓库源可以有多个 TAG，代表这个仓库源的不同个版本，如ubuntu仓库源里，有15.10、14.04等多个不同的版本，我们使用 REPOSITORY:TAG 来定义不同的镜像。
如果要使用版本为14.04的ubuntu系统镜像来运行容器时，命令如下：
```
docker run -t -i ubuntu:14.04 /bin/bash
```
如果你不指定一个镜像的版本标签，例如你只使用 ubuntu，docker 将默认使用 ubuntu:latest 镜像。
## 查找镜像
可以从 Docker Hub 网站来搜索镜像，Docker Hub 网址为： https://hub.docker.com/
我们也可以使用 `docker search` 命令来搜索镜像。比如我们需要一个httpd的镜像来作为我们的web服务。我们可以通过 docker search 命令搜索 httpd 来寻找适合我们的镜像。
```
docker search httpd
```
## 拉取镜像
当我们在本地主机上使用一个不存在的镜像时 Docker 就会自动下载这个镜像。如果我们想预先下载这个镜像，我们可以使用 `docker pull` 命令来下载它。
```
# docker pull ubuntu:13.10
13.10: Pulling from library/ubuntu
6599cadaf950: Pull complete
23eda618d451: Pull complete
f0be3084efe9: Pull complete
52de432f084b: Pull complete
a3ed95caeb02: Pull complete
Digest: sha256:15b79a6654811c8d992ebacdfbd5152fcf3d165e374e264076aa435214a947a3
Status: Downloaded newer image for ubuntu:13.10
```
下载完成后，我们可以直接使用这个镜像来运行容器。
## 创建镜像

74
docs/docker/basics/docker-install.md
View File

@ -1,74 +0,0 @@
# Docker 安装
> 本教程基于 `Docker 1.37`。
>
> Docker 有两种可安装版本：
>
> - [Community Edition (CE)](https://www.docker.com/community-edition/)，即 Docker 社区版，适合学习。
> - [Enterprise Edition (EE)](https://www.docker.com/enterprise-edition)，即 Docker 企业版，适合企业级开发使用。
<!-- TOC depthFrom:2 depthTo:2 -->
- [Windows 下安装 Docker](#windows-下安装-docker)
- [安装参考](#安装参考)
<!-- /TOC -->
## Windows 下安装 Docker
安装 Docker Toolbox 步骤：
（1）双击运行安装包
![](http://oyz7npk35.bkt.clouddn.com/images/20180920180926103056.png)
（2）点击需要安装的程序，建议全安装
![](http://oyz7npk35.bkt.clouddn.com/images/20180920180926103147.png)
（3）安装附加选项，建议选择前三个
![](http://oyz7npk35.bkt.clouddn.com/images/20180920180926103213.png)
（4）安装结果
![](http://oyz7npk35.bkt.clouddn.com/images/20180920180926102959.png)
### 可能遇到的问题
问题 1 - bash.exe 找不到
![](http://oyz7npk35.bkt.clouddn.com/images/20180920180926104526.png)
打开快捷方式的属性窗口，在目标栏设置如下：
```
"C:\Program Files\Git\bin\bash.exe" --login -i "D:\Tools\DockerToolbox\start.sh"
```
![](http://oyz7npk35.bkt.clouddn.com/images/20180920180926105007.png)
问题 2 - Hyper-V 冲突
![](http://oyz7npk35.bkt.clouddn.com/images/20180920180926105357.png)
## 安装参考
**Enterprise Edition (EE)**
- https://docs.docker.com/install/windows/docker-ee/
- https://docs.docker.com/install/linux/docker-ee/ubuntu/
- https://docs.docker.com/install/linux/docker-ee/rhel/
- https://docs.docker.com/install/linux/docker-ee/centos/
- https://docs.docker.com/install/linux/docker-ee/oracle/
- https://docs.docker.com/install/linux/docker-ee/suse/
**Community Edition (CE)**
- https://docs.docker.com/docker-for-mac/install/
- https://docs.docker.com/docker-for-windows/install/
- https://docs.docker.com/install/linux/docker-ce/ubuntu/
- https://docs.docker.com/install/linux/docker-ce/debian/
- https://docs.docker.com/install/linux/docker-ce/centos/
- https://docs.docker.com/install/linux/docker-ce/fedora/
- https://docs.docker.com/install/linux/docker-ce/binaries/

35
docs/docker/basics/docker-introduction.md
View File

@ -1,35 +0,0 @@
# Docker 简介
## Docker 是什么
Docker 是开发，传输和运行应用程序的开放平台。
Docker 使您能够将应用程序与基础架构分开，以便快速交付软件。
借助 Docker，您可以像管理应用程序一样管理基础架构。通过利用 Docker 的方法快速进行运输，测试和部署代码，您可以显著缩短编写代码和在生产环境中运行代码之间的耗时。
## Docker 平台
Docker 提供了被称为容器的松散隔离环境，在环境中可以打包和运行应用程序。隔离和安全性允许您在给定主机上同时运行多个容器。容器是轻量级的，因为它们不需要管理程序的额外负载，而是直接在主机的内核中运行。这意味着您可以在给定的硬件组合上运行更多容器，而不是使用虚拟机。你甚至可以在实际上是虚拟机的主机中运行 Docker 容器！
Docker 提供工具和平台来管理容器的生命周期：
* 使用容器开发您的应用程序及其支持组件。
* 容器成为分发和测试你的应用程序的单元。
* 准备好后，将您的应用程序部署到生产环境中，作为容器或协调服务。无论您的生产环境是本地数据中心，云提供商还是两者的混合，这都是一样的。
## Docker 引擎
Docker 引擎是一个 C/S 架构的应用，它有这些主要的组件：
服务器是一个长期运行的程序，被称为守护进程。
REST API 指定程序可用于与守护进程进行通信并指示其执行操作的接口。
命令行客户端。
![https://docs.docker.com/engine/images/engine-components-flow.png](https://docs.docker.com/engine/images/engine-components-flow.png)
CLI 使用 Docker REST API 通过脚本或直接 CLI 命令来控制 Docker 守护进程或与其进行交互。许多其他 Docker 应用程序使用底层的 API 和 CLI。
守护进程创建并管理 Docker 对象，如镜像，容器，网络和卷。

100
docs/docker/basics/docker-repository.md 100644
View File

@ -0,0 +1,100 @@
# Docker 仓库
仓库（Repository）是集中存放镜像的地方。
一个容易混淆的概念是注册服务器（Registry）。实际上注册服务器是管理仓库的具体服务器，每个服务器上可以有多个仓库，而每个仓库下面有多个镜像。从这方面来说，仓库可以被认为是一个具体的项目或目录。例如对于仓库地址 dl.dockerpool.com/ubuntu 来说，dl.dockerpool.com 是注册服务器地址，ubuntu 是仓库名。
## Docker Hub
目前 Docker 官方维护了一个公共仓库 [Docker Hub](https://hub.docker.com/)，其中已经包括了数量超过 15,000 的镜像。大部分需求都可以通过在 Docker Hub 中直接下载镜像来实现。
### 注册
你可以在 [https://cloud.docker.com](https://cloud.docker.com/) 免费注册一个 Docker 账号。
### 登录
可以通过执行 `docker login` 命令交互式的输入用户名及密码来完成在命令行界面登录 Docker Hub。
你可以通过 `docker logout` 退出登录。
### 拉取镜像
你可以通过 `docker search` 命令来查找官方仓库中的镜像，并利用 `docker pull` 命令来将它下载到本地。
例如以 `centos` 为关键词进行搜索：
```bash
$ docker search centos
NAME DESCRIPTION STARS OFFICIAL AUTOMATED
centos The official build of CentOS. 465 [OK]
tianon/centos CentOS 5 and 6, created using rinse instea... 28
blalor/centos Bare-bones base CentOS 6.5 image 6 [OK]
saltstack/centos-6-minimal 6 [OK]
tutum/centos-6.4 DEPRECATED. Use tutum/centos:6.4 instead. ... 5 [OK]
```
可以看到返回了很多包含关键字的镜像，其中包括镜像名字、描述、收藏数（表示该镜像的受关注程度）、是否官方创建、是否自动创建。
官方的镜像说明是官方项目组创建和维护的，automated 资源允许用户验证镜像的来源和内容。
根据是否是官方提供，可将镜像资源分为两类。
一种是类似 `centos` 这样的镜像，被称为基础镜像或根镜像。这些基础镜像由 Docker 公司创建、验证、支持、提供。这样的镜像往往使用单个单词作为名字。
还有一种类型，比如 `tianon/centos` 镜像，它是由 Docker 的用户创建并维护的，往往带有用户名称前缀。可以通过前缀 `username/` 来指定使用某个用户提供的镜像，比如 tianon 用户。
另外，在查找的时候通过 `--filter=stars=N` 参数可以指定仅显示收藏数量为 `N` 以上的镜像。
下载官方 `centos` 镜像到本地。
```bash
$ docker pull centos
Pulling repository centos
0b443ba03958: Download complete
539c0211cd76: Download complete
511136ea3c5a: Download complete
7064731afe90: Download complete
```
### 推送镜像
用户也可以在登录后通过 `docker push` 命令来将自己的镜像推送到 Docker Hub。
以下命令中的 `username` 请替换为你的 Docker 账号用户名。
```bash
$ docker tag ubuntu:18.04 username/ubuntu:18.04
$ docker image ls
REPOSITORY TAG IMAGE ID CREATED SIZE
ubuntu 18.04 275d79972a86 6 days ago 94.6MB
username/ubuntu 18.04 275d79972a86 6 days ago 94.6MB
$ docker push username/ubuntu:18.04
$ docker search username
NAME DESCRIPTION STARS OFFICIAL AUTOMATED
username/ubuntu
```
### 自动创建
自动创建（Automated Builds）功能对于需要经常升级镜像内程序来说，十分方便。
有时候，用户创建了镜像，安装了某个软件，如果软件发布新版本则需要手动更新镜像。
而自动创建允许用户通过 Docker Hub 指定跟踪一个目标网站（目前支持 [GitHub](https://github.com/) 或 [BitBucket](https://bitbucket.org/)）上的项目，一旦项目发生新的提交或者创建新的标签（tag），Docker Hub 会自动构建镜像并推送到 Docker Hub 中。
要配置自动创建，包括如下的步骤：
- 创建并登录 Docker Hub，以及目标网站；
- 在目标网站中连接帐户到 Docker Hub；
- 在 Docker Hub 中 [配置一个自动创建](https://registry.hub.docker.com/builds/add/)；
- 选取一个目标网站中的项目（需要含 `Dockerfile`）和分支；
- 指定 `Dockerfile` 的位置，并提交创建。
之后，可以在 Docker Hub 的 [自动创建页面](https://registry.hub.docker.com/builds/) 中跟踪每次创建的状态。

BIN
docs/docker/containers-and-vm.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 47 KiB

734
docs/docker/docker-cheat-sheet.md
View File

@ -1,734 +0,0 @@
# Docker Cheat Sheet
> 本文转自 [Docker Cheat Sheet](https://github.com/wsargent/docker-cheat-sheet/blob/master/zh-cn/README.md)
**想要一起来完善这份速查表吗？请看[贡献手册](#贡献手册contributing)部分！**
目录
---
<!-- TOC depthFrom:2 depthTo:2 -->
- [为何使用 Docker](#为何使用-docker)
- [系统环境](#系统环境)
- [安装](#安装)
- [容器(Container)](#容器container)
- [镜像(Images)](#镜像images)
- [网络(Networks)](#网络networks)
- [仓管中心和仓库(Registry & Repository)](#仓管中心和仓库registry--repository)
- [Dockerfile](#dockerfile)
- [层(Layers)](#层layers)
- [链接(Links)](#链接links)
- [卷标(Volumes)](#卷标volumes)
- [暴露端口(Exposing ports)](#暴露端口exposing-ports)
- [最佳实践](#最佳实践)
- [安全(Security)](#安全security)
- [小贴士](#小贴士)
- [贡献手册(Contributing)](#贡献手册contributing)
<!-- /TOC -->
## 为何使用 Docker
"通过 Docker, 开发者可以使用任何语言任何工具创建任何应用。“Dockerized” 的应用是完全可移植的，能在任何地方运行 - 不管是同事的 OS X 和 Windows 笔记本，或是在云端运行的 Ubuntu QA 服务，还是在虚拟机运行的 Red Hat 产品数据中心。
Docker Hub 上有 13,000+ 的应用，开发者可以从中选取一个进行快速扩展开发。Docker 跟踪管理变更和依赖关系，让系统管理员能更容易理解开发人员是如何让应用运转起来的。而开发者可以通过 Docker Hub 的共有/私有仓库，构建他们的自动化编译，与其他合作者共享成果。
Docker 帮助开发者更快地构建和发布高质量的应用。" -- [什么是 Docker](https://www.docker.com/what-docker/#copy1)
## 系统环境
我用的是 [Oh My Zsh](https://github.com/robbyrussell/oh-my-zsh) ，和 [Docker 插件](https://github.com/robbyrussell/oh-my-zsh/wiki/Plugins#docker) ，它可以自动补全 docker 的命令。YMMV。
### Linux
3.10.x 内核是能运行 Docker 的[最低要求](https://docs.docker.com/engine/installation/binaries/#check-kernel-dependencies)。
### MacOS
10.8 “Mountain Lion” 或者更新的版本。
## 安装
### Linux
Docker 提供了快速安装脚本：
```
curl -sSL https://get.docker.com/ | sh
```
如果你不想执行一个不明不白的 shell 脚本，那么请看[安装教程](https://docs.docker.com/engine/installation/linux/)，选择你在用的发行版本。
如果你是一个 Docker 超新手，那么我建议你先去看看[系列教程](https://docs.docker.com/engine/getstarted/)。
### Mac OS X
下载和安装 [Docker Toolbox](https://docs.docker.com/toolbox/overview/)。[Docker For Mac](https://docs.docker.com/docker-for-mac/) 很赞，但是它的安装和 VirtualBox 不太一样。详情请查阅[比较](https://docs.docker.com/docker-for-mac/docker-toolbox/)。
> **注意** 如果你已经有安装了 docker toolbox，那么你可能会考虑通过 [Docker Machine](https://docs.docker.com/machine/install-machine/) 安装包(不管是从 URL 或是 `docker-machine upgrade default`)升级，它确实会完成 docker-machine 的升级。但是它不会帮你升级 docker 版本 -- `docker-machine` 变成了 `1.10.3` 而 `docker` 还是原来的 `1.8.3` 或者你之前的什么版本。
>
> 所以你最好是通过 Docker Toolbox DMG 文件来升级，它会一次性的帮你处理好所有的升级。
安装好 Docker Toolbox 之后，通过 VirtualBox provider 安装带 Docker Machine 的 VM:
```
docker-machine create --driver=virtualbox default
docker-machine ls
eval "$(docker-machine env default)"
```
然后启动 container:
```
docker run hello-world
```
好了，你现在有了一个运行中的 Docker container 了。
如果你是一个 Docker 超新手，那么我建议你先去看看[系列教程](https://docs.docker.com/engine/getstarted/)。
## 容器(Container)
[最基本的 Docker 进程](http://etherealmind.com/basics-docker-containers-hypervisors-coreos/)。容器(Container)之于虚拟机(Virtual Machine)就好比线程之于进程。或者你可以把他们想成是 chroots on steroids。
### 生命周期
- [`docker create`](https://docs.docker.com/engine/reference/commandline/create) 创建一个容器但是不启动。
- [`docker rename`](https://docs.docker.com/engine/reference/commandline/rename/) 允许重命名容器。
- [`docker run`](https://docs.docker.com/engine/reference/commandline/run) 在同一个操作中创建并启动一个容器。
- [`docker rm`](https://docs.docker.com/engine/reference/commandline/rm) 删除容器。
- [`docker update`](https://docs.docker.com/engine/reference/commandline/update/) 更新容器的资源限制。
如果你想要一个临时容器，`docker run --rm` 会在容器停止之后删除它。
如果你想映射宿主(host)的一个文件夹到 docker 容器，`docker run -v $HOSTDIR:$DOCKERDIR`。参考 [Volumes](https://github.com/wsargent/docker-cheat-sheet/#volumes)。
如果你想同时删除和容器关联的 volumes ，那么在删除容器的时候必须包含 -v 选项，像这样 `docker rm -v`。
在 docker 1.10 中还有一个 [logging driver](https://docs.docker.com/engine/admin/logging/overview/)，每个容器可以独立使用。如果你想执行 docker 并带上自定义日志驱动，这样 `docker run --log-driver=syslog`
### 启动和停止
- [`docker start`](https://docs.docker.com/engine/reference/commandline/start) 启动容器。
- [`docker stop`](https://docs.docker.com/engine/reference/commandline/stop) 停止运行中的容器。
- [`docker restart`](https://docs.docker.com/engine/reference/commandline/restart) 停止之后再启动容器。
- [`docker pause`](https://docs.docker.com/engine/reference/commandline/pause/) 暂停运行中的容器，将其 "冻结" 在当前状态。
- [`docker unpause`](https://docs.docker.com/engine/reference/commandline/unpause/) 结束容器暂停状态。
- [`docker wait`](https://docs.docker.com/engine/reference/commandline/wait) 阻塞，到运行中的容器停止为止。
- [`docker kill`](https://docs.docker.com/engine/reference/commandline/kill) 向运行中容器发送 SIGKILL 指令。
- [`docker attach`](https://docs.docker.com/engine/reference/commandline/attach) 链接到运行中容器。
如果你想整合容器到[宿主进程管理(host process manager)](https://docs.docker.com/engine/admin/host_integration/)，那么以 `-r=false` 启动守护进程(daemon)然后使用 `docker start -a`。
如果你想通过宿主暴露容器的端口(ports)，请看[暴露端口](#exposing-ports)一节。
故障 docker 实例的重启策略在[这里](http://container42.com/2014/09/30/docker-restart-policies/)。
#### CPU 限制
你可以限制 CPU，包括使用所有 CPU 的百分比，或者使用特定内核数。
比如，你可以设置 [`cpu-shares`](https://docs.docker.com/engine/reference/run/#/cpu-share-constraint) 。这个设置看起来有点奇怪 -- 1024 的意思是 100% CPU，因此如果你希望容器使用全体 CPU 内核的 50%，应将其设置为 512。更多信息，请查阅 https://goldmann.pl/blog/2014/09/11/resource-management-in-docker/#_cpu :
```
docker run -ti --c 512 agileek/cpuset-test
```
你可以只对某些 CPU 内核使用 [`cpuset-cpus`](https://docs.docker.com/engine/reference/run/#/cpuset-constraint)]。请参阅 https://agileek.github.io/docker/2014/08/06/docker-cpuset/ 获取更多细节以及一些不错的视频:
```
docker run -ti --cpuset-cpus=0,4,6 agileek/cpuset-test
```
注意，Docker 在容器内仍然可以**看到**所有的 CPU -- 虽然它只是用了其中一部分。请查阅 https://github.com/docker/docker/issues/20770 获取更多细节。
#### 内存限制
你同样可以在 Docker 设置[内存限制](https://docs.docker.com/engine/reference/run/#/user-memory-constraints) :
```
docker run -it -m 300M ubuntu:14.04 /bin/bash
```
#### 能力(Capabilities)
Linux 的 capability 可以通过使用 `cap-add` 和 `cap-drop` 设置。请参阅 https://docs.docker.com/engine/reference/run/#/runtime-privilege-and-linux-capabilities 获取更多细节。这有助于提高安全性。
如需要挂载基于 FUSE 文件系统，你需要同时结合 --cap-add 和 --device 使用:
```
docker run --rm -it --cap-add SYS_ADMIN --device /dev/fuse sshfs
```
授予对单个设备访问权限:
```
docker run -it --device=/dev/ttyUSB0 debian bash
```
授予所有设备访问权限:
```
docker run -it --privileged -v /dev/bus/usb:/dev/bus/usb debian bash
```
有关容器特权的更多详情请参考[这里](https://docs.docker.com/engine/reference/run/#/runtime-privilege-and-linux-capabilities)
### 信息
- [`docker ps`](https://docs.docker.com/engine/reference/commandline/ps) 查看运行中的所有容器。
- [`docker logs`](https://docs.docker.com/engine/reference/commandline/logs) 从容器中获取日志。(你也可以使用自定义日志驱动，不过在 1.10 中，它只支持 `json-file` 和 `journald`)
- [`docker inspect`](https://docs.docker.com/engine/reference/commandline/inspect) 查看某个容器的所有信息(包括 IP 地址)。
- [`docker events`](https://docs.docker.com/engine/reference/commandline/events) 从容器中获取事件(events)。
- [`docker port`](https://docs.docker.com/engine/reference/commandline/port) 查看容器的公开端口。
- [`docker top`](https://docs.docker.com/engine/reference/commandline/top) 查看容器中活动进程。
- [`docker stats`](https://docs.docker.com/engine/reference/commandline/stats) 查看容器的资源使用情况统计信息。
- [`docker diff`](https://docs.docker.com/engine/reference/commandline/diff) 查看容器的 FS 中有变化文件信息。
`docker ps -a` 查看所有容器，包括正在运行的和已停止的。
`docker stats --all` 显示正在运行的容器列表
### 导入 / 导出
- [`docker cp`](https://docs.docker.com/engine/reference/commandline/cp) 在容器和本地文件系统之间复制文件或文件夹。
- [`docker export`](https://docs.docker.com/engine/reference/commandline/export) 将容器的文件系统切换为压缩包(tarball archive stream)输出到 STDOUT。
### 执行命令
- [`docker exec`](https://docs.docker.com/engine/reference/commandline/exec) 在容器中执行命令。
比如，进入正在运行的容器，在名为 foo 的容器中打开一个新的 shell 进程: `docker exec -it foo /bin/bash`.
## 镜像(Images)
镜像是[docker 容器的模板](https://docs.docker.com/engine/understanding-docker/#how-does-a-docker-image-work)。
### 生命周期
- [`docker images`](https://docs.docker.com/engine/reference/commandline/images) 查看所有镜像。
- [`docker import`](https://docs.docker.com/engine/reference/commandline/import) 从压缩文件中创建镜像。
- [`docker build`](https://docs.docker.com/engine/reference/commandline/build) 从 Dockerfile 创建镜像。
- [`docker commit`](https://docs.docker.com/engine/reference/commandline/commit) 为容器创建镜像，如果容器正在运行则会临时暂停。
- [`docker rmi`](https://docs.docker.com/engine/reference/commandline/rmi) 删除镜像。
- [`docker load`](https://docs.docker.com/engine/reference/commandline/load) 通过 STDIN 从压缩包加载镜像，包括镜像和标签(images and tags) (0.7 起).
- [`docker save`](https://docs.docker.com/engine/reference/commandline/save) 通过 STDOUT 保存镜像到压缩包，包括所有的父层，标签和版本(parent layers, tags & versions) (0.7 起).
### 信息
- [`docker history`](https://docs.docker.com/engine/reference/commandline/history) 查看镜像历史记录。
- [`docker tag`](https://docs.docker.com/engine/reference/commandline/tag) 给镜像命名打标(tags) (本地或者仓库)。
### 清理
虽然你可以用 `docker rmi` 命令来删除指定的镜像，但是这里有个称为 [docker-gc](https://github.com/spotify/docker-gc) 的工具，它可以以一种安全的方式，清理掉那些不再被任何容器使用的镜像。
### 加载/保存镜像
从文件中加载镜像:
```
docker load < my_image.tar.gz
```
保存既有镜像:
```
docker save my_image:my_tag | gzip > my_image.tar.gz
```
### 导入/导出容器
从文件中将容器作为镜像导入:
```
cat my_container.tar.gz | docker import - my_image:my_tag
```
导出既有容器:
```
docker export my_container | gzip > my_container.tar.gz
```
### 加载被保存的镜像和导入作为镜像导出的容器之间的不同
通过 `load` 命令来加载镜像，会创建一个新的镜像，并继承原镜像的所有历史。
通过 `import` 将容器作为镜像导入，也会创建一个新的镜像，但并不包含原镜像的历史，因此生成的镜像会比使用加载方式生成的镜像要小。
## 网络(Networks)
Docker 有[网络(networks)](https://docs.docker.com/engine/userguide/networking/)功能。我并不是很了解它，所以这是一个扩展本文的好地方。这里有篇笔记指出，这是一种可以不使用端口来达成 docker 容器间通信的好方法。详情查阅[通过网络来工作](https://docs.docker.com/engine/userguide/networking/work-with-networks/)。
### 生命周期
- [`docker network create`](https://docs.docker.com/engine/reference/commandline/network_create/)
- [`docker network rm`](https://docs.docker.com/engine/reference/commandline/network_rm/)
### 信息
- [`docker network ls`](https://docs.docker.com/engine/reference/commandline/network_ls/)
- [`docker network inspect`](https://docs.docker.com/engine/reference/commandline/network_inspect/)
### 链接
- [`docker network connect`](https://docs.docker.com/engine/reference/commandline/network_connect/)
- [`docker network disconnect`](https://docs.docker.com/engine/reference/commandline/network_disconnect/)
你可以为[容器指定 IP 地址](https://blog.jessfraz.com/post/ips-for-all-the-things/):
```
# 使用你自己的子网和网关创建一个桥接网络
docker network create --subnet 203.0.113.0/24 --gateway 203.0.113.254 iptastic
# 基于以上创建的网络，运行一个nginx容器并指定ip
$ docker run --rm -it --net iptastic --ip 203.0.113.2 nginx
# 在其他地方使用curl访问这个ip（假设这是一个公网ip）
$ curl 203.0.113.2
```
## 仓管中心和仓库(Registry & Repository)
仓库(repository)是*被托管(hosted)*的已命名镜像(tagged images)集合，这组镜像用于构建容器文件系统。
仓管中心(registry)是一个*托管服务(host)* -- 一个服务，用于存储仓库和提供 HTTP API，以便[管理上传和下载仓库](https://docs.docker.com/engine/tutorials/dockerrepos/)。
Docker.com 把它自己的[索引](https://hub.docker.com/)托管到了它的仓管中心，那里有数量众多的仓库。不过话虽如此，这个仓管中心[并没有很好的验证镜像](https://titanous.com/posts/docker-insecurity)，所以如果你很担心安全问题的话，请尽量避免使用它。
- [`docker login`](https://docs.docker.com/engine/reference/commandline/login) 登入仓管中心。
- [`docker logout`](https://docs.docker.com/engine/reference/commandline/logout) 登出仓管中心。
- [`docker search`](https://docs.docker.com/engine/reference/commandline/search) 从仓管中心检索镜像。
- [`docker pull`](https://docs.docker.com/engine/reference/commandline/pull) 从仓管中心拉去镜像到本地。
- [`docker push`](https://docs.docker.com/engine/reference/commandline/push) 从本地推送镜像到仓管中心。
### 本地仓管中心
你可以创立一个本地的仓管中心，通过使用 [docker distribution](https://github.com/docker/distribution) 工程，细节请查看 [本地发布(local deploy)](https://github.com/docker/docker.github.io/blob/master/registry/deploying.md) 介绍。
也可以参考 [邮件列表](https://groups.google.com/a/dockerproject.org/forum/#!forum/distribution)。
## Dockerfile
[配置文件](https://docs.docker.com/engine/reference/builder/)。当你执行 `docker build` 的时候会根据该配置文件设置 Docker 容器。远优于使用 `docker commit`。
下面是一些常用的编写 Dockerfile 的编辑器和语法高亮模块︰
- 如果你使用 [jEdit](http://jedit.org)，我为 [Dockerfile](https://github.com/wsargent/jedit-docker-mode) 做了个语法高亮模块。
- [Sublime Text 2](https://packagecontrol.io/packages/Dockerfile%20Syntax%20Highlighting)
- [Atom](https://atom.io/packages/language-docker)
- [Vim](https://github.com/ekalinin/Dockerfile.vim)
- [Emacs](https://github.com/spotify/dockerfile-mode)
- [TextMate](https://github.com/docker/docker/tree/master/contrib/syntax/textmate)
- 如果要找更全面的关于编辑器或者 IDE 的内容，请看 [当 Docker 遇上 IDE](https://domeide.github.io/)
### 指令
- [.dockerignore](https://docs.docker.com/engine/reference/builder/#dockerignore-file)
- [FROM](https://docs.docker.com/engine/reference/builder/#from) 为其他指令设置基础镜像(Base Image)。
- [MAINTAINER](https://docs.docker.com/engine/reference/builder/#maintainer) 为生成的镜像设置作者字段。
- [RUN](https://docs.docker.com/engine/reference/builder/#run) 在当前镜像的基础上生成一个新层并执行命令。
- [CMD](https://docs.docker.com/engine/reference/builder/#cmd) 设置容器默认执行命令。
- [EXPOSE](https://docs.docker.com/engine/reference/builder/#expose) 告知 Docker 容器在运行时所要监听的网络端口。注意：并没有实际上将端口设置为可访问。
- [ENV](https://docs.docker.com/engine/reference/builder/#env) 设置环境变量。
- [ADD](https://docs.docker.com/engine/reference/builder/#add) 将文件，文件夹或者远程文件复制到容器中。缓存无效。尽量用 `COPY` 代替 `ADD`。
- [COPY](https://docs.docker.com/engine/reference/builder/#copy) 将文件或文件夹复制到容器中。
- [ENTRYPOINT](https://docs.docker.com/engine/reference/builder/#entrypoint) 将一个容器设置为可执行。
- [VOLUME](https://docs.docker.com/engine/reference/builder/#volume) 为外部挂载卷标或其他容器设置挂载点(mount point)。
- [USER](https://docs.docker.com/engine/reference/builder/#user) 设置执行 RUN / CMD / ENTRYPOINT 命令的用户名。
- [WORKDIR](https://docs.docker.com/engine/reference/builder/#workdir) 设置工作目录。
- [ARG](https://docs.docker.com/engine/reference/builder/#arg) 定义编译时(build-time)变量。
- [ONBUILD](https://docs.docker.com/engine/reference/builder/#onbuild) 添加触发指令，当该镜像被作为其他镜像的基础镜像时该指令会被触发。
- [STOPSIGNAL](https://docs.docker.com/engine/reference/builder/#stopsignal) 设置通过系统向容器发出退出指令。
- [LABEL](https://docs.docker.com/engine/userguide/labels-custom-metadata/) 将键值对元数据(key/value metadata)应用到你的镜像，容器，或者守护进程。
### 教程
- [Flux7's Dockerfile Tutorial](http://flux7.com/blogs/docker/docker-tutorial-series-part-3-automation-is-the-word-using-dockerfile/)
### 例子
- [Examples](https://docs.docker.com/engine/reference/builder/#dockerfile-examples)
- [Best practices for writing Dockerfiles](https://docs.docker.com/engine/userguide/eng-image/dockerfile_best-practices/)
- [Michael Crosby](http://crosbymichael.com/) 还有更多的 [Dockerfiles best practices](http://crosbymichael.com/dockerfile-best-practices.html) / [take 2](http://crosbymichael.com/dockerfile-best-practices-take-2.html)
- [Building Good Docker Images](http://jonathan.bergknoff.com/journal/building-good-docker-images) / [Building Better Docker Images](http://jonathan.bergknoff.com/journal/building-better-docker-images)
- [Managing Container Configuration with Metadata](https://speakerdeck.com/garethr/managing-container-configuration-with-metadata)
## 层(Layers)
Docker 的版本化文件系统是基于层的。就像[git 的提交或文件变更系统](https://docs.docker.com/engine/userguide/storagedriver/imagesandcontainers/)一样。
注意: 如果你使用 [aufs](https://en.wikipedia.org/wiki/Aufs) 作为你的文件系统，当删除一个容器的时候，Docker 并不一定能成功删除的文件卷标！更多详细信息请参阅 [PR 8484](https://github.com/docker/docker/pull/8484)。
## 链接(Links)
链接(Links)[通过 TCP/IP 端口](https://docs.docker.com/userguide/dockerlinks/)实现了 Docker 容器之间的通讯。[链接到 Redis](https://docs.docker.com/examples/running_redis_service/) 和 [Atlassian](https://blogs.atlassian.com/2013/11/docker-all-the-things-at-atlassian-automation-and-wiring/) 是两个可用的例子。你还可以[通过 hostname 关联链接](https://docs.docker.com/engine/userguide/networking/default_network/dockerlinks/#/updating-the-etchosts-file)。
注意: 如果你希望容器之间**只**通过链接进行通讯，在启动 docker 守护进程的时候请添加参数 `-icc=false` 来禁用内部进程通讯。
如果你有一个名为 CONTAINER 的容器(通过 `docker run --name CONTAINER` 指定) 并且在 Dockerfile 中，它的端口暴露为:
```
EXPOSE 1337
```
然后，我们创建另外一个名为 LINKED 的容器:
```
docker run -d --link CONTAINER:ALIAS --name LINKED user/wordpress
```
然后 CONTAINER 的端口和别名将会以如下的环境变量出现在 LINKED 中:
```
$ALIAS_PORT_1337_TCP_PORT
$ALIAS_PORT_1337_TCP_ADDR
```
之后你就可以通过这种方式来链接它了。
要删除链接，通过命令 `docker rm --link`。
通常，docker 服务之间的链接，是"服务发现"的一个子集，如果你打算在生产中大规模使用 Docker，这将是一个很大的问题。请参阅[The Docker Ecosystem: Service Discovery and Distributed Configuration Stores](https://www.digitalocean.com/community/tutorials/the-docker-ecosystem-service-discovery-and-distributed-configuration-stores)获得更多细节。
## 卷标(Volumes)
Docker 的卷标(volumes)是一个[free-floating 文件系统](https://docs.docker.com/engine/tutorials/dockervolumes/)。它们不应该链接到特定的容器上。好的做法是如果可能，应当把卷标挂载到[纯数据容器(data-only containers)](https://medium.com/@ramangupta/why-docker-data-containers-are-good-589b3c6c749e)上。
### 生命周期
- [`docker volume create`](https://docs.docker.com/engine/reference/commandline/volume_create/)
- [`docker volume rm`](https://docs.docker.com/engine/reference/commandline/volume_rm/)
### 信息
- [`docker volume ls`](https://docs.docker.com/engine/reference/commandline/volume_ls/)
- [`docker volume inspect`](https://docs.docker.com/engine/reference/commandline/volume_inspect/)
卷标在不能使用链接(只有 TCP/IP )的情况下非常有用。例如，如果你有两个 docker 实例需要通讯并在文件系统上留下记录。
你可以一次性将其挂载到多个 docker 容器上，通过 `docker run --volumes-from`。
因为卷标是独立的文件系统，它们通常被用于存储各容器之间的瞬时状态。也就是说，你可以配置一个无状态临时容器，关掉之后，当你有第二个这种临时容器实例的时候，你可以从上一次保存的状态继续执行。
查看[卷标进阶](http://crosbymichael.com/advanced-docker-volumes.html)来获取更多细节。Container42 [非常有用](http://container42.com/2014/11/03/docker-indepth-volumes/)。
你可以[将宿主 MacOS 的文件夹映射为 docker 卷标](https://docs.docker.com/engine/tutorials/dockervolumes/#mount-a-host-directory-as-a-data-volume):
```
docker run -v /Users/wsargent/myapp/src:/src
```
你也可以用远程 NFS 卷标，如果你觉得你[有足够勇气](https://docs.docker.com/engine/tutorials/dockervolumes/#/mount-a-shared-storage-volume-as-a-data-volume)。
可还可以考虑运行一个纯数据容器，像[这里](http://container42.com/2013/12/16/persistent-volumes-with-docker-container-as-volume-pattern/)所说的那样，提供可移植数据。
## 暴露端口(Exposing ports)
通过宿主容器暴露输入端口是相当[繁琐，但有效](https://docs.docker.com/engine/reference/run/#expose-incoming-ports)的。
这种方式可以将容器端口映射到宿主端口上(只使用本地主机(localhost)接口)，通过使用 `-p`:
```
docker run -p 127.0.0.1:$HOSTPORT:$CONTAINERPORT --name CONTAINER -t someimage
```
你可以告诉 Docker 容器在运行时监听指定的网络端口，通过使用 [EXPOSE](https://docs.docker.com/engine/reference/builder/#expose):
```
EXPOSE <CONTAINERPORT>
```
但是注意 EXPOSE 并不会暴露端口，你需要用参数 `-p` 。比如说你要在 localhost 上暴露容器的端口:
```
iptables -t nat -A DOCKER -p tcp --dport <LOCALHOSTPORT> -j DNAT --to-destination <CONTAINERIP>:<PORT>
```
如果你是在 Virtualbox 中运行 Docker，那么你需要转发端口(forward the port)，使用 [forwarded_port](https://docs.vagrantup.com/v2/networking/forwarded_ports.html)。它可以用于在 Vagrantfile 上配置暴露端口段，这样你就可以动态的映射它们了:
```
Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
...
(49000..49900).each do |port|
config.vm.network :forwarded_port, :host => port, :guest => port
end
...
end
```
如果你忘记你将什么端口映射到宿主容器上的话，使用 `docker port` 来查看它:
```
docker port CONTAINER $CONTAINERPORT
```
## 最佳实践
这里有一些最佳实践的总结，以及一些讨论:
- [The Rabbit Hole of Using Docker in Automated Tests](http://gregoryszorc.com/blog/2014/10/16/the-rabbit-hole-of-using-docker-in-automated-tests/)
- [Bridget Kromhout](https://twitter.com/bridgetkromhout) has a useful blog post on [running Docker in production](http://sysadvent.blogspot.co.uk/2014/12/day-1-docker-in-production-reality-not.html) at Dramafever.
- There's also a best practices [blog post](http://developers.lyst.com/devops/2014/12/08/docker/) from Lyst.
- [A Docker Dev Environment in 24 Hours!](https://engineering.salesforceiq.com/2013/11/05/a-docker-dev-environment-in-24-hours-part-2-of-2.html)
- [Building a Development Environment With Docker](https://tersesystems.com/2013/11/20/building-a-development-environment-with-docker/)
- [Discourse in a Docker Container](https://samsaffron.com/archive/2013/11/07/discourse-in-a-docker-container)
## 安全(Security)
这节准备讨论一些关于 Docker 安全性的问题。[安全](https://docs.docker.com/articles/security/)这章讲述了更多细节。
首先第一件事: Docker 是有 root 权限的。如果你在 `docker` 组，那么你就有[ root 权限](http://reventlov.com/advisories/using-the-docker-command-to-root-the-host)。如果你暴露了 docker unix socket 给容器，意味着你赋予了容器[宿主的 root 权限](https://www.lvh.io/posts/dont-expose-the-docker-socket-not-even-to-a-container.html)。Docker 不应该是你唯一的防御措施。
### 安全提示
为了最大的安全性，你应该会考虑在虚拟机上运行 Docker 。这是直接从 Docker 安全团队拿来的资料 -- [slides](http://www.slideshare.net/jpetazzo/linux-containers-lxc-docker-and-security) / [notes](http://www.projectatomic.io/blog/2014/08/is-it-safe-a-look-at-docker-and-security-from-linuxcon/)。然后，可以使用 AppArmor / seccomp / SELinux / grsec 之类的来[限制容器的权限](http://linux-audit.com/docker-security-best-practices-for-your-vessel-and-containers/)。更多细节，请查阅 [Docker 1.10 security features](https://blog.docker.com/2016/02/docker-engine-1-10-security/)。
Docker 镜像 id 属于[敏感信息](https://medium.com/@quayio/your-docker-image-ids-are-secrets-and-its-time-you-treated-them-that-way-f55e9f14c1a4) 所以它不应该向外界公开。你应该把他们当成密码来对待。
参考 [Docker Security Cheat Sheet](https://github.com/konstruktoid/Docker/blob/master/Security/CheatSheet.adoc)中 - 作者是 [Thomas Sjögren](https://github.com/konstruktoid) - 关于如何提高容器安全的建议。
下载[docker 安全测试脚本](https://github.com/docker/docker-bench-security)，下载[白皮书](https://blog.docker.com/2015/05/understanding-docker-security-and-best-practices/) 以及订阅[邮件列表](https://www.docker.com/docker-security) (不幸的是 Docker 并没有独立的邮件列表，只有 dev / user)。
你应该远离那些使用编译版本 grsecurity / pax 的不稳定内核，比如 [Alpine Linux](https://en.wikipedia.org/wiki/Alpine_Linux)。如果在产品中用了 grsecurity ，那么你应该考虑使用有[商业支持](https://grsecurity.net/business_support.php)的[稳定版本](https://grsecurity.net/announce.php)，就像你对待 RedHat 那样。它要 $200 每月，对于你的运维预算来说不值一提。
从 docker 1.11 开始，你可以轻松的限制在容器中可用的进程数，以防止 fork bombs。 这要求 linux 内核 >= 4.3 并且要在内核配置中打开 CGROUP_PIDS=y 。
```
docker run --pids-limit=64
```
同时，从 docker 1.11 开始，你也可以限制进程有再获取新权限的能力了。该功能是 linux 内核从 version 3.5 开始就拥有的。你可以从[这篇博客](http://www.projectatomic.io/blog/2016/03/no-new-privs-docker/)中阅读到更多关于这方面的内容。
```
docker run --security-opt=no-new-privileges
```
参考 [Docker Security Cheat Sheet](http://container-solutions.com/content/uploads/2015/06/15.06.15_DockerCheatSheet_A2.pdf) (它是个 PDF 版本，搞得非常难用，所以拷贝出来了) 的 [容器解決方案](http://container-solutions.com/is-docker-safe-for-production/):
关闭内部进程通讯:
```
docker -d --icc=false --iptables
```
设置容器为只读:
```
docker run --read-only
```
通过 hashsum 来验证卷标:
```
docker pull debian@sha256:a25306f3850e1bd44541976aa7b5fd0a29be
```
设置卷标为只读:
```
docker run -v $(pwd)/secrets:/secrets:ro debian
```
在 Dockerfile 中定义并运行一个用户，避免在容器中以 root 身份操作:
```
RUN groupadd -r user && useradd -r -g user user
USER user
```
### 用户命名空间(User Namespaces)
还可以通过使用 [user namespaces](https://s3hh.wordpress.com/2013/07/19/creating-and-using-containers-without-privilege/) -- 这已经是 1.10 内建功能了，但默认情况下是不启用的。
要在 Ubuntu 15.10 中启用用户命名空间 ("remap the userns")，请[跟着这篇博客的例子](https://raesene.github.io/blog/2016/02/04/Docker-User-Namespaces/)来做。
### 安全相关视频
- [Using Docker Safely](https://youtu.be/04LOuMgNj9U)
- [Securing your applications using Docker](https://youtu.be/KmxOXmPhZbk)
- [Container security: Do containers actually contain?](https://youtu.be/a9lE9Urr6AQ)
### 安全路线图
Docker 的路线图提到关于[seccomp 的支持](https://github.com/docker/docker/blob/master/ROADMAP.md#11-security)。
这里有个 AppArmor 策略生成器，叫做 [bane](https://github.com/jfrazelle/bane)，他们正在实现[安全配置文件](https://github.com/docker/docker/issues/17142)。
## 小贴士
来源:
- [15 Docker Tips in 5 minutes](http://sssslide.com/speakerdeck.com/bmorearty/15-docker-tips-in-5-minutes)
### 最后的 Ids
```
alias dl='docker ps -l -q'
docker run ubuntu echo hello world
docker commit `dl` helloworld
```
### 带命令行的提交 (需要 Dockerfile)
```
docker commit -run='{"Cmd":["postgres", "-too -many -opts"]}' `dl` postgres
```
### 获取 IP 地址
```
docker inspect `dl` | grep IPAddress | cut -d '"' -f 4
```
或者安装 [jq](https://stedolan.github.io/jq/):
```
docker inspect `dl` | jq -r '.[0].NetworkSettings.IPAddress'
```
或者用[go 模板](https://docs.docker.com/engine/reference/commandline/inspect)
```
docker inspect -f '{{ .NetworkSettings.IPAddress }}' <container_name>
```
### 获取端口映射
```
docker inspect -f '{{range $p, $conf := .NetworkSettings.Ports}} {{$p}} -> {{(index $conf 0).HostPort}} {{end}}' <containername>
```
### 通过正则获取容器
```
for i in $(docker ps -a | grep "REGEXP_PATTERN" | cut -f1 -d" "); do echo $i; done`
```
### 获取环境设定
```
docker run --rm ubuntu env
```
### 强迫关闭正在运行的容器
```
docker kill $(docker ps -q)
```
### 删除旧容器
```
docker ps -a | grep 'weeks ago' | awk '{print $1}' | xargs docker rm
```
### 删除停止容器
```
docker rm -v `docker ps -a -q -f status=exited`
```
### 删除 dangling 镜像
```
docker rmi $(docker images -q -f dangling=true)
```
### 删除所有镜像
```
docker rmi $(docker images -q)
```
### 删除 dangling 卷标
Docker 1.9 开始:
```
docker volume rm $(docker volume ls -q -f dangling=true)
```
1.9.0 中，过滤器 `dangling=false` 居然 _没_ 用 - 它会被忽略然后列出所有的卷标。
### 查看镜像依赖
```
docker images -viz | dot -Tpng -o docker.png
```
### Docker 容器瘦身 [Intercity 博客](http://bit.ly/1Wwo61N)
- 在当前运行层(RUN layer)清理 APT
这应当和其他 apt 命令在同一层中完成。
否则，前面的层将会保持原有信息，而你的镜像则依旧臃肿。
```
RUN {apt commands} \
&& apt-get clean \
&& rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
```
- 压缩镜像
```
ID=$(docker run -d image-name /bin/bash)
docker export $ID | docker import – flat-image-name
```
- 备份
```
ID=$(docker run -d image-name /bin/bash)
(docker export $ID | gzip -c > image.tgz)
gzip -dc image.tgz | docker import - flat-image-name
```
### 监视运行中容器的系统资源利用率
检查某个单独容器的 CPU, 内存, 和 网络 i/o 使用情况，你可以:
```
docker stats <container>
```
按 id 列出所有的容器:
```
docker stats $(docker ps -q)
```
按名称列出所有容器:
```
docker stats $(docker ps --format '{{.Names}}')
```
按指定镜像名称列出所有容器:
```
docker ps -a -f ancestor=ubuntu
```
## 贡献手册(Contributing)
这是关于如何为这份速查表做贡献的说明。
### 打开 README.md
点击 [README.md](https://github.com/wsargent/docker-cheat-sheet/blob/master/README.md) <-- 这个链接
![点击它](../images/click.png)
### 编辑页面
![选择它](../images/edit.png)
### 更新和提交
![改变它](../images/change.png)
![提交](../images/commit.png)

95
docs/docker/docker-introduction.md 100644
View File

@ -0,0 +1,95 @@
# Docker 简介
> **Docker 属于 Linux 容器的一种封装，提供简单易用的容器使用接口。**
## 概述
### Docker 是什么
Docker 是开发，传输和运行应用程序的开放平台。
Docker 使您能够将应用程序与基础架构分开，以便快速交付软件。
借助 Docker，您可以像管理应用程序一样管理基础架构。通过利用 Docker 的方法快速进行运输，测试和部署代码，您可以显著缩短编写代码和在生产环境中运行代码之间的耗时。
### Docker 平台
Docker 提供了被称为容器的松散隔离环境，在环境中可以打包和运行应用程序。隔离和安全性允许您在给定主机上同时运行多个容器。容器是轻量级的，因为它们不需要管理程序的额外负载，而是直接在主机的内核中运行。这意味着您可以在给定的硬件组合上运行更多容器，而不是使用虚拟机。你甚至可以在实际上是虚拟机的主机中运行 Docker 容器！
Docker 提供工具和平台来管理容器的生命周期：
- 使用容器开发您的应用程序及其支持组件。
- 容器成为分发和测试你的应用程序的单元。
- 准备好后，将您的应用程序部署到生产环境中，作为容器或协调服务。无论您的生产环境是本地数据中心，云提供商还是两者的混合，这都是一样的。
### Docker 引擎
Docker 引擎是一个 C/S 架构的应用，它有这些主要的组件：
服务器是一个长期运行的程序，被称为守护进程。
REST API 指定程序可用于与守护进程进行通信并指示其执行操作的接口。
命令行客户端。
![https://docs.docker.com/engine/images/engine-components-flow.png](https://docs.docker.com/engine/images/engine-components-flow.png)
CLI 使用 Docker REST API 通过脚本或直接 CLI 命令来控制 Docker 守护进程或与其进行交互。许多其他 Docker 应用程序使用底层的 API 和 CLI。
守护进程创建并管理 Docker 对象，如镜像，容器，网络和卷。
### 传统虚拟机和 Docker
![](http://dunwu.test.upcdn.net/images/os/docker/containers-and-vm.png)
## 概念
Docker 包括三个基本概念
- 镜像（Image）
- 容器（Container）
- 仓库（Repository）
### 镜像
我们都知道，操作系统分为内核和用户空间。对于 Linux 而言，内核启动后，会挂载 root 文件系统为其提供用户空间支持。而 Docker 镜像（Image），就相当于是一个 root 文件系统。比如官方镜像 ubuntu:18.04 就包含了完整的一套 Ubuntu 18.04 最小系统的 root 文件系统。
Docker 镜像是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数（如匿名卷、环境变量、用户等）。镜像不包含任何动态数据，其内容在构建之后也不会被改变。
#### 分层存储
因为镜像包含操作系统完整的 root 文件系统，其体积往往是庞大的，因此在 Docker 设计时，就充分利用 Union FS 的技术，将其设计为分层存储的架构。所以严格来说，镜像并非是像一个 ISO 那样的打包文件，镜像只是一个虚拟的概念，其实际体现并非由一个文件组成，而是由一组文件系统组成，或者说，由多层文件系统联合组成。
镜像构建时，会一层层构建，前一层是后一层的基础。每一层构建完就不会再发生改变，后一层上的任何改变只发生在自己这一层。比如，删除前一层文件的操作，实际不是真的删除前一层的文件，而是仅在当前层标记为该文件已删除。在最终容器运行的时候，虽然不会看到这个文件，但是实际上该文件会一直跟随镜像。因此，在构建镜像的时候，需要额外小心，每一层尽量只包含该层需要添加的东西，任何额外的东西应该在该层构建结束前清理掉。
分层存储的特征还使得镜像的复用、定制变的更为容易。甚至可以用之前构建好的镜像作为基础层，然后进一步添加新的层，以定制自己所需的内容，构建新的镜像。
### 容器
镜像（`Image`）和容器（`Container`）的关系，就像是面向对象程序设计中的 `类` 和 `实例` 一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。
容器的实质是进程，但与直接在宿主执行的进程不同，容器进程运行于属于自己的独立的 [命名空间](https://en.wikipedia.org/wiki/Linux_namespaces)。因此容器可以拥有自己的 `root` 文件系统、自己的网络配置、自己的进程空间，甚至自己的用户 ID 空间。容器内的进程是运行在一个隔离的环境里，使用起来，就好像是在一个独立于宿主的系统下操作一样。这种特性使得容器封装的应用比直接在宿主运行更加安全。也因为这种隔离的特性，很多人初学 Docker 时常常会混淆容器和虚拟机。
前面讲过镜像使用的是分层存储，容器也是如此。每一个容器运行时，是以镜像为基础层，在其上创建一个当前容器的存储层，我们可以称这个为容器运行时读写而准备的存储层为**容器存储层**。
容器存储层的生存周期和容器一样，容器消亡时，容器存储层也随之消亡。因此，任何保存于容器存储层的信息都会随容器删除而丢失。
按照 Docker 最佳实践的要求，容器不应该向其存储层内写入任何数据，容器存储层要保持无状态化。所有的文件写入操作，都应该使用 [数据卷（Volume）](https://yeasy.gitbooks.io/docker_practice/content/data_management/volume.html)、或者绑定宿主目录，在这些位置的读写会跳过容器存储层，直接对宿主（或网络存储）发生读写，其性能和稳定性更高。
数据卷的生存周期独立于容器，容器消亡，数据卷不会消亡。因此，使用数据卷后，容器删除或者重新运行之后，数据却不会丢失。
### 仓库
镜像构建完成后，可以很容易的在当前宿主机上运行，但是，如果需要在其它服务器上使用这个镜像，我们就需要一个集中的存储、分发镜像的服务，[Docker Registry](https://yeasy.gitbooks.io/docker_practice/content/repository/registry.html) 就是这样的服务。
一个 **Docker Registry** 中可以包含多个**仓库**（`Repository`）；每个仓库可以包含多个**标签**（`Tag`）；每个标签对应一个镜像。
通常，一个仓库会包含同一个软件不同版本的镜像，而标签就常用于对应该软件的各个版本。我们可以通过 `<仓库名>:<标签>` 的格式来指定具体是这个软件哪个版本的镜像。如果不给出标签，将以 `latest` 作为默认标签。
以 [Ubuntu 镜像](https://store.docker.com/images/ubuntu) 为例，`ubuntu` 是仓库的名字，其内包含有不同的版本标签，如，`16.04`, `18.04`。我们可以通过 `ubuntu:14.04`，或者 `ubuntu:18.04` 来具体指定所需哪个版本的镜像。如果忽略了标签，比如 `ubuntu`，那将视为 `ubuntu:latest`。
仓库名经常以 _两段式路径_ 形式出现，比如 `jwilder/nginx-proxy`，前者往往意味着 Docker Registry 多用户环境下的用户名，后者则往往是对应的软件名。但这并非绝对，取决于所使用的具体 Docker Registry 的软件或服务。
## 引用和引申
- https://yeasy.gitbooks.io/docker_practice/content/basic_concept/repository.html

133
docs/docker/docker-quickstart.md
View File

@ -1,124 +1,43 @@
# Docker
# Docker 入门
<!-- TOC depthFrom:2 depthTo:2 -->
<!-- TOC depthFrom:2 depthTo:3 -->
- [镜像(Images)](#镜像images)
- [容器(Container)](#容器container)
- [网络(Networks)](#网络networks)
- [仓管中心和仓库(Registry & Repository)](#仓管中心和仓库registry--repository)
- [Dockerfile](#dockerfile)
- [卷标(Volumes)](#卷标volumes)
- [Hello World 示例](#hello-world-示例)
<!-- /TOC -->
## 镜像(Images)
## Hello World 示例
- [`docker image ls`](https://github.com/yeasy/docker_practice/blob/master/image/list.md) - 查看所有镜像。
- [`docker image rm`](https://github.com/yeasy/docker_practice/blob/master/image/rm.md) - 删除本地镜像。
- `docker import` - 从压缩文件中创建镜像。
- `docker export` - 导出既有容器。
- `docker build` - 从 Dockerfile 创建镜像。
- `docker commit` - 为容器创建镜像，如果容器正在运行则会临时暂停。
- `docker rmi` - 删除镜像。
- `docker load` - 通过 STDIN 从压缩包加载镜像，包括镜像和标签(images and tags) (0.7 起).
- `docker save` - 通过 STDOUT 保存镜像到压缩包，包括所有的父层，标签和版本(parent layers, tags & versions) (0.7 起).
- `docker history` - 查看镜像历史记录。
- `docker tag` - 给镜像命名打标(tags) (本地或者仓库)。
（1）拉取镜像
## 容器(Container)
```
docker image pull library/hello-world
```
### 生命周期
`docker image pull` 是抓取 image 文件的命令。`library/hello-world` 是 image 文件在仓库里面的位置，其中 `library` 是 image 文件所在的组，`hello-world` 是 image 文件的名字。
- `docker create` - 创建一个容器但是不启动。
- `docker rename` - 允许重命名容器。
- `docker run` - 在同一个操作中创建并启动一个容器。
- `docker rm` - 删除容器。
- `docker update` - 更新容器的资源限制。
由于 Docker 官方提供的 image 文件，都放在[`library`](https://hub.docker.com/r/library/)组里面，所以它的是默认组，可以省略。因此，上面的命令可以写成下面这样。
### 启动和停止
```
docker image pull hello-world
```
- `docker start` - 启动容器。
- `docker stop` - 停止运行中的容器。
- `docker restart` - 停止之后再启动容器。
- `docker pause` - 暂停运行中的容器，将其 "冻结" 在当前状态。
- `docker unpause` - 结束容器暂停状态。
- `docker wait` - 阻塞，到运行中的容器停止为止。
- `docker kill` - 向运行中容器发送 SIGKILL 指令。
- `docker attach` - 链接到运行中容器。
（2）查看镜像
### 信息
```sh
~ docker image ls
REPOSITORY TAG IMAGE ID CREATED SIZE
hello-world latest 4ab4c602aa5e 3 months ago 1.84kB
```
- `docker ps` - 查看运行中的所有容器。
- `docker logs` - 从容器中获取日志。(你也可以使用自定义日志驱动，不过在 1.10 中，它只支持 json-file 和 journald)
- `docker inspect` - 查看某个容器的所有信息(包括 IP 地址)。
- `docker events` - 从容器中获取事件(events)。
- `docker port` - 查看容器的公开端口。
- `docker top` - 查看容器中活动进程。
- `docker stats` - 查看容器的资源使用情况统计信息。
- `docker diff` - 查看容器的 FS 中有变化文件信息。
（3）运行镜像
### 导入 / 导出
```
docker container run hello-world
```
docker cp 在容器和本地文件系统之间复制文件或文件夹。
docker export 将容器的文件系统切换为压缩包(tarball archive stream)输出到 STDOUT。
`docker container run` 命令会从 image 文件，生成一个正在运行的容器实例。
### 执行命令
注意，`docker container run` 命令具有自动抓取 image 文件的功能。如果发现本地没有指定的 image 文件，就会从仓库自动抓取。因此，前面的 `docker image pull` 命令并不是必需的步骤。
docker exec 在容器中执行命令。
## 网络(Networks)
### 生命周期
- `docker network create`
- `docker network rm`
### 信息
- `docker network ls`
- `docker network inspect`
### 链接
- `docker network connect`
- `docker network disconnect`
## 仓管中心和仓库(Registry & Repository)
- `docker login` - 登入仓管中心。
- `docker logout` - 登出仓管中心。
- `docker search` - 从仓管中心检索镜像。
- `docker pull` - 从仓管中心拉去镜像到本地。
- `docker push` - 从本地推送镜像到仓管中心。
## Dockerfile
- .dockerignore
- FROM 为其他指令设置基础镜像(Base Image)。
- MAINTAINER 为生成的镜像设置作者字段。
- RUN 在当前镜像的基础上生成一个新层并执行命令。
- CMD 设置容器默认执行命令。
- EXPOSE 告知 Docker 容器在运行时所要监听的网络端口。注意：并没有实际上将端口设置为可访问。
- ENV 设置环境变量。
- ADD 将文件，文件夹或者远程文件复制到容器中。缓存无效。尽量用 COPY 代替 ADD。
- COPY 将文件或文件夹复制到容器中。
- ENTRYPOINT 将一个容器设置为可执行。
- VOLUME 为外部挂载卷标或其他容器设置挂载点(mount point)。
- USER 设置执行 RUN / CMD / ENTRYPOINT 命令的用户名。
- WORKDIR 设置工作目录。
- ARG 定义编译时(build-time)变量。
- ONBUILD 添加触发指令，当该镜像被作为其他镜像的基础镜像时该指令会被触发。
- STOPSIGNAL 设置通过系统向容器发出退出指令。
- LABEL 将键值对元数据(key/value metadata)应用到你的镜像，容器，或者守护进程。
## 卷标(Volumes)
### 生命周期
- `docker volume create`
- `docker volume rm`
### 信息
- `docker volume ls`
- `docker volume inspect`
如果运行成功，你会在屏幕上读到下面的输出。

70
docs/docker/docker.md 100644
View File

@ -0,0 +1,70 @@
# Docker 教程
## [简介](docker-introduction.md)
> **Docker 属于 Linux 容器的一种封装，提供简单易用的容器使用接口。**
>
> Docker 将应用程序与该程序的依赖，打包在一个文件里面。运行这个文件，就会生成一个虚拟容器。程序在这个虚拟容器里运行，就好像在真实的物理机上运行一样。有了 Docker，就不用担心环境问题。
![](http://dunwu.test.upcdn.net/images/os/docker/containers-and-vm.png)
## [入门篇](docker-quickstart.md)
## 基础篇
### 安装
Docker 分为 CE 和 EE 两大版本。
- CE 即社区版（免费，支持周期 7 个月）。Docker CE 分为 `stable`, `test`, 和 `nightly` 三个更新频道。每六个月发布一个 stable 版本。
- EE 即企业版，强调安全，付费使用，支持周期 24 个月。
Docker CE 可以安装在 Linux 、Windows 10 (PC) 和 MAC 上。
> 参考：
>
> - [官方安装指南](https://docs.docker.com/install/)
> - [Docker 中文教程安装指南](https://yeasy.gitbooks.io/docker_practice/content/install/)
### [Docker 镜像](basics/docker-image.md)
### [Docker 容器](basics/docker-container.md)
### [Dockerfile](basics/docker-dockerfile.md)
- FROM(指定基础镜像)
- RUN(执行命令)
- COPY(复制文件)
- ADD(更高级的复制文件)
- CMD(容器启动命令)
- ENTRYPOINT(入口点)
- ENV(设置环境变量)
- ARG(构建参数)
- VOLUME(定义匿名卷)
- EXPOSE(暴露端口)
- WORKDIR(指定工作目录)
- USER(指定当前用户)
- HEALTHCHECK(健康检查)
- ONBUILD(为他人作嫁衣裳)
## 进阶篇
### 设计
## 实战篇
## 常见问题
## 附录
### [命令](appendix/docker-cli.md)
### [资源](appendix/docker-resources.md)
### 术语
### 技巧
### 版本
### 反馈

176
docs/kubernetes/kubernetes.md 100644
View File

@ -0,0 +1,176 @@
# Kubernetes
> Kubernetes 是用于自动部署，扩展和管理 Docker 应用程序的开源系统。简称 K8S
>
> 关键词： `docker`
<!-- TOC depthFrom:2 depthTo:2 -->
- [功能](#功能)
- [简介](#简介)
- [基础](#基础)
- [进阶](#进阶)
- [命令](#命令)
- [引用和引申](#引用和引申)
<!-- /TOC -->
## 功能
- 基于容器的应用部署、维护和滚动升级
- 负载均衡和服务发现
- 跨机器和跨地区的集群调度
- 自动伸缩
- 无状态服务和有状态服务
- 广泛的 Volume 支持
- 插件机制保证扩展性
## 简介
Kubernetes 主控组件（Master） 包含三个进程，都运行在集群中的某个节上，通常这个节点被称为 master 节点。这些进程包括：`kube-apiserver`、`kube-controller-manager` 和 `kube-scheduler`。
集群中的每个非 master 节点都运行两个进程：
- kubelet，和 master 节点进行通信。
- kube-proxy，一种网络代理，将 Kubernetes 的网络服务代理到每个节点上。
### Kubernetes 对象
Kubernetes 包含若干抽象用来表示系统状态，包括：已部署的容器化应用和负载、与它们相关的网络和磁盘资源以及有关集群正在运行的其他操作的信息。
- Pod - kubernetes 对象模型中最小的单元，它代表集群中一个正在运行的进程。
- Service
- Volume
- Namespace
![](http://dunwu.test.upcdn.net/images/os/kubernetes/pod.svg)
高级对象
- ReplicaSet
- Deployment
- StatefulSet
- DaemonSet
- Job
## 基础
## 进阶
## 命令
### 客户端配置
```sh
# Setup autocomplete in bash; bash-completion package should be installed first
source <(kubectl completion bash)
# View Kubernetes config
kubectl config view
# View specific config items by json path
kubectl config view -o jsonpath='{.users[?(@.name == "k8s")].user.password}'
# Set credentials for foo.kuberntes.com
kubectl config set-credentials kubeuser/foo.kubernetes.com --username=kubeuser --password=kubepassword
```
### 查找资源
```sh
# List all services in the namespace
kubectl get services
# List all pods in all namespaces in wide format
kubectl get pods -o wide --all-namespaces
# List all pods in json (or yaml) format
kubectl get pods -o json
# Describe resource details (node, pod, svc)
kubectl describe nodes my-node
# List services sorted by name
kubectl get services --sort-by=.metadata.name
# List pods sorted by restart count
kubectl get pods --sort-by='.status.containerStatuses[0].restartCount'
# Rolling update pods for frontend-v1
kubectl rolling-update frontend-v1 -f frontend-v2.json
# Scale a replicaset named 'foo' to 3
kubectl scale --replicas=3 rs/foo
# Scale a resource specified in "foo.yaml" to 3
kubectl scale --replicas=3 -f foo.yaml
# Execute a command in every pod / replica
for i in 0 1; do kubectl exec foo-$i -- sh -c 'echo $(hostname) > /usr/share/nginx/html/index.html'; done
```
### 资源管理
```sh
# Get documentation for pod or service
kubectl explain pods,svc
# Create resource(s) like pods, services or daemonsets
kubectl create -f ./my-manifest.yaml
# Apply a configuration to a resource
kubectl apply -f ./my-manifest.yaml
# Start a single instance of Nginx
kubectl run nginx --image=nginx
# Create a secret with several keys
cat <<EOF | kubectl create -f -
apiVersion: v1
kind: Secret
metadata:
name: mysecret
type: Opaque
data:
password: $(echo "s33msi4" | base64)
username: $(echo "jane"| base64)
EOF
# Delete a resource
kubectl delete -f ./my-manifest.yaml
```
### 监控和日志
```sh
# Deploy Heapster from Github repository
kubectl create -f deploy/kube-config/standalone/
# Show metrics for nodes
kubectl top node
# Show metrics for pods
kubectl top pod
# Show metrics for a given pod and its containers
kubectl top pod pod_name --containers
# Dump pod logs (stdout)
kubectl logs pod_name
# Stream pod container logs (stdout, multi-container case)
kubectl logs -f pod_name -c my-container
```
## 引用和引申
- 官方
- [Github](https://github.com/kubernetes/kubernetes)
- [官网](https://kubernetes.io/)
- 教程
- [Kubernetes 中文指南](https://jimmysong.io/kubernetes-handbook/)
- 文章
- https://github.com/LeCoupa/awesome-cheatsheets/blob/master/tools/kubernetes.sh
- 更多资源
- [awesome-kubernetes](https://github.com/ramitsurana/awesome-kubernetes)

86
docs/linux/README.md
View File

@ -1,20 +1,74 @@
# Linux
# Linux 教程
## 内容
## :bulb: 指南
- [查看 Linux 命令帮助信息](01.查看Linux命令帮助信息.md) - 关键词：`help`, `whatis`, `info`, `which`, `whereis`, `man`
- [Linux 文件目录管理](02.Linux文件目录管理.md) - 关键词：`cd`, `ls`, `pwd`, `mkdir`, `rmdir`, `tree`, `touch`, `ln`, `rename`, `stat`, `file`, `chmod`, `chown`, `locate`, `find`, `cp`, `mv`, `rm`
- [Linux 文件内容查看命令](03.Linux文件内容查看编辑.md) - 关键词：`cat`, `head`, `tail`, `more`, `less`, `sed`, `vi`, `grep`
- [Linux 文件压缩和解压](04.Linux文件压缩和解压.md) - 关键词：`tar`, `gzip`, `zip`, `unzip`
- [Linux 用户管理](05.Linux用户管理.md) - 关键词：`groupadd`, `groupdel`, `groupmod`, `useradd`, `userdel`, `usermod`, `passwd`, `su`, `sudo`
- [Linux 系统管理](06.Linux系统管理.md) - 关键词：`reboot`, `exit`, `shutdown`, `date`, `mount`, `umount`, `ps`, `kill`, `systemctl`, `service`, `crontab`
- [Linux 网络管理](07.Linux网络管理.md) - 关键词：关键词：`curl`, `wget`, `telnet`, `ip`, `hostname`, `ifconfig`, `route`, `ssh`, `ssh-keygen`, `firewalld`, `iptables`, `host`, `nslookup`, `nc`/`netcat`, `ping`, `traceroute`, `netstat`
- [Linux 硬件管理](08.Linux硬件管理.md) - 关键词：`df`, `du`, `top`, `free`, `iotop`
- [Linux 软件管理](09.Linux软件管理.md) - 关键词：`rpm`, `yum`, `apt-get`
- [samba 使用详解](samba使用详解.md)
- [命令行的艺术（转载）](命令行的艺术.md)
学习之前，先看一下入门三问：
## 资料
> 什么是 Linux？
>
> Linux 是一套免费使用和自由传播的类 Unix 操作系统，是一个基于 POSIX 和 UNIX 的多用户、多任务、支持多线程和多 CPU 的操作系统。它能运行主要的 UNIX 工具软件、应用程序和网络协议。它支持 32 位和 64 位硬件。Linux 继承了 Unix 以网络为核心的设计思想，是一个性能稳定的多用户网络操作系统。
> 为什么学习 Linux？
>
> Linux 常用于网站服务器或嵌入式应用。世界上大部分网站都部署在 Linux 服务器上，作为一名 web 开发人员，
如何学习 Linux？
## :memo: 知识点
### [Linux 命令](cli)
> 根据应用场景，将常见 Linux 命令分门别类的一一介绍。
>
> 如果想快速学习，推荐参考这篇文章：[命令行的艺术（转载）](cli/命令行的艺术.md)
1. [查看 Linux 命令帮助信息](cli/01.查看Linux命令帮助信息.md) - 关键词：`help`, `whatis`, `info`, `which`, `whereis`, `man`
2. [Linux 文件目录管理](cli/02.Linux文件目录管理.md) - 关键词：`cd`, `ls`, `pwd`, `mkdir`, `rmdir`, `tree`, `touch`, `ln`, `rename`, `stat`, `file`, `chmod`, `chown`, `locate`, `find`, `cp`, `mv`, `rm`
3. [Linux 文件内容查看命令](cli/03.Linux文件内容查看编辑.md) - 关键词：`cat`, `head`, `tail`, `more`, `less`, `sed`, `vi`, `grep`
4. [Linux 文件压缩和解压](cli/04.Linux文件压缩和解压.md) - 关键词：`tar`, `gzip`, `zip`, `unzip`
5. [Linux 用户管理](cli/05.Linux用户管理.md) - 关键词：`groupadd`, `groupdel`, `groupmod`, `useradd`, `userdel`, `usermod`, `passwd`, `su`, `sudo`
6. [Linux 系统管理](cli/06.Linux系统管理.md) - 关键词：`reboot`, `exit`, `shutdown`, `date`, `mount`, `umount`, `ps`, `kill`, `systemctl`, `service`, `crontab`
7. [Linux 网络管理](cli/07.Linux网络管理.md) - 关键词：关键词：`curl`, `wget`, `telnet`, `ip`, `hostname`, `ifconfig`, `route`, `ssh`, `ssh-keygen`, `firewalld`, `iptables`, `host`, `nslookup`, `nc`/`netcat`, `ping`, `traceroute`, `netstat`
8. [Linux 硬件管理](cli/08.Linux硬件管理.md) - 关键词：`df`, `du`, `top`, `free`, `iotop`
9. [Linux 软件管理](cli/09.Linux软件管理.md) - 关键词：`rpm`, `yum`, `apt-get`
### [工具](tool)
- [Git](tool/git)
- [Vim](tool/vim.md)
### [Linux 运维](ops)
#### Linux 服务器运维
- [Linux 典型运维应用](ops/linux典型运维应用.md)
- [samba 使用详解](ops/samba使用详解.md)
#### 应用、服务、工具运维和调优
- 研发环境
- [JDK](ops/service/jdk.md)
- [Nodejs](ops/service/nodejs.md)
- [Tomcat](ops/service/tomcat.md)
- [Zookeeper](ops/service/zookeeper.md)
- 研发工具
- [Nexus](ops/service/nexus.md)
- [Jenkins](ops/service/jenkins.md) - 持续集成和持续交付平台。
- [Elastic](ops/service/elastic) - 常被称为 `ELK` ，是 Java 世界最流行的分布式日志解决方案 。 `ELK` 是 Elastic 公司旗下三款产品 [ElasticSearch](https://www.elastic.co/products/elasticsearch) 、[Logstash](https://www.elastic.co/products/logstash) 、[Kibana](https://www.elastic.co/products/kibana) 的首字母组合。
- [Apollo](ops/service/apollo) - 分布式配置中心
- 版本控制
- [Gitlab](ops/service/gitlab) - Git 代码管理平台。
- [Svn](ops/service/svn.md) - Svn 是 Subversion 的简称，是一个开放源代码的版本控制系统，它采用了分支管理系统。
- 消息中间件
- [Kafka](ops/service/kafka.md) - 应该是 Java 世界最流行的消息中间件了吧。
- [RocketMQ](ops/service/rocketmq.md) - 阿里巴巴开源的消息中间件。
- 数据库
- [Mysql](https://github.com/dunwu/database/blob/master/docs/mysql/install-mysql.md) - 关系型数据库
- [PostgreSQL](https://github.com/dunwu/database/blob/master/docs/postgresql.md#安装) - 关系型数据库
- [Mongodb](https://github.com/dunwu/database/blob/master/docs/mongodb/install-mongodb.md) - Nosql
- [Redis](https://github.com/dunwu/database/blob/master/docs/redis/install-redis.md) - Nosql
## :books: 学习资源
### Linux 资源汇总
@ -33,3 +87,7 @@
- [Linux 命令大全](http://man.linuxde.net/) - Linux 命令在线帮助手册
- [linux-command](https://github.com/jaywcjlove/linux-command) - Linux 命令在线帮助手册
- [linux-tutorial](https://github.com/judasn/Linux-Tutorial) - Linux 环境下各种软件安装部署
## :door: 传送门
| [回首頁](https://github.com/dunwu/os-tutorial) |

0
docs/linux/01.查看Linux命令帮助信息.md → docs/linux/cli/01.查看Linux命令帮助信息.md
View File

39
docs/linux/02.Linux文件目录管理.md → docs/linux/cli/02.Linux文件目录管理.md
View File

@ -10,7 +10,7 @@ tags:
# Linux 文件目录管理
> 关键词：`cd`, `ls`, `pwd`, `mkdir`, `rmdir`, `tree`, `touch`, `ln`, `rename`, `stat`, `file`, `chmod`, `chown`, `locate`, `find`, `cp`, `mv`, `rm`
> 关键词：`cd`, `ls`, `pwd`, `mkdir`, `rmdir`, `tree`, `touch`, `ln`, `rename`, `stat`, `file`, `chmod`, `chown`, `locate`, `find`, `cp`, `scp`, `mv`, `rm`
<!-- TOC depthFrom:2 depthTo:3 -->
@ -38,6 +38,7 @@ tags:
- [locate](#locate)
- [find](#find)
- [cp](#cp)
- [scp](#scp)
- [mv](#mv)
- [rm](#rm)
@ -131,6 +132,7 @@ dr-xr-xr-x 4 root root 4096 Apr 19 2012 boot
### 文件和目录通用管理
- 复制文件或目录 - 使用 [cp](#cp)
- 复制文件或目录到远程服务器 - 使用 [scp](#scp)
- 移动文件或目录 - 使用 [mv](#mv)
- 删除文件或目录 - 使用 [rm](#rm)
@ -440,6 +442,41 @@ cp -rf /usr/men/* /usr/zh
cp -i /usr/men m*.c /usr/zh
```
### scp
> scp 命令用于在 Linux 下进行远程拷贝文件的命令，和它类似的命令有 cp，不过 cp 只是在本机进行拷贝不能跨服务器，而且 scp 传输是加密的。可能会稍微影响一下速度。当你服务器硬盘变为只读 read only system 时，用 scp 可以帮你把文件移出来。另外，scp 还非常不占资源，不会提高多少系统负荷，在这一点上，rsync 就远远不及它了。虽然 rsync 比 scp 会快一点，但当小文件众多的情况下，rsync 会导致硬盘 I/O 非常高，而 scp 基本不影响系统正常使用。
示例：
```bash
# 拷贝文件到远程服务器的指定目录
scp <file> <user>@<ip>:<url>
scp test.txt root@192.168.0.1:/opt
# 拷贝目录到远程服务器的指定目录
scp -r <folder> <user>@<ip>:<url>
scp -r test root@192.168.0.1:/opt
```
#### 免密码传输
（1）生成 ssh 公私钥对
```
ssh-keygen -t rsa
```
（2）将服务器 A 的 `~/.ssh/id_rsa.pub` 文件内容复制到服务器 B 的 `~/.ssh/authorized_keys` 文件中。
```bash
# 服务器 A 上执行以下命令
scp ~/.ssh/id_rsa.pub root@192.168.0.2:~/.ssh/id_rsa.pub.tmp
# 服务器 B 上执行以下命令
cat ~/.ssh/id_rsa.pub.tmp >> ~/.ssh/authorized_keys
rm ~/.ssh/id_rsa.pub.tmp
```
### mv
> mv 命令用来对文件或目录重新命名，或者将文件从一个目录移到另一个目录中。source 表示源文件或目录，target 表示目标文件或目录。如果将一个文件移到一个已经存在的目标文件中，则目标文件的内容将被覆盖。

0
docs/linux/03.Linux文件内容查看编辑.md → docs/linux/cli/03.Linux文件内容查看编辑.md
View File

0
docs/linux/04.Linux文件压缩和解压.md → docs/linux/cli/04.Linux文件压缩和解压.md
View File

0
docs/linux/05.Linux用户管理.md → docs/linux/cli/05.Linux用户管理.md
View File

0
docs/linux/06.Linux系统管理.md → docs/linux/cli/06.Linux系统管理.md
View File

0
docs/linux/07.Linux网络管理.md → docs/linux/cli/07.Linux网络管理.md
View File

0
docs/linux/08.Linux硬件管理.md → docs/linux/cli/08.Linux硬件管理.md
View File

0
docs/linux/09.Linux软件管理.md → docs/linux/cli/09.Linux软件管理.md
View File

17
docs/linux/cli/README.md 100644
View File

@ -0,0 +1,17 @@
# Linux 命令行
## :memo: 知识点
> 根据应用场景，将常见 Linux 命令分门别类的一一介绍。
>
> 如果想快速学习，推荐参考这篇文章：[命令行的艺术（转载）](命令行的艺术.md)
1. [查看 Linux 命令帮助信息](01.查看Linux命令帮助信息.md) - 关键词：`help`, `whatis`, `info`, `which`, `whereis`, `man`
2. [Linux 文件目录管理](02.Linux文件目录管理.md) - 关键词：`cd`, `ls`, `pwd`, `mkdir`, `rmdir`, `tree`, `touch`, `ln`, `rename`, `stat`, `file`, `chmod`, `chown`, `locate`, `find`, `cp`, `mv`, `rm`
3. [Linux 文件内容查看命令](03.Linux文件内容查看编辑.md) - 关键词：`cat`, `head`, `tail`, `more`, `less`, `sed`, `vi`, `grep`
4. [Linux 文件压缩和解压](04.Linux文件压缩和解压.md) - 关键词：`tar`, `gzip`, `zip`, `unzip`
5. [Linux 用户管理](05.Linux用户管理.md) - 关键词：`groupadd`, `groupdel`, `groupmod`, `useradd`, `userdel`, `usermod`, `passwd`, `su`, `sudo`
6. [Linux 系统管理](06.Linux系统管理.md) - 关键词：`reboot`, `exit`, `shutdown`, `date`, `mount`, `umount`, `ps`, `kill`, `systemctl`, `service`, `crontab`
7. [Linux 网络管理](07.Linux网络管理.md) - 关键词：关键词：`curl`, `wget`, `telnet`, `ip`, `hostname`, `ifconfig`, `route`, `ssh`, `ssh-keygen`, `firewalld`, `iptables`, `host`, `nslookup`, `nc`/`netcat`, `ping`, `traceroute`, `netstat`
8. [Linux 硬件管理](08.Linux硬件管理.md) - 关键词：`df`, `du`, `top`, `free`, `iotop`
9. [Linux 软件管理](09.Linux软件管理.md) - 关键词：`rpm`, `yum`, `apt-get`

2
docs/linux/命令行的艺术.md → docs/linux/cli/命令行的艺术.md
View File

@ -1,6 +1,6 @@
> 转载自 https://github.com/jlevy/the-art-of-command-line
*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Indonesia](README-id.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Română](README-ro.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)*
*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](../README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Indonesia](README-id.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Română](README-ro.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)*
# 命令行的艺术

1
docs/deploy/linux基本配置.md → docs/linux/ops/linux典型运维应用.md
View File

@ -1,3 +1,4 @@
# Linux 典型运维应用
### 设置 Linux 启动模式

0
docs/linux/samba使用详解.md → docs/linux/ops/samba使用详解.md
View File

0
docs/apollo/README.md → docs/linux/ops/service/apollo/README.md
View File

0
docs/apollo/apollo.xmind → docs/linux/ops/service/apollo/apollo.xmind
View File

0
docs/tool/elastic/README.md → docs/linux/ops/service/elastic/README.md
View File

0
docs/tool/elastic/elastic-beats.md → docs/linux/ops/service/elastic/elastic-beats.md
View File

0
docs/tool/elastic/elastic-kibana.md → docs/linux/ops/service/elastic/elastic-kibana.md
View File

0
docs/tool/elastic/elastic-logstash.md → docs/linux/ops/service/elastic/elastic-logstash.md
View File

0
docs/tool/elastic/elastic-quickstart.md → docs/linux/ops/service/elastic/elastic-quickstart.md
View File

3
docs/linux/ops/service/gitlab/gitlab-ci.md 100644
View File

@ -0,0 +1,3 @@
# Gitlab
![](https://docs.gitlab.com/ce/ci/img/cicd_pipeline_infograph.png)

28
docs/tool/gitlab.md → docs/linux/ops/service/gitlab/gitlab-install.md
View File

@ -1,4 +1,4 @@
# Gitlab
# Gitlab 安装
> 环境：
>
@ -15,6 +15,7 @@
- [自签名证书](#自签名证书)
- [创建证书](#创建证书)
- [gitlab 配置](#gitlab-配置)
- [引申和引用](#引申和引用)
<!-- /TOC -->
@ -75,17 +76,19 @@ docker pull docker.io/gitlab/gitlab-ce
启动
```
docker run --detach \
     --hostname 127.0.0.1 \
     --publish 8443:443 --publish 80:80 --publish 2222:22 \
     --name gitlab \
     --restart always \
     --volume /home/gitlab/config:/etc/gitlab \
     --volume /home/gitlab/logs:/var/log/gitlab \
     --volume /home/gitlab/data:/var/opt/gitlab \
     docker.io/gitlab/gitlab-ce:latest
docker run -d \
--hostname gitlab.zp.io \
--publish 8443:443 --publish 80:80 --publish 2222:22 \
--name gitlab \
--restart always \
--volume $GITLAB_HOME/config:/etc/gitlab \
--volume $GITLAB_HOME/logs:/var/log/gitlab \
--volume $GITLAB_HOME/data:/var/opt/gitlab \
gitlab/gitlab-ce
```
![](http://dunwu.test.upcdn.net/snap/20190131150515.png)
## 安装 gitlab-ci-multi-runner
> 参考：https://docs.gitlab.com/runner/install/
@ -289,3 +292,8 @@ sudo cp /etc/gitlab/ssl/gitlab.domain.com.crt /etc/gitlab/trusted-certs/
sudo gitlab-ctl reconfigure
sudo gitlab-ctl restart
```
## 引申和引用
- **引申**
- [操作系统、运维部署总结系列](https://github.com/dunwu/OS)

76
docs/linux/ops/service/gitlab/gitlab-quickstart.md 100644
View File

@ -0,0 +1,76 @@
# Gitlab 快速教程
> 准备
>
> Git - 如果不熟悉 Git ，可以先阅读：[Git 教程](https://github.com/dunwu/OS/tree/master/docs/git)
## 创建你的 SSH key
1. 使用 Gitlab 的第一步是生成你自己的 SSH 密钥对（Github 也类似）。
2. 登录 Gitlab
3. 打开 **Profile settings**.
![Profile settings dropdown](https://docs.gitlab.com/ce/gitlab-basics/img/profile_settings.png)
4. 跳转到 **SSH keys** tab 页
![SSH Keys](https://docs.gitlab.com/ce/gitlab-basics/img/profile_settings_ssh_keys.png)
5. 黏贴你的 SSH 公钥内容到 Key 文本框
![Paste SSH public key](https://docs.gitlab.com/ce/gitlab-basics/img/profile_settings_ssh_keys_paste_pub.png)
6. 为了便于识别，你可以为其命名
![SSH key title](https://docs.gitlab.com/ce/gitlab-basics/img/profile_settings_ssh_keys_title.png)
7. 点击 **Add key** 将 SSH 公钥添加到 GitLab
![SSH key single page](https://docs.gitlab.com/ce/gitlab-basics/img/profile_settings_ssh_keys_single_key.png)
## 创建项目
![](http://dunwu.test.upcdn.net/snap/20190131150658.png)
输入项目信息，点击 Create project 按钮，在 Gitlab 创建项目。
![](http://dunwu.test.upcdn.net/snap/20190131150759.png)
## 克隆项目到本地
可以选择 SSH 或 HTTPS 方式克隆项目到本地（推荐 SSH）
拷贝项目地址，然后在本地执行 `git clone <url>`
![1548919326929](C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1548919326929.png)
## 创建 Issue
依次点击 **Project’s Dashboard** > **Issues** > **New Issue** 可以新建 Issue
![New issue from the issue list view](https://docs.gitlab.com/ce/user/project/issues/img/new_issue_from_tracker_list.png)
在项目中直接添加 issue
![New issue from the issues list](https://docs.gitlab.com/ce/user/project/issues/img/new_issue.png)
在未关闭 issue 中，点击 **New Issue** 添加 issue
![New issue from an open issue](https://docs.gitlab.com/ce/user/project/issues/img/new_issue_from_open_issue.png)
通过项目面板添加 issue
![New issue from a project's dashboard](https://docs.gitlab.com/ce/user/project/issues/img/new_issue_from_projects_dashboard.png)
通过 issue 面板添加 issue
![From the issue board](https://docs.gitlab.com/ce/user/project/issues/img/new_issue_from_issue_board.png)
## 引申和引用
- **引申**
- [操作系统、运维部署总结系列](https://github.com/dunwu/OS)
- **引用**
- [官网](https://about.gitlab.com/)

5
docs/tool/jdk.md → docs/linux/ops/service/jdk.md
View File

@ -130,7 +130,10 @@ $ rpm -ivh jdk-8u181-linux-x64.rpm
（4）检验是否安装成功，执行 `java -version` 命令
## 参考资料
## 引申和引用
- **引申**
- [操作系统、运维部署总结系列](https://github.com/dunwu/OS)
- **引用**
- http://www.runoob.com/java/java-environment-setup.html
- https://blog.csdn.net/deliciousion/article/details/78046007

5
docs/tool/jenkins.md → docs/linux/ops/service/jenkins.md
View File

@ -119,8 +119,11 @@ sed -i 's/www.google.com/www.baidu.com/g' /root/.jenkins/updates/default.json
sed -i '/^<url>/s/.*/<url>http:\/\/mirror.xmission.com\/jenkins\/updates\/update-center.json<\/url>/g' /root/.jenkins/hudson.model.UpdateCenter.xml
```
## 参考资料
## 引申和引用
- **引申**
- [操作系统、运维部署总结系列](https://github.com/dunwu/OS)
- **引用**
- https://jenkins.io/doc/pipeline/tour/getting-started/
- https://www.cnblogs.com/austinspark-jessylu/p/6894944.html
- http://blog.csdn.net/jlminghui/article/details/54952148

5
docs/tool/kafka.md → docs/linux/ops/service/kafka.md
View File

@ -140,3 +140,8 @@ Topic:my-replicated-topic PartitionCount:1 ReplicationFactor:3 Configs:
- leader - 负责指定分区的所有读取和写入的节点。每个节点将成为随机选择的分区部分的领导者。
- replicas - 是复制此分区日志的节点列表，无论它们是否为领导者，或者即使它们当前处于活动状态。
- isr - 是“同步”复制品的集合。这是副本列表的子集，该列表当前处于活跃状态并且已经被领导者捕获。
## 引申和引用
- **引申**
- [操作系统、运维部署总结系列](https://github.com/dunwu/OS)

5
docs/tool/nexus.md → docs/linux/ops/service/nexus.md
View File

@ -193,8 +193,11 @@ $ mvn clean package -Dmaven.skip.test=true -P zp
$ mvn clean deploy -Dmaven.skip.test=true -P zp
```
## 参考资料
## 引申和引用
- **引申**
- [操作系统、运维部署总结系列](https://github.com/dunwu/OS)
- **引用**
- https://www.cnblogs.com/hoobey/p/6102382.html
- https://blog.csdn.net/wzygis/article/details/49276779
- https://blog.csdn.net/clj198606061111/article/details/52200928

5
docs/tool/nodejs.md → docs/linux/ops/service/nodejs.md
View File

@ -53,3 +53,8 @@ nvm use 8.9.4
## 脚本
| [安装脚本](https://github.com/dunwu/OS/tree/master/codes/deploy/tool/nodejs) |
## 引申和引用
- **引申**
- [操作系统、运维部署总结系列](https://github.com/dunwu/OS)

5
docs/tool/rocketmq.md → docs/linux/ops/service/rocketmq.md
View File

@ -117,7 +117,10 @@ brokerIP1 = 10.10.30.63
nohup sh bin/mqbroker -n localhost:9876 -c conf/broker.conf &
```
## 参考资料
## 引申和引用
- **引申**
- [操作系统、运维部署总结系列](https://github.com/dunwu/OS)
- **引用**
- [RocketMQ 官方文档](http://rocketmq.apache.org/docs/quick-start/)
- [RocketMQ 搭建及刨坑](http://laciagin.me/2017/12/07/RocketMQ%E6%90%AD%E5%BB%BA%E5%8F%8A%E5%88%A8%E5%9D%91/)

0
docs/tool/svn.md → docs/linux/ops/service/svn.md
View File

5
docs/tool/tomcat.md → docs/linux/ops/service/tomcat.md
View File

@ -45,3 +45,8 @@ cd /opt/tomcat/apache-tomcat-8.5.28/bin
## 脚本
| [安装脚本](https://github.com/dunwu/OS/tree/master/codes/deploy/tool/tomcat) |
## 引申和引用
- **引申**
- [操作系统、运维部署总结系列](https://github.com/dunwu/OS)

5
docs/tool/zookeeper.md → docs/linux/ops/service/zookeeper.md
View File

@ -89,3 +89,8 @@ $ bin/zkServer.sh stop
```
> 本节安装内容参考：[Zookeeper 安装](https://www.w3cschool.cn/zookeeper/zookeeper_installation.html)
## 引申和引用
- **引申**
- [操作系统、运维部署总结系列](https://github.com/dunwu/OS)

0
docs/python.md → docs/linux/scripts/python.md
View File

0
docs/shell.md → docs/linux/scripts/shell.md
View File

0
docs/git/README.md → docs/linux/tool/git/README.md
View File

0
docs/git/advanced/git-flow.md → docs/linux/tool/git/advanced/git-flow.md
View File

0
docs/git/appendix/git-command.md → docs/linux/tool/git/appendix/git-command.md
View File

0
docs/git/appendix/git-faq.md → docs/linux/tool/git/appendix/git-faq.md
View File

2
docs/git/appendix/git-resource.md → docs/linux/tool/git/appendix/git-resource.md
View File

@ -19,7 +19,7 @@
* [Git中文教程](https://github.com/geeeeeeeeek/git-recipes)
* [廖雪峰的Git教程](https://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000)
* [有关 git 的学习资料](https://github.com/xirong/my-git)
* [有关 git 的学习资源](https://github.com/xirong/my-git)
## 文章

0
docs/git/appendix/github-git-cheat-sheet.pdf → docs/linux/tool/git/appendix/github-git-cheat-sheet.pdf
View File

0
docs/git/basics/git-configuration.md → docs/linux/tool/git/basics/git-configuration.md
View File

0
docs/git/basics/git-installation.md → docs/linux/tool/git/basics/git-installation.md
View File

0
docs/git/git-quickstart.md → docs/linux/tool/git/git-quickstart.md
View File

0
docs/git/git.xmind → docs/linux/tool/git/git.xmind
View File

0
docs/vim.md → docs/linux/tool/vim.md
View File