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

Posted zhaojiedi1992

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了阿里云负载均衡权重管理脚本相关的知识,希望对你有一定的参考价值。

阿里云权重管理

背景

我们的公司采用的是阿里云环境,发布体系中需要滚动更新功能,需要编写脚本来完成负载均衡对应主机的权重为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 = rc:\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

 

 

以上是关于阿里云负载均衡权重管理脚本的主要内容,如果未能解决你的问题,请参考以下文章

阿里云负载均衡SSL证书配置

阿里云创建负载均衡

阿里云 负载均衡 HTTP转HTTPS

阿里云ECS服务器SLB负载均衡实践

阿里slb做为k8s的负载均衡的限制

阿里云容器服务:负载均衡与容器的关系