【CMDB 项目架构】基于DRF+Django+Mysql+单例模式

CMDB 项目概述

项目概述

背景
- 大目标：运维自动化
- 小目标：资产管理，降本增效
- 系统开发出来：可以自动采集资产信息，并且提供给其他系统数据支持
运维岗位
- IDC
- 业务
- 桌面
- 监控
物理机和虚拟机

项目架构

资产采集脚本：远程连接服务器，并获取服务器的资产信息，将资产信息汇报给API
资产管理系统：API 负责将资产信息写入数据库，且变会做资产变更记录，为以后搭建自动化运维平台，为其他系统提供数据
资产管控平台，为用户提供数据展示和报表。

资产采集方式

基于SSH模块：使用paramiko模块采集数据。适用100台左右的服务器群
基于 agent模式（client）采集：
- 适用服务器比较多的时候，数量1000台
- 每一台Server，存在一个py资产采集脚本，开启定时任务，直接与CMDB系统API交互
ansible 软件。py编写基于主从架构
- 底层基于：paramiko模块，主节点能主动连接从节点采集信息
saltstack，puppet 工具 py编写

项目实现（资产采集，API）

资产采集流程

脚本，实现资产数据的采集
api 提供数据上传接口

采集不同硬件设备的数据

约束。面向对象中，对于子类的约束。 NotImplementedError
反射。根据字符串找到对应的类或者方法（根据字符串导入相关的包）

开放封闭原则。设计模式：反射+开放封闭原则=工厂模式

开放：配置文件开发
封闭：对源码的修改封闭

# 动态变更的需求，及时修改配置文件

插件模式。插件功能过可扩展
多线程/多协程提高采集速度

小结

为什么开发CMDB？

- 公司要搭建自动化运维平台，CMDB的平台搭建是基石
- 提高资产记录的准确性。通过CMDB可以实现资产信息的自动采集和资产变更记录管理

依据公司服务器的数量决定。>=100

CMDB 如何实现？

- cmdb 包含三部分：资产采集的中控机，API，资产管控平台
	- 资产采集部分开发方式：通过paramiko远程操作服务器采集数据，将数据通过API汇报给CMDB平台。采用工厂模式，开放封闭原则，参考django的中间件等。
	- API：基于restful 和 drf组件 实现。：资产的入库，资产变更处理
	- 资产管控平台：对资产数据的展示 和 资产数据报表的处理。

单例模式

在面向对象中，使用单例模式。对实例对象可复用性
确保一个类只有一个实例
减少内存开销
类似于维护一个全局变量的变量
如何实现单利模式
- __new__ 实现单利模式
- python 文件导入实现单利模式
- 多线程对单利对象上锁

使用场景

python 文件导入，也可实现单利模式

# from 和 import 导入一次后。不再导入第二次
得到的logger 对象就是一个 单利对象，不会创建第二个

数据库连接池
频繁创建对象场景

线程池

多线程遇到 IO 阻塞时，会造成重新实例化对象。解决办法：对创建对象的函数 __new__方法上锁🔒

# -*-coding:utf-8-*-
# 多线程时，需要对对象创建函数。上锁
import threading
import time


class Singleton(object):
    instance = None
    lock = threading.Lock()

    def __init__(self, i):
        self.i = i

    def __new__(cls, *args, **kwargs):
        # 如果有实例对象，直接返回
        if cls.instance:
            return cls.instance
        # 上锁。阻止IO阻塞，线程被挂起
        with cls.lock:
            if not cls.instance:
                time.sleep(1) # 模拟线程阻塞
                cls.instance = object.__new__(cls)
            return cls.instance


def task(args):
    obj = Singleton(args)
    print(obj)


for i in range(10):
    thread = threading.Thread(target=task, args=(i,))
    thread.start()

time.sleep(10)
return_obj = Singleton(1)
print("return_obj:", return_obj)

日志文件对象
网站计数器
django 使用到单例模式
- django-admin的admin.site.register()。将model注册到 Register对象的字典中
- 配置文件 settings。将全局配置gloabl_setting 和自定义配置导入，django web对象中

资产采集补充

采集命令

CPU
```
dmidecode -q -t 17 2>/dev/null
```
Memory

日志处理

可以采用单利模式实现 logger

import traceback 模块。反应程序的堆栈信息

import traceback

def run():
    try:
        int("asd")
    except Exception as e:
        print(traceback.format_exc())

支持 agent 模式（简单工厂模式）

CMDB 资产采集后为什么不直接放到数据库中？

避免高频写入，维护数据库连接多
采集的数据需要清洗
解耦设计：采集数据和程序执行
为其他系统提供数据接口。

资产数据入库

表结构设计

主机表
硬盘表
内存表
NIC 网卡表
主板表
部门表
用户表
RBAC ...

编写 api 接口，实现数据入库

利用工厂模式，对采集的数据分化处理。

# drf 项目结构
- AutoServer  # 项目
	- api  # 对外接口app
  	- plugins  # 插件模块
    	- __init__.py # 学习django的 settings配置，导入 资产数据解析工厂对象，且是一个单例对象。
    	- base_data_analysis.py  # 资产数据拆解基类
      - disk_data_analysis.py  # 磁盘信息的拆解处理类
     	...
      
### 使用如下面代码：⬇️

`init.py 实现代码`

# -*-coding:utf-8-*-
import importlib
from AutoServer.settings import CMDB_PLUGIN_DICT


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

    @staticmethod
    def process_server_info(asset_data, server_obj):
        """
            # 处理中控机，采集的资产信息
        :param asset_data:  # 全部资产数据
        :param server_obj:  # 主机外键
        :return:
        """
        for key, path in CMDB_PLUGIN_DICT.items():
            data = asset_data.get(key, {})  # 每一种解析类对应的采集数据
            if not data:  # 没有采集该种类的数据，跳过
                continue
            module_path, class_name = path.rsplit(".", maxsplit=1)
            module = importlib.import_module(module_path)
            cls = getattr(module, class_name)
            print("正在处理：", cls.__name__)
            cls_obj = cls()
            cls_obj.process(data, server_obj)


psi_factory = ProcessSeverInfoFactory()

`views.py 视图脚本`

# 导入 psi_factory 资产数据处理工厂单例对象
import datetime
import json

from django.db.models import Q
from rest_framework.response import Response
from rest_framework.views import APIView

from api.models import ServerModel, CpuModel, BoardModel, NicModel, DiskModel, MemoryModel
from api.plugins import psi_factory


class ServerAPIView(APIView):
    def post(self, request, *args, **kwargs):
        """
            接收资产数据，并添加到数据库中
        :param request:
        :param args:
        :param kwargs:
        :return:
        """

        request_data = request.data or {}
        # 1. Server 主机查询
        hostname = request_data.get("hostname", "")
        server_obj = ServerModel.objects.filter(hostname=hostname).first()
        if not server_obj:
            return Response("主机不存在")

        # 2. 利用工厂模式，将不同类型的采集信息。分成模块化处理
        asset_data = request_data.get("info", "")
        psi_factory.process_server_info(asset_data, server_obj)

        # 3. 更新主机的采集时间
        server_obj.last_date = datetime.datetime.today()
        server_obj.save()
        return Response("ip:{},资产采集完毕！".format(hostname))

利用集合的方式对数据实现`增删改`

新增：新提交 - db已有的
删除： db已有的 - 新提交的

修改： db已有的 & 新提交的

# 磁盘为例：
# -*-coding:utf-8-*-
from api.models import DiskModel, ServerAssetChangeRecordModel
from api.plugins.base_data_analysis import BaseDataAnalysis


class DiskDataAnalysis(BaseDataAnalysis):
    def process(self, data, server_obj):
        """
            ### 利用 集合的特性：交集（更新），差集（新增，删除）。并集
            # 1. 数据新增
            # 2. 数据更新
            # 3. 数据删除
            # 4. 数据变更记录
        :param data:
        :param server_obj:
        :return:
        """
        if not data['status']:
            return

        record_msg_list = []
        disk_info = data.get("data", {})
        disk_query_set = DiskModel.objects.filter(server=server_obj)
        db_disk_query_dict = {disk_obj.slot: disk_obj for disk_obj in disk_query_set}  # db中的：{"槽位"：obj...}

        # 集合
        new_disk_slot_set = disk_info.keys()
        old_disk_slot_set = db_disk_query_dict.keys()

        # 1. 新增
        add_set = new_disk_slot_set - old_disk_slot_set
        batch_add_lst = []
        for slot_index, new_value in disk_info.items():
            if slot_index in add_set:
                batch_add_lst.append(DiskModel(**new_value, server=server_obj))
        if add_set:
            DiskModel.objects.bulk_create(batch_add_lst, batch_size=10)
            msg = "【新增硬盘】在 {} 槽位增加了硬盘".format(",".join(add_set))
            record_msg_list.append(msg)

        # 2. 删除
        delete_set = old_disk_slot_set - new_disk_slot_set
        if delete_set:
            DiskModel.objects.filter(slot__in=delete_set).delete()
            msg = "【删除硬盘】在 {} 槽位删除了硬盘".format(",".join(delete_set))
            record_msg_list.append(msg)

        # 3. 更新
        update_set = old_disk_slot_set & new_disk_slot_set
        for update_slot_index in update_set:
          	
            update_msg_lst = []
            new_disk_dict = disk_info[update_slot_index]
            old_disk_object = db_disk_query_dict[update_slot_index]
            for update_new_key, update_new_val in new_disk_dict.items():
                # 根据字段获取数据表中起的verbose_name
                verbose_name = DiskModel._meta.get_field(key).verbose_name
                # 利用反射知识。修改ORM
                if update_new_val != getattr(old_disk_object, update_new_key):
                    msg = "{}由{}变更为{}".format(verbose_name, getattr(old_disk_object, update_new_key), update_new_val)
                    update_msg_lst.append(msg)
                    setattr(old_disk_object, update_new_key, update_new_val)
            if update_msg_lst:
                msg = "【更新硬盘】槽位[{}] : {} ".format(update_slot_index, ",".join(update_msg_lst))
                record_msg_list.append(msg)
                old_disk_object.save()

        # 4. 日志
        if record_msg_list:
            ServerAssetChangeRecordModel.objects.create(server=server_obj, content="\n".join(record_msg_list))

资产变更记录数据表存储的字段改为 db数据表中的verbose_name

# 根据字段获取数据表中起的verbose_name
verbose_name = Server._meta.get_field(key).verbose_name

使用django orm 的Q实现复杂的查询条件

import datetime
import json

from django.db.models import Q
from rest_framework.response import Response
from rest_framework.views import APIView

from api.models import ServerModel, CpuModel, BoardModel, NicModel, DiskModel, MemoryModel
from api.plugins import psi_factory


class ServerAPIView(APIView):

    def get(self, request, *args, **kwargs):
        """
            # 查询 执行资产数据变更的 IP列表
        :param request:
        :param args:
        :param kwargs:
        :return:
        """
        today = datetime.datetime.today()
        ip_lst = ServerModel.objects \
            .filter(status="online") \
            .filter(Q(last_date__isnull=True) | Q(last_date__lt=today)) \
            .values("hostname")
        print("今日未采集IP：", ip_lst)
        ip_lst = ["xxxx", ]
        return Response(ip_lst)

资产采集小结

中控机 汇报给 API 的资产。需要做变更记录的处理
	- 由于资产采集时，利用`工厂模式`实现可扩展插件。在API端也使用相同模式对数据进行一一处理
  - 在拆解资产信息时，利用交集的特性（交集和差集）。实现删除/更新/新增
  - 实现更新操作时，利用ORM+面向对象中的反射。实现对新旧资产数据的比对和记录的修改

插件模式（使用import_module导入子模块）

# 目录结构
- plugins
		- __init__.py # ProcessFactory 工厂对象
		- base_data_analysis.py # 基类
		- board_data_analysis.py # 具体实现自类

	
### __init__.py 实现

# -*-coding:utf-8-*-
import importlib
from AutoServer.settings import CMDB_PLUGIN_DICT


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

    @staticmethod
    def process_server_info(asset_data, server_obj):
        """
            # 处理中控机，采集的资产信息
        :param asset_data:  # 全部资产数据
        :param server_obj:  # 主机外键
        :return:
        """
        for asset_class, path in CMDB_PLUGIN_DICT.items():
            data = asset_data.get(asset_class, {})  # 每一种解析类对应的采集数据
            if not data:  # 没有采集该种类的数据，跳过
                continue
            module_path, class_name = path.rsplit(".", maxsplit=1)
            module = importlib.import_module(module_path)
            cls = getattr(module, class_name)
            print("#" * 40)
            print("资产采集正在解析：", cls.__name__)
            cls_obj = cls(asset_class=asset_class)
            cls_obj.process(data, server_obj)
            print("资产采集解析完毕：", cls.__name__)
            print("#" * 40)


psi_factory = ProcessSeverInfoFactory()

简单后台

新增Server
- Server_add.html
- Server_add_Model_Form

查询 Server列表

# -*-coding:utf-8-*-
from django.shortcuts import render
from api.models import ServerModel


def server_index(request, *args, **kwargs):
    print(request, args, kwargs)
    server_query = ServerModel.objects.all()
    return render(request, "web/server_index.html", {"server_lst": server_query})

图表统计不同部门的使用资产数量。饼图为例，highChars

# -*-coding:utf-8-*-
from django.db.models import Count
from django.http import JsonResponse
from django.shortcuts import render

from api.models import ServerModel
def server_depart_analysis(request, *args, **kwargs):
    result = ServerModel.objects.all().values("depart__title").annotate(ct=Count('depart__title'))
    analysis_data_lst = []
    for each_item in result:
        analysis_data_lst.append({
            "name": each_item.get("depart__title", "未知"),
            "y": each_item.get("ct"),
            "sliced": True,
            "selected": True
        })
    return JsonResponse(analysis_data_lst, safe=False)

前端示例代码

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>123</title>
    <!-- 最新版本的 Bootstrap 核心 CSS 文件 -->
    <link rel="stylesheet" href="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.4.1/css/bootstrap.min.css"
          integrity="sha384-HSMxcRTRxnN+Bdg0JdbxYKrThecOKuH5zCYotlSAcp1+c8xmyTe9GYg1l9a69psu" crossorigin="anonymous">

    <!-- 可选的 Bootstrap 主题文件（一般不用引入） -->
    <link rel="stylesheet" href="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.4.1/css/bootstrap-theme.min.css"
          integrity="sha384-6pzBo3FDv/PJ8r2KRkGHifhEocL+1X2rVCTTkUfGk7/0pbek5mMa1upzvWbrUbOZ" crossorigin="anonymous">
</head>
<body>

<div class="panel panel-default">
    <!-- Default panel contents -->
    <div class="panel-heading">主机列表</div>
    <div class="panel-body">
        <p>主机部门使用图</p>
        <div id="container" style="min-width:400px;height:400px"></div>
    </div>

    <!-- Table -->
    <table class="table">
        <thead>
        <td>ID</td>
        <td>主机名</td>
        <td>状态</td>
        <td>最后更新</td>
        <td>部门</td>
        </thead>
        <tbody>
        {% for server_item in server_lst %}
            <tr>
                <td>{{ server_item.id }}</td>
                <td>{{ server_item.hostname }}</td>
                <td>{{ server_item.get_status_display }}</td>
                <td>{{ server_item.last_date|date:"Y-m-d" }}</td>
                <td>{{ server_item.depart.title }}</td>
            </tr>
        {% endfor %}
        </tbody>
    </table>
</div>
</body>
<script src="http://libs.baidu.com/jquery/2.0.0/jquery.min.js"></script>
<!-- 最新的 Bootstrap 核心 JavaScript 文件 -->
<script src="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.4.1/js/bootstrap.min.js"
        integrity="sha384-aJ21OjlMXNL5UyIl/XNwTMqvzeRMZH2w8c5cRVpzpU8Y5bApTppSuUkhZXN0VxHd"
        crossorigin="anonymous"></script>
<script src="https://code.hcharts.cn/highcharts/highcharts.js"></script>
<script src="https://code.hcharts.cn/highcharts/modules/exporting.js"></script>
<script src="https://code.hcharts.cn/plugins/zh_cn.js"></script>
<script>

    function depart_server_analysis(title, data) {
        // Build the chart
        Highcharts.chart('container', {
            chart: {
                plotBackgroundColor: null,
                plotBorderWidth: null,
                plotShadow: false,
                type: 'pie'
            },
            title: {
                text: title
            },
            tooltip: {
                pointFormat: '{series.name}: <b>{point.percentage:.1f}%</b>'
            },
            plotOptions: {
                pie: {
                    allowPointSelect: true,
                    cursor: 'pointer',
                    dataLabels: {
                        enabled: false
                    },
                    showInLegend: true
                }
            },
            series: [{
                name: 'Brands',
                colorByPoint: true,
                data: data
            }]
        });
    }

    $.ajax({
        url: "http://127.0.0.1:8000/v1/server/server_depart_analysis/",
        method: "GET"
    }).then(res => {
        console.log(res)
        let title = '2024年各个部门使用Server份额'
        depart_server_analysis(title, res)
    })


</script>
</html>

部署项目

部署资产采集项目 AutoClient

# 配置 
	- 数据提交API接口地址修改为AutoSever发布的地址
	- 配置 采集资产模式。采用 saltStack/SSH
	- 采集资产任务。采用定时任务 crontab 系统定时任务，执行时间1点30采集	
		- 30 1 * * * python3 app.py

部署后台资产管理系统 AutoServer

- mysql 5.6
- django3.x
- uwsgi 
- nginx 部署

linux 远程执行命令方式

ssh

# 基于ssh公私密钥
# 1. 生成公私密钥
		ssh-keygen -t rsa  # 四个回车

  # 2. ssh-copy-id -i 拷贝公钥到远程服务器
    ssh-copy-id -i ~/.ssh/id_rsa.pub root@xxx.xxx.xxx.xxx # 自动创建authorized_keys到远程目录
  
# 3. 修改资产采集项目配置。 采用ssh方式执行 linux 资产采集命令
  setting.py 中的 : MODE = "SSH"

# 4. python2/3使用 paramiko 创建ssh执行对象
  import paramiko

  private_key = paramiko.RSAKey.from_private_key_file('/home/auto/.ssh/id_rsa')

  # 创建SSH对象
  ssh = paramiko.SSHClient()
  # 允许连接不在know_hosts文件中的主机
  ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  # 连接服务器
  ssh.connect(hostname='xxx.xxx.xxx.xxx', port=22, username='root', key=private_key)

  # 执行命令
  stdin, stdout, stderr = ssh.exec_command('df')
  # 获取命令结果
  result = stdout.read()

  # 关闭连接
  ssh.close()

SaltStack

# 基于 saltstack 工具
# 1. master 端 安装 salt 
  1. 安装salt-master
      yum install salt-master
  2. 修改配置文件：/etc/salt/master
      interface: 0.0.0.0    # 表示Master的IP 
  3. 启动
      service salt-master start

# 2. 远程服务器 安装 salt-minion
	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
    
# 3. 授权。即：远程服务器被master授权
    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
    
# 4. 修改资产采集项目配置。采用SALT模式进行资产采集
  setting.py 中的 : MODE = "SALT"
  
# 5. python2 不支持python3 需要具体情况具体分析
	linux ：
  	指令： salt 'c2.salt.com' cmd.run  'ifconfig'
	python2：
  	import salt.client
    local = salt.client.LocalClient()
    result = local.cmd('c2.salt.com', 'cmd.run', ['ifconfig'])

posted @ 2024-04-17 00:23 染指未来阅读(94) 评论(0) 编辑收藏举报

刷新页面返回顶部

染指未来