使用docker-py建立docker纳管系统链接 建立docker信息可视化界面

ansible api 2.0

2.0与1.9的差别十分大，2.0之后是通过回调的方法去实现API接口。

1. 定义一个结果对象

2. 初始化ansible节点对象

3. 初始化结果对象

4. 创建一个任务

5. 运行ansible节点

登陆ansible控制机器的密码，如果通过公钥方式连接，此password可以传入个错误的，但不能不传。

给出官网给的api样例

#!/usr/bin/env python

import json
from collections import namedtuple
from ansible.parsing.dataloader import DataLoader
from ansible.vars.manager import VariableManager
from ansible.inventory.manager import InventoryManager
from ansible.playbook.play import Play
from ansible.executor.task_queue_manager import TaskQueueManager
from ansible.plugins.callback import CallbackBase

class ResultCallback(CallbackBase):                     # 定义一个结果对象

    def v2_runner_on_ok(self, result, **kwargs):        # 当结果成功的时候执行(indent=4表示缩进为4格)
        host = result._host
        print(json.dumps({host.name: result._result}, indent=4))

Options = namedtuple('Options', ['connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check', 'diff'])   # namedtuple创建一个和tuple类似的对象，而且对象拥有可访问的属性。

loader = DataLoader()                                   # 创建一个变量管理器
options = Options(connection='local', module_path='/path/to/mymodules', forks=100, become=None, become_method=None, become_user=None, check=False,
                  diff=False)                           # 定义参数,具体意义参考下方列表
passwords = dict(vault_pass='secret')                   # 定义密码

results_callback = ResultCallback()                     # 初始化结果对象

inventory = InventoryManager(loader=loader, sources=['localhost'])  # 定义一个inventory,source可以定义hosts文件位置(/etc/ansible/hosts)
variable_manager = VariableManager(loader=loader, inventory=inventory)  # 定义变量管理器

                                                        # 创建playbook
play_source =  dict(
        name = "Ansible Play",
        hosts = 'localhost',
        gather_facts = 'no',
        tasks = [
            dict(action=dict(module='shell', args='ls'), register='shell_out'),
            dict(action=dict(module='debug', args=dict(msg='{{shell_out.stdout}}')))
         ]
    )
play = Play().load(play_source, variable_manager=variable_manager, loader=loader)

tqm = None                                              # 初始化任务队列
try:                                                    # 定义任务队列
    tqm = TaskQueueManager(
              inventory=inventory,
              variable_manager=variable_manager,
              loader=loader,
              options=options,
              passwords=passwords,
              stdout_callback=results_callback,
          )
    result = tqm.run(play)
finally:
    if tqm is not None:
        tqm.cleanup()

其中Option(参数)的说明

option | 说明 | 定义中对应

---|--- | ---

-v	| 详细信息输出

-i	| 指定inventory的目录,缺省会使用/etc/ansible/hosts

-f	| fork(并发处理)的进程个数,默认是5 | forks

–private-key=xxx	| 指定ssh连接用的文件

-m	| 指定module

–module-name | 指定module名称

–module-path | 指定module的path 默认是/usr/share/ansible | module_path

-a	| 指定module的参数

-k	| 提示输入password

-K	| 提示输入sudo密码 与–sudo一起使用

-T	| 设定连接超时时长 | timeout

-B	| 设定后台运行并设定超时时长

-c	| 设定连接类型 有ssh或者local等。| connection

-b	| su的方式，可以指定用户 | become_user

-C	| only for check | check

使用二进制文件和ansible安装docker

既然要实现自动化，就要使用ansible api。通过ansible api为python提供的端口我们可以轻松的使用python调用ansible命令。我写了一个python的函数来执行playbook.(ansible 1.9和2.0很不一样，现在2.4好像又和2.0不一样，我做了很多尝试，下面这个是最简单的执行playbook的函数，输出就和在shell上一样，具体封装resultcallback我还需要再研究研究)

#!/usr/bin/env python
from collections import namedtuple
from ansible.parsing.dataloader import DataLoader
from ansible.vars.manager import VariableManager
from ansible.inventory.manager import InventoryManager
from ansible.executor.playbook_executor import PlaybookExecutor

def ansible_playbook(playbook):
    """
    执行一个playbook
    """
    Options = namedtuple('Options',
                         ['listtags', 'listtasks', 'listhosts', 'syntax', 'connection', 'module_path', 'forks',
                          'remote_user', 'private_key_file', 'ssh_common_args', 'ssh_extra_args', 'sftp_extra_args',
                          'scp_extra_args', 'become', 'become_method', 'become_user', 'verbosity', 'check', 'diff'])
    loader = DataLoader()                                                                                       # 创建一个变量管理器
    options = Options(listtags=False, listtasks=False, listhosts=False, syntax=False, connection='ssh',
                      module_path=None, forks=100, remote_user='slotlocker', private_key_file=None,
                      ssh_common_args=None, ssh_extra_args=None, sftp_extra_args=None, scp_extra_args=None, become=True,
                      become_method=None, become_user='root', verbosity=None, check=False, diff=False)          # 定义参数
    passwords = dict(vault_pass='secret')                                                                       # 定义密码
    inventory = InventoryManager(loader=loader, sources=['/etc/ansible/hosts'])                                 # 定义一个inventory及hosts文件位置(/etc/ansible/hosts)
    variable_manager = VariableManager(loader=loader, inventory=inventory)                                     # 定义变量管理器
    playbook = PlaybookExecutor(playbooks=[playbook], inventory=inventory, variable_manager=variable_manager, loader=loader,
                            options=options, passwords=passwords)                                              # 定义一个playbook
    playbook.run()                                                                                             # 执行playbook

之后就可以在python函数中调用playbook函数执行playbook文件了。

我使用的是17.12.0-ce版本的docker二进制文件,具体选择哪个版本可以在下方选择下面的网址

https://download.docker.com/linux/static/stable/x86_64/

下载之后解压，就会得到安装docker的二进制文件。

然后编写playbook

- hosts: hosts
  remote_user: root
  tasks:
    - name: 创建/root/local/bin/文件夹
      shell: mkdir -p /root/local/bin

    - name: 下载 docker 二进制文件
      copy: src=/usr/src/docker/bin/{{ item }} dest=/root/local/bin/{{ item }} mode=0755
      with_items:
      - docker-containerd
      - docker-containerd-shim
      - docker-init
      - docker-runc
      - docker
      - docker-containerd-ctr
      - dockerd
      - docker-proxy

    - name: docker命令自动补全
      copy: src=/usr/src/docker/bin/docker dest=/etc/bash_completion.d/docker mode=0644

    - name: docker国内镜像加速
      copy: src=/usr/src/docker/daemon.json dest=/etc/docker/daemon.json

    - name: 创建docker的systemd unit文件
      template: src=/usr/src/docker/docker.service.j2 dest=/etc/systemd/system/docker.service

    - name: 开启docker 服务
      shell: systemctl daemon-reload && systemctl restart docker

    - name: 实现开机自启
      shell: systemctl enable docker

实现添加主机并自动为主机安装docker

1. 加入主机获取ip,用户和密码 

2. 实现主机之间免ssh密码连接

   sshpass -p 'root' ssh-copy-id -o StrictHostKeyChecking=no root@192.168.0.106

3. 在程序中调用playbook安装docker

   ansible_playbook('connect/playbook/docker.yml')

   注意，docker安装完一般是只允许本地主机访问的，需要在/etc/docker/daemon.json中加入

     "hosts": ["unix:///var/run/docker.sock", "0.0.0.0:4789"]

   指定访问的端口，这样就可以通过访问ip:4789来远程操作主机上的容器

4. 访问目标docker

   这个就十分简单了，在之前的建立docker信息可视化界面 说过使用docker-py来调用docker命令

>>> import docker
>>> client = docker.Client(base_url='192.168.0.106:4789')                       
>>> client.version()
{'Platform': {'Name': ''}, 'Components': [{'Name': 'Engine', 'Version': '17.12.0-ce', 'Details': {'ApiVersion': '1.35', 'Arch': 'amd64', 'BuildTime': '2017-12-27T20:12:29.000000000+00:00', 'Experimental': 'false', 'GitCommit': 'c97c6d6', 'GoVersion': 'go1.9.2', 'KernelVersion': '3.10.0-693.el7.x86_64', 'MinAPIVersion': '1.12', 'Os': 'linux'}}], 'Version': '17.12.0-ce', 'ApiVersion': '1.35', 'MinAPIVersion': '1.12', 'GitCommit': 'c97c6d6', 'GoVersion': 'go1.9.2', 'Os': 'linux', 'Arch': 'amd64', 'KernelVersion': '3.10.0-693.el7.x86_64', 'BuildTime': '2017-12-27T20:12:29.000000000+00:00'}

1. 在界面的操作   

代码都放在github上https://github.com/daba0007/docker_form

ansible自动化构建运维平台：http://www.roncoo.com/course/view/e9cb403ffd3543ba8062e653685ae052