CMDB和运维自动化

1. IT运维的分类
2. 传统运维痛点
3. 自动化运维平台的特性
4. 资产管理系统（CMDB）
    CMDB包含的功能
    CMDB实现的四种方式

 

IT运维的分类

IT运维，指的是对已经搭建好的网络，软件，硬件进行维护。运维领域也是细分的，有硬件运维和软件运维

    硬件运维主要包括对基础设施的运维，比如机房的设备，主机的硬盘，内存这些物理设备的维护
    软件运维主要包括系统运维和应用运维，系统运维主要包括对OS，数据库，中间件的监控和维护，这些系统介于设备和应用之间，应用运维主要是对线上业务系统的运维

这里讨论的主要是软件运维的自动化，包括系统运维和应用运维的自动化

传统运维痛点

日常工作繁琐

日常运维工作是比较繁琐的，研发同学会经常需要到服务器上查日志，重启应用，或者是说今天上线某个产品，需要部署下环境。这些琐事是传统运维的大部分工作

应用运行环境不统一

在部署某应用后，应用不能访问，就会听到开发人员说，在我的环境运行很好的，怎么部署到测试环境后，就不能用了，因为各类环境的类库不统一
还有一种极端情况，运维人员习惯不同，可能凭自己的习惯来安装部署软件，每种服务器上运行软件的目录不统一

运维及部署效率低下

想想运维人员需要登陆到服务器上执行命令，部署程序，不仅效率很低，并且非常容易出现人为的错误，一旦手工出错，追溯问题将会非常不容易

无用报警信息过多

经常会收到很多报警信息，多数是无用的报警信息，造成运维人员经常屏蔽报警信
另外如果应用的访问速度出了问题，总是需要从系统、网络、应用、数据库等一步步的查找原因

资产管理和应用管理混乱

资产管理，服务管理经常记录在excel、文本文件或者wiki中，不便于管理，老员工因为比较熟，不注重这些文档的维护，只有靠每次有新员工入职时，资产才能够更正一次

自动化运维平台的特性

针对传统运维的痛点，我们可以知道自动化运维需要支持哪些功能

运维自动化最重要的就是标准化一切

• OS的选择统一化，同一个项目使用同样的OS系统部署其所需要的各类软件
• 软件安装标准化，例如JAVA虚拟机，php，nginx，mysql等各类应用需要的软件版本，安装目录，数据存放目录，日志存放目录等
• 应用包目录统一标准化，及应用命名标准化
• 启动脚本统一目录和名字，需要变化的部分通过参数传递
• 配置文件标准化，需要变化的部分通过参数传递
• 日志输出，日志目录，日志名字标准化
• 应用生成的数据要实现统一的目录存放
• 主机/虚拟机命名标准化，虚拟机管理使用标准化模板
• 使用docker比较容易实现软件运行环境的标准化

资产管理系统（CMDB）

CMDB是所有运维工具的数据基础

CMDB包含的功能

1. 用户管理，记录测试，开发，运维人员的用户表
2. 业务线管理，需要记录业务的详情
3. 项目管理，指定此项目用属于哪条业务线，以及项目详情
4. 应用管理，指定此应用的开发人员，属于哪个项目，和代码地址，部署目录，部署集群，依赖的应用，软件等信息
5. 主机管理，包括云主机，物理机，主机属于哪个集群，运行着哪些软件，主机管理员，连接哪些网络设备，云主机的资源池，存储等相关信息
6. 主机变更管理，主机的一些信息变更，例如管理员，所属集群等信息更改，连接的网络变更等
7. 网络设备管理，主要记录网络设备的详细信息，及网络设备连接的上级设备
8. IP管理，IP属于哪个主机，哪个网段, 是否被占用等

CMDB实现的四种方式

Agent实现方式

Agent方式，可以将服务器上面的Agent程序作定时任务，定时将资产信息提交到指定API录入数据库

其本质上就是在各个服务器上执行subprocess.getoutput()命令，然后将每台机器上执行的结果，返回给主机API，然后主机API收到这些数据之后，放入到数据库中，最终通过web界面展现给用户

优点：速度快
缺点：需要为每台服务器部署一个Agent程序

import subprocess

# 使用subprocess模块执行相关的命令，来获取主机信息
res = subprocess.getoutput("ifconfig")
ip = res[10:20]
print(res)

ssh实现方式 （基于Paramiko模块）

中控机通过Paramiko（py模块）登录到各个服务器上，然后执行命令的方式去获取各个服务器上的信息

优点：无Agent 缺点：速度慢

如果在服务器较少的情况下，可应用此方法

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

saltstack方式

此方案本质上和第二种方案大致是差不多的流程，中控机发送命令给服务器执行。服务器将结果放入另一个队列中，中控机获取将服务信息发送到API进而录入数据库。

优点：快，开发成本低

缺点：依赖于第三方工具

salstack的安装和配置

1. 安装和配置

master配置

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

slave配置

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进行远程操作

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

基于API的方式, 只能基于python2使用

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

saltstack参考安装与使用方法:

https://www.cnblogs.com/tiger666/articles/10351693.html

Puppet（ruby语言开发）（了解）

每隔30分钟，通过RPC消息队列将执行的结果返回给用户

目录结构的设计

bin: 启动文件(可执行文件)
conf: 配置文件
lib: 库文件目录
src: 源码目录
log: 日志文件(记住以后不要在代码中写入日志,最好放在/var/log下)
test: 测试文件目录

高内聚低耦合

模块独立性指每个模块只完成系统要求的独立子功能，并且与其他模块的联系最少且接口简单，两个定性的度量标准――内聚性和耦合性。

内聚性又称块内联系。指单个模块的功能强度的度量，即一个模块内部各个元素彼此结合的紧密程度的度量。若一个模块内各元素联系的越紧密，则它的内聚性就越高，就是常说的高内聚。
特点：最充分的利用模块中每一个元素的功能，达到功能实现最大化，内聚性越强越好，用最小的资源干最大的事情！

耦合性也称块间联系。指软件系统结构中各模块间相互联系紧密程度的一种度量。模块之间联系越紧密，其耦合性就越强，模块的独立性则越差。
特点：项目中的各个模块之间的关联要尽可能的小，耦合性（相互间的联系）越低越好，减小“牵一发而动全身”的可能性！

高内聚低耦合是软件设计的一个基本原则，说的是在程序的各个模块中，尽量让每个模块独立，相关的处理尽量在单个模块中完成，就是俗话说的：该干嘛干嘛去！

优点：能提降低各模块的之间的联系，减少“牵一发而动全身”的几率，提高开发效率，降低升级维护成本，也便于进行单元测试，提高软件质量。

 

AES介绍

from Crypto.Cipher import AES

def encrypt(message):
    key = b'dfdsdfsasdfdsdfs'
    cipher = AES.new(key, AES.MODE_CBC, key)
    ba_data = bytearray(message, encoding='utf-8')
    v1 = len(ba_data)
    v2 = v1 % 16
    if v2 == 0:
        v3 = 16
    else:
        v3 = 16 - v2
    for i in range(v3):
        ba_data.append(v3)
    final_data = ba_data.decode('utf-8')
    msg = cipher.encrypt(final_data)  # 要加密的字符串，必须是16个字节或16个字节的倍数
    return msg


# ############################## 解密 ##############################
def decrypt(msg):
    from Crypto.Cipher import AES
    key = b'dfdsdfsasdfdsdfs'
    cipher = AES.new(key, AES.MODE_CBC, key)
    result = cipher.decrypt(
        msg)  # result = b'\xe8\xa6\x81\xe5\x8a\xa0\xe5\xaf\x86\xe5\x8a\xa0\xe5\xaf\x86\xe5\x8a\xa0sdfsd\t\t\t\t\t\t\t\t\t'
    data = result[0:-result[-1]]
    return str(data, encoding='utf-8')


msg = encrypt('你好好爱好爱好sss')
res = decrypt(msg)
print(res)

字符串格式化函数

String.prototype.format = function(args){
        return this.replace(/\{(\w+)\}/g, function(s, i){
            return args[i];
        });
    };

多线程采集

import time
from concurrent.futures import ThreadPoolExecutor

def run(i):
    time.sleep(2)
    print(i)

p = ThreadPoolExecutor(10)

for i in range(100):
    p.submit(run, i)

API验证

# 第一种方案
client_md5_token = request.META.get("HTTP_TOKEN")
server_token = "alsdkfjasdlgkjsdfglkjsdgsdfgjeewrtf"
# if server_token != client_token:
#     return HttpResponse("非法用户")

# 第二种方案，使用hashlib的md5加密
# 第一关，判断客户端是否有token
if not client_md5_token:
    return HttpResponse("非法用户")

server_time = time.time()
client_md5, client_time = client_md5_token.split("|")
client_time = float(client_time)  # 将字符串形式的客户端时间转换为浮点型，后面计算用

# 第二关，判断token是否过期
if server_time - client_time > 20:
    return HttpResponse("超时的token")

server_md5_token = "{}|{}".format(server_token, client_time)
m = hashlib.md5()
m.update(bytes(server_md5_token, encoding="utf-8"))
server_md5 = m.hexdigest()

# 第三关，判断token是否有效
if server_md5 != client_md5:
    return HttpResponse("无效的token")

# 第四关，判断token是否已被使用
if client_md5_token in key_record:
    return HttpResponse("token已经被使用")
else:
    key_record[client_md5_token] = client_time + 10

return HttpResponse(json.dumps(["c1.com", "c2.com", "c3.com"]))

服务端接收到的POST数据

{
    'basic': {'code': 10000, 'data': {'os_platform': 'linux', 'os_version': 'CentOS release 6.6 (Final)\nKernel \r on an \\m', 'hostname': 'c2.com'}},
    'cpu': {'code': 10000, 'data': {'cpu_count': 24, 'cpu_physical_count': 2, 'cpu_model': ' Intel(R) Xeon(R) CPU E5-2620 v2 @ 2.10GHz'}},
    'disk': {
        'code': 10000,
        'data': {
            '0': {'slot': '0', 'pd_type': 'SAS', 'capacity': '279.396', 'model': 'SEAGATE ST300MM0006     LS08S0K2B5NV'},
            '1': {'slot': '1', 'pd_type': 'SAS', 'capacity': '279.396', 'model': 'SEAGATE ST300MM0006     LS08S0K2B5AH'},
            '2': {'slot': '2', 'pd_type': 'SATA', 'capacity': '476.939', 'model': 'S1SZNSAFA01085L     Samsung SSD 850 PRO 512GB               EXM01B6Q'},
            '3': {'slot': '3', 'pd_type': 'SATA', 'capacity': '476.939', 'model': 'S1AXNSAF912433K     Samsung SSD 840 PRO Series              DXM06B0Q'},
            '4': {'slot': '4', 'pd_type': 'SATA', 'capacity': '476.939', 'model': 'S1AXNSAF303909M     Samsung SSD 840 PRO Series              DXM05B0Q'},
            '5': {'slot': '5', 'pd_type': 'SATA', 'capacity': '476.939', 'model': 'S1AXNSAFB00549A     Samsung SSD 840 PRO Series              DXM06B0Q'}
        }
    },
    'memory': {
        'code': 10000, 
        'data': {
            'DIMM #0': {'capacity': 1024, 'slot': 'DIMM #0', 'model': 'DRAM', 'speed': '667 MHz', 'manufacturer': 'Not Specified', 'sn': 'Not Specified'}, 
            'DIMM #1': {'capacity': ' No Module Installed', 'slot': 'DIMM #1', 'model': 'DRAM', 'speed': '667 MHz', 'manufacturer': 'Not Specified', 'sn': 'Not Specified'}, 
            'DIMM #2': {'capacity': ' No Module Installed', 'slot': 'DIMM #2', 'model': 'DRAM', 'speed': '667 MHz', 'manufacturer': 'Not Specified', 'sn': 'Not Specified'}, 
            'DIMM #3': {'capacity': ' No Module Installed', 'slot': 'DIMM #3', 'model': 'DRAM', 'speed': '667 MHz', 'manufacturer': 'Not Specified', 'sn': 'Not Specified'}, 
            'DIMM #4': {'capacity': ' No Module Installed', 'slot': 'DIMM #4', 'model': 'DRAM', 'speed': '667 MHz', 'manufacturer': 'Not Specified', 'sn': 'Not Specified'}, 
            'DIMM #5': {'capacity': ' No Module Installed', 'slot': 'DIMM #5', 'model': 'DRAM', 'speed': '667 MHz', 'manufacturer': 'Not Specified', 'sn': 'Not Specified'}, 
            'DIMM #6': {'capacity': ' No Module Installed', 'slot': 'DIMM #6', 'model': 'DRAM', 'speed': '667 MHz', 'manufacturer': 'Not Specified', 'sn': 'Not Specified'}, 
            'DIMM #7': {'capacity': ' No Module Installed', 'slot': 'DIMM #7', 'model': 'DRAM', 'speed': '667 MHz', 'manufacturer': 'Not Specified', 'sn': 'Not Specified'}
        }
    },
    'nic': {'code': 10000, 'data': {'eth0': {'up': True, 'hwaddr': '00:1c:42:a5:57:7a', 'ipaddrs': '10.211.55.4', 'netmask': '255.255.255.0'}}}
}

数据库操作

def asset(request):
    if request.method == "POST":
        data = request.body
        data_info = json.loads(data)

        # 1 先取主机名，通过主机名来查询这条数据
        host_name = data_info["basic"]["data"]["hostname"]
        server_obj = models.Server.objects.filter(hostname=host_name).first()
        if not server_obj:
            return HttpResponse("资产不存在， 请检查")

        # 2 将新旧数据分别取出(新数据为data_info, 旧数据为数据库查询的), 然后开始清洗数据
        new_disk_code = data_info["disk"]["code"]
        new_disk_data = data_info["disk"]["data"]
        if new_disk_code != 10000:
            models.ErrorLog.objects.create(
                asset_obj=server_obj, title="{}采集出错了".format(host_name), content=new_disk_data
            )

        # 3 将新旧槽位的列表转换成集合，准备进行比对操作
        # 新的槽位列表
        new_disk_slot = set(new_disk_data.keys())
        # 旧的槽位列表
        old_disk_slot = list()
        res = models.Disk.objects.filter(server_obj=server_obj).all()

        for v in res:
            old_disk_slot.append(v.slot)
        old_disk_slot = set(old_disk_slot)
        # 得到的old_disk_slot数据: [DISK(slot=0, xxx), DISK(slot=1, xxx)]

        # 4 开始进行新旧数据集合的比对
        # 4-1 增加
        add_slot = new_disk_slot.difference(old_disk_slot)
        if add_slot:
            log_list = list()
            for slot in add_slot:
                disk_res = new_disk_data[slot]
                tmp = "增加槽位{slot}, 磁盘类型{pd_type}, 磁盘容量{capacity}, 磁盘类型{model}".format(**disk_res)
                disk_res["server_obj"] = server_obj
                models.Disk.objects.create(**disk_res)
                log_list.append(tmp)
            if log_list:
                log_str = ";".join(log_list)
                models.AssetRecord.objects.create(asset_obj=server_obj, content=log_str)

        # 4-2 删除
        del_slot = old_disk_slot.difference(new_disk_slot)
        if del_slot:
            models.Disk.objects.filter(slot__in=del_slot, server_obj=server_obj).delete()
            s = ";".join(del_slot)
            tmp = "删除的槽位是{}".format(s)
            models.AssetRecord.objects.create(asset_obj=server_obj, content=tmp)

        # 4-3 更新
        up_slot = new_disk_slot.intersection(old_disk_slot)
        if up_slot:
            record_list = list()
            for slot in up_slot:
                old_disk_row = models.Disk.objects.filter(slot=slot, server_obj=server_obj).first()
                new_disk_row = new_disk_data[slot]
                for k, new_v in new_disk_row.items():
                    old_v = getattr(old_disk_row, k)
                    if new_v != old_v:
                        setattr(old_disk_row, k, new_v)
                        tmp = "槽位{}, {}由{}变成了{}".format(slot, k, old_v, new_v)
                        record_list.append(tmp)
                old_disk_row.save()

            if record_list:
                s = ";".join(record_list)
                models.AssetRecord.objects.create(asset_obj=server_obj, content=s)

        return HttpResponse("ok")
    else:
        # 第一种方案
        client_md5_token = request.META.get("HTTP_TOKEN")
        server_token = "alsdkfjasdlgkjsdfglkjsdgsdfgjeewrtf"
        # if server_token != client_token:
        #     return HttpResponse("非法用户")

        # 第二种方案，使用hashlib的md5加密
        # 第一关，判断客户端是否有token
        if not client_md5_token:
            return HttpResponse("非法用户")

        server_time = time.time()
        client_md5, client_time = client_md5_token.split("|")
        client_time = float(client_time)  # 将字符串形式的客户端时间转换为浮点型，后面计算用

        # 第二关，判断token是否过期
        if server_time - client_time > 20:
            return HttpResponse("超时的token")

        server_md5_token = "{}|{}".format(server_token, client_time)
        m = hashlib.md5()
        m.update(bytes(server_md5_token, encoding="utf-8"))
        server_md5 = m.hexdigest()

        # 第三关，判断token是否有效
        if server_md5 != client_md5:
            return HttpResponse("无效的token")

        # 第四关，判断token是否已被使用
        if client_md5_token in key_record:
            return HttpResponse("token已经被使用")
        else:
            key_record[client_md5_token] = client_time + 10

        return HttpResponse(json.dumps(["c1.com", "c2.com", "c3.com"]))