server-deploy/utils.py

import logging
import json
import sys
import time
import requests

from aliyunsdkcore.client import AcsClient
from aliyunsdkecs.request.v20140526.RunInstancesRequest import RunInstancesRequest
from aliyunsdkecs.request.v20140526.DescribeInstancesRequest import DescribeInstancesRequest
from aliyunsdkecs.request.v20140526.DescribeNetworkInterfacesRequest import DescribeNetworkInterfacesRequest
from aliyunsdkslb.request.v20140515.DescribeLoadBalancerAttributeRequest import DescribeLoadBalancerAttributeRequest
from aliyunsdkecs.request.v20140526.RunCommandRequest import RunCommandRequest
from aliyunsdkcore.request import CommonRequest

logging.basicConfig(level=logging.INFO,
                    format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                    datefmt='%a, %d %b %Y %H:%M:%S')


def send_msg_to_feishu(webhook, key_word, msg_text):
    """发送消息到飞书"""
    headers = {'Content-Type': 'application/json'}
    payload_message = {
        "msg_type": "text",
        "content": {
            "text": '{}: {}'.format(key_word, msg_text)
        }
    }
    response = requests.request('POST', url=webhook, headers=headers, data=json.dumps(payload_message))
    logging.info(response.text)


def connect_client(access_key_id, access_key_secret, region_id):
    """
    初始化账号，连接客户端
    :param access_key_id: access key Id, type-string
    :param access_key_secret: access key secret, type-string
    :param region_id: region_id
    :return: clt
    """
    try:
        clt = AcsClient(ak=access_key_id, secret=access_key_secret, region_id=region_id)
        return clt
    except Exception as e:
        # 失败，记录报错信息，发送通知，停止并退出
        logging.error(e)
        sys.exit()


def build_create_instances_request(image_id, vswitch_id, security_group_id, zone_id, instance_type, instance_name,
                                   disk_size, disk_category, key_pair_name, tags):
    """
    购买服务器参数配置
    :param image_id: 使用的镜像信息 type-string
    :param vswitch_id: 选择的交换机 type-string
    :param security_group_id: 当前vpc类型的安全组 type-string
    :param zone_id: 服务器所在区域 type-string
    :param instance_type: 实例规格 type-string
    :param instance_name: 实例命名 type-string
    :param disk_size: 磁盘大小，单位：G，type-string
    :param disk_category: 磁盘类型 type-string
    :param key_pair_name: 密钥对名称 type-string
    :param tags: 标签 type-list, eg: [{"Key": "ecs", "Value": "rov-server.prod"}, ...]
    :return: request
    """
    request = RunInstancesRequest()
    request.set_ImageId(image_id)
    request.set_VSwitchId(vswitch_id)
    request.set_SecurityGroupId(security_group_id)
    request.set_ZoneId(zone_id)
    request.set_InstanceType(instance_type)
    request.set_InstanceName(instance_name)
    request.set_SystemDiskSize(disk_size)
    request.set_SystemDiskCategory(disk_category)
    request.set_KeyPairName(key_pair_name)
    request.set_Tags(tags)
    return request


def send_request(client, request):
    """
    发送API请求
    :param client: 客户端连接
    :param request: 请求配置
    :return: response
    """
    request.set_accept_format('json')
    try:
        response = client.do_action_with_exception(request)
        response = json.loads(response)
        logging.info(response)
        return response
    except Exception as e:
        # 失败，记录报错信息，发送通知，停止并退出
        logging.error(e)
        sys.exit()


def check_instance_running(client, instance_ids):
    """
    检查服务器运行状态
    :param client: 客户端连接
    :param instance_ids: 实例id列表, type-list
    :return: running_count，Status为Running的实例数
    """
    try:
        request = DescribeInstancesRequest()
        request.set_InstanceIds(json.dumps(instance_ids))
        response = send_request(client=client, request=request)
        if response.get('Code') is None:
            instances_list = response.get('Instances').get('Instance')
            running_count = 0
            running_instances = []
            for instance_detail in instances_list:
                if instance_detail.get('Status') == "Running":
                    running_count += 1
                    running_instances.append(instance_detail.get('InstanceId'))
            return running_count, running_instances
        else:
            # 失败，记录报错信息，发送通知，停止并退出
            logging.error(response)
            sys.exit()
    except Exception as e:
        # 失败，记录报错信息，发送通知，停止并退出
        logging.error(e)
        sys.exit()


def create_multiple_instances(amount,
                              access_key_id, access_key_secret, region_id,
                              image_id, vswitch_id, security_group_id, zone_id, instance_type, instance_name,
                              disk_size, disk_category, key_pair_name, tags):
    """
    创建多个ECS实例
    :param amount: 创建实例数 type-int 取值范围：[1, 100]
    :param access_key_id: access key Id, type-string
    :param access_key_secret: access key secret, type-string
    :param region_id: region_id, type-string
    :param image_id: 使用的镜像信息 type-string
    :param vswitch_id: 选择的交换机 type-string
    :param security_group_id: 当前vpc类型的安全组 type-string
    :param zone_id: 服务器所在区域 type-string
    :param instance_type: 实例规格 type-string
    :param instance_name: 实例命名 type-string
    :param disk_size: 磁盘大小，单位：G，type-string
    :param disk_category: 磁盘类型 type-string
    :param key_pair_name: 密钥对名称 type-string
    :param tags: 标签 type-list, eg: [{"Key": "ecs", "Value": "rov-server.prod"}, ...]
    :return:
    """
    logging.info(f"create instances start, request amount: {amount}.")
    # 1. 连接客户端
    create_instances_clt = connect_client(
        access_key_id=access_key_id, access_key_secret=access_key_secret, region_id=region_id
    )
    # 2. 请求参数配置
    request = build_create_instances_request(
        image_id=image_id, vswitch_id=vswitch_id, security_group_id=security_group_id, zone_id=zone_id,
        instance_type=instance_type, instance_name=instance_name, disk_size=disk_size, disk_category=disk_category,
        key_pair_name=key_pair_name, tags=tags
    )
    request.set_Amount(amount)
    # 3. 发送API请求，购买机器并启动
    response = send_request(client=create_instances_clt, request=request)
    if response.get('Code') is None:
        instance_ids = response.get('InstanceIdSets').get('InstanceIdSet')
        logging.info(f"success amount: {len(instance_ids)}, instance ids: {instance_ids}.")
        # 获取机器运行状态
        running_amount = 0
        while running_amount < amount:
            time.sleep(10)
            running_amount, running_instances = check_instance_running(client=create_instances_clt,
                                                                       instance_ids=instance_ids)
            logging.info(f"running amount: {running_amount}, running instances: {running_instances}.")
        return instance_ids
    else:
        # 失败，记录报错信息，发送通知，停止并退出
        logging.error(response)
        sys.exit()


def run_command(client, instance_ids, command):
    """
    批量执行命令
    :param client: 客户端连接
    :param instance_ids: 实例id列表, type-list
    :param command: 命令 type-string
    :return:
    """
    request = RunCommandRequest()
    request.set_accept_format('json')
    request.set_Type("RunShellScript")
    request.set_CommandContent(command)
    request.set_InstanceIds(instance_ids)
    response = send_request(client=client, request=request)
    logging.info(response)


def get_instances(client, slb_id):
    """
    获取slb下所有服务器信息
    :param client: 客户端连接
    :param slb_id: 负载均衡id type-string
    :return:
    """
    request = DescribeLoadBalancerAttributeRequest()
    request.set_accept_format('json')
    request.set_LoadBalancerId(slb_id)
    response = send_request(client=client, request=request)
    return response


def get_ip_address(client, instance_id):
    """
    获取实例IP地址
    :param client: 客户端连接
    :param instance_id: 实例id, type-string
    :return: ip_address, type-string
    """
    request = DescribeNetworkInterfacesRequest()
    request.set_accept_format('json')
    request.set_InstanceId(instance_id)
    response = send_request(client=client, request=request)
    ip_address = response['NetworkInterfaceSets']['NetworkInterfaceSet'][0]['PrivateIpAddress']
    return ip_address


def set_weight_for_instances(client, slb_id, instance_id_list, weight):
    """
    同时设置多台服务器的slb权重，权重一样
    :param client: 客户端连接
    :param slb_id: slb_id
    :param instance_id_list: 服务器id list
    :param weight: 权重值
    :return: None
    """
    BackendServers = [{"ServerId": instance_id, "Weight": weight} for instance_id in instance_id_list]
    request = CommonRequest()
    request.set_accept_format('json')
    request.set_domain('slb.aliyuncs.com')
    request.set_version('2014-05-15')
    request.set_method('POST')
    request.set_action_name('SetBackendServers')
    request.add_query_param('BackendServers', BackendServers)
    request.add_query_param('LoadBalancerId', slb_id)
    response = send_request(client=client, request=request)
    return response