Docker中文文档(十二)：Fig项目实战 - AndyX.Net

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 的更多信息可以查看 创建Docker镜像和 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: true

5、环境变量参考

*注意: 现在已经不推荐使用环境变量链接服务。替代方案是使用链接名称（默认就是被连接的服务名字）作为主机名来链接。

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 syncdb

7、使用 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 的更多信息可以查看 创建Docker镜像和 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 ，就会看到它的地址）。

译文文档源自： http://www.dockerinfo.net/docker-project-fig

浏览量: 173

打赏赞