阿里云负载均衡权重管理脚本

Posted 2021-01-05 zhaojiedi1992

阿里云权重管理

背景

我们的公司采用的是阿里云环境，发布体系中需要滚动更新功能，需要编写脚本来完成负载均衡对应主机的权重为0，然后发布代码到这个服务器上， 重启成功后修改回原有权重，然后一个一个处理完毕集群的所有主机。

阿里云负载均衡简介

负载均衡的几个常见概念。

名词	说明
负载均衡服务 (Server Load Balancer)	阿里云计算提供的一种网络负载均衡服务，结合阿里云提供的ECS服务，提供四层和七层负载均衡服务。
负载均衡实例(Server Load Balancer Instances)	负载均衡实例是一个运行的负载均衡服务。要使用负载均衡服务，必须先创建一个负载均衡实例。
服务地址 (SLB IP address)	系统为创建的负载均衡实例分配的服务IP地址。根据创建的负载均衡实例的类型，服务地址可能是公网IP也可能是私网IP。您可以将域名解析到公网IP地址提供对外服务。
监听 (Listeners)	负载均衡服务监听规定了如何将请求转发给后端服务器。一个负载均衡实例至少添加一个监听。
后端服务器 (Backend Servers)	处理负载均衡分发的前端请求的ECS实例。
虚拟服务器组 (Backend Servers Groups)	一组处理负载均衡分发的前端请求的ECS实例。不同的监听可以关联不同的虚拟服务器组，实现监听维度的请求转发。

阿里云提供2种服务器组， 一个是默认服务器组，一个是虚拟服务器组， 如果一个负载均衡上面只挂一个域名的多个主机，建议直接将后端的服务器加入到默认服务器组即可，

如果你的负载均衡挂多个域名的话， 建议以域名为虚拟服务器的名字，创建多个虚拟服务器组，每个组下面挂载对应的后端服务器。

我们的线上环境建议采用一个域名一个负载均衡， 测试环境可以考虑一个负载下弄多个域名，省点钱，我们简单算下使用多负载均衡和一个负载负载多域名方案价格差异。

阿里云官方的负载均衡配置价格不贵，配置费用为0.02元每小时。公网流量费用0.48元/GB，对于2种方案来说流量都是一样的。采用多负载均衡会多出多个配置费用， 1个负载均衡的配置费用1年下来大概为0.02*24*365≈175元。可以根据自身公司情况选择一种方案。

管理脚本

使用这个脚本，需要安装python3环境，并安装如下包

pip install aliyun-python-sdk-core-v3
pip install aliyun-python-sdk-ecs
pip install aliyun-python-sdk-slb

slb_manager.py内容如下：

# !/usr/bin/env python
# -*-coding:utf-8 -*-

from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.request import CommonRequest

import json
import os
import sys

from enum import Enum


def byte_to_json(response):
    response_str = str(response, encoding=‘utf-8‘)
    response_json = json.loads(response_str)
    return response_json


class SlbManagerInfo():
    def __init__(self, exit_code=0, exit_message=""):
        self.exit_code = exit_code
        self.exit_message = exit_message
        self.extra_message = {}

    def __str__(self):
        return str(self.__dict__)


class SlbManager():
    """
        阿里云负载均衡管理，支持对默认的组和虚拟服务器组的管理
    """

    def __init__(self, slb_config_file, region_id="cn-beijing"):
        """
        初始化client,slb_config_file内容为以下格式
        {
            "slb_ak":"xxxxxxxxxxxxxx",
            "slb_sk":"xxxxxxxxxxxxxxxxxxxxxxxxxxxx"
        }
        """
        self.slb_config_file = slb_config_file
        self.region_id = region_id

        self.slb_manager_info = SlbManagerInfo()

        self.ak, self.sk = self.get_aksk_from_config_file()
        self.client = AcsClient(self.ak, self.sk, self.region_id)
    def pre_check(self):
        if isinstance(self.weight,int):
            if (self.weight >100 or self.weight <0):
                self.slb_manager_info.exit_code = 1
                self.slb_manager_info.exit_message = "权重设置不符合要求（0=100）" + "你的设置为" +str(self.weight)
        else:
            self.slb_manager_info.exit_code = 2
            self.slb_manager_info.exit_message = "权重不是int的，请检查"
    def set_comm_request(self, request, product_type="slb"):
        request.set_accept_format(‘json‘)
        request.set_method(‘POST‘)
        request.set_domain(product_type + ‘.aliyuncs.com‘)

    def get_aksk_from_config_file(self):
        if not (os.path.exists(self.slb_config_file)):
            self.slb_manager_info.exit_code = 1
            self.slb_manager_info.exit_message = self.slb_config_file + "文件找不到"
        try:
            with open(self.slb_config_file, ‘r‘) as f:
                slb_config = json.load(f)
        except IOError as e:
            self.slb_manager_info.exit_code = 2
            self.slb_manager_info.exit_message = "文件读取失败" + str(e)
        return slb_config["slb_ak"], slb_config["slb_sk"]

    def get_slb_id(self):
        request = CommonRequest()
        self.set_comm_request(request)
        request.set_version(‘2014-05-15‘)
        request.set_action_name(‘DescribeLoadBalancers‘)
        request.add_query_param(‘LoadBalancerName‘, self.slb_name)
        response = self.client.do_action_with_exception(request)
        response_json = byte_to_json(response)
        if response_json["TotalCount"] != 1 :
            self.slb_manager_info.exit_code = 3
            self.slb_manager_info.exit_message ="根据负载均衡名字获取到的总个数不为1 ，请确认负载的名字，真实获取的个数为" +str(response_json["TotalCount"] )
        else:
            self.slb_id = response_json["LoadBalancers"]["LoadBalancer"][0]["LoadBalancerId"]
        a=1
    def get_ecs_id(self):
        request = CommonRequest()
        self.set_comm_request(request, product_type=‘ecs‘)
        request.set_version(‘2014-05-26‘)
        request.set_action_name(‘DescribeInstances‘)
        request.add_query_param(‘InstanceName‘, self.ecs_name)
        response = self.client.do_action_with_exception(request)
        response_json = byte_to_json(response)
        if response_json["TotalCount"] != 1 :
            self.slb_manager_info.exit_code = 4
            self.slb_manager_info.exit_message = "获取不到ecsid,请检查ecs_name"
        else:
            self.ecs_id = response_json["Instances"]["Instance"][0]["InstanceId"]

    def set_weight_for_ecs(self):
        for backend_server in self.backend_servers:
            backend_server["ServerId"] = backend_server["VmName"]
            if backend_server["VmName"] == self.ecs_id:
                # 保留下设置前的权重
                self.slb_manager_info.extra_message["old_weight"] = backend_server["Weight"]
                backend_server["Weight"] = self.weight

    def set_weight_for_default_group_backend_servers(self):
        request = CommonRequest()
        self.set_comm_request(request)
        request.set_version(‘2014-05-15‘)
        request.set_action_name(‘SetBackendServers‘)
        request.add_query_param(‘LoadBalancerId‘, self.slb_id)
        request.add_query_param(‘BackendServers‘, self.backend_servers)
        response = self.client.do_action_with_exception(request)
        response_json = byte_to_json(response)
        # 这个貌似没法对结果进行判定。

    def set_weight_for_virtual_group_backend_servers(self):
        request = CommonRequest()
        self.set_comm_request(request)
        request.set_version(‘2014-05-15‘)
        request.set_action_name(‘SetVServerGroupAttribute‘)
        request.add_query_param(‘LoadBalancerId‘, self.slb_id)
        request.add_query_param(‘VServerGroupId‘, self.virtual_group_id)
        # request.add_query_param(‘VServerGroupName‘, ‘test2‘)
        request.add_query_param(‘BackendServers‘, self.backend_servers)
        response = self.client.do_action_with_exception(request)
        response_json = byte_to_json(response)
        # 这个貌似没法对结果进行判定。

    def get_slb_info(self):
        request = CommonRequest()
        self.set_comm_request(request)
        request.set_version(‘2014-05-15‘)
        request.set_action_name(‘DescribeLoadBalancersRelatedEcs‘)
        request.add_query_param(‘LoadBalancerId‘, self.slb_id)
        response = self.client.do_action_with_exception(request)
        response_json = byte_to_json(response)
        if not response_json["Success"]:
            self.slb_manager_info.exit_code = 4
            self.slb_manager_info.exit_message = response_json["Message"]
        else:
            self.slb_info = response_json["LoadBalancers"]["LoadBalancer"][0]

        if self.is_default_group:
            self.backend_servers = self.slb_info["BackendServers"]["BackendServer"]
        else:
            self.virtual_server_group= None
            for virtual_group in self.slb_info["VServerGroups"]["VServerGroup"]:
                if virtual_group["GroupName"] == self.group_name:
                    self.virtual_server_group = virtual_group
                    break
            if self.virtual_server_group is None:
                self.slb_manager_info.exit_code = 6
                self.slb_manager_info.exit_message = "你输入的虚拟服务器组，不在特定的负载均衡下，请检查"
            else:
                self.virtual_group_id = self.virtual_server_group["GroupId"]
                self.backend_servers = self.virtual_server_group["BackendServers"]["BackendServer"]

        # self.backend_servers =  response_json["LoadBalancers"]["LoadBalancer"][0]["VServerGroups"]["VServerGroup"][0]["BackendServers"]["BackendServer"]

    def set_weight_for_default_group(self, slb_name, ecs_name, weight):
        # set
        self.slb_name = slb_name
        self.ecs_name = ecs_name
        self.weight = weight
        self.is_default_group = True
        if self.slb_manager_info.exit_code == 0:
            self.pre_check()
        if self.slb_manager_info.exit_code == 0:
            self.get_slb_id()
        if self.slb_manager_info.exit_code == 0:
            self.get_ecs_id()

        if self.slb_manager_info.exit_code == 0:
            self.get_slb_info()

        if self.slb_manager_info.exit_code == 0:
            self.set_weight_for_ecs()

        if self.slb_manager_info.exit_code == 0:
            self.set_weight_for_default_group_backend_servers()
        print(self.slb_manager_info)
        return self.slb_manager_info.exit_code

    def set_weight_for_virtual_group(self, slb_name, group_name, ecs_name, weight):
        # set
        self.slb_name = slb_name
        self.ecs_name = ecs_name
        self.group_name = group_name
        self.weight = weight
        self.is_default_group = False
        if self.slb_manager_info.exit_code == 0:
            self.pre_check()
        if self.slb_manager_info.exit_code == 0:
            self.get_slb_id()
        if self.slb_manager_info.exit_code == 0:
            self.get_ecs_id()
        if self.slb_manager_info.exit_code == 0:
            self.get_slb_info()
        if self.slb_manager_info.exit_code == 0:
            self.set_weight_for_ecs()
        if self.slb_manager_info.exit_code == 0:
            self.set_weight_for_virtual_group_backend_servers()
        print(self.slb_manager_info)
        return self.slb_manager_info.exit_code


def main():

    """
    python3 slb_manager.py <you_slb_name> <you_group_name> <you_ecs_name> <you_ecs_weight>
    """
    print(sys.argv)
    slb_name = sys.argv[1]
    group_name = sys.argv[2]
    ecs_name = sys.argv[3]
    weight = int(sys.argv[4])
    slb_config_file = r‘c:\slbconfig‘
    region_id = ‘cn-beijing‘
    manager = SlbManager(slb_config_file=slb_config_file, region_id=region_id)
    ret =0
    if group_name == "default":
        ret =manager.set_weight_for_default_group(slb_name, ecs_name, weight)
    else:
        ret =manager.set_weight_for_virtual_group(slb_name, group_name, ecs_name, weight)
    sys.exit(ret)

if __name__ == "__main__":
    main()
    # manager = SlbManager(slb_config_file=r‘c:\slbconfig‘,region_id=‘cn-beijing‘)
    # manager.set_weight_for_default_group(‘lb_tmp‘,‘aliyun_test03‘,10)
    # manager.set_weight_for_virtual_group(‘lb_tmp‘,‘test2‘,‘aliyun_test02‘,0)

注意事项

1. 脚本是支持默认服务器组和虚拟服务器的， 如果接受的第三个参数为default，表示设置的默认后端服务器的权重， 如果为其他的，表示设置虚拟服务器组，且组名为你传递过来的值，所有使用此脚本你的虚拟服务器组不能设置叫default的组名。
2. 可以根据退出码来判定设置结果情况。
3. 输出的结果信息里面有修改前的权重值，可以使用bash命令来提取这个脚本的输出来获取。
4. 你提供的ecs名字在ecs在你所有的ec的名字中是唯一的
5. 你提供的slb名字在你自己的slb的所有名字中是唯一的。

脚本使用

第一步： ram创建一个账号， 并授予该账号的slb所有权限，ecs所有权限，并为该用户生成ak,sk。

第二步： 创建一个文件写入ak,sk信息。

内容如下

{
      "slb_ak":"xxxxxxxxxxxxxx",
      "slb_sk":"xxxxxxxxxxxxxxxxxxxxxxxxxxxx"
}

第三步： 

修改脚本的 slb_config_file的路径为你的aksk文件路径，修改region-id默认值。

第四步： 创建一个按量付费的负载均衡测试下。

使用样例

C:UsersAdministratorAnaconda3python.exe E:/haoweilai/Devops/scripts/slb_manager.py lb_tmp3 test23 aliyun_test02 13
[‘E:/haoweilai/Devops/scripts/slb_manager.py‘, ‘lb_tmp3‘, ‘test23‘, ‘aliyun_test02‘, ‘13‘]
{‘exit_code‘: 3, ‘exit_message‘: ‘根据负载均衡名字获取到的总个数不为1 ，请确认负载的名字，真实获取的个数为0‘, ‘extra_message‘: {}}

C:UsersAdministratorAnaconda3python.exe E:/haoweilai/Devops/scripts/slb_manager.py lb_tmp test23 aliyun_test02 14
[‘E:/haoweilai/Devops/scripts/slb_manager.py‘, ‘lb_tmp‘, ‘test23‘, ‘aliyun_test02‘, ‘14‘]
{‘exit_code‘: 0, ‘exit_message‘: ‘‘, ‘extra_message‘: {‘old_weight‘: 100}}

C:UsersAdministratorAnaconda3python.exe E:/haoweilai/Devops/scripts/slb_manager.py lb_tmp default aliyun_test02 50
[‘E:/haoweilai/Devops/scripts/slb_manager.py‘, ‘lb_tmp‘, ‘default‘, ‘aliyun_test02‘, ‘50‘]
{‘exit_code‘: 0, ‘exit_message‘: ‘‘, ‘extra_message‘: {‘old_weight‘: 100}}

参考

阿里云官方在线调试：  https://api.aliyun.com/

阿里云python sdk地址： https://developer.aliyun.com/tools/sdk?#/python

负载均衡产品api参考： https://help.aliyun.com/document_detail/27566.html?spm=a2c4g.11186623.6.703.5a986327GsPz8E