编排（Orchestration）功能是复杂系统实现灵活可操作性的关键。
特别是在Docker应用场景中，编排意味着用户可以灵活的对各种容器资源实现定义和管理。

作为Docker官方编排工具，Compose的重要性不言而喻，
它可以让用户通过编写一个简单模板文件，快速地创建和管理基于Docker容器地应用集群。

Compose项目是Docker官方的开源项目，负责实现对Docker容器的快速编排。从功能上看，跟OpenStack中的Heat十分相似。
Compose定位是“定义和运行多个Docker容器的应用”，其前身是开源项目Fig，目前仍然兼容Fig格式的模板文件。

我们知道使用一个DockerFile模板文件，可以让用户很方便的定义一个单独的应用容器。
如果需要定义多个容器就需要容器编排，那么就可以使用Compose了。
Compose允许用户通过一个单独的docker-compose.yml模板文件（YAML格式）来定义一组相关联的应用容器为一个项目。

Compose中有两个重要的概念：
　　服务(service)：一个应用的容器，实际上可以包括若干个运行相同镜像的容器实例。
　　项目(project)：由一组关联的应用容器组成的一个完整的业务单元，在docker-compose.yml文件中定义。

Compose的默认管理对象是项目，通过子命令对项目中的一组容器进行便捷地生命周期管理。
Compose项目由Python编写，实现上调用了Docker服务提供地API来对容器进行地管理。
因此，只要所操作地平台支持Docker API，就可以在其上利用Compose来进行编排管理。

一、安装与卸载

（1）pip安装 　　

  1. pip install -U docker-compose

（2）二进制包安装

  1. curl -L https://github.com/docker/compose/releases/download/1.23.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
  2. chmod +x /usr/local/bin/docker-compose

（3）在容器中执行

官方提供了安装脚本

  1. curl -L https://github.com/docker/compose/releases/download/1.23.0/run.sh > /usr/local/bin/docker-compose
  2. chmod +x /usr/local/bin/docker-compose

（4）卸载

　　如果是二进制包安装，将包删除就可以了，如果是pip安装，使用pip uninstall

二、命令与说明

对于Compose来说，大部分命令地对象既可以是项目本身，也可以指定为项目中地服务或者容器。
如果没有特别说明，命令对象将是项目，这意味着项目中所有的服务都会受到命令地影响。
命令格式：
　　docker-compose [-f <arg>...] [options] [COMMAND] [ARGS...]
options选项：

Compose选项：

命令使用说明：

（1）build

构建或重建项目中的服务器。
格式：
　　build [options] [--build-arg key=val...] [SERVICE...]
说明：
　　--compress 使用gzip压缩构陷上下文
　　--force-rm 删除构建过程中的临时容器
　　--no-cache 构建镜像过程中不适用缓存，否则会加长构建过程
　　--pull 始终尝试拉取较新版本的镜像
　　--m, --memory MEM 设置构建容器的内存限制
　　--build-arg key=val 设置服务构建时的变量
　　--parallel 并行构建镜像

（2）bundle

从Compose中生成Docker包
格式：
　　bundle [options]
说明：
　　--push-images 自动推送任何服务的镜像
　　-o, --output PATH 设置文件的写入路径

（3）config

验证并查看Compose文件
格式：
　　config [options]
说明：
　　--resolve-image-digests 将镜像标签标记为摘要
　　-q, --quiet 仅验证配置，不打印任何东西
　　--services 打印服务名，每行一个
　　--volumes 打印卷名，每行一个
　　--hash="*" 打印服务配置的哈希

（4）create

为服务创建容器，不推荐使用此命令。推荐up --no-start
格式：
　　create [options] [SERVICE...]
说明：
　　--force-recreate 重新配置容器，即使它们的配置和镜像没有改变
　　--no-recreate 如果容器已经存在，不要重新创建
　　--no-build 不构建镜像，即使丢失了
　　--build 在创建容器之前构建镜像

（5）down

停止并删除容器以及网络、镜像和卷
格式：
　　down [options]
说明：
　　--rmi type 删除镜像，type是all或者local
　　-v, --volumes 删除volumes中声明的命名卷
　　--remove-orphans 删除没有在服务中定义的容器
　　-t, --timeout TIMEOUT 以秒为单位指定关闭超时

（6）events

从容器接受实时事件
格式：
　　events [options] [SERVICE...]
说明：
　　--json 将事件作为json对象流输出

（7）images

列出创建容器所使用的镜像
格式：
　　images [options] [SERVICE...]
说明：
　　-q, --quiet 仅输出镜像的id

（8）kill

强制停止一个容器的服务
格式：
　　kill [options] [SERVICE...]
说明：
　　-s SIGNAL 发送SIGNAL信号，默认发送的是SIGKILL

（9）logs

查看容器的输出
格式：
　　logs [options] [SERVICE...]
说明：
　　--no-color 单色输出
　　-f, --follow 遵循日志输出
　　-t, --timestamps 显示时间戳
　　--tail="all" 每个容器的日志末尾显示行数

（10）port

打印某个容器端口所映射的公共端口
格式：
　　port [options] SERVICE PRIVATE_PORT
说明：
　　--protocol=proto 协议的类型，tcp或udp
　　--index=index 如果有多个容器，则为容器的索引值，默认为1

（11）ps

列出项目中的所有容器
格式：
　　ps [options] [SERVICE...]
说明：
　　-q, --quiet 仅显示ID
　　--services 显示服务
　　--filter KEY=VAL 通过一个键值对过滤

（12）pull

为compose文件中定义的服务拉取镜像，但不启动容器。
格式：
　　Usage: pull [options] [SERVICE...]
说明：
　　--ignore-pull-failures 忽略拉取过程中的错误
　　--parallel 并行拉出多个镜像
　　--no-parallel 禁用并行
　　-q, --quiet 拉出而不打印进度信息
　　--include-deps 拉取服务的声明作为依赖项

（13）rm

删除所有停止状态的服务容器
说明：
　　-f，--force 强制直接删除，包括非停止状态的容器
　　-v 删除容器所挂载的数据卷

（14）run

在指定服务上执行一个命令。
默认情况下，如果存在关联，则关联的服务也将会被自动启动，除非这些服务已经载运行中。
如果不希望自动启动关联容器，可以使用--no-deps选项。
格式：
　　run [options] [-v VOLUME...] [-p PORT...] [-e KEY=VAL...] [-l KEY=VALUE...] SERVICE [COMMAND] [ARGS...]
说明：
　　-d 在后台运行服务容器
　　--name NAME 为容器指定一个名字
　　--entrypoint CMD覆盖默认的容器启动指令
　　-e KEY=VAL 设置环境变量，可多次使用选项来设置多个环境变量
　　-u， --user=“” 指定运行容器的用户名或者Uid
　　--no-deps 不自动启动关联的服务容器
　　--rm 运行命令后自动删除容器，d模式下忽略
　　-p， --publish=[] 映射容器端口到本地主机
　　--service-ports 配置服务端口，并映射到本地主机
　　-T 不分配伪tty，意味着依赖tty的指令将无法运行

（15）scale

设置服务运行个容器个数
格式：
　　scale [options] [SERVICE=NUM...]
说明：
　　-t， --timeout TIMEOUT停止容器时候的超时，默认10秒

（16）up

该命令十分强大，它将尝试自动完成包括构建镜像，重新创建服务，启动服务，并关联服务相关容器的一系列操作。
链接的服务都将会被自动启动，除非已经处于运行状态。
如果容器已经存在，up将尝试将容器停止，然后创建。
格式：
　　up [options] [--scale SERVICE=NUM...] [SERVICE...]
说明：
　　-d 在后台运行服务器
　　--no-color 单色输出
　　--no-deps 不启动服务所关联的容器
　　--force-recreate 强制重新创建容器
　　--no-recreate 如果容器已经存在了，则不重新创建
　　--no-build 不自动构建缺失的服务镜像
　　-t， --timeout TIMEOUT 停止容器时候的超时

三、环境变量

环境变量可以用来配置Compose的行为：

四、模板文件

模板文件是使用Compose的核心，默认的模板文件名称为docker-compose.yml，格式为YAML格式。
每个服务都必须通过image指定镜像或build（需要Dockerfile）来自动构成生成镜像。

先来看一个基本示例：

  1. version: '2'
  2. services:
  3. 	web:
  4. 	image: dockercloud/hello-world
  5. 		ports:
  6. 			- 8080
  7. 		networks:
  8. 			- front-tier
  9. 			- back-tier
  10. 	redis:
  11. 		image: redis
  12. 		links:
  13. 			- web
  14. 		networks:
  15. 			- back-tier
  16. 	lb:
  17. 		image: dockercloud/haproxy
  18. 		ports:
  19. 			- 80:80
  20. 		links:
  21. 			- web
  22. 		networks:
  23. 			- front-tier
  24. 			- back-tier
  25. 		volumes:
  26. 			- /var/run/docker.sock:/var/run/docker.sock
  27. networks:
  28. 	front-tier:
  29. 		driver: bridge
  30. 	back-tier:
  31. driver: bridge

可以看到一份标准配置文件应该包含version、service、network三大部分。
其中最关键的就是services和networks两部分。

下面是具体命令的书写规则：

（1）image

  1. services:
  2. 	web:
  3. 	　　image: dockercloud/hello-world　　

在services标签下的第二个标签是web，这个名字是用户自己自定义，它就是服务器名称。
image则是指定服务的镜像名称。如果镜像在本地不存在，Compose将会尝试拉取这个镜像。
下面这些格式都是可行的：

  1. image: redis
  2. image: ubuntu:14.04
  3. image: tutum/influxdb
  4. image: example-registry.com:4000/postgresql
  5. image: a4bc65fd

（2）build

服务除了可以基于指定的镜像，还可以基于以分Dockerfile，在使用up启动之时执行构建任务。
这个构建标签就是build，它可以指定Dockerfile所在文件夹的路径。
Compose将会利用它自动构建这个镜像，然后利用这个镜像启动服务容器。

  1. build: /path/to/build/dir

也可以时相对路径

  1. build: ./dir

设定上下文根目录，然后以该目录为准指定Dockerfile。

  1. build:
  2.   context: ../
  3.   dockerfile: path/of/Dockerfile

注意build都是一个目录，如果你要指定Dockerfile文件，需要在build标签的子级标签中使用dockerfile标签指定。
如果你同时指定了image和build两个标签，那么Compose会构建镜像并且把镜像命名为image后面的那个名字。

  1. build: ./dir
  2. image: webapp:tag

既然可以在docker-compose.yml中定义构建任务，那么一定少不了arg这个标签，
就像Dockerfile中的ARG指令，它可以在构建过程中指定环境变量，但是在构建成功后取消。
在docker-compose.yml文件中也支持这样的写法：

  1. build:
  2.   context: .
  3.   args:
  4.     buildno: 1
  5.     password: secret

下面这种写法也是支持的，一般来说下面的写法更适合阅读。

  1. build:
  2.   context: .
  3.   args:
  4.     - buildno=1
  5.     - password=secret

与ENV不同的是，ARG是允许空指的，例如：

  1. args:
  2.   - buildno
  3.   - password

这样构建过程可以向它们赋值。

注意：YAML的布尔值（true、false、yes、no、on、off）必须要使用引号引起来，否则会当成字符串解析。

（3）command

使用command可以覆盖容器启动后默认执行的命令。

  1. command: bundle exec thin -p 3000

也可以写成类似Dockerfile中的格式

  1. command: [bundle, exec, thin, -p, 3000]

（4）container_name

前面说过Compose的容器名称格式是：<项目名称><服务名称><序号>
虽然可以自定义项目名称、服务名称，但是如果你想完全控制容器的命名，可以使用下面标签指定：

  1. container_name: app

这样容器的名字就指定为app了。

注意：指定容器名称之后，该服务将无法进行扩展，因为Docker不允许多个容器具有相同的名称。

（5）depends_on

在使用Compose时，最大的好处就是少打启动命令，但一般项目容器启动的顺序是有要求的。
如果直接从上到下启动容器，必然会因为容器依赖问题而启动失败。
例如我们在没有启动数据库容器的时候启动了应用容器，这时候应用容器会应为找不到数据库而退出。
为了避免这种情况我们需要加入一个标签，就是depend_on，这个标签解决了容器的依赖、启动先后的问题。
例如下面容器会先启动redis和db两个服务，最后才启动web服务：

  1. version: '2'
  2. services:
  3.   web:
  4.     build: .
  5.     depends_on:
  6.       - db
  7.       - redis
  8.   redis:
  9.     image: redis
  10.   db:
  11.     image: postgres

注意的是，默认情况下使用docker-compose up web这样的方式启动web服务时，也会启动redis和db两个服务。因为配置文件中定义了依赖关系。

（6）dns

和--dns参数一样用途，格式如下：

  1. dns: 8.8.8.8

也可以是一个列表：

  1. dns:
  2.   - 8.8.8.8
  3.   - 9.9.9.9

此外dns_search的配置也类似：

  1. dns_search: example.com
  2. dns_search:
  3.   - dc1.example.com
  4.   - dc2.example.com

（7）tmpfs

挂载临时目录到容器内部，与run的参数一样效果：

  1. tmpfs: /run
  2. tmpfs:
  3.   - /run
  4.   - /tmp

（8）entrypoint

在Dockerfile中有一个指令ENTRYPOINT指令，用于指定接入点。
在docker-compose.yml中可以定义接入点，覆盖Dockerfile中的定义：

  1. entrypoint: /code/entrypoint.sh

格式和Docker类似，不过还可以写成这样：

  1. entrypoint:
  2. 	php
  3. 	- -d
  4. 	- zend_extension=/usr/local/lib/php/extensions/no-debug-non-zts-20100525/xdebug.so
  5. 	- -d    - memory_limit=-1
  6. 	- vendor/bin/phpunit

（9）env_file

在docker-compose.yml中可以定义一个专门存放变量的文件。
如果通过docker-compose -f FILE指定配置文件，则env_file中路径会使用配置文件路径。
如果有变量名称与environment指令冲突，则以后者为准。格式如下：

  1. env_file: .env

或者根据docker-compose.yml设置多个：

  1. env_file:
  2.   - ./common.env
  3.   - ./apps/web.env
  4.   - /opt/secrets.env

注意的是这里所说的环境变量是对宿主机的Compose而言，如果在配置文件中有build操作，
这些变量并不会进入构建过程，如果要在构建中使用变量还是首选前面所说的arg标签。
环境变量中的每一行必须符合格式，支持#开头的注释行。

（10）environment

与上面的env_file标签完全不同，这个标签的作用是设置镜像变量，
它可以保存变量到镜像里面，也就是说启动的容器也会包含这些变量设置，这是与arg最大的不同。
一般arg标签的变量仅用在构建过程中。
而enviroment和Dockerfile中ENV指令一样会把变量一直保存在镜像、容器中，类似docker run -e的效果。

  1. environment:
  2.   RACK_ENV: development
  3.   SHOW: 'true'
  4.   SESSION_SECRET:
  5.  
  6. environment:
  7.   - RACK_ENV=development
  8.   - SHOW=true
  9.   - SESSION_SECRET

（11）expose

这个标签进和Dockerfile中EXPOSE指令一样，用于指定暴露的端口，
但是只是作为一种参考，实际上docker-compose.yml的端口映射还得ports这样的标签。

  1. expose:
  2.  - "3000"
  3.  - "8000"

（12）external_links

在使用Docker过程中，我们会有许多单独使用docker run启动的容器，
为了使Compose能够连接这些不在docker-compose.yml中定义的容器，
我们需要一个特殊的标签，也就是external_links，它可以让Compose项目里面的容器连接到那些项目配置外部的容器。
前提是外部容器中必须至少有一个容器是连接到项目内的服务的同一个网络里面。

  1. external_links:
  2.  - redis_1
  3.  - project_db_1:mysql
  4.  - project_db_1:postgresql

（13）extra_hosts

添加主机名的标签，就是往/etc/hosts文件中添加一些记录，与Docker client的--add-host类似：

  1. extra_hosts:
  2.  - "somehost:162.242.195.82"
  3.  - "otherhost:50.31.209.229"

启动之后查看容器内部hosts：

  1. 162.242.195.82 somehost
  2. 50.31.209.229 otherhost

（14）labels

向容器添加元数据，和Dockerfile的LABEL指令一个意思，格式如下：

  1. labels:
  2.   com.example.description: "Accounting webapp"
  3.   com.example.department: "Finance"
  4.   com.example.label-with-empty-value: ""
  5. labels:
  6.   - "com.example.description=Accounting webapp"
  7.   - "com.example.department=Finance"
  8.   - "com.example.label-with-empty-value"

（15）links

前面讲过depends_on，那个标签解决启动顺序问题，这个标签解决的是容器的连接问题。
与Docker client的--link一样效果，会连接到其它服务中的容器。
格式如下：

  1. links:
  2.  - db
  3.  - db:database
  4.  - redis

使用的别名将会自动在服务容器中的/etc/hosts里创建。例如：

  1. 172.12.2.186  db
  2. 172.12.2.186  database
  3. 172.12.2.187  redis

相应的环境变量也将被创建。

（16）logging

这个标签用于配置日志服务。格式如下：

  1. logging:
  2.   driver: syslog
  3.   options:
  4.     syslog-address: "tcp://192.168.0.42:123"

默认的driver是json-file。只有json-file和journald可以通过docker-compose logs显示日志。
其它方式有其它的查看方式，但目前Compose还不支持。对于可选值可以使用options指定。
详细信息：https://docs.docker.com/engine/admin/logging/overview/

（17）pid

将PID模式设置为主机PID模式，跟主机系统共享进程命名空间。
容器使用这个标签将能够访问和操作其它容器和宿主机的名称空间。

  1. pid: "host"

（18）ports

映射端口的标签。
使用HOST.CONTAINER格式或者指定容器的端口，宿主机会随机映射端口。

  1. ports:
  2.  - "3000"
  3.  - "8000:8000"
  4.  - "49100:22"
  5.  - "127.0.0.1:8001:8001"

注意：当使用HOST>CONTAINER格式来映射端口时，如果你使用的容器端口小于60可能会得到错误的结果。
因为YAML将会解析xxyy这种数字格式为60进制。所以建议采用字符串格式。

（19）security_opt

为一个容器覆盖默认的标签。简单说来就是管理全部服务的标签。
比如设置全部服务的user标签值为USER。

  1. security_opt:
  2.   - label:user:USER
  3.   - label:role:ROLE

（20）stop_signal

设置一个信号来停止容器。在默认情况下是使用的是SIGTERM停止容器。
设置另一个信号可以使用stop_signal标签。

  1. stop_signal: SIGUSR1

（21）volumes

挂载一个目录或者一个已存在的数据卷容器，可以直接使用[HOST:CONTAINER]这样的格式，
或者使用[HOST:CONTAINER:ro]这样的格式，后者对于容器来说，数据卷是只读的，这样可以有效保护宿主机的文件系统。
Compose的数据卷指定路径可以是相对路径，使用.或者..来指定相对路径。
数据卷的格式可以是下面多种形式：

  1. volumes:
  2.   // 只是指定一个路径，Docker 会自动在创建一个数据卷（这个路径是容器内部的）。
  3.   - /var/lib/mysql
  4.  
  5.   // 使用绝对路径挂载数据卷
  6.   - /opt/data:/var/lib/mysql
  7.  
  8.   // 以 Compose 配置文件为中心的相对路径作为数据卷挂载到容器。
  9.   - ./cache:/tmp/cache
  10.  
  11.   // 使用用户的相对路径（~/ 表示的目录是 /home/<用户目录>/ 或者 /root/）。
  12.   - ~/configs:/etc/configs/:ro
  13.  
  14.   // 已经存在的命名的数据卷。
  15.   - datavolume:/var/lib/mysql

如果你不使用宿主机的路径，你可以指定一个volume_driver.

  1. volume_driver: mydriver

（22）volumes_from

从其他容器或者服务挂载数据卷，可选参数是：ro或：rw，
前者表示容器只读，后者表示容器对数据卷是可读可写的。默认情况下是可读可写的。

  1. volumes_from:
  2.   - service_name
  3.   - service_name:ro
  4.   - container:container_name
  5.   - container:container_name:rw

（23）cap_add,cap_drop

添加或删除容器的内核功能

  1. cap_add:
  2.   - ALL  让容器拥有所有能力
  3.  
  4. cap_drop:  去掉某些能力
  5.   - NET_ADMIN
  6.   - SYS_ADMIN

（24）cgroup_parent

指定一个容器的父级cgroup

  1. cgroup_parent: m-executor-abcd

（25）devices

设备映射列表。与Docker client的--device参数类似。

  1. devices:
  2.   - "/dev/ttyUSB0:/dev/ttyUSB0"　　

（26）extends

这个标签可以扩展另一个服务，扩展内容可以是来自当前文件，也可以是来自其它文件，
相同服务的情况下，后来者会有选择的覆盖原有配置。

  1. extends:
  2.   file: common.yml
  3.   service: webapp

用户可以在任何地方使用这个标签，只要标签内容包含file和service两个值就可以了。
file的值可以是相对或者绝对路径，如果不指定file的值，那么Compose会读取当前YML文件的信息。
注意避免循环依赖。

（27）network_mode

网络模式，与Docker client的--net参数类似，只是相对多了一个service:[service name]的格式。

  1. network_mode: "bridge"
  2. network_mode: "host"
  3. network_mode: "none"
  4. network_mode: "service:[service name]"
  5. network_mode: "container:[container name/id]"

可以指定使用服务或者容器的网络。

（28）networks

加入指定网络。

  1. services:
  2.   some-service:
  3.     networks:
  4.      - some-network
  5.      - other-network

关于这个标签还有一个特别的子标签aliases，这是一个用来设置服务别名的标签：

  1. services:
  2.   some-service:
  3.     networks:
  4.       some-network:
  5.         aliases:
  6.          - alias1
  7.          - alias3
  8.       other-network:
  9.         aliases:
  10.          - alias2

相同的服务可以在不同的网络有不同的别名。

（29）ulimits

指定容器的ulimits限制值。
例如，指定最大进程数为65535，指定文件句柄数为20000（软限制，应用可以随时修改，不能超过硬限制）和40000（系统硬限制，只能root用户提高）

  1. ulimits:
  2. 	nproc: 65535
  3. 	nofile:
  4. 		soft: 20000
  5. 		hard: 40000

（30）其它

此外，还有包括cpu_shares、cpuset、domainname、hostname、ipc、mac_address、mem_limit、memswap_limit、
privileged、read_only、restart、stdin_open、tty、user、working_dir等指令。
指定使用CPU核0和核1，只用50%的CPU资源：

  1. cpu_shares: 73
  2. cpuset: 0,1

指定容器中运行应用的用户名：

  1. user: nginx

指定容器中工作目录：

  1. working_dir: /code

指定容器中搜索域名、主机名、mac地址等：

  1. domainname: your_website.com
  2. hostname: test
  3. mac_address: 08-00-27-00-0C-0A

指定容器：

  1. ipc: host

指定容器中内存和内存减缓去限制都为1G：

  1. mem_limit: 1g
  2. menswap_limit: 1g

允许容器运行一些特权命令：

  1. privileged: true

指定容器退出后的重启策略为始终重启。该命令对保持服务始终运行十分有效，推荐配置为always或者unless-stopped

  1. restart: always

以只读模式挂载容器的root文件系统，意味着不能对容器内容进行修改：

  1. read_only: true

打开标准输入，可以接受外部输入：

  1. stdin_open: true

模拟一个假的远程控制台：

  1. tty: true

（31）读取环境变量

从1.5.0版本开始，Compose模板文件支持动态读取主机的系统环境变量。
例如：下面的Compose文件将从运行它的环境中读取变量${MONGO_VERSION}的值，并将其写入执行的指令中。

  1. db:
  2. 	images: “mongo:${MONGO_VERSION}”

　　

五、应用实例

1.nginx服务启动

  1. dvc:
  2.     image: centos
  3.     volumes:
  4.         - /root/composetest:/usr/share/nginx/html/:ro
  5.  
  6. nginx:
  7.     image: nginx
  8.     volumes_from:
  9.         - dvc
  10.     ports:
  11.         - "8081:80"

　　

2.web负载均衡

创建一个web项目：将Haproxy作为负载均衡器，后端挂载三个web容器。

首相创建一个haproxy_web目录作为项目的工作目录，其中分别创建两个子目录：web和haproxy。

  1. [root@centos002 haproxy_web]# ls
  2. docker-compose.yml  haproxy  web
  3.  
  4. [root@centos002 haproxy_web]# tree .
  5. .
  6. |-- docker-compose.yml
  7. |-- haproxy
  8. |   `-- haproxy.cfg
  9. `-- web
  10.     |-- Dockerfile
  11.     |-- index.html
  12.     `-- index.py
  13.  
  14. 2 directories, 5 files

（1）web子目录

index.py

  1. #!/usr/bin/python
  2.  
  3. import sys
  4. import BaseHTTPServer
  5. from SimpleHTTPServer import SimpleHTTPRequestHandler
  6. import socket
  7. import fcntl
  8. import struct
  9. import pickle
  10. from datetime import datetime
  11. from collections import OrderedDict
  12.  
  13. class HandlerClass(SimpleHTTPRequestHandler):
  14.     def get_ip_address(self,ifname):
  15.         s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  16.         return socket.inet_ntoa(fcntl.ioctl(
  17.             s.fileno(),
  18.             0x8915,  # SIOCGIFADDR
  19.             struct.pack('256s', ifname[:15])
  20.         )[20:24])
  21.     def log_message(self, format, *args):
  22.         if len(args) < 3 or "200" not in args[1]:
  23.             return
  24.         try:
  25.             request = pickle.load(open("pickle_data.txt","r"))
  26.         except:
  27.             request=OrderedDict()
  28.         time_now = datetime.now()
  29.         ts = time_now.strftime('%Y-%m-%d %H:%M:%S')
  30.         server = self.get_ip_address('eth0')
  31.         host=self.address_string()
  32.         addr_pair = (host,server)
  33.         if addr_pair not in request:
  34.             request[addr_pair]=[1,ts]
  35.         else:
  36.             num = request[addr_pair][0]+1
  37.             del request[addr_pair]
  38.             request[addr_pair]=[num,ts]
  39.         file=open("index.html", "w")
  40.         file.write("<!DOCTYPE html> <html> <body><center><h1><font color=\"blue\" face=\"Georgia, Arial\" size=8><em>HA</em></font> Webpage Visit Results</h1>");
  41.         for pair in request:
  42.             if pair[0] == host:
  43.                 guest = "LOCAL: "+pair[0]
  44.             else:
  45.                 guest = pair[0]
  46.             if (time_now-datetime.strptime(request[pair][1],'%Y-%m-%d %H:%M:%S')).seconds < 3:
  47.                 file.write("<p style=\"font-size:150%\" >#"+ str(request[pair][1]) +": <font color=\"red\">"+str(request[pair][0])+ "</font> requests " + "from &lt<font color=\"blue\">"+guest+"</font>&gt to WebServer &lt<font color=\"blue\">"+pair[1]+"</font>&gt</p>")
  48.             else:
  49.                 file.write("<p style=\"font-size:150%\" >#"+ str(request[pair][1]) +": <font color=\"maroon\">"+str(request[pair][0])+ "</font> requests " + "from &lt<font color=\"navy\">"+guest+"</font>&gt to WebServer &lt<font color=\"navy\">"+pair[1]+"</font>&gt</p>")
  50.         file.write("</center></body> </html>");
  51.         file.close()
  52.         pickle.dump(request,open("pickle_data.txt","w"))
  53.  
  54. if __name__ == '__main__':
  55.     try:
  56.         ServerClass  = BaseHTTPServer.HTTPServer
  57.         Protocol     = "HTTP/1.0"
  58.         addr = len(sys.argv) < 2 and "0.0.0.0" or sys.argv[1]
  59.         port = len(sys.argv) < 3 and 80 or int(sys.argv[2])
  60.         HandlerClass.protocol_version = Protocol
  61.         httpd = ServerClass((addr, port), HandlerClass)
  62.         sa = httpd.socket.getsockname()
  63.         print "Serving HTTP on", sa[0], "port", sa[1], "..."
  64.         httpd.serve_forever()
  65.     except:
  66.         exit()

关于index.py里面说的什么我们不需要去深究，只需要知道用来响应HTTP的请求，返回结果就行了。
同时它还会像index.html的文件中写入标签元素。

index.html

这是一个空的文件，它的内容由index.py动态写入。

Dockerfile

  1. FROM python:2.7
  2. WORKDIR /code
  3. ADD . /code
  4. EXPOSE 80
  5. CMD python index.py

我们知道Dockerfile用来创建一个容器。
这里会创建一个python2.7的容器，同时还会执行index.py文件

（2）hpproxy子目录

该目录将配置haproxy镜像，这里面的配置其实是haproxy的配置文件，我们将会利用这个配置文件来构建我们想要的镜像。

  1. global
  2.   log 127.0.0.1 local0
  3.   log 127.0.0.1 local1 notice
  4.   maxconn 4096
  5.  
  6. defaults
  7.   log global
  8.   mode http
  9.   option httplog
  10.   option dontlognull
  11.   timeout connect 5000ms
  12.   timeout client 50000ms
  13.   timeout server 50000ms
  14.  
  15. listen stats
  16.   bind 0.0.0.0:70
  17.   mode http
  18.   stats enable
  19.   stats hide-version
  20.   stats scope .
  21.   stats realm Haproxy\ Statistics
  22.   stats uri /
  23.   stats auth user:pass
  24.  
  25. frontend balancer
  26.   bind 0.0.0.0:80
  27.   mode http
  28.   default_backend web_backends
  29.  
  30. backend web_backends
  31.   mode http
  32.   option forwardfor
  33.   balance roundrobin
  34.   server weba weba:80 check
  35.   server webb webb:80 check
  36.   server webc webc:80 check
  37.   option httpchk GET /
  38.   http-check expect status 200

（3）dockerfile-compose.yml

这个文件Compose使用的主模板文件。
其中会指定启动3个web容器（weba、webb、webc），以及一个haproxy容器。

  1. #创建三个web服务
  2. weba:
  3.     build: ./web  指定Dockerfile文件所在的路径，Compose将会使用这个文件来构建镜像，然后利用这个镜像来创建容器
  4.     expose:
  5.         - 80
  6.  
  7. webb:
  8.     build: ./web
  9.     expose:
  10.         - 80
  11.  
  12. webc:
  13.     build: ./web
  14.     expose:
  15.         - 80
  16.  
  17. haproxy:
  18.     image: haproxy:1.6  拉取镜像
  19.     volumes:  挂载配置文件到指定的位置
  20.         - ./haproxy:/haproxy-override
  21.         - ./haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
  22.     links:  links标签解决容器的连接问题，它会连接到另外的三个容器，以此来达到编排的目的。
  23.         - weba
  24.         - webb
  25.         - webc
  26.     ports:
  27.         - "80:80"  端口映射，可以使用docker ps来查看
  28.         - "70:70"

（4）运行compose项目

启动：
　　docker-compose up 会自动查找当前目录下的docker-compose.yml文件，如果没有会去上级目录查找
查看容器信息：

  1. [root@centos002 haproxy_web]# docker ps
  2. CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                                    NAMES
  3. 9eac212b5a4d        haproxy:1.6         "/docker-entrypoint.…"   44 minutes ago      Up 44 minutes       0.0.0.0:70->70/tcp, 0.0.0.0:80->80/tcp   haproxy_web_haproxy_1_8843fbe31d1f
  4. 696b91016f39        haproxy_web_webc    "/bin/sh -c 'python …"   44 minutes ago      Up 44 minutes       80/tcp                                   haproxy_web_webc_1_159bfc7f2644
  5. dfcb7f1a0e8e        haproxy_web_weba    "/bin/sh -c 'python …"   44 minutes ago      Up 44 minutes       80/tcp                                   haproxy_web_weba_1_f047051398b2
  6. 0508a092fca0        haproxy_web_webb    "/bin/sh -c 'python …"   44 minutes ago      Up 44 minutes       80/tcp                                   haproxy_web_webb_1_ef0b108c4e3b

我们可以看到创建并启动了四个容器，haproxy完成了两个端口的映射，web服务默认使用的80端口，expose只是声明。

查看镜像：
理论上说会下载python2.7和haproxy1.6的镜像，同时又会在python镜像的基础上创建3个web镜像。

查看负载均衡的效果：
我们连续刷新三次：

我们可以看到在三个ip之前来回切换，这样就达到了负载均衡的效果。

（5）总结

再回来看目录结果：

  1. [root@centos002 haproxy_web]# tree
  2. .
  3. |-- docker-compose.yml
  4. |-- haproxy
  5. |   `-- haproxy.cfg
  6. `-- web
  7.     |-- Dockerfile
  8.     |-- index.html
  9.     `-- index.py
  10.  
  11. 2 directories, 5 files

貌似有好几个目录，但是其实核心目录只有一个就是docker-compose.yml。
我们稍微改一下，也许就会更加清晰明确。

  1. weba:
  2. 	image：nginx
  3.  
  4. webb:
  5. 	image：nginx
  6.  
  7. webc:
  8. 	image：nginx
  9.  
  10. haproxy:
  11.     image: haproxy:1.6
  12.     volumes:
  13.         - haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
  14.     links:
  15.         - weba
  16.         - webb
  17.         - webc
  18.     ports:
  19.         - "80:80"
  20.         - "70:70"

这样我们的目录结构：

  1. [root@centos002 web_haproxy]# tree
  2. .
  3. |-- docker-compose.yml
  4. `-- haproxy.cfg  这个文件没有的话，不能实现负载均衡的
  5.  
  6. 0 directories, 2 files

之所以创建web和haproxy这两个目录，就是为了更加的清晰明确。

　　

docker——三剑客之Docker Compose的更多相关文章

  1. Docker 三剑客之 Docker Swarm

    上一篇:Docker 三剑客之 Docker Compose 阅读目录: Docker Machine 创建 Docker 主机 Docker Swarm 配置集群节点 Docker Service ...

  2. Docker(五)：Docker 三剑客之 Docker Machine

    上篇文章Docker(四):Docker 三剑客之 Docker Compose介绍了 Docker Compose,这篇文章我们来了解 Docker Machine . Docker Machine ...

  3. Docker三剑客之Docker Swarm

    一.什么是Docker Swarm Swarm是Docker公司推出的用来管理docker集群的平台,几乎全部用GO语言来完成的开发的,代码开源在https://github.com/docker/s ...

  4. Docker 三剑客之 Docker Swarm（基于 overlay 组网通信）

    相关文章:Docker 三剑客之 Docker Swarm 这一篇主要是对 Docker Swarm 的完善,增加基于 overlay 组网通信,以便 Docker 容器可以跨主机访问. 不同主机间的 ...

  5. Docker(四)：Docker 三剑客之 Docker Compose

    前两篇文章我们介绍了 Dockerfile 的使用Docker(二):Dockerfile 使用介绍,我们知道使用一个 Dockerfile 模板文件可以定义一个单独的应用容器,如果需要定义多个容器就 ...

  6. Docker三剑客之Docker Compose

    一.什么是Docker Compose Compose 项目是Docker官方的开源项目,负责实现Docker容器集群的快速编排,开源代码在https://github.com/docker/comp ...

  7. docker——三剑客之Docker swarm

    Docker Swarm是Docker官方的三剑客项目之一,提供Docker容器集群服务,是Docker官方对容器云生态进行支持的核心方案.使用它,用户可以将多个Docker主机封装为单个大型的虚拟D ...

  8. Docker(六)：Docker 三剑客之 Docker Swarm

    实践中会发现,生产环境中使用单个 Docker 节点是远远不够的,搭建 Docker 集群势在必行.然而,面对 Kubernetes, Mesos 以及 Swarm 等众多容器集群系统,我们该如何选择 ...

  9. docker——三剑客之Docker Machine

    Docker Machine是Docker官方三剑客项目之一,负责使用Docker的第一步,在多种平台上快速安装Docker环境.它支持多种平台,让用户在很短时间内搭建一套Docker主机集群. Ma ...

  10. Docker三剑客之Docker Machine

    一.什么是Docker Machine Docker Machine 是Docker官方编排项目之一,使用go语言编写的,使用不同引擎在多种平台上快速的安装Docker环境,开源地址:https:// ...

随机推荐

  1. Linq中使用Left Join rught join

    准备一些测试数据,如下: use Test Create table Student( ID int identity(1,1) primary key, [Name] nvarchar(50) no ...

  2. docker学习之-什么是docker

    docker是一个用来装应用的容器,就想杯子可以装水,笔筒可以装笔,书包可以放书一样,可以把网站放到docker里,可以把任何应用放到docker里.

  3. Linux环境下$开头的相关变量的含义

    $0 这个程式的执行名字$n 这个程式的第n个参数值,n=1..9$* 这个程式的所有参数,此选项参数可超过9个.$# 这个程式的参数个数$$ 这个程式的PID(脚本运行的当前进程ID号)$! 执行上 ...

  4. Python3 urllib 库

    urllib 简介 urllib 基础模块 使用 urllib 发送请求 使用 urllib 构造请求对象 关于 Handler 与 opener 使用 urllib 进行身份验证 使用 urllib ...

  5. docker pull 详解

    docker pull 用于从镜像仓库中拉取或更新指定镜像,用法如:docker pull centos ,默认是从 Docker Hub 中拉取镜像 在拉取镜像前,我们可以先配置 docker 加速 ...

  6. UEditor整合代码高亮插件SyntaxHighlighter

    1  下载UEditor : http://ueditor.baidu.com/website/download.html 下载SyntaxHighlighter :https://github.co ...

  7. sencha touch 扩展篇之将sencha touch打包成安装程序（上）- 使用sencha cmd打包安装程序

    由于最近一直忙着android原生的开发,很久没有更新博客了,官方的sencha cmd工具功能非常强大,创建项目,压缩项目,打包安装程序都能轻松实现,这讲我们就给大家介绍下如何使用sencha cm ...

  8. CRUX下实现进程隐藏（2）

    前面我们介绍了如何修改/proc目录读取函数的方法实现进程隐藏.这篇博文将介绍另一种方法—— 劫持系统调用实现进程隐藏. 其基本原理是:加载一个内核模块(LKM),通过劫持系统调用sys_getden ...

  9. EUI组件之BitmapLabel 位图字体

    一.制作文图字体文件 使用TextureMerger制作位图字体,具体查看 官方教程. 我们这里制作了一组位图字体. 二.导入位图字体 位图字体素材放入资源配置文件default.res.json 三 ...

  10. Android EditText光标颜色 与inputType

    1.EditText有一个属性:android:textCursorDrawable,这个属性是用来控制光标颜色的   android:textCursorDrawable="@null&q ...