Fig 项目介绍
Fig
在你的应用里面添加一个 fig.yml 文件，并指定一些简单的内容，执行 fig up 它就能帮你快速建立起一个容器。目前已经正式更名为 Compose。
1、快速搭建基于 Docker 的隔离开发环境
使用 Dockerfile 文件指定你的应用环境，让它能在任意地方复制使用：
FROM python:2.7
ADD . /code
WORKDIR /code
RUN pip install -r requirements.txt
在 fig.yml 文件中指定应用使用的不同服务，让它们能够在一个独立的环境中一起运行：
web:
build: .
command: python app.py
links:
- db
ports:
- "8000:8000"
db:
image: postgres
*注意不需要再额外安装 Postgres 了！
接着执行命令 fig up ，然后 Fig 就会启动并运行你的应用了。
Fig 可用的命令有:
- 启动、停止，和重建服务
- 查看服务的运行状态
- 查看运行中的服务的输入日志
- 对服务发送命令
1.1 快速上手
我们试着让一个基本的 Python web 应用运行在 Fig 上。这个实验假设你已经知道一些 Python 知识，如果你不熟悉，但清楚概念上的东西也是没有问题的。
首先，安装 Docker 和 Fig
为你的项目创建一个目录
$ mkdir figtest
$ cd figtest
进入目录，创建 app.py，这是一个能够让 Redis 上的一个值自增的简单 web 应用，基于 Flask 框架。
from flask import Flask
from redis import Redis
import os
app = Flask(__name__)
redis = Redis(host='redis', port=6379)
@app.route('/')
def hello():
redis.incr('hits')
return 'Hello World! I have been seen %s times.' % redis.get('hits')
if __name__ == "__main__":
app.run(host="0.0.0.0", debug=True)
在 requirements.txt 文件中指定应用的 Python 依赖包。
flask
redis
下一步我们要创建一个包含应用所有依赖的 Docker 镜像，这里将阐述怎么通过 Dockerfile 文件来创建。
FROM python:2.7
ADD . /code
WORKDIR /code
RUN pip install -r requirements.txt
以上的内容首先告诉 Docker 在容器里面安装 Python ，代码的路径还有Python 依赖包。关于 Dockerfile 的更多信息可以查看 镜像创建 和 Dockerfile 使用
接着我们通过 fig.yml 文件指定一系列的服务：
web:
build: .
command: python app.py
ports:
- "5000:5000"
volumes:
- .:/code
links:
- redis
redis:
image: redis
这里指定了两个服务：
- web 服务，通过当前目录的
Dockerfile创建。并且说明了在容器里面执行python app.py命令 ，转发在容器里开放的 5000 端口到本地主机的 5000 端口，连接 Redis 服务，并且挂载当前目录到容器里面，这样我们就可以不用重建镜像也能直接使用代码。 - redis 服务，我们使用公用镜像 redis。 * 现在如果执行
fig up命令 ，它就会拉取 redis 镜像，启动所有的服务。
$ fig up
Pulling image redis...
Building web...
Starting figtest_redis_1...
Starting figtest_web_1...
redis_1 | [8] 02 Jan 18:43:35.576 # Server started, Redis version 2.8.3
web_1 | * Running on http://0.0.0.0:5000/
这个 web 应用已经开始在你的 docker 守护进程里面监听着 5000 端口了（如果你有使用 boot2docker ，执行 boot2docker ip ，就会看到它的地址）。
如果你想要在后台运行你的服务，可以在执行 fig up 命令的时候添加 -d 参数，然后使用 fig ps 查看有什么进程在运行。
$ fig up -d
Starting figtest_redis_1...
Starting figtest_web_1...
$ fig ps
Name Command State Ports
-------------------------------------------------------------------
figtest_redis_1 /usr/local/bin/run Up
figtest_web_1 /bin/sh -c python app.py Up 5000->5000/tcp
fig run 指令可以帮你向服务发送命令。例如：查看 web 服务可以获取到的环境变量:
$ fig run web env
执行帮助命令 fig --help 查看其它可用的参数。
假设你使用了 fig up -d 启动 Fig，可以通过以下命令停止你的服务：
$ fig stop
以上内容或多或少的讲述了如何使用Fig 。通过查看下面的引用章节可以了解到关于命令、配置和环境变量的更多细节。如果你有任何想法或建议，可以在 GitHub 上提出。
2、安装 Fig
首先，安装 1.3 或者更新的 Docker 版本。
如果你的工作环境是 OS X ，可以通过查看 Mac 安装指南(英文) ，完成安装 Docker 和 boot2docker 。一旦 boot2docker 运行后，执行以下指令设置一个环境变量，接着 Fig 就可以和它交互了。
$(boot2docker shellinit)
*如果想避免重启后重新设置，可以把上面的命令加到你的 ~/.bashrc 文件里。
关于 Ubuntu 还有 其它的平台 的安装，可以参照 Ubuntu 安装指南(中文) 以及 官方安装手册(英文)。
下一步，安装 Fig ：
curl -L https://github.com/docker/fig/releases/download/1.0.1/fig-`uname -s`-`uname -m` > /usr/local/bin/fig; chmod +x /usr/local/bin/fig
*如果你的 Docker 是管理员身份安装，以上命令可能也需要相同的身份。
目前 Fig 的发行版本只支持 OSX 和 64 位的 Linux 系统。但因为它是用 Python 语言写的，所以对于其它平台上的用户，可以通过 Python 安装包来完成安装（支持的系统同样适用）。
$ sudo pip install -U fig
到这里就已经完成了。 执行 fig --version ，确认能够正常运行。
3、Fig客户端参考
大部分命令都可以运行在一个或多个服务上。如果没有特别的说明，这个命令则可以应用在所有的服务上。
执行 fig [COMMAND] --help 查看所有的使用说明。
3.1 选项
--verbose
显示更多信息。
--version
打印版本并退出。
-f, --file FILE
使用特定的Fig文件，默认使用fig.yml。
-p, --project-name NAME
使用特定的项目名称，默认使用文件夹名称。
3.2 命令
build
构建或重新构建服务。
服务一旦构建后，将会标记为project_service，例如figtest_db。 如果修改服务的 Dockerfile 或构建目录信息，你可以运行 fig build 来重新构建。
help
获得一个命令的帮助。
kill
强制停止服务容器。
logs
查看服务的输出。
port
打印端口绑定的公共端口。
ps
列出所有容器。
pull
拉取服务镜像。
rm
删除停止的服务容器。
run
在一个服务上执行一个命令。
例如：
$ fig run web python manage.py shell
默认情况下，链接的服务将会启动，除非这些服务已经在运行中。
一次性命令会在使用与服务的普通容器相同的配置的新容器中开始运行，然后卷、链接等等都将会按照期望创建。 与普通容器唯一的不同就是，这个命令将会覆盖原有的命令，如果端口有冲突则不会创建。
链接还可以在一次性命令和那个服务的其他容器间创建，然后你可以像下面一样进行一些操作：
$ fig run db psql -h db -U docker
如果你不希望在执行一次性命令时启动链接的容器，可以指定–no-deps选项：
$ fig run --no-deps web python manage.py shell
scale
设置一个服务需要运行的容器个数。
通过service=num的参数来设置数量。例如：
$ fig scale web=2 worker=3
start
启动一个服务已经存在的容器.
stop
停止一个已经运行的容器，但不删除它。通过 fig start 可以再次启动这些容器。
up
构建，（重新）创建，启动，链接一个服务的容器。
链接的服务都将会启动，除非他们已经运行。
默认情况， fig up 将会聚合每个容器的输出，而且如果容器已经存在，所有容器将会停止。如果你运行 fig up -d ，将会在后台启动并运行所有的容器。
默认情况，如果这个服务的容器已经存在， fig up 将会停止并重新创建他们（保持使用volumes-from挂载的卷），以保证 fig.yml 的修改生效。如果你不想容器被停止并重新创建，可以使用 fig up --no-recreate。如果需要的话，这样将会启动已经停止的容器。
3.3 环境变量
环境变量可以用来配置Fig的行为。
变量以DOCKER_开头，它们和用来配置Docker命令行客户端的使用一样。如果你在使用 boot2docker ,$(boot2docker shellinit) 将会设置它们为正确的值。
FIG_PROJECT_NAME
设置通过Fig启动的每一个容器前添加的项目名称.默认是当前工作目录的名字。
FIG_FILE
设置要使用的 fig.yml 的路径。默认路径是当前工作目录。
DOCKER_HOST
设置docker进程的URL。默认docker client使用 unix:///var/run/docker.sock 。
DOCKER_TLS_VERIFY
如果设置不为空的字符，允许和进程进行 TLS 通信。
DOCKER_CERT_PATH
配置 ca.pem 的路径， cert.pem 和 key.pem 文件用来进行TLS验证.默认路径是 ~/.docker 。
4、fig.yml 参考
每个在 fig.yml 定义的服务都需要指定一个镜像或镜像的构建内容。像 docker run 的命令行一样，其它内容是可选的。
docker run 在 Dockerfile 中设置的选项(例如：CMD, EXPOSE, VOLUME, ENV) 作为已经提供的默认设置 – 你不需要在 fig.yml 中重新设置。
image
这里可以设置为标签或镜像ID的一部分。它可以是本地的，也可以是远程的 – 如果镜像在本地不存在，Fig 将会尝试拉去这个镜像。
image: ubuntu
image: orchardup/postgresql
image: a4bc65fd
build
指定 Dockerfile 所在文件夹的路径。 Fig 将会构建这个镜像并给它生成一个名字，然后使用这个镜像。
build: /path/to/build/dir
command
覆盖默认的命令。
command: bundle exec thin -p 3000
links
在其它的服务中连接容器。使用服务名称（经常也作为别名）或服务名称加服务别名 （SERVICE:ALIAS） 都可以。
links:
- db
- db:database
- redis
可以在服务的容器中的 /etc/hosts 里创建别名。例如：
172.17.2.186 db
172.17.2.186 database
172.17.2.187 redis
环境变量也将被创建 – 细节查看环境变量参考章节。
ports
暴露端口。使用宿主和容器 （HOST:CONTAINER） 或者仅仅容器的端口（宿主将会随机选择端口）都可以。
注：当使用 HOST:CONTAINER 格式来映射端口时，如果你使用的容器端口小于60你可能会得到错误得结果，因为 YAML 将会解析 xx:yy 这种数字格式为60进制。所以我们建议用字符指定你得端口映射。
ports:
- "3000"
- "8000:8000"
- "49100:22"
- "127.0.0.1:8001:8001"
expose
暴露不发布到宿主机的端口 – 它们只被连接的服务访问。仅仅内部的端口可以被指定。
expose:
- "3000"
- "8000"
volumes
卷挂载路径设置。可以设置宿主机路径 （HOST:CONTAINER） 或访问模式 （HOST:CONTAINER:ro） 。
volumes:
- /var/lib/mysql
- cache/:/tmp/cache
- ~/configs:/etc/configs/:ro
volumes_from
从另一个服务或容器挂载所有卷。
volumes_from:
- service_name
- container_name
environment
设置环境变量。你可以使用数组或字典两种格式。
环境变量在运行 Fig 的机器上被解析成一个key。它有助于安全和指定的宿主值。
environment:
RACK_ENV: development
SESSION_SECRET:
environment:
- RACK_ENV=development
- SESSION_SECRET
net
设置网络模式。使用和 docker client 的 --net 参数一样的值。
net: "bridge"
net: "none"
net: "container:[name or id]"
net: "host"
dns
配置DNS服务器。它可以是一个值，也可以是一个列表。
dns: 8.8.8.8
dns:
- 8.8.8.8
- 9.9.9.9
working_dir, entrypoint, user, hostname, domainname, mem_limit, privileged
这些都是和 docker run 对应的一个值。
working_dir: /code
entrypoint: /code/entrypoint.sh
user: postgresql
hostname: foo
domainname: foo.com
mem_limit: 1000000000
privileged: true5、环境变量参考
*注意: 现在已经不推荐使用环境变量链接服务。替代方案是使用链接名称（默认就是被连接的服务名字）作为主机名来链接。
Fig 使用 Docker 链接来暴露一个服务的容器给其它容器。每一个链接的容器会注入一组以容器名称的大写字母开头得环境变量。
查看一个服务有那些有效的环境变量可以执行 fig run SERVICE env。
name_PORT
完整URL，例如： DB_PORT=tcp://172.17.0.5:5432
name_PORT_num_protocol
完整URL，例如： DB_PORT_5432_TCP=tcp://172.17.0.5:5432
name_PORT_num_protocol_ADDR
容器的IP地址，例如： DB_PORT_5432_TCP_ADDR=172.17.0.5
name_PORT_num_protocol_PORT
暴露端口号，例如： DB_PORT_5432_TCP_PORT=5432
name_PORT_num_protocol_PROTO
协议（tcp 或 udp），例如： DB_PORT_5432_TCP_PROTO=tcp
name_NAME
完整合格的容器名称，例如： DB_1_NAME=/myapp_web_1/myapp_db_1
6、使用 Django 入门 Fig
我们现在将使用 Fig 配置并运行一个 Django/PostgreSQL 应用。在此之前，先确保 Fig 已经 安装。
在一切工作开始前，需要先设置好三个必要的文件。
第一步，因为应用将要运行在一个满足所有环境依赖的 Docker 容器里面，那么我们可以通过编辑Dockerfile 文件来指定 Docker 容器要安装内容。内容如下：
FROM python:2.7
ENV PYTHONUNBUFFERED 1
RUN mkdir /code
WORKDIR /code
ADD requirements.txt /code/
RUN pip install -r requirements.txt
ADD . /code/
以上内容指定应用将使用安装了 Python 以及必要依赖包的镜像。
第二步，在 requirements.txt 文件里面写明需要安装的具体依赖包名 。
Django
psycopg2
就是这么简单。
第三步，fig.yml 文件将把所有的东西关联起来。它描述了应用的构成（一个 web 服务和一个数据库）、使用的 Docker 镜像、镜像之间的连接、挂载到容器的卷，以及服务开放的端口。
db:
image: postgres
web:
build: .
command: python manage.py runserver 0.0.0.0:8000
volumes:
- .:/code
ports:
- "8000:8000"
links:
- db
现在我们就可以使用 fig run 命令启动一个 Django 应用了。
$ fig run web django-admin.py startproject figexample .
Fig 会先使用 Dockerfile 为 web 服务创建一个镜像，接着使用这个镜像在容器里运行 django-admin.py startproject figexample . 指令。
这将在当前目录生成一个 Django 应用。
$ ls
Dockerfile fig.yml figexample manage.py requirements.txt
首先，我们要为应用设置好数据库的连接信息。用以下内容替换 figexample/settings.py 文件中 DATABASES = ... 定义的节点内容。
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': 'postgres',
'USER': 'postgres',
'HOST': 'db',
'PORT': 5432,
}
}
这些信息是在 postgres Docker 镜像固定设置好的。
然后，运行 fig up ：
Recreating myapp_db_1...
Recreating myapp_web_1...
Attaching to myapp_db_1, myapp_web_1
myapp_db_1 |
myapp_db_1 | PostgreSQL stand-alone backend 9.1.11
myapp_db_1 | 2014-01-27 12:17:03 UTC LOG: database system is ready to accept connections
myapp_db_1 | 2014-01-27 12:17:03 UTC LOG: autovacuum launcher started
myapp_web_1 | Validating models...
myapp_web_1 |
myapp_web_1 | 0 errors found
myapp_web_1 | January 27, 2014 - 12:12:40
myapp_web_1 | Django version 1.6.1, using settings 'figexample.settings'
myapp_web_1 | Starting development server at http://0.0.0.0:8000/
myapp_web_1 | Quit the server with CONTROL-C.
这个 web 应用已经开始在你的 docker 守护进程里监听着 5000 端口了（如果你有使用 boot2docker ，执行boot2docker ip ，就会看到它的地址）。
你还可以在 Docker 上运行其它的管理命令，例如对于同步数据库结构这种事，在运行完 fig up 后，在另外一个终端运行以下命令即可：
$ fig run web python manage.py syncdb7、使用 Rail 入门 Fig
我们现在将使用 Fig 配置并运行一个 Rails/PostgreSQL 应用。在开始之前，先确保 Fig 已经 安装。
在一切工作开始前，需要先设置好三个必要的文件。
首先，因为应用将要运行在一个满足所有环境依赖的 Docker 容器里面，那么我们可以通过编辑 Dockerfile文件来指定 Docker 容器要安装内容。内容如下：
FROM ruby
RUN apt-get update -qq && apt-get install -y build-essential libpq-dev
RUN mkdir /myapp
WORKDIR /myapp
ADD Gemfile /myapp/Gemfile
RUN bundle install
ADD . /myapp
以上内容指定应用将使用安装了 Ruby、Bundler 以及其依赖件的镜像。 下一步，我们需要一个引导加载 Rails 的文件 Gemfile 。 等一会儿它还会被 rails new 命令覆盖重写。
source 'https://rubygems.org'
gem 'rails', '4.0.2'
最后，fig.yml 文件才是最神奇的地方。 fig.yml 文件将把所有的东西关联起来。它描述了应用的构成（一个 web 服务和一个数据库）、每个镜像的来源（数据库运行在使用预定义的 PostgreSQL 镜像，web 应用侧将从本地目录创建）、镜像之间的连接，以及服务开放的端口。
db:
image: postgres
ports:
- "5432"
web:
build: .
command: bundle exec rackup -p 3000
volumes:
- .:/myapp
ports:
- "3000:3000"
links:
- db
所有文件就绪后，我们就可以通过使用 fig run 命令生成应用的骨架了。
$ fig run web rails new . --force --database=postgresql --skip-bundle
Fig 会先使用 Dockerfile 为 web 服务创建一个镜像，接着使用这个镜像在容器里运行 rails new 和它之后的命令。一旦这个命令运行完后，应该就可以看一个崭新的应用已经生成了。
$ ls
Dockerfile app fig.yml tmp
Gemfile bin lib vendor
Gemfile.lock config log
README.rdoc config.ru public
Rakefile db test
在新的 Gemfile 文件去掉加载 therubyracer 的行的注释，这样我们便可以使用 Javascript 运行环境：
gem 'therubyracer', platforms: :ruby
现在我们已经有一个新的 Gemfile 文件，需要再重新创建镜像。（这个会步骤会改变 Dockerfile 文件本身，仅仅需要重建一次）。
$ fig build
应用现在就可以启动了，但配置还未完成。Rails 默认读取的数据库目标是 localhost ，我们需要手动指定容器的 db 。同样的，还需要把用户名修改成和 postgres 镜像预定的一致。 打开最新生成的 database.yml 文件。用以下内容替换：
development: &default
adapter: postgresql
encoding: unicode
database: postgres
pool: 5
username: postgres
password:
host: db
test:
<<: *default
database: myapp_test
现在就可以启动应用了。
$ fig up
如果一切正常，你应该可以看到 PostgreSQL 的输出，几秒后可以看到这样的重复信息：
myapp_web_1 | [2014-01-17 17:16:29] INFO WEBrick 1.3.1
myapp_web_1 | [2014-01-17 17:16:29] INFO ruby 2.0.0 (2013-11-22) [x86_64-linux-gnu]
myapp_web_1 | [2014-01-17 17:16:29] INFO WEBrick::HTTPServer#start: pid=1 port=3000
最后， 我们需要做的是创建数据库，打开另一个终端，运行：
$ fig run web rake db:create
这个 web 应用已经开始在你的 docker 守护进程里面监听着 3000 端口了（如果你有使用 boot2docker ，执行 boot2docker ip ，就会看到它的地址）。
8、使用 WordPress 入门 Fig
Fig 让 WordPress 运行在一个独立的环境中很简易。 安装 Fig ，然后下载 WordPress 到当前目录：
wordpress.org/latest.tar.gz | tar -xvzf -
这将会创建一个叫 wordpress 目录，你也可以重命名成你想要的名字。在目录里面，创建一个 Dockerfile文件，定义应用的运行环境：
FROM orchardup/php5
ADD . /code
以上内容告诉 Docker 创建一个包含 PHP 和 WordPress 的镜像。更多关于如何编写 Dockerfile 文件的信息可以查看 镜像创建 和 Dockerfile 使用。
下一步，fig.yml 文件将开启一个 web 服务和一个独立的 MySQL 实例：
web:
build: .
command: php -S 0.0.0.0:8000 -t /code
ports:
- "8000:8000"
links:
- db
volumes:
- .:/code
db:
image: orchardup/mysql
environment:
MYSQL_DATABASE: wordpress
要让这个应用跑起来还需要两个文件。 第一个，wp-config.php ，它是一个标准的 WordPress 配置文件，有一点需要修改的是把数据库的配置指向 db 容器。
<?php
define('DB_NAME', 'wordpress');
define('DB_USER', 'root');
define('DB_PASSWORD', '');
define('DB_HOST', "db:3306");
define('DB_CHARSET', 'utf8');
define('DB_COLLATE', '');
define('AUTH_KEY', 'put your unique phrase here');
define('SECURE_AUTH_KEY', 'put your unique phrase here');
define('LOGGED_IN_KEY', 'put your unique phrase here');
define('NONCE_KEY', 'put your unique phrase here');
define('AUTH_SALT', 'put your unique phrase here');
define('SECURE_AUTH_SALT', 'put your unique phrase here');
define('LOGGED_IN_SALT', 'put your unique phrase here');
define('NONCE_SALT', 'put your unique phrase here');
$table_prefix = 'wp_';
define('WPLANG', '');
define('WP_DEBUG', false);
if ( !defined('ABSPATH') )
define('ABSPATH', dirname(__FILE__) . '/');
require_once(ABSPATH . 'wp-settings.php');
第二个，router.php ，它告诉 PHP 内置的服务器怎么运行 WordPress:
<?php
$root = $_SERVER['DOCUMENT_ROOT'];
chdir($root);
$path = '/'.ltrim(parse_url($_SERVER['REQUEST_URI'])['path'],'/');
set_include_path(get_include_path().':'.__DIR__);
if(file_exists($root.$path))
{
if(is_dir($root.$path) && substr($path,strlen($path) - 1, 1) !== '/')
$path = rtrim($path,'/').'/index.php';
if(strpos($path,'.php') === false) return false;
else {
chdir(dirname($root.$path));
require_once $root.$path;
}
}else include_once 'index.php';
这些配置文件就绪后，在你的 WordPress 目录里面执行 fig up 指令，Fig 就会拉取镜像再创建我们所需要的镜像，然后启动 web 和数据库容器。 接着访问 docker 守护进程监听的 8000 端口就能看你的 WordPress 网站了。（如果你有使用 boot2docker ，执行 boot2docker ip ，就会看到它的地址）。