（1）CMDB项目1

 1 CMDB概念

　　CMDB ：  Configuraion Management Database配置管理数据库，CMDB存储与管理企业IT架构中设备的各种配置信息，它与所有服务支持和服务交付流程都紧密相连，支持这些流程的运转、发挥配置信息的价值，同时依赖于相关流程保证数据的准确性。

　　在实际项目中，CMDB常常被认为是构建其他ITIL流程的基础而有限考虑，ITIL项目的成败与是否成功建立CMDB有非常大的关系。70%~80%的IT相关问题与环境的变更有着更直接的关系。实施变更的难点和重点并不是工具，而是流程。即通过一个自动化的，可重复的流程管理变更，使得当变更发生的时候，有一个标准化的流程去执行，能够预测到这个变更对整个系统管理产生的影响，并对这些影响进行评估和控制。而变更管理流程自动化的实现关键就是CMDB。

　　CMDB工具中至少包括这几种关键的功能：整合、调和、同步、映射和可视化。

　　整合：是指能够充分利用来自其他数据源的信息，对CMDB中包含的记录源属性进行存取，将多个数据源合并至一个视图中，生成连同来自CMDB和其他数据源信息在内的报告。

　　调和：调和能力是指通过对来字每个数据源的匹配字段进行对比，保证CMDB中的记录在多个数据源中没有重复现象，维持CMDB中每个配置项目数据源的完整性；自动调整流程使得初始实施、数据库管理员的手动运作和现场维护支持工作将至最低。

　　同步：是指确保CMDB中的信息能够反映联合数据源的更新情况，在联合数据源更新频率的基础上确定CMDB更新日程，按照经过批准的变更来更新CMDB，找出未被批准的变更。

　　应用映射与可视化：说明应用间的关系并反应应用和其他组件之间的依存关系，了解变更造成的影响并帮助诊断问题。

　　CMDB是运维自动化项目，它可以减少人工干预，降低人员成本。

　　功能：自动装机、实时监控、自动化部署软件，建立在他们的基础上是资产信息变更记录（资产管控自动进行汇报）

2  资产采集

2.1 资产采集分析　　

 　　CMDB资产管理项目的代码可以分为：资产采集部分，api部分，后台管理部分。

　　资产采集部分：

　　  　  ---  采集资产：在各个服务器（在CMDB中是客户端）执行采集数据信息命令，使用正则或字符串匹配方式获取想要数据。

　　　　　　如果此服务器是中控机，需要有执行命令的各个主机名，和执行的命令。

　　　　　　如果服务器为agent，则只需要执行命令。 

　　　　---  兼容性（各种资产采集的架构：agent，SSH或者salt都可以兼容）

　　　　---  汇报数据     

     需要复习知识点：

1 高内聚，低耦合
2 反射： getattr(obj,'xxx')
3 导入模块：
import  re
import importlib
importlib.import_module('re')
django中是如何导入模块的：
m = importlib.import_module('django.middleware.clickjacking')
cls = getattr(m,'XFrameOptionsMiddleware')
cls()
4 面向对象：
(1)
class Foo：
    def  __init__(self,xx):
            pass
    @classmethod
    def   instance(cls):
            return cls()
    def process(self):
           pass
if hasattr(Foo,'instance'):
     obj=Foo.instance()
else:
     obj=Foo()
obj.process()
(2)
class A:
    def f1(self):
        self.f2()
    def  f2(self):
        self('A.f2')
class B:
    def f2(self):
        print('B.f2')
obj = B()
obj.f1()

2.2 资产采集的四种方案

2.2.1 Agent方式

　　使用场景：主机数量多

       使用架构： 数据库------api程序----------各个主机

       使用： 

       agent自动采集是在各个主机上运行程序，采集数据。需要使用subprocess和requests模块

v1= subprocess.getoutput('ifconfig')
#并发送
url="http://127.0.0.1:8000/asset.html"
response = request.post(url,data={'k1':value1,'k2':value2}) 
print(response.text)

   当agent采集数据发送到api程序时，api主要的任务是：1 url写路由  2 接收自动采集的数据的格式    3 返回值

 2.2.2  SSH方式

使用场景：主机数量少，ssh连接即使慢也没事
使用架构：数据库 ----api程序----中控机----各个主机
中控机需要远程获取各个主机的信息：python中ssh登录各个主机，执行命令，得到数据
第三方的批量软件： fabric ansible 也是使用ssh原理

需要使用Paramiko模块：

import  paramiko 
# 创建SSH对象
ssh = paramiko.SSHClient()
# 允许连接不在know_hosts文件中的主机
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) 
# 连接服务器
ssh.connect(hostname='192.168.11.98',port=22,username='wupeiqi',password='123')
#执行命令
stdin,stdout,stderr=ssh.exec_command('ls')
#获取命令结果
result= stdout.read()
#关闭连接
ssh.close()

2.2.3 saltstack方式 

saltstack: master主服务器 salve客户端
数据库 ----api程序----saltstack服务的master端----各个slave主机

v = subprocess.getoutput(salt "*" cmd.run "ls")

根据正则表达式提交到数据库

saltstack应用

1 安装和配置

""" salt服务器安装和配置
1. 安装salt-master
    yum install salt-master
2. 修改配置文件：/etc/salt/master
    interface: 0.0.0.0    # 表示Master的IP 
3. 启动
    service salt-master start

"""

"""
salt客户端安装和配置
1. 安装salt-minion
    yum install salt-minion

2. 修改配置文件 /etc/salt/minion
    master: 10.211.55.4           # master的地址
    或
    master:
        - 10.211.55.4
        - 10.211.55.5
    random_master: True

    id: c2.salt.com                    # 客户端在salt-master中显示的唯一ID
3. 启动
    service salt-minion start
"""

2 授权

"""
salt-key -L                    # 查看已授权和未授权的slave
salt-key -a  salve_id      # 接受指定id的salve
salt-key -r  salve_id      # 拒绝指定id的salve
salt-key -d  salve_id      # 删除指定id的salve
"""

3  执行命令

在master服务器上对salve进行远程操作

（1）使用salt自己命令

salt 'c2.salt.com' cmd.run  'ifconfig'

（2）使用salt.client模块

import salt.client
local = salt.client.LocalClient()
result = local.cmd('c2.salt.com', 'cmd.run', ['ifconfig'])

2.2.4 puppet方式

使用场景：公司现在在使用puppet
使用架构：数据库 ----api程序----puppet服务的master端----各个slave主机

2.3  创建资产采集代码的目录

bin    # 可执行文件
config  # 配置文件
      -settings.py
lib     #  公共的模块
   - conf 
         -config.py 
         - global_setting.py
src     # 业务代码目录
 #  log     # 日志  一般不放这里，写在系统的某个目录

 

2.4 资产采集代码中的配置文件

有两个配置文件：用户自定义配置文件 ， 默认配置文件。   配置文件中的变量名一般都是大写。

使用一个配置文件将两个配置文件结合起来

此例django的默认配置文件： from django.conf import global_settings
此例django中from django.conf import settings 会把默认配置和自定义配置合起来，使用settings.使用所有的配置

lib/conf/config.py 配置文件代码：

import os
import importlib
from . import global_settings
class Settings(object):
    def __init__(self):
        # ######## 找到默认配置 ########  先找默认，后找自定义配置
        for name in dir(global_settings):
            if name.isupper():
                value = getattr(global_settings,name)
                setattr(self,name,value)

        # ######## 找到自定义配置 ########
        # os.environ是全局环境变量，是字典类型
        # 根据字符串导入模块   
        settings_module = os.environ.get('USER_SETTINGS')  
        if not settings_module:  #如果没有自定义配置文件，直接使用默认文件
            return
        m = importlib.import_module(settings_module)
        for name in dir(m):     # dir() 可以得到此变量的所有属性
            if name.isupper():     #  配置文件中的变量名一般大写
                value = getattr(m,name)   # 拿到自定义配置
                setattr(self,name,value)     # 将自定义配置的键和值设置在当前配置文件中
settings = Settings()

使用

import os
os.environ['USER_SETTINGS'] = "config.settings"  #os.environ 系统环境变量 ，只在当前运行程序生效
import sys  # 将代码模块路径放到sys中
BASEDIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASEDIR)
from lib.conf.config import settings  #只需要导入settings，默认和自定义配置文件都会导入
print(settings.USER)
print(settings.EMAIL)

一般软件的配置文件都是这样做，有两个配置文件，没有自定义就是用默认配置文件。 

2.5 可插拨式资产采集插件

公司采集资产有差别，因此插件最好是可插拨式

在src目录下创建plugins文件夹下basic，board，cpu，disk，menery，nic的py文件，默认采集basic，board，cpu，disk，menery，nic信息

2.5.1 定义插件类

# src/plugins/nic.py中的Nic类
class Nic(object):
    def process(self):
        return 'Nic'
# src/plugins/board.py中的Board类
class Board(object):
    def process(self):
        return 'Board'
#.....

2.5.2  插件类写到配置文件中

#condif/settings.py自定义配置文件写入
PLUGINS_DICT = {
    'basic': "src.plugins.basic.Basic",
    'board': "src.plugins.board.Board",
    'cpu': "src.plugins.cpu.Cpu",
    'disk': "src.plugins.disk.Disk",
    'memory': "src.plugins.memory.Memory",
    'nic': "src.plugins.nic.Nic",
}

2.5.3 可插拨式采集资产插件的使用方法

　当导入src/plugins里面模块时时，首先会执行src/plugins/__init__.py，src/plugins/__init__.py导入配置文件，获取插件的目录和类名，并导入。根据类名，执行其方法采集资产。

　　

不同架构执行命令： 例如salt和agent方式不同，在代码上涉及判断
（1）-- 插件上使用继承解决
　继承的类里面command函数需要判断配置文件中的采集数据方式，根据不同的方式执行命令

# src/plugins/base.py 在command方法中写判断采集数据类型
class BasePlugin(object):
    def  command(self,cmd):
    if "salt":
         pass
    elif "SSH":
        pass
    # ....
# src/plugins/cpu.py   各个插件继承BasePlugin类，使用其command方法
from .base import BasePlugin
class Cpu(BasePlugin):
     def process(self):
    self.command('xxx')
    return "123321123"

（2）-- 插件上多传一个命令参数
在src/plugins/__init__.py中定义command函数，并将command函数在执行插件时作为参数传过去
插拔式插件需要有command函数的形参，不用继承，还可以使用__init__.py的所有属性
command函数需要判断配置文件中的采集数据方式，根据不同的方式执行命令

2.5.4 插件部分代码运行逻辑

请求会先执行src/plugins/__init__.py中所有代码
首先PluginManager的__init__函数，在配置文件中注册的所有插件拿出，
PluginManager的exec_plugin函数执行各个插件下的process方法，参数为command函数，接收各个process函数返回值，并返回最终值
各个插件的process方法会拿各个插件自己的命令执行command函数，接收command函数的返回值，并返回
command根据采集数据的模式不同执行命令，并返回值

发给api的信息，最好的类型时字典：
{
cpu: 'xxx',
disk:'...'
}

2.5.5 资产查询插件中的钩子

如果你想在构造方法(就是__init__)创建的时候想让插件模块自定义一些操作，可以使用@classmethod和initial函数来做。

#  src/plugins/__init__.py中PluginManager类的exec_plugin函数
def exec_plugins(self):
        # 获取所有的插件，并执行插件并返回值
        response = {}
        for k,v in self.plugin_dict.items():
            # 'basic': "src.plugins.basic.Basic"
            # result= "根据v获取类，并执行其方法采集资产"
            module_path,class_name=v.rsplit('.',1)
            m = importlib.import_module(module_path)
            cls = getattr(m,class_name)    # 找到类
            if hasattr(cls,'initial'):
                obj = cls.initial()
            else:
                obj = cls()
            result = obj.process(self.command)
            response[k]= result
        return response

#  src/plugins/cpu.py中Cpu类的initial函数

class Cpu(object):
    def __init__(self):
        pass

    @classmethod
    def initial(cls):
        return cls()

    def process(self,command_func):
        return 'Cpu'

2.5.6  插件对获取的数据进行处理

 src/plugins/cpu.py下的类Cpu中parse方法

 def parse(self, content):
        """
        解析shell命令返回结果
        :param content: shell 命令结果
        :return:解析后的结果
        """
        response = {'cpu_count': 0, 'cpu_physical_count': 0, 'cpu_model': ''}

        cpu_physical_set = set()

        content = content.strip()
        for item in content.split('

'):
            for row_line in item.split('
'):
                key, value = row_line.split(':')
                key = key.strip()
                if key == 'processor':
                    response['cpu_count'] += 1
                elif key == 'physical id':
                    cpu_physical_set.add(value)
                elif key == 'model name':
                    if not response['cpu_model']:
                        response['cpu_model'] = value
        response['cpu_physical_count'] = len(cpu_physical_set)

        return response

2.5.7 插件获取到错误堆栈信息时的处理

trackback模块
traceback.format_exc() 错误信息堆栈

  def exec_plugin(self):
        """
        获取所有的插件，并执行获取插件返回值
        :return:
        """
        response = {}
        for k,v in self.plugin_dict.items():
            #  'basic': "src.plugins.basic.Basic",
            ret = {'status':True,'data':None}
            try:
                module_path, class_name = v.rsplit('.', 1)
                m = importlib.import_module(module_path)
                cls = getattr(m,class_name)
                if hasattr(cls,'initial'):
                    obj = cls.initial()
                else:
                    obj = cls()
                result = obj.process(self.command,self.debug) # result = "根据v获取类，并执行其方法采集资产"
                ret['data'] = result
            except Exception as e:
                ret['status'] = False
                ret['data'] = "[%s][%s] 采集数据出现错误 : %s" %(self.hostname if self.hostname else "AGENT",k,traceback.format_exc())
                #  traceback.format_exc() 错误信息堆栈
            response[k] = ret
        return response
    '''
    {
       'disk':{'status':True,'data':'xxx'},
       'nic':{'status':False,'data':'xxxxxx'}
    }

    '''

2.5.8 向api发送数据

支持3种模式：
　　agent直接发送就行
　　中控机向后台发送，ssh或者salt应该先从后台获取未采集数据的主机列表，再循环主机列表从而获取各个客户端的主机信息，最后将信息数据返回给后台服务器。

#向api发送数据    和采集资产整合起来
import requests
from lib.conf.config import settings
from src.plugins import PluginManager
import json

class Base(object):
    def post_asse(self,server_info):
        requests.post(settings.API,json=server_info)
        # server_info 是字典里面有字典，不能直接传过去，需要json转化
        # body:json.dumps(server_info)
        # headers = {'content-type':'application/json'}
        # json.loads(request.body)
class Agent(Base):
    def execute(self):
        server_info = PluginManager().exec_plugin()
        self.post_asse(server_info)

class SSHSALT(Base):
    def get_host(self):
        # 获取未采集的主机列表
        response=requests.get(settings.API)
        result = json.loads(requests.text) #  “{status:'True',data:['c1.com','c2.com']}”

        if result['status']:
            return
        return result['data']

    def execute(self):
        host_list = self.get_host()
        for host in host_list:
            server_info = PluginManager(host).exec_plugins()
            self.post_asse(server_info)

插件只是用来采集资产，并且自己判断是哪种模式
client.py 是组织插件的功能和拿到数据发送给api的业务

问题：

发送到api时还可以加密
还有并发的问题，使用线程池

2.5.9  唯一标识

创造唯一标识时，之前必须要做标准化 。 比如认为主板SN  物理机的话可以作为唯一标识，虚拟机的话就不是唯一标识了。

标准化：主机名不重复；对于agent方式，主机名是唯一标识，可以将主机名写在客户端服务器的某个文件中，采集数据时可以进行主机名比较，如果不一致就拿文件中的主机名。

标准化：

　　- 主机名不重复

　　- 流程：

　　- 资产录入，机房，机柜，机柜位置

　　- 装机时，需要将服务信息录入CMDB，c1.com （手动录入或者cobber装机软件录入）

　　- 资产采集：c1.com

标准化创造唯一标识步骤：

（1）装系统，初始化软件（CMDB），运行CMDB：

　　　　- 通过命令获取主机名

　　　　- 写入本地指定文件

（2） 将资产信息发送到API

（3） 获取资产信息：

　　　　- 本地文件主机名   != 命令获取的主机名（按照文件中的主机名）

　　　　- 本地文件主机名   == 命令获取的主机名

最终流程：

标准化：主机名不重复；流程标准化（装机同时，主机名在cmdb中设置）

服务器资产采集（Agent）：

　　a. 第一次：文件不存在，或内容为空；

  　　 　　采集资产：

　　　　　　　　- 主机名写入文件

　　　　　　　　- 发送API

　　b. 第N次：采集资产，主机名：文件中获取

agent方式唯一标识代码：

class Agent(Base):
    def execute(self):
        server_info = PluginManager().exec_plugin()
        hostname = server_info['basic']['data']['hostname']
        certname = open(settings.CERT_PATH,'r',encoding='utf-8').read()
        if not certname.strip():
            with open(settings.CERT_PATH,'w',encoding='utf-8') as f:
                f.write(hostname)
        else:
            server_info['basic']['data']['hostname'] = certname

        self.post_asse(server_info)

 SSH或Salt方式：中控机从后台获取未采集主机名列表：【c1.com 】，再直接去找客户端，本身拿到的主机名就是唯一标识

2.5.10 基于线程池实现并发采集资产

Ssh和salt的采集资产方式才可以有线程池。  提高并发：线程、进程

Python2：

　　线程池：无

　　进程池：有

Python3：

　　线程池：有

　　进程池：有

线程池简单例子：

import time
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor

def task(i):
    time.sleep(1)
    print(i)
p = ThreadPoolExecutor(10)
for row in range(100):
    p.submit(task,row)

进程池简单例子：

import time
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor

def task(i):
    time.sleep(1)
    print(i)

p = ProcessPoolExecutor(10)
for row in range(100):
    p.submit(task,row)

线程池在CMDB中采集数据时的应用：

# src/client.py
class SSHSALT(Base):
    def get_host(self):
        # 获取未采集的主机列表
        response=requests.get(settings.API)
        result = json.loads(requests.text) #  “{status:'True',data:['c1.com','c2.com']}”

        if result['status']:
            return
        return result['data']

    def run(self,host):
        server_info = PluginManager(host).exec_plugins()
        self.post_asse(server_info)

    def execute(self):
        host_list = self.get_host()
        from concurrent.futures import ThreadPoolExecutor
        pool = ThreadPoolExecutor(10)
        for host in host_list:
            pool.submit(self.run,host)

2.5.11 代码

 略