搭建牛逼环境之后的文档总结

for-github

swarm集群搭建

早期的docker swarm

Swarm deamon只是一个调度器（Scheduler）加路由器(router)，Swarm自己不运行容器，它只是接受docker客户端发送过来的请求，调度适合的节点来运行容器。
需要服务发现(Discovery service backend)功能。Swarm支持以下几种discovery service backend：
1. Docker Hub上面内置的服务发现功能，
2. 本地的静态文件描述集群(static file describing the cluster)，
3. etcd，consul，zookeeper和一些静态的ip列表(a static list of ips)

在使用docker Swarm进行集群管理之前，需要先把准备加入集群的所有的节点的docker deamon的监听端口修改为0.0.0.0:2375

Docker Swarm服务发现

Swarm是管理docker host的工具，能够感知到集群中节点的动态加入与退出即为服务发现，支持的服务发现方式：

• Token
  Token 发现策略使用 ID 来唯一标识集群，每一个节点通过指定集群 ID 来标识加入的集群。所以首先使用 Swarm 产生一个集群 ID，然后每一个节点通过 join Cluster-ID 动态加入这个集群。

• Nodes
  Nodes 发现策略依赖于集群节点，我们在集群 manage节点执行加入集群指令时，就需要指定要加入集群的其他节点。所以集群成员需要预先定义。

• File
  首先将加入集群的节点存储在一个文件中，我们在集群 manage 节点执行加入集群指令时，指定存储集群中所有节点的文件。所以集群成员也是需要预先定义。

• 分布式 key/value 存储
  Swarm 使用第三方软件的 key/value 形式存储节点信息，分布式 key-value 存储不仅能够实现 Swarm 节点的动态加入，同时提供了很多其他的功能，直观显示集群中的每个节点以及每个节点提供的服务等。推荐Consul

使用docker-machine创建

The very important point is that so far we have only used a single Docker host. If we really want to run a distributed application and scale it, we will need access to a cluster of Docker hosts so that containers can get started on multiple hosts. In Docker speak, a cluster of Docker hosts is called a Swarm. Thankfully, Docker Machine lets you create a Swarm. Note that you could also create a Swarm with well-known configuration management tools (e.g., Ansible, Chef, Puppet) or other tools, such as Terraform.

• 先使用dm(docker-machien)创建一个kvstore vm，在虚拟机里启动Consul server容器作为Consul server
• 使用dm创建swarm-master
  使用--swarm --swarm-master --swarm-discovery="consul://$(docker-machine ip kvstore):8500" --engine-opt="cluster-store=consul://$(docker-machine ip kvstore):8500" --engine-opt="cluster-advertise=eth0:2376"参数创建 swarm-master节点.
• 使用dm创建searm slave节点
  --swarm --swarm-discovery="consul://$(docker-machine ip kvstore):8500" --engine-opt="cluster-store=consul://$(docker-machine ip kvstore):8500" --engine-opt="cluster-advertise=eth0:2376"创建swarm-node-1节点并广播swarm slave ip:port
• 在swarm slave节点内启动consul agent

使用swarm镜像创建

法一：
1. 在物理服务器或者vm上，直接使用docker run --rm swarm:latest create命令创建一次性swarm，swarm会前往Docker Hub上内建的发现服务中获取一个全球唯一的token，用以唯一的标识swarm管理的Docker集群。
2. 在所有要加入集群的机器上执行swarm join,sudo docker run –-rm swarm join –addr=ip_address:2375 token://。。。。。。。。。
3. 启动swarm manager，sudo docker run –d –p 2376:2375 swarm manage token:// d947b55aa8fb9198b5d13ad81f61ac4d，此处主机端口不能是2375,可以是2376或其它的。

法二：（使用文件）不方便不推荐！！！！
1. 将加入swarm的主机IP:2375写入cluster文件echo xx.xx.xx.xx:2375 >> cluster
2. 使用swarm manage命令启动集群sudo docker run –d –p 2376:2375 –v $(pwd)/cluster:/tmp/cluster swarm manage file:///tmp/cluster
3. 查看集群信息必须指定cluster文件才行sudo docker run –rm –v $(pwd)/cluster:/tmp/cluster swarm list file:///tmp/cluster

shipyard built in swarm

此处讲的shipyard core版本，主要是把多个 Docker host上的 containers 统一管理（支持跨越多个host）。
必须配置所有主机docker daemond监听-H tcp://0.0.0.0:2375

• concepts

engine
一个shipyard管理的docker集群可以包含一个或多个engine（引擎），一个engine就是监听tcp端口的docker daemon。shipyard管理docker daemon、images、containers完全基于Docker API，不需要做其他的修改。另外，shipyard可以对每个engine做资源限制，包括CPU和内存；因为TCP监听相比Unix socket方式会有一定的安全隐患，所以shipyard还支持通过SSL证书与docker后台进程安全通信。

rethinkdb
RethinkDB是一个shipyard项目的一个docker镜像，用来存放账号（account）、引擎（engine）、服务密钥（service key）、扩展元数据（extension metadata）等信息，但不会存储任何有关容器或镜像的内容。一般会启动一个shipyard/rethinkdb容器shipyard-rethinkdb-data来使用它的/data作为数据卷供另外rethinkdb一个挂载，专门用于数据存储。

• 启动swarm manager
  docker run -tid \
-p 3375:3375 \
--restart=always \
--name shipyard-swarm-manager \
swarm:latest \
manage --host tcp://0.0.0.0:3375 consul://[consul server ip]:8500

• 启动swarm agent
  docker run -tid \
--restart=always \
--name shipyard-swarm-agent \
swarm:latest \
join --addr [local ip]:2375 consul://[consul server ip]:8500

• 启动rethinkDB
  docker run -tid \
--restart=always \
--name shipyard-rethinkdb \
-p 28015:28015 \
-p 29015:29015 \ #为了支持rethinkDB集群
-v /data/rethinkdb:/data \
index.tenxcloud.com/docker_library/rethinkdb

• 部署shipyard镜像
  docker run -tid \
--restart=always \
--name shipyard-controller \
--link shipyard-rethinkdb:rethinkdb \
--link shipyard-swarm-manager:swarm \
-p 80:8080 \
shipyard/shipyard:latest \
server \
-d tcp://swarm:3375

Consul KV store

Consul 提供了分布式环境中服务的注册和发现，支持分布式，高可用，多数据中心。

concepts

1. Agent：Consul 集群中每个成员运行的守护进程，以 Client 或者 Server 的模式存在。
2. Client：发送 RPC 请求给服务器的 Agent。
3. Server：是一个 Agent，负责响应 RPC 查询，维护集群状态，参与 Raft 仲裁等。

Server 有三种存在状态。Server 的三种状态形式：Leader，Follower，Candidate。

1. Candidate：Server 参与 Raft 仲裁，竞选期间所有服务器的状态。

2. Leader：Server 参与 Raft 仲裁，竞选结束获胜服务器的状态。

3. Follower：Server 参与 Raft 仲裁，竞选结束未获胜服务器的状态。

三种状态之间关系如下：

Consul 集群 Server 节点中要有一个 Leader。Leader 负责维护集群中所有节点的状态。当集群还没有 Leader 或者 Leader 出现故障时候，所有的 Server 运行 Raft 算法，开始竞选。竞选期间所有 Server 的状态称为 Candidate。最终集群中的 Server 经过竞选，只有一台 Server 获胜，竞选结束。这个时候集群中获胜的 Server 称为 Leader，其他的 Server 称为 Follower。

Consul架构

一个数据中心的 Consul 集群由客户端和服务器组成，服务器以 Leader 和 Follower 两种角色存在。Client 会定时向 Server 发送 RPC 请求，汇报自己的运行状态。Leader 收到 Client 的 RPC 请求，会给 client 发送 RPC 响应，同时存储 Client 的状态等信息。Follower 收到 Client 的 RPC 请求，会转发给 Leader。Leader 存储该 Client 的信息。

使用consul容器搭建

1. Consul server启动
   docker run -d --restart always -p 8300:8300 -p 8301:8301 -p 8301:8301/udp -p 8302:8302/udp \
-p 8302:8302 -p 8400:8400 -p 8500:8500 -p 53:53/udp -h $HOSTNAME progrium/consul \ -server -bootstrap -ui-dir /ui -advertise $(dm ip consul-server)

-p 8500 consul http端口与docker daemond和web UI访问
-p 53 consul DNS端口
-p 8400 PRC端口
-bootstrap starting a Consul cluster (of one node) from scratch, rather than joining an existing cluster. We must bootstrap it
-advertise x.x.x.x 给集群其他节点的广播地址
-client 0.0.0.0 监听所有接口

1. consul agent

可以每个节点手动运行docker run -d --restart=always \
-p 8300:8300 \
-p 8301:8301 \
-p 8301:8301/udp \
-p 8302:8302 \
-p 8302:8302/udp \
-p 8400:8400 \
-p 8500:8500 \
-h $HOSTNAME \ --name=consul progrium/consul -server -join $(dm ip consul-server) -advertise <this-host-ip> -client 0.0.0.0

或者：

在swarm master执行docker-compose -f xx.yml up -d,ip自己改

version: '2'  
services:  
agent-1:  
image: progrium/consul  
container_name: consul_agent_1  
ports:  
  - 8300:8300  
  - 8301:8301  
  - 8301:8301/udp  
  - 8302:8302  
  - 8302:8302/udp  
  - 8400:8400  
  - 8500:8500  
  - 53:53/udp  
environment:  
  - "constraint:node==nb1"  
command: -ui-dir /ui -join 192.168.99.106 -advertise 192.168.99.110  
networks:  
  default:  
    aliases:  
      - agent-1  
agent-2:  
image: progrium/consul  
container_name: consul_agent_2  
ports:  
  - 8300:8300  
  - 8301:8301  
  - 8301:8301/udp  
  - 8302:8302  
  - 8302:8302/udp  
  - 8400:8400  
  - 8500:8500  
  - 53:53/udp  
environment:  
  - "constraint:node==nb2"  
command: -ui-dir /ui -join 192.168.99.106 -advertise 192.168.99.111  
networks:  
  default:  
    aliases:  
      - agent-2  
agent-3:  
image: progrium/consul  
container_name: consul_agent_3  
ports:  
  - 8300:8300  
  - 8301:8301  
  - 8301:8301/udp  
  - 8302:8302  
  - 8302:8302/udp  
  - 8400:8400  
  - 8500:8500  
  - 53:53/udp  
environment:  
  - "constraint:node==nb3"  
command: -ui-dir /ui -join 192.168.99.106 -advertise 192.168.99.112  
networks:  
  default:  
    aliases:  
      - agent-3  
networks:  
default:  
external:  
  name: my-net

• 服务注册

为了在consul里注册一个服务，我们得先给我们的本地consul客户端发送一个非常简单的REST调用，它也许看上去会是这个样子：

{  
"Name": "service1",  
"address": "10.0.0.12",  
"port": 8080,  
"Check": {  
 "http": "http://10.0.0.12:8080/health",  
 "interval": "5s"  
}  
}  

当健康检查返回的是某些在200范围内的状态码时，该服务会被标记为是健康的，然后它便可以被其他服务检索到。一本来说服务注册需要通过curl命令类似curl -v -XPUT -d "$MSG" http://consul_agent_$SERVER_ID:8500/v1/agent/service/register && /app/main "$@"注册到consul agent,再由consul agent广播到consul server存储该服务键值。

可以使用registrator自动发现服务并注册到consul server.：
docker run -d --restart=always --name=registrator --net=host -v /var/run/docker.sock:/tmp/docker.sock gliderlabs/registrator -ip <ip-of-host> consul://localhost:8500
-v /var/run/docker.sock:/tmp/docker.sock This mounts the docker daemon socket into the container, so it can monitor the API for start/stop events from other containers.
consul://localhost:8500 Tell registrator that we’re using Consul (and not etcd!), and to look for it on the bridge address。
registrator发现服务的命名规则是以 “镜像的名字+端口”的方式命名的

当某服务需要访问其他某服务时，通过在consul server DNS进行服务名解析获取要访问服务的某以容器ip进行访问。

Nginx与nginx plus及consul-template

安装consul-template

可以直接安装在主机，必须与nginx安装在同一台主机，因为consul-template需要动态修改nginx配置文件。
只需要把nginx.conf默认配置复制到/root/nginx_web.ctmpl,然后修改upstream段，例如：

vim /root/nginx_web.ctmpl 
worker_processes  1;
events {
    worker_connections  1024;
}
http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    keepalive_timeout  65;
   upstream app {
     {{range $key, $pairs := tree "hello/" | byKey}}{{range $serverid, $pair := $pairs}}
     server {{.Value}}； weight=1 {{end}}{{end}}
   }
   server {
        listen       80;
        server_name  localhost;
       location / {
         http://app;
       }
    }
}

启动consul-template,consul-template -consul consul-server:8500 -template /root/nginx_web.ctmpl:/usr/local/nginx/conf/nginx.conf:"/usr/local/nginx/sbin/nginx -s reload"

使用nginx支持应用TSL/SSL访问，以及nginx plus实现服务转发负载均衡

参考：

• 使用NGINX和NGINX Plus进行Docker Swarm负载均衡
• Docker Swarm Load Balancing with NGINX and NGINX Plus
• Deploying NGINX and NGINX Plus with Docker

容器资源监控

资源监控采用 cadvisor + influxDB + grafana

cadvisor谷歌公司自己用来监控他们基础设施的一款工具，这个工具厉害之处不仅能监控docker容器的实时信息，而且还能将你的cadvisor这容器所在的主机的系统的实时信息！，但是由于cadvisor只是能监控到实时的信息而不能保存，所以我们要使用influxdb将这些实时监控到的信息存放起来，以备以后需要。而grafana这个就是将influxdb存放的信息以图表的形式，非常清晰，完美地展现出来！

influxDB

docker run -d \
-p 8083:8083 \
-p 8086:8086 \
--expose 8090 \
--expose 8099 \
-v /opt/test/data/influxdb:/data \
--name influxsrv tutum/influxdb:0.10
-p 8083 influxDB web访问
-p 8086 数据api接口，到时候cadvisor会访问这个接口.

启动后创建cadvisor数据库，并使用该数据库创建用户root,密码root，给予所有权限。

启动cadvisor

docker run -d \
--volume=/:/rootfs:ro \
--volume=/var/run:/var/run:rw \
--volume=/sys:/sys:ro \
--volume=/var/lib/docker/:/var/lib/docker:ro \
--publish=8080:8080 \
-h $HOSTNAME \
--detach=true \
--name=cadvisor google/cadvisor:latest \
-docker_only \
-storage_driver=influxdb \
-storage_driver_db=cadvisor \
-storage_driver_host=<influxDB-host-ip>:8086
-docker_only 只监控容器，忽视宿主机

部署grafana

docker run -d \
-p 3000:3000 \
-e INFLUXDB_HOST=<influxDB-host-ip> \
-e INFLUXDB_PORT=8086 \
-e INFLUXDB_NAME=cadvisor \
-e INFLUXDB_USER=root \
-e INFLUXDB_PASS=root \
--link influxsrv:influxsrv \
--name grafana grafana/grafana

详细有github提供整套部署的compose，自己改改直接运行。 docker-monitoring/docker-compose.yml

swarm集群日志采集与分析

日志收集与采集使用 graylog + elasticsearch + mongo

 1 version: '2'
  2 services:
  3     mongo:
  4         image: "mongo:3"
  5         volumes:
  6             - /opt/graylog/data/mongo:/data/db
  7     elasticsearch:
  8         image: "elasticsearch:2.3"
  9         command: "elasticsearch -Des.cluster.name='graylog'"
 10         volumes:
 11             - /opt/graylog/data/elasticsearch:/usr/share/elasticsearch/data
 12     graylog:
 13         image: graylog2/server:2.0.3-2
 14         volumes:
 15             - /opt/graylog/data/journal:/usr/share/graylog/data/journal
 16             #- /opt/graylog/config:/usr/share/graylog/data/config
 17         environment:
 18             GRAYLOG_PASSWORD_SECRET: somepasswordpepper
 19             GRAYLOG_ROOT_PASSWORD_SHA2: 4bbdd5a829dba09d7a7ff4c1367be7d36a017b4267d728d31bd264f63debeaa6
 20             GRAYLOG_REST_TRANSPORT_URI: http://202.117.16.168:12900
 21         depends_on:
 22             - mongo
 23             - elasticsearch
 24         ports:
 25             - "9000:9000"
 26             - "12900:12900"
 27             - "12201/udp:12201/udp"
 28             - "12202/udp:12202/udp"

使用命令docker-compose -f docker-compose-5.yml up 启动服务，访问202.117.16.168:9000，使用用户:admin,密码:graylog登入。

设置接收器

Gelf UDP的input方法来接收日志，用udp协议的好处是，当日志系统性能有问题或者别的故障时，不会影响生产服务。
system==>input==>select input ===>GELF UDP。

容器日志转发设置

用docker原生自带的log-driver方法来收集日志，如果想把docker的应用日志输出到外面，也就是说用docker logs -f可以看到，需要我们在编写dockerfile时把日志做一下处理，为了方便起见，设置全局日志转发：

other_args="r -H tcp://127.0.0.1:2375 -H unix:///var/run/docker.sock --log-driver=gelf --log-opt gelf-address=udp://10.2.0.134:12201 --insecure-registry xx.xx.xx.xx:5000 " 
DOCKER_TMPDIR=/opt/test/docker/tmp

重启daemond，就好啦！

参考过的文档

按照编写顺序整理

• 基于 Consul 的 Docker Swarm 服务发现
• How to Use Docker Machine to Create a Swarm Cluster
• Docker GUI之Shipyard+Swarm · docker集群化
• Docker学习笔记 — Swarm搭建Docker集群
• Docker结合Consul实现的服务发现（一）
• 使用NGINX和NGINX Plus进行Docker Swarm负载均衡
• Docker Swarm Load Balancing with NGINX and NGINX Plus
• Deploying NGINX and NGINX Plus with Docker
• vegasbrianc/docker-monitoring