xuekailun 4 months ago
parent
commit
7139157af8

+ 0 - 545
alb_utils.py

@@ -1,545 +0,0 @@
-import logging
-import json
-import sys
-import time
-from asyncio import wait_for
-
-import requests
-import asyncio
-import time
-
-from alibabacloud_tea_util.client import Client as UtilClient
-from aliyunsdkcore.client import AcsClient
-from aliyunsdkslb.request.v20140515.AddBackendServersRequest import AddBackendServersRequest
-from aliyunsdkslb.request.v20140515.RemoveBackendServersRequest import RemoveBackendServersRequest
-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 aliyunsdkecs.request.v20140526.SendFileRequest import SendFileRequest
-from aliyunsdkecs.request.v20140526.StopInstancesRequest import StopInstancesRequest
-from aliyunsdkecs.request.v20140526.DeleteInstancesRequest import DeleteInstancesRequest
-from aliyunsdkecs.request.v20140526.DescribeInstanceStatusRequest import DescribeInstanceStatusRequest
-from aliyunsdkcore.request import CommonRequest
-from alibabacloud_alb20200616.client import Client as Alb20200616Client
-from alibabacloud_tea_openapi import models as open_api_models
-from alibabacloud_alb20200616 import models as alb_models
-from alibabacloud_alb20200616 import models as alb_20200616_models
-from alibabacloud_tea_util import models as util_models
-from aliyunsdkalb.request.v20200616.ListServerGroupServersRequest import ListServerGroupServersRequest
-from aliyunsdkcore.acs_exception.exceptions import ClientException, ServerException
-from urllib3.connection import port_by_scheme
-
-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 connect_alb_client(access_key_id, access_key_secret, endpoint):
-    """
-    初始化ALB客户端
-    :param access_key_id: access key Id, type-string
-    :param access_key_secret: access key secret, type-string
-    :return: alb_client
-    """
-    config = open_api_models.Config(
-        access_key_id=access_key_id,
-        access_key_secret=access_key_secret,
-        endpoint=endpoint
-    )
-    alb_client = Alb20200616Client(config)
-    return alb_client
-
-
-
-
-
-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_req(client, request):
-    """
-    发送API请求
-    :param client: 客户端连接
-    :param request: 请求配置
-    :return: response
-    """
-    request.set_accept_format('json')
-    response = client.do_action_with_exception(request)
-    #print(response)
-    response = json.loads(response)
-    print(response)
-        # logging.info(response)
-    print(response.get('Code'))
-    return response
-    #except Exception as e:
-        # 失败,记录报错信息,发送通知,停止并退出
-    #logging.error(e)
-    #sys.exit()
-
-
-def check_instance_running(ecs_client, instance_ids):
-    """
-    检查服务器运行状态
-    :param ecs_client: 客户端连接
-    :param instance_ids: 实例id列表, type-list
-    :return: running_count,Status为Running的实例数
-    """
-    try:
-        request = DescribeInstancesRequest()
-        request.set_InstanceIds(json.dumps(instance_ids))
-        request.set_PageSize(100)
-        response = send_request(ecs_client=ecs_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 get_ip_address(ecs_client, instance_id):
-    """
-    获取实例IP地址
-    :param ecs_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(ecs_client=ecs_client, request=request)
-    ip_address = response['NetworkInterfaceSets']['NetworkInterfaceSet'][0]['PrivateIpAddress']
-    return ip_address
-
-
-
-def create_multiple_instances(amount, ecs_client,
-                              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 ecs_client: 购买机器客户端连接
-    :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(ecs_client=ecs_client, 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(ecs_client=ecs_client, 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 release_instances(ecs_client, instance_ids, force=False):
-    """
-    释放实例
-    :param ecs_client:
-    :param instance_ids: instance_id, type-list
-    :param force: 是否强制释放, True-强制释放, False-正常释放, type-bool
-    :return:
-    """
-    request = DeleteInstancesRequest()
-    request.set_InstanceIds(instance_ids)
-    request.set_Force(force)
-    response = send_request(ecs_client=ecs_client, request=request)
-    return response
-
-
-
-def get_instances_status(ecs_client, instance_ids):
-    """
-    获取实例运行状态
-    :param ecs_client:
-    :param instance_ids: instance_id, type-list
-    :return:
-    """
-    request = DescribeInstanceStatusRequest()
-    request.set_InstanceIds(instance_ids)
-    request.set_PageSize(50)
-    response = send_request(ecs_client=ecs_client, request=request)
-    return response
-
-
-
-def stop_instances(ecs_client, instance_ids, force_stop=False):
-    """
-    停止实例
-    :param ecs_client:
-    :param instance_ids: 实例ID, type-list
-    :param force_stop: 是否强制关机, True-强制关机, False-正常关机, type-bool
-    :return:
-    """
-    request = StopInstancesRequest()
-    request.set_InstanceIds(instance_ids)
-    request.set_ForceStop(force_stop)
-    response = send_request(ecs_client=ecs_client, request=request)
-    return response
-
-
-
-
-def send_request(ecs_client, request):
-    """
-    发送API请求
-    :param ecs_client: 客户端连接
-    :param request: 请求配置
-    :return: response
-    """
-    request.set_accept_format('json')
-    try:
-        response = ecs_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 run_command(ecs_client, instance_ids, command):
-    """
-    批量执行命令
-    :param ecs_client: 客户端连接
-    :param instance_ids: 实例id列表, type-list, 最多能指定50台ECS实例ID
-    :param command: 命令 type-string
-    :return:
-    """
-    for i in range(len(instance_ids) // 50 + 1):
-        instance_id_list = instance_ids[i * 50:(i + 1) * 50]
-        if len(instance_id_list) == 0:
-            return
-        request = RunCommandRequest()
-        request.set_accept_format('json')
-        request.set_Type("RunShellScript")
-        request.set_CommandContent(command)
-        request.set_InstanceIds(instance_id_list)
-        response = send_request(ecs_client=ecs_client, request=request)
-        logging.info(response)
-
-
-def send_file_to_ecs(ecs_client, instance_id_list, target_dir, name, content):
-    """
-    发送文件到ecs;alb应用,区分上方clb
-    :param ecs_client:
-    :param instance_id_list: 最多能指定50台ECS实例ID
-    :param target_dir: 文件存放目录 type-string
-    :param name: 文件名 type-string
-    :param content: 文件内容 type-string
-    :return:
-    """
-    if not instance_id_list:
-        logging.warning("实例ID列表为空,无法发送文件。")
-        return
-
-    for i in range(len(instance_id_list) // 50 + 1):
-        instance_ids = instance_id_list[i * 50:(i + 1) * 50]
-        if len(instance_ids) == 0:
-            logging.info("没有更多的实例ID需要发送文件,退出。")
-            return
-        request = SendFileRequest()
-        request.set_Content(content)
-        request.set_TargetDir(target_dir)
-        request.set_Name(name)
-        request.set_Overwrite(True)
-        request.set_InstanceIds(instance_ids)
-        try:
-            logging.info(f"正在向实例 {instance_ids} 发送文件 '{name}' 到目录 '{target_dir}'")
-            response = send_request(ecs_client=ecs_client, request=request)
-            logging.info(f"成功发送文件到实例 {instance_ids},响应: {response}")
-        except Exception as e:
-            logging.error(f"发送文件到实例 {instance_ids} 失败,错误: {str(e)}")
-
-
-
-def add_servers_to_server_group(alb_client, server_group_id, instance_id, weight, port):
-    """
-    添加服务器到ALB服务器组
-    :param alb_client: ALB客户端连接
-    :param server_group_id: 服务器组ID
-    :param instance_id: 实例ID
-    :param weight: 权重
-    :param port: 后端服务器使用的端口
-    """
-    server = alb_models.AddServersToServerGroupRequestServers(
-        server_id=instance_id,
-        server_type='ecs',
-        weight=weight,
-        port=port
-    )
-    request = alb_models.AddServersToServerGroupRequest(
-        server_group_id=server_group_id,
-        servers=[server]
-    )
-    runtime = util_models.RuntimeOptions()
-    try:
-        alb_client.add_servers_to_server_group_with_options(request, runtime)
-        logging.info(f"Successfully added server {instance_id} to server group {server_group_id} with weight {weight}.")
-    except Exception as e:
-        logging.error(f"Failed to add server {instance_id} to server group {server_group_id}: {str(e)}")
-
-
-
-def remove_servers_from_server_group(alb_client, server_group_id, instance_ids, port):
-    """
-    从ALB服务器组中移除服务器
-    :param alb_client: ALB客户端连接
-    :param server_group_id: 服务器组ID
-    :param instance_ids: 实例ID
-    :param port: 后端服务器使用的端口
-    """
-    for instance_id in instance_ids:
-        server = alb_models.RemoveServersFromServerGroupRequestServers(
-            port=port,
-            server_id=instance_id,
-            server_type='ecs'
-        )
-        request = alb_models.RemoveServersFromServerGroupRequest(
-            server_group_id=server_group_id,
-            servers=[server]
-        )
-        runtime = util_models.RuntimeOptions()
-        try:
-            alb_client.remove_servers_from_server_group_with_options(request, runtime)
-            logging.info(f"Successfully removed server {instance_id} from server group {server_group_id}.")
-        except Exception as e:
-            logging.error(f"Failed to remove server {instance_id} from server group {server_group_id}: {str(e)}")
-
-
-
-
-def list_server_group_servers(alb_client, server_group_id):
-    """
-    列出服务器组中的服务器并返回实例ID列表
-    @param alb_client: ALB客户端
-    @param server_group_id: 服务器组ID
-    @return: 实例ID列表
-    """
-    list_server_group_servers_request = alb_20200616_models.ListServerGroupServersRequest(
-        server_group_id=server_group_id
-    )
-    runtime = util_models.RuntimeOptions()
-
-    try:
-        response = alb_client.list_server_group_servers_with_options(list_server_group_servers_request, runtime)
-        instance_ids = [server.server_id for server in response.body.servers]
-        return instance_ids
-    except Exception as error:
-        print(str(error))
-        UtilClient.assert_as_string(str(error))
-        return []
-
-
-async def list_server_group_servers_async(alb_client, server_group_id):
-    """
-    异步列出指定服务器组中的服务器并返回实例ID列表
-    @param alb_client: ALB客户端
-    @param server_group_id: 服务器组ID
-    @return: 实例ID列表
-    """
-    list_server_group_servers_request = alb_20200616_models.ListServerGroupServersRequest(
-        server_group_id=server_group_id
-    )
-    runtime = util_models.RuntimeOptions()
-
-    try:
-        response = await alb_client.list_server_group_servers_with_options_async(list_server_group_servers_request, runtime)
-        instance_ids = [server.server_id for server in response.body.servers]
-        return instance_ids
-    except Exception as error:
-        print(str(error))
-        UtilClient.assert_as_string(str(error))
-        return []
-
-
-def update_server_group_server_weight(alb_client, server_group_id, instance_id, weight, port):
-    """
-    更指定服务器在服务器组中的权重
-    :param alb_client: ALB客户端
-    :param server_group_id: 服务器组ID
-    :param instance_id: 实例ID
-    :param weight: 权重值
-    :param port: 后端服务器使用的端口
-    """
-    server = alb_20200616_models.UpdateServerGroupServersAttributeRequestServers(
-        server_type='Ecs',
-        server_id=instance_id,
-        weight=weight,
-        port=port
-    )
-    request = alb_20200616_models.UpdateServerGroupServersAttributeRequest(
-        servers=[server],
-        server_group_id=server_group_id
-    )
-    runtime = util_models.RuntimeOptions()
-    try:
-        alb_client.update_server_group_servers_attribute_with_options(request, runtime)
-        print(f"Successfully updated server {instance_id} in group {server_group_id} to weight {weight}.")
-    except Exception as error:
-        print(str(error))
-        UtilClient.assert_as_string(str(error))
-
-def update_server_group_servers_attribute(alb_client, server_group_id_list, instance_id_list, weight_list, port):
-    """
-    更新服务器组中的服务器权重
-    :param alb_client: ALB客户端
-    :param server_group_id_list: 服务器组ID列表
-    :param instance_id_list: 实例ID列表
-    :param weight_list: 权重修改列表 type-list [(weight, sleep_time), ...]
-    :param port: 后端服务器使用的端口
-    """
-    for server_group_id in server_group_id_list:
-        for instance_id in instance_id_list:
-            for weight, sleep_time in weight_list:
-                update_server_group_server_weight(alb_client, server_group_id, instance_id, weight, port)
-                time.sleep(sleep_time)
-
-
-
-
-async def update_server_group_server_weight_async(alb_client, server_group_id, instance_id, weight, port):
-    """
-    异步更新特定服务器在服务器组中的权重
-    :param alb_client: ALB客户端
-    :param server_group_id: 服务器组ID
-    :param instance_id: 实例ID
-    :param weight: 权重值
-    :param port: 后端服务器使用的端口
-    """
-    server = alb_20200616_models.UpdateServerGroupServersAttributeRequestServers(
-        server_type='Ecs',
-        server_id=instance_id,
-        weight=weight,
-        port=port
-    )
-    request = alb_20200616_models.UpdateServerGroupServersAttributeRequest(
-        servers=[server],
-        server_group_id=server_group_id
-    )
-    runtime = util_models.RuntimeOptions()
-    try:
-        await alb_client.update_server_group_servers_attribute_with_options_async(request, runtime)
-        print(f"Successfully updated server {instance_id} in group {server_group_id} to weight {weight} asynchronously.")
-    except Exception as error:
-        print(str(error))
-        UtilClient.assert_as_string(str(error))
-
-async def update_server_group_servers_attribute_async(alb_client, server_group_id_list, instance_ids, weight_list, port):
-    """
-    异步更新服务器组中的服务器属性
-    :param alb_client: ALB客户端
-    :param server_group_id_list: 服务器组ID列表
-    :param instance_ids: 实例ID列表
-    :param weight_list: 权重修改列表 type-list [(weight, sleep_time), ...]
-    """
-    tasks = []
-    for server_group_id in server_group_id_list:
-        for instance_id in instance_ids:
-            for weight, sleep_time in weight_list:
-                tasks.append(update_server_group_server_weight_async(alb_client, server_group_id, instance_id, weight, port))
-                await asyncio.sleep(sleep_time)
-    await asyncio.gather(*tasks)

+ 0 - 0
gateway/__init__.py


+ 9 - 12
gateway/gateway_update.py

@@ -3,14 +3,11 @@
 import docker
 import sys
 import requests
-import json
 import queue
 import threading
 import time
-from aliyunsdkcore import client
-from aliyunsdkecs.request.v20140526.DescribeNetworkInterfacesRequest import DescribeNetworkInterfacesRequest
 import gateway_config
-import alb_utils
+from util import utils
 
 # 从配置文件中获取应用程序名称和容器仓库地址
 apps = gateway_config.apps
@@ -46,7 +43,7 @@ def update(instance_id, port):
     time.sleep(10)  # 等待10秒钟
     global success_count
 
-    ipadd = alb_utils.get_ip_address(ecs_client, instance_id)  # 使用 utils 获取实例的 IP 地址
+    ipadd = utils.get_ip_address(ecs_client, instance_id)  # 使用 utils 获取实例的 IP 地址
     print("服务器信息:" + "%s/%s" % (instance_id, ipadd))
     client = docker.DockerClient(base_url='tcp://%s:2375' % (ipadd), timeout=60)
 
@@ -69,7 +66,7 @@ def update(instance_id, port):
         checkHealth(ipadd)
         print("%s :权重修改中......" % (ipadd))
         weight_list = [(10, 5), (20, 5), (40, 5), (60, 5), (80, 5), (100, 5)]
-        alb_utils.update_server_group_servers_attribute(alb_client,  gateway_config.server_group_id_list, instance_id_list=instance_id, weight_list=weight_list, port=port)
+        utils.update_server_group_servers_attribute(alb_client, gateway_config.server_group_id_list, instance_id_list=instance_id, weight_list=weight_list, port=port)
         success_count += 1
         print("更新进度" + "%s/%s" % (success_count, total))
     except Exception as e:
@@ -80,7 +77,7 @@ def update(instance_id, port):
 def pull_image():
     """从镜像仓库中拉取指定版本的镜像"""
     instanceId = q1.get()
-    ipaddr = alb_utils.get_ip_address(ecs_client, instanceId)
+    ipaddr = utils.get_ip_address(ecs_client, instanceId)
     cd_url = "tcp://{}:2375".format(ipaddr)
     client = docker.DockerClient(base_url=cd_url, timeout=30)
 
@@ -95,12 +92,12 @@ def pull_image():
 
 if __name__ == '__main__':
     # 初始化 ECS 客户端
-    ecs_client = alb_utils.connect_client(access_key_id=gateway_config.ecs_client_params['access_key_id'],
+    ecs_client = utils.connect_client(access_key_id=gateway_config.ecs_client_params['access_key_id'],
                                       access_key_secret=gateway_config.ecs_client_params['access_key_secret'],
                                       region_id=gateway_config.ecs_client_params['region_id'])
 
     # 初始化 ALB 客户端
-    alb_client = alb_utils.connect_alb_client(gateway_config.alb_client_params['access_key_id'],
+    alb_client = utils.connect_alb_client(gateway_config.alb_client_params['access_key_id'],
                                           gateway_config.alb_client_params['access_key_secret'],
                                           endpoint=gateway_config.alb_client_params['endpoint']
                                           )
@@ -112,7 +109,7 @@ if __name__ == '__main__':
     q1 = queue.Queue()
 
     # 获取 ALB 下服务器组的实例 ID
-    res = alb_utils.list_server_group_servers(alb_client=alb_client, server_group_id=gateway_config.server_group_id_list[0])
+    res = utils.list_server_group_servers(alb_client=alb_client, server_group_id=gateway_config.server_group_id_list[0])
     total += len(res)
     InstanceIDs.extend(res)
     print(InstanceIDs)
@@ -133,6 +130,6 @@ if __name__ == '__main__':
     # 更新每个实例
     for instanceID in InstanceIDs:
         for server_group_id in gateway_config.server_group_id_list:
-            alb_utils.update_server_group_server_weight(alb_client, server_group_id, instanceID,
-                                                       weight=0, port=gateway_config.port)  # 设置初始权重为0
+            utils.update_server_group_server_weight(alb_client, server_group_id, instanceID,
+                                                    weight=0, port=gateway_config.port)  # 设置初始权重为0
         update(instanceID, port=gateway_config.port)

+ 0 - 186
gateway_config.py

@@ -1,186 +0,0 @@
-import os
-import logging
-
-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')
-
-# gateway-alb-ecs组-生产环境
-# server_group_id_list = ["sgp-l2k0p33e470vfmj538"]
-
-# alb后端服务器_调试使用组
-server_group_id_list = ["sgp-ec4gopoclruofsfmxu"]
-
-apps = 'piaoquan-gateway'
-repository = 'registry-vpc.cn-hangzhou.aliyuncs.com/stuuudy/{}'
-registry = 'registry-vpc.cn-hangzhou.aliyuncs.com/stuuudy/{}:{}'
-
-# 后端服务器使用的端口
-port = "9000"
-
-# 修改负载均衡权限
-alb_client_params = {
-    'access_key_id': 'LTAI5tASD5yEZLeC8ffmNebY',
-    'access_key_secret': '1PtsFRdp8viJmI78lEhNZR8MezWZBq',
-    'endpoint': 'alb-vpc.cn-hangzhou.aliyuncs.com',
-    'region_id': 'cn-hangzhou'
-}
-# 购买机器权限
-ecs_client_params = {
-    'access_key_id': 'LTAI4GBWbFvvXoXsSVBe1o9f',
-    'access_key_secret': 'kRAikWitb4kDxaAyBqNrmLmllMEDO3',
-    'region_id': 'cn-hangzhou'
-}
-
-docker_config = {
-    'username': 'stuuudys',
-    'password': 'Qingqu@2019',
-    'registry': 'registry-vpc.cn-hangzhou.aliyuncs.com'
-}
-# 机器配置
-instance_config = {
-    # 使用的镜像信息
-    'image_id': 'm-bp12bkuvg20k6ueqmb4v',
-    # 设置实例规格
-    'instance_type': 'ecs.c6.2xlarge',
-    # 选择的交换机
-    'vswitch_id': 'vsw-bp19lpjwtc6j0p0m9mdc2',
-    # 当前VPC类型的安全组
-    'security_group_id': 'sg-bp1irhrkr4vfj272hk4y',
-    # 硬盘的大小,单位:G
-    'disk_size': '200',
-    # 服务器命名
-    'instance_name': 'ESS-vlogapi-[1,2]',
-    # 服务器所在区域
-    'zone_id': 'cn-hangzhou-h',
-    # 磁盘类型:云盘
-    'disk_category': 'cloud_efficiency',
-    # 密钥
-    'key_pair_name': 'stuuudy',
-    # tag
-    'tags': [{"Key": "ecs", "Value": "longvideoapi.prod"}]
-}
-
-# 机器配置_hangzhou_i
-instance_config_i = {
-    # 使用的镜像信息
-    'image_id': 'm-bp12bkuvg20k6ueqmb4v',
-    # 设置实例规格
-    'instance_type': 'ecs.c6.2xlarge',
-    # 选择的交换机
-    'vswitch_id': 'vsw-bp17c002ovyomzwnhhdhj',
-    # 当前VPC类型的安全组
-    'security_group_id': 'sg-bp1irhrkr4vfj272hk4y',
-    # 硬盘的大小,单位:G
-    'disk_size': '200',
-    # 服务器命名
-    'instance_name': 'ESS-vlogapi-[1,2]',
-    # 服务器所在区域
-    'zone_id': 'cn-hangzhou-i',
-    # 磁盘类型:云盘
-    'disk_category': 'cloud_efficiency',
-    # 密钥
-    'key_pair_name': 'stuuudy',
-    # tag
-    'tags': [{"Key": "ecs", "Value": "longvideoapi.prod"}]
-}
-
-# 机器配置_hangzhou_g
-instance_config_g = {
-    # 使用的镜像信息
-    'image_id': 'm-bp12bkuvg20k6ueqmb4v',
-    # 设置实例规格
-    'instance_type': 'ecs.c6.2xlarge',
-    # 选择的交换机
-    'vswitch_id': 'vsw-bp10m69sb9ydfa64jdrn3',
-    # 当前VPC类型的安全组
-    'security_group_id': 'sg-bp1irhrkr4vfj272hk4y',
-    # 硬盘的大小,单位:G
-    'disk_size': '200',
-    # 服务器命名
-    'instance_name': 'ESS-vlogapi-[1,2]',
-    # 服务器所在区域
-    'zone_id': 'cn-hangzhou-g',
-    # 磁盘类型:云盘
-    'disk_category': 'cloud_efficiency',
-    # 密钥
-    'key_pair_name': 'stuuudy',
-    # tag
-    'tags': [{"Key": "ecs", "Value": "longvideoapi.prod"}]
-}
-
-# 机器配置_hangzhou_j
-instance_config_j = {
-    # 使用的镜像信息
-    'image_id': 'm-bp12bkuvg20k6ueqmb4v',
-    # 设置实例规格
-    'instance_type': 'ecs.c6.2xlarge',
-    # 选择的交换机
-    'vswitch_id': 'vsw-bp1ssuwxyrt0p17ceeir0',
-    # 当前VPC类型的安全组
-    'security_group_id': 'sg-bp1irhrkr4vfj272hk4y',
-    # 硬盘的大小,单位:G
-    'disk_size': '200',
-    # 服务器命名
-    'instance_name': 'ESS-vlogapi-[1,2]',
-    # 服务器所在区域
-    'zone_id': 'cn-hangzhou-j',
-    # 磁盘类型:云盘
-    'disk_category': 'cloud_efficiency',
-    # 密钥
-    'key_pair_name': 'stuuudy',
-    # tag
-    'tags': [{"Key": "ecs", "Value": "longvideoapi.prod"}]
-}
-
-# 机器配置_hangzhou_k
-instance_config_k = {
-    # 使用的镜像信息
-    'image_id': 'm-bp12bkuvg20k6ueqmb4v',
-    # 设置实例规格
-    'instance_type': 'ecs.c6.2xlarge',
-    # 选择的交换机
-    'vswitch_id': 'vsw-bp14e4xu6uzte9nyn6nvr',
-    # 当前VPC类型的安全组
-    'security_group_id': 'sg-bp1irhrkr4vfj272hk4y',
-    # 硬盘的大小,单位:G
-    'disk_size': '200',
-    # 服务器命名
-    'instance_name': 'ESS-longvideoapi-alb-[1,2]',
-    # 服务器所在区域
-    'zone_id': 'cn-hangzhou-k',
-    # 磁盘类型:云盘
-    'disk_category': 'cloud_efficiency',
-    # 密钥
-    'key_pair_name': 'stuuudy',
-    # tag
-    'tags': [{"Key": "ecs", "Value": "longvideoapi.prod"}]
-}
-
-# 机器配置_hangzhou_k alb
-instance_config_k_alb = {
-    # 使用的镜像信息
-    'image_id': 'm-bp12bkuvg20k6ueqmb4v',
-    # 设置实例规格
-    'instance_type': 'ecs.c6.2xlarge',
-    # 选择的交换机
-    'vswitch_id': 'vsw-bp14e4xu6uzte9nyn6nvr',
-    # 当前VPC类型的安全组
-    'security_group_id': 'sg-bp1irhrkr4vfj272hk4y',
-    # 硬盘的大小,单位:G
-    'disk_size': '200',
-    # 服务器命名
-    'instance_name': 'ESS-vlogapi-alb-[1,2]',
-    # 服务器所在区域
-    'zone_id': 'cn-hangzhou-k',
-    # 磁盘类型:云盘
-    'disk_category': 'cloud_efficiency',
-    # 密钥
-    'key_pair_name': 'stuuudy',
-    # tag
-    'tags': [{"Key": "ecs", "Value": "longvideoapi.prod"}]
-}
-
-
-
-

+ 0 - 138
gateway_update.py

@@ -1,138 +0,0 @@
-#!/bin/env python
-# coding=utf-8
-import docker
-import sys
-import requests
-import json
-import queue
-import threading
-import time
-from aliyunsdkcore import client
-from aliyunsdkecs.request.v20140526.DescribeNetworkInterfacesRequest import DescribeNetworkInterfacesRequest
-import gateway_config
-import utils
-
-# 从配置文件中获取应用程序名称和容器仓库地址
-apps = gateway_config.apps
-repository = gateway_config.repository
-registry = gateway_config.registry
-version = sys.argv[1]  # 从命令行参数获取版本号
-
-
-class MyThread(threading.Thread):
-    def __init__(self, func):
-        threading.Thread.__init__(self)
-        self.func = func
-
-    def run(self):
-        self.func()
-
-
-def checkHealth(ipadd):
-
-    while True:
-        health_url = 'http://%s:9000/healthcheck' % (ipadd)
-        header = {"Content-Type": "application/json"}
-        try:
-            health_code = requests.get(health_url).status_code
-        except Exception as e:
-            continue  # 如果请求失败,继续重试
-        if health_code == 200:
-            print("httpcode 200,开始挂载流量")
-            return False  # 健康检查通过,返回
-
-
-def update(instance_id, port):
-    time.sleep(10)  # 等待10秒钟
-    global success_count
-
-    ipadd = utils.get_ip_address(ecs_client, instance_id)  # 使用 utils 获取实例的 IP 地址
-    print("服务器信息:" + "%s/%s" % (instance_id, ipadd))
-    client = docker.DockerClient(base_url='tcp://%s:2375' % (ipadd), timeout=60)
-
-    # 尝试删除旧的容器
-    try:
-        id = client.containers.get(apps)
-        id.remove(force=True)
-    except Exception as e:
-        print("容器不存在或者无法删除当前容器")
-
-    # 尝试登录并启动新的容器
-    try:
-        # 使用 gateway_config 中的 Docker 登录配置
-        docker_config = gateway_config.docker_config
-        client.login(username=docker_config['username'], password=docker_config['password'],
-                     registry=docker_config['registry'])
-        client.containers.run(registry.format(apps, version), detach=True, cap_add='SYS_PTRACE', network_mode='host', name=apps,
-                              volumes={'/datalog/': {'bind': '/datalog/', 'mode': 'rw'}})
-        print("开始健康检查")
-        checkHealth(ipadd)
-        print("%s :权重修改中......" % (ipadd))
-        weight_list = [(10, 5), (20, 5), (40, 5), (60, 5), (80, 5), (100, 5)]
-        utils.update_server_group_servers_attribute(alb_client,  gateway_config.server_group_id_list, instance_id_list=instance_id, weight_list=weight_list, port=port)
-        success_count += 1
-        print("更新进度" + "%s/%s" % (success_count, total))
-    except Exception as e:
-        print(e)
-        sys.exit()
-
-
-def pull_image():
-    """从镜像仓库中拉取指定版本的镜像"""
-    instanceId = q1.get()
-    ipaddr = utils.get_ip_address(ecs_client, instanceId)
-    cd_url = "tcp://{}:2375".format(ipaddr)
-    client = docker.DockerClient(base_url=cd_url, timeout=30)
-
-    try:
-        client.images.pull(repository.format(apps), tag=version)  #
-        print(ipaddr, "pull images success ")
-        return True
-    except Exception as e:
-        print(e, "images pull fail")
-        return False
-
-
-if __name__ == '__main__':
-    # 初始化 ECS 客户端
-    ecs_client = utils.connect_client(access_key_id=gateway_config.ecs_client_params['access_key_id'],
-                                      access_key_secret=gateway_config.ecs_client_params['access_key_secret'],
-                                      region_id=gateway_config.ecs_client_params['region_id'])
-
-    # 初始化 ALB 客户端
-    alb_client = utils.connect_alb_client(gateway_config.alb_client_params['access_key_id'],
-                                          gateway_config.alb_client_params['access_key_secret'],
-                                          endpoint=gateway_config.alb_client_params['endpoint']
-                                          )
-
-    success_count = 0
-    threads = []
-    total = 0
-    InstanceIDs = []
-    q1 = queue.Queue()
-
-    # 获取 ALB 下服务器组的实例 ID
-    res = utils.list_server_group_servers(alb_client=alb_client, server_group_id=gateway_config.server_group_id_list[0])
-    total += len(res)
-    InstanceIDs.extend(res)
-    print(InstanceIDs)
-
-    # 将实例 ID 放入队列中
-    for instance_id in InstanceIDs:
-        q1.put(instance_id)
-
-    # 多线程预先拉取镜像
-    for i in range(len(InstanceIDs)):
-        thread = MyThread(pull_image)
-        thread.start()
-        threads.append(thread)
-
-    for thread in threads:
-        thread.join()
-
-    # 更新每个实例
-    for instanceID in InstanceIDs:
-        for server_group_id in gateway_config.server_group_id_list:
-            utils.update_server_group_server_weight(alb_client, server_group_id, instanceID,
-                                                       weight=0, port=gateway_config.port)  # 设置初始权重为0
-        update(instanceID, port=gateway_config.port)

+ 0 - 3
longvideo_start.sh

@@ -1,3 +0,0 @@
-#!/bin/bash
-docker login --username=admin --password=Harbor12345 registry.piaoquantv.com
-docker run --cap-add=SYS_PTRACE -d -it --name longvideoapi --restart=always --network host registry.piaoquantv.com/piaoquan/longvideoapi:$1

+ 0 - 0
longvideoapi/__init__.py


+ 19 - 22
longvideoapi/longvideoapi_grayscale_update.py

@@ -1,15 +1,12 @@
-import asyncio
 import sys
 import time
 import requests
-import alb_utils
+from util import utils
 import logging
 import os
 import docker
 import longvideoapi_config
 
-from concurrent.futures import ThreadPoolExecutor
-
 health_instances = []
 ess_instances = []
 remove_container_instances = []
@@ -23,7 +20,7 @@ def server_health_check(ecs_client, instance_id):
     :return:
     """
     global health_instances
-    ip_address = alb_utils.get_ip_address(ecs_client=ecs_client, instance_id=instance_id)
+    ip_address = utils.get_ip_address(ecs_client=ecs_client, instance_id=instance_id)
     while True:
         health_check_url = f"http://{ip_address}:8080/longvideoapi/test"
         try:
@@ -48,7 +45,7 @@ def remove_container_image(ecs_client, instance_id, container_name_list):
     :param container_name_list: 容器名称 type-list
     :return:
     """
-    ip_address = alb_utils.get_ip_address(ecs_client=ecs_client, instance_id=instance_id)
+    ip_address = utils.get_ip_address(ecs_client=ecs_client, instance_id=instance_id)
     logging.info(f"服务器信息:{instance_id}/{ip_address}")
     client = docker.DockerClient(base_url=f'tcp://{ip_address}:2375', timeout=60)
 
@@ -106,10 +103,10 @@ def update_instance(ecs_client, alb_client, instance_id, version, port):
     # 1. 摘流量,将权重降为0
     # health_instance_ids = [instance_id]
     weight_list = [(0, 20)]  # 设置权重为0,等待20秒
-    alb_utils.update_server_group_servers_attribute(alb_client,
-                                               longvideoapi_config.server_group_id_list,
-                                               instance_id_list=instance_id,
-                                               weight_list=weight_list,
+    utils.update_server_group_servers_attribute(alb_client,
+                                                longvideoapi_config.server_group_id_list,
+                                                instance_id_list=instance_id,
+                                                weight_list=weight_list,
                                                 port=port)
     logging.info(f"Set weight to 0 for instance: {instance_id}")
 
@@ -125,13 +122,13 @@ def update_instance(ecs_client, alb_client, instance_id, version, port):
         sys.exit()
 
     # 3. 发送启动脚本到机器上
-    alb_utils.send_file_to_ecs(ecs_client=ecs_client, instance_id_list=[instance_id], **longvideoapi_config.start_sh)
+    utils.send_file_to_ecs(ecs_client=ecs_client, instance_id_list=[instance_id], **longvideoapi_config.start_sh)
     logging.info(f"send start shell file finished, instance: {instance_id}")
 
     # 4. 启动服务
     server_start_sh = os.path.join(longvideoapi_config.start_sh['target_dir'], longvideoapi_config.start_sh['name'])
     server_start_command = f"sh {server_start_sh} {version}"
-    alb_utils.run_command(ecs_client=ecs_client, instance_ids=[instance_id], command=server_start_command)
+    utils.run_command(ecs_client=ecs_client, instance_ids=[instance_id], command=server_start_command)
 
     # 5. 探活
     global health_instances
@@ -147,10 +144,10 @@ def update_instance(ecs_client, alb_client, instance_id, version, port):
     time.sleep(20)
 
     add_weight_list = [(10, 5), (20, 5), (40, 5), (60, 5), (80, 5), (100, 5)]
-    alb_utils.update_server_group_servers_attribute(alb_client,
-                                               longvideoapi_config.server_group_id_list,
-                                               instance_id_list=health_instances,
-                                               weight_list=add_weight_list,
+    utils.update_server_group_servers_attribute(alb_client,
+                                                longvideoapi_config.server_group_id_list,
+                                                instance_id_list=health_instances,
+                                                weight_list=add_weight_list,
                                                 port=port)
     logging.info(f"finished instances: {health_instances}, count: {len(health_instances)}")
 
@@ -158,20 +155,20 @@ def update_instance(ecs_client, alb_client, instance_id, version, port):
 def main():
     try:
         version = sys.argv[1]
-        alb_client = alb_utils.connect_alb_client(
+        alb_client = utils.connect_alb_client(
             access_key_id=longvideoapi_config.alb_client_params['access_key_id'],
             access_key_secret=longvideoapi_config.alb_client_params['access_key_secret'],
             endpoint=longvideoapi_config.alb_client_params['endpoint']
         )
 
-        ecs_client = alb_utils.connect_client(access_key_id=longvideoapi_config.ecs_client_params['access_key_id'],
-                                             access_key_secret=longvideoapi_config.ecs_client_params[
+        ecs_client = utils.connect_client(access_key_id=longvideoapi_config.ecs_client_params['access_key_id'],
+                                          access_key_secret=longvideoapi_config.ecs_client_params[
                                                  'access_key_secret'],
-                                             region_id=longvideoapi_config.ecs_client_params['region_id'])
+                                          region_id=longvideoapi_config.ecs_client_params['region_id'])
 
         # 1. 获取ALB下所有机器
-        online_instance_ids = alb_utils.list_server_group_servers(alb_client=alb_client,
-                                                     server_group_id=longvideoapi_config.server_group_id_list[0])
+        online_instance_ids = utils.list_server_group_servers(alb_client=alb_client,
+                                                              server_group_id=longvideoapi_config.server_group_id_list[0])
         online_instance_count = len(online_instance_ids)
         logging.info(f"online instance count: {online_instance_count}.")
         logging.info(f"online instance ids: {online_instance_ids}")

+ 13 - 13
longvideoapi/longvideoapi_reduce_with_count.py

@@ -1,6 +1,6 @@
 import sys
 import time
-import alb_utils
+from util import utils
 import longvideoapi_config
 import logging
 
@@ -21,11 +21,11 @@ def remove_instances(ecs_client, alb_client, instance_ids, port):
     # 1. 摘除流量
     weight_list = [(0, 20)]  # 设置权重为0,等待20秒
     try:
-        alb_utils.update_server_group_servers_attribute(alb_client,
-                                                   longvideoapi_config.server_group_id_list,
-                                                   instance_id_list=instance_ids,
-                                                   weight_list=weight_list,
-                                                   port=port)
+        utils.update_server_group_servers_attribute(alb_client,
+                                                    longvideoapi_config.server_group_id_list,
+                                                    instance_id_list=instance_ids,
+                                                    weight_list=weight_list,
+                                                    port=port)
     except Exception as e:
         logging.error(f"Failed to set instance weight: {e}")
         sys.exit()
@@ -36,7 +36,7 @@ def remove_instances(ecs_client, alb_client, instance_ids, port):
     # 2. 从 ALB 服务器组中移除实例
     for server_group_id in longvideoapi_config.server_group_id_list:
         try:
-            alb_utils.remove_servers_from_server_group(alb_client=alb_client, server_group_id=server_group_id,
+            utils.remove_servers_from_server_group(alb_client=alb_client, server_group_id=server_group_id,
                                                    instance_ids=instance_ids, port=port)
             logging.info(f"Successfully removed instances from server group {server_group_id}.")
         except Exception as e:
@@ -45,7 +45,7 @@ def remove_instances(ecs_client, alb_client, instance_ids, port):
     logging.info(f"Remove from ALB finished, instances: {instance_ids}")
 
     # 3. 停止机器
-    stop_response = alb_utils.stop_instances(ecs_client=ecs_client, instance_ids=instance_ids)
+    stop_response = utils.stop_instances(ecs_client=ecs_client, instance_ids=instance_ids)
     if stop_response.get('Code') is None:
         logging.info(f"Instances stop finished, instances: {instance_ids}")
     else:
@@ -54,7 +54,7 @@ def remove_instances(ecs_client, alb_client, instance_ids, port):
 
     # 4. 判断机器运行状态是否为 Stopped
     while True:
-        response = alb_utils.get_instances_status(ecs_client=ecs_client, instance_ids=instance_ids)
+        response = utils.get_instances_status(ecs_client=ecs_client, instance_ids=instance_ids)
         if response.get('Code') is None:
             instances_list = response.get('InstanceStatuses').get('InstanceStatus')
             stopped_instances = [instance.get('InstanceId') for instance in instances_list if
@@ -70,7 +70,7 @@ def remove_instances(ecs_client, alb_client, instance_ids, port):
             sys.exit()
 
     # 5. 释放机器
-    release_response = alb_utils.release_instances(ecs_client=ecs_client, instance_ids=stopped_instances)
+    release_response = utils.release_instances(ecs_client=ecs_client, instance_ids=stopped_instances)
     if release_response.get('Code') is None:
         logging.info(f"Release instances finished, instances: {stopped_instances}")
     else:
@@ -80,13 +80,13 @@ def remove_instances(ecs_client, alb_client, instance_ids, port):
 
 def main():
     try:
-        alb_client = alb_utils.connect_alb_client(
+        alb_client = utils.connect_alb_client(
             access_key_id=longvideoapi_config.alb_client_params['access_key_id'],
             access_key_secret=longvideoapi_config.alb_client_params['access_key_secret'],
             endpoint=longvideoapi_config.alb_client_params['endpoint']
         )
 
-        ecs_client = alb_utils.connect_client(
+        ecs_client = utils.connect_client(
             access_key_id=longvideoapi_config.ecs_client_params['access_key_id'],
             access_key_secret=longvideoapi_config.ecs_client_params['access_key_secret'],
             region_id=longvideoapi_config.ecs_client_params['region_id']
@@ -97,7 +97,7 @@ def main():
         logging.info(f"reduce instances count: {reduce_count}")
 
         # 获取 ALB 下所有机器
-        online_instance_ids = alb_utils.list_server_group_servers(alb_client=alb_client, server_group_id=longvideoapi_config.server_group_id_list[0])
+        online_instance_ids = utils.list_server_group_servers(alb_client=alb_client, server_group_id=longvideoapi_config.server_group_id_list[0])
         online_instance_count = len(online_instance_ids)
         logging.info(f"online instance count: {online_instance_count}.")
         logging.info(f"online instance ids: {online_instance_ids}")

+ 16 - 16
longvideoapi/longvideoapi_restart.py

@@ -2,7 +2,7 @@ import logging
 import time
 import docker
 import longvideoapi_config
-import alb_utils
+from util import utils
 from longvideoapi_update_k import server_health_check
 
 logging.basicConfig(level=logging.INFO,
@@ -13,15 +13,15 @@ def server_restart(ecs_client, alb_client, instance_id, image_name, port):
     try:
         logging.info(f"Restarting instance: {instance_id}")
         # 获取ip
-        ip_address = alb_utils.get_ip_address(ecs_client=ecs_client, instance_id=instance_id)
+        ip_address = utils.get_ip_address(ecs_client=ecs_client, instance_id=instance_id)
         logging.info(f"IP address: {instance_id}/{ip_address}")
 
         # 摘流量
-        alb_utils.update_server_group_servers_attribute(alb_client=alb_client,
-                                                   server_group_id_list=longvideoapi_config.server_group_id_list,
-                                                   instance_id_list=instance_id,
-                                                   weight_list=[(0, 20)],
-                                                   port=port)
+        utils.update_server_group_servers_attribute(alb_client=alb_client,
+                                                    server_group_id_list=longvideoapi_config.server_group_id_list,
+                                                    instance_id_list=instance_id,
+                                                    weight_list=[(0, 20)],
+                                                    port=port)
         logging.info(f"Set weight to 0 for instance: {instance_id}")
 
         # 连接 Docker 客户端并重启容器
@@ -37,11 +37,11 @@ def server_restart(ecs_client, alb_client, instance_id, image_name, port):
 
         # 设置权重
         add_weight_list = [(10, 5), (20, 5), (40, 5), (60, 5), (80, 5), (100, 5)]
-        alb_utils.update_server_group_servers_attribute(alb_client,
-                                                   server_group_id_list=longvideoapi_config.server_group_id_list,
-                                                   instance_id_list=instance_id,
-                                                   weight_list=add_weight_list,
-                                                   port=port)
+        utils.update_server_group_servers_attribute(alb_client,
+                                                    server_group_id_list=longvideoapi_config.server_group_id_list,
+                                                    instance_id_list=instance_id,
+                                                    weight_list=add_weight_list,
+                                                    port=port)
         logging.info(f"Server restart finished, instance: {instance_id}/{ip_address}")
     except Exception as e:
         logging.error(f"Server restart failed, instance: {instance_id}")
@@ -50,19 +50,19 @@ def server_restart(ecs_client, alb_client, instance_id, image_name, port):
 
 def main():
     try:
-        ecs_client = alb_utils.connect_client(access_key_id=longvideoapi_config.ecs_client_params['access_key_id'],
+        ecs_client = utils.connect_client(access_key_id=longvideoapi_config.ecs_client_params['access_key_id'],
                                           access_key_secret=longvideoapi_config.ecs_client_params['access_key_secret'],
                                           region_id=longvideoapi_config.ecs_client_params['region_id'])
 
-        alb_client = alb_utils.connect_alb_client(
+        alb_client = utils.connect_alb_client(
             access_key_id=longvideoapi_config.alb_client_params['access_key_id'],
             access_key_secret=longvideoapi_config.alb_client_params['access_key_secret'],
             endpoint=longvideoapi_config.alb_client_params['endpoint']
         )
 
         # 获取 ALB 下所有机器
-        online_instance_ids = alb_utils.list_server_group_servers(alb_client=alb_client,
-                                                     server_group_id=longvideoapi_config.server_group_id_list[0])
+        online_instance_ids = utils.list_server_group_servers(alb_client=alb_client,
+                                                              server_group_id=longvideoapi_config.server_group_id_list[0])
         online_instance_count = len(online_instance_ids)
         logging.info(f"Online instance count: {online_instance_count}.")
         logging.info(f"Online instance ids: {online_instance_ids}")

+ 10 - 13
longvideoapi/longvideoapi_scaling_k_count.py

@@ -5,13 +5,10 @@ import logging
 import time
 import requests
 
-import alb_utils
+from util import utils
 import longvideoapi_config
-
 from concurrent.futures import ThreadPoolExecutor
 
-from longvideoapi.longvideoapi_config import alb_client_params
-
 health_instances = []
 
 
@@ -25,7 +22,7 @@ def longvideoapi_health_check(ecs_client, instance_id, max_wait_time=None):
     """
     global health_instances
     start_time = time.time()
-    ip_address = alb_utils.get_ip_address(ecs_client=ecs_client, instance_id=instance_id)
+    ip_address = utils.get_ip_address(ecs_client=ecs_client, instance_id=instance_id)
     while True:
         health_check_url = f"http://{ip_address}:8080/longvideoapi/test"
         try:
@@ -60,7 +57,7 @@ async def ess_instance(ecs_client, alb_client, ess_count, max_workers, port):
     :return:
     """
     # 1. 购买机器并启动
-    ess_instance_ids = alb_utils.create_multiple_instances(
+    ess_instance_ids = utils.create_multiple_instances(
         amount=ess_count,
         ecs_client=ecs_client,
         **longvideoapi_config.instance_config_k,
@@ -68,13 +65,13 @@ async def ess_instance(ecs_client, alb_client, ess_count, max_workers, port):
     time.sleep(60)
 
     # 2. 发送启动脚本到机器上
-    alb_utils.send_file_to_ecs(ecs_client=ecs_client, instance_id_list=ess_instance_ids, **longvideoapi_config.start_sh)
+    utils.send_file_to_ecs(ecs_client=ecs_client, instance_id_list=ess_instance_ids, **longvideoapi_config.start_sh)
     logging.info(f"send start shell file finished, instances: {ess_instance_ids}")
     # 3. 启动服务
     start_sh_param = "latest"
     server_start_sh = os.path.join(longvideoapi_config.start_sh['target_dir'], longvideoapi_config.start_sh['name'])
     server_start_commend = f"sh {server_start_sh} {start_sh_param}"
-    alb_utils.run_command(ecs_client=ecs_client, instance_ids=ess_instance_ids, command=server_start_commend)
+    utils.run_command(ecs_client=ecs_client, instance_ids=ess_instance_ids, command=server_start_commend)
     # 4. 异步探活
     global health_instances
     health_instances = []
@@ -94,7 +91,7 @@ async def ess_instance(ecs_client, alb_client, ess_count, max_workers, port):
         time.sleep(20)
         for instance_id, ip in health_instances:
             for server_group_id in longvideoapi_config.server_group_id_list:
-                alb_utils.add_servers_to_server_group(alb_client, server_group_id, instance_id, weight=100, port=port)
+                utils.add_servers_to_server_group(alb_client, server_group_id, instance_id, weight=100, port=port)
         logging.info(f"ess count: {ess_count}, "
                      f"create count: {len(ess_instance_ids)}, "
                      f"finished count: {len(health_instances)}")
@@ -108,10 +105,10 @@ async def ess_instance(ecs_client, alb_client, ess_count, max_workers, port):
 
 def main():
     try:
-        ecs_client = alb_utils.connect_client(access_key_id=longvideoapi_config.ecs_client_params['access_key_id'],
-                                             access_key_secret=longvideoapi_config.ecs_client_params['access_key_secret'],
-                                             region_id=longvideoapi_config.ecs_client_params['region_id'])
-        alb_client = alb_utils.connect_alb_client(
+        ecs_client = utils.connect_client(access_key_id=longvideoapi_config.ecs_client_params['access_key_id'],
+                                          access_key_secret=longvideoapi_config.ecs_client_params['access_key_secret'],
+                                          region_id=longvideoapi_config.ecs_client_params['region_id'])
+        alb_client = utils.connect_alb_client(
             access_key_id=longvideoapi_config.alb_client_params['access_key_id'],
             access_key_secret=longvideoapi_config.alb_client_params['access_key_secret'],
             endpoint=longvideoapi_config.alb_client_params['endpoint']

+ 15 - 17
longvideoapi_update_k.py → longvideoapi/longvideoapi_update_k.py

@@ -2,7 +2,7 @@ import asyncio
 import sys
 import time
 import requests
-import utils
+from util import utils
 import logging
 import os
 import docker
@@ -10,8 +10,6 @@ import longvideoapi_config
 
 from concurrent.futures import ThreadPoolExecutor
 
-from gateway.gateway_config import server_group_id_list
-
 health_instances = []
 ess_instances = []
 remove_container_instances = []
@@ -91,10 +89,10 @@ async def ess_instance(ecs_client, alb_client, ess_count, max_workers, version,
 
         add_weight_list = [(10, 5), (20, 5), (40, 5), (60, 5), (80, 5), (100, 5)]
         utils.update_server_group_servers_attribute(alb_client,
-                                                   server_group_id_list=longvideoapi_config.server_group_id_list,
-                                                   instance_id_list=health_instance_ids,
-                                                   weight_list=add_weight_list,
-                                                   port=port)
+                                                    server_group_id_list=longvideoapi_config.server_group_id_list,
+                                                    instance_id_list=health_instance_ids,
+                                                    weight_list=add_weight_list,
+                                                    port=port)
         global ess_instances
         ess_instances.extend(health_instance_ids)
         logging.info(f"ess count: {ess_count}, "
@@ -226,10 +224,10 @@ async def update_instance(ecs_client, alb_client, instance_ids, max_workers, ver
 
             add_weight_list = [(10, 5), (20, 5), (40, 5), (60, 5), (80, 5), (100, 5)]
             utils.update_server_group_servers_attribute(alb_client,
-                                                       server_group_id_list=longvideoapi_config.server_group_id_list,
-                                                       instance_id_list=health_instance_ids,
-                                                       weight_list=add_weight_list,
-                                                       port=port)
+                                                        server_group_id_list=longvideoapi_config.server_group_id_list,
+                                                        instance_id_list=health_instance_ids,
+                                                        weight_list=add_weight_list,
+                                                        port=port)
             logging.info(f"finished instances: {health_instances}, count: {len(health_instances)}")
             update_finished_count += len(health_instances)
             logging.info(f"update finished: {update_finished_count}/{len(instance_ids)}")
@@ -251,10 +249,10 @@ def remove_instances(ecs_client, alb_client, instance_ids, port):
     weight_list = [(0, 20)]  # 设置权重为0,等待20秒
     try:
         utils.update_server_group_servers_attribute(alb_client,
-                                                   server_group_id_list=longvideoapi_config.server_group_id_list,
-                                                   instance_id_list=instance_ids,
-                                                   weight_list=weight_list,
-                                                   port=port)
+                                                    server_group_id_list=longvideoapi_config.server_group_id_list,
+                                                    instance_id_list=instance_ids,
+                                                    weight_list=weight_list,
+                                                    port=port)
     except Exception as e:
         logging.error(f"Failed to set instance weight: {e}")
         sys.exit()
@@ -313,8 +311,8 @@ def main():
             endpoint=longvideoapi_config.alb_client_params['endpoint']
         )
         ecs_client = utils.connect_client(access_key_id=longvideoapi_config.ecs_client_params['access_key_id'],
-                                             access_key_secret=longvideoapi_config.ecs_client_params['access_key_secret'],
-                                             region_id=longvideoapi_config.ecs_client_params['region_id'])
+                                          access_key_secret=longvideoapi_config.ecs_client_params['access_key_secret'],
+                                          region_id=longvideoapi_config.ecs_client_params['region_id'])
 
         # 1. 获取alb下所有机器
         online_instance_ids = utils.list_server_group_servers(alb_client=alb_client, server_group_id=longvideoapi_config.server_group_id_list[0])

+ 0 - 193
longvideoapi_config.py

@@ -1,193 +0,0 @@
-import os
-import logging
-
-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')
-
-slb_id_list = ["lb-bp1qk9mkvjtundlzz7owm", "lb-bp1pj2v06ladvgftgxcp0", "lb-bp1y63rnrb2e64whryghz", "lb-bp17woaq4vz3gnb8ujzvh"]
-
-# longvideoapi-alb-ecs组-生产环境
-# server_group_id_list = ["sgp-h79h3lkvua1xs3418y"]
-
-# alb后端服务器_调试使用组
-server_group_id_list = ["sgp-ec4gopoclruofsfmxu"]
-
-
-
-
-# 后端服务器使用的端口
-port = "8080"
-
-# 修改负载均衡权限
-alb_client_params = {
-    'access_key_id': 'LTAI5tASD5yEZLeC8ffmNebY',
-    'access_key_secret': '1PtsFRdp8viJmI78lEhNZR8MezWZBq',
-    'endpoint': 'alb-vpc.cn-hangzhou.aliyuncs.com',
-    'region_id': 'cn-hangzhou'
-}
-# 购买机器权限
-ecs_client_params = {
-    'access_key_id': 'LTAI4GBWbFvvXoXsSVBe1o9f',
-    'access_key_secret': 'kRAikWitb4kDxaAyBqNrmLmllMEDO3',
-    'region_id': 'cn-hangzhou'
-}
-
-# 机器配置
-instance_config = {
-    # 使用的镜像信息
-    'image_id': 'm-bp12bkuvg20k6ueqmb4v',
-    # 设置实例规格
-    'instance_type': 'ecs.c6.2xlarge',
-    # 选择的交换机
-    'vswitch_id': 'vsw-bp19lpjwtc6j0p0m9mdc2',
-    # 当前VPC类型的安全组
-    'security_group_id': 'sg-bp1irhrkr4vfj272hk4y',
-    # 硬盘的大小,单位:G
-    'disk_size': '200',
-    # 服务器命名
-    'instance_name': 'ESS-vlogapi-[1,2]',
-    # 服务器所在区域
-    'zone_id': 'cn-hangzhou-h',
-    # 磁盘类型:云盘
-    'disk_category': 'cloud_efficiency',
-    # 密钥
-    'key_pair_name': 'stuuudy',
-    # tag
-    'tags': [{"Key": "ecs", "Value": "longvideoapi.prod"}]
-}
-
-# 机器配置_hangzhou_i
-instance_config_i = {
-    # 使用的镜像信息
-    'image_id': 'm-bp12bkuvg20k6ueqmb4v',
-    # 设置实例规格
-    'instance_type': 'ecs.c6.2xlarge',
-    # 选择的交换机
-    'vswitch_id': 'vsw-bp17c002ovyomzwnhhdhj',
-    # 当前VPC类型的安全组
-    'security_group_id': 'sg-bp1irhrkr4vfj272hk4y',
-    # 硬盘的大小,单位:G
-    'disk_size': '200',
-    # 服务器命名
-    'instance_name': 'ESS-vlogapi-[1,2]',
-    # 服务器所在区域
-    'zone_id': 'cn-hangzhou-i',
-    # 磁盘类型:云盘
-    'disk_category': 'cloud_efficiency',
-    # 密钥
-    'key_pair_name': 'stuuudy',
-    # tag
-    'tags': [{"Key": "ecs", "Value": "longvideoapi.prod"}]
-}
-
-# 机器配置_hangzhou_g
-instance_config_g = {
-    # 使用的镜像信息
-    'image_id': 'm-bp12bkuvg20k6ueqmb4v',
-    # 设置实例规格
-    'instance_type': 'ecs.c6.2xlarge',
-    # 选择的交换机
-    'vswitch_id': 'vsw-bp10m69sb9ydfa64jdrn3',
-    # 当前VPC类型的安全组
-    'security_group_id': 'sg-bp1irhrkr4vfj272hk4y',
-    # 硬盘的大小,单位:G
-    'disk_size': '200',
-    # 服务器命名
-    'instance_name': 'ESS-vlogapi-[1,2]',
-    # 服务器所在区域
-    'zone_id': 'cn-hangzhou-g',
-    # 磁盘类型:云盘
-    'disk_category': 'cloud_efficiency',
-    # 密钥
-    'key_pair_name': 'stuuudy',
-    # tag
-    'tags': [{"Key": "ecs", "Value": "longvideoapi.prod"}]
-}
-
-# 机器配置_hangzhou_j
-instance_config_j = {
-    # 使用的镜像信息
-    'image_id': 'm-bp12bkuvg20k6ueqmb4v',
-    # 设置实例规格
-    'instance_type': 'ecs.c6.2xlarge',
-    # 选择的交换机
-    'vswitch_id': 'vsw-bp1ssuwxyrt0p17ceeir0',
-    # 当前VPC类型的安全组
-    'security_group_id': 'sg-bp1irhrkr4vfj272hk4y',
-    # 硬盘的大小,单位:G
-    'disk_size': '200',
-    # 服务器命名
-    'instance_name': 'ESS-vlogapi-[1,2]',
-    # 服务器所在区域
-    'zone_id': 'cn-hangzhou-j',
-    # 磁盘类型:云盘
-    'disk_category': 'cloud_efficiency',
-    # 密钥
-    'key_pair_name': 'stuuudy',
-    # tag
-    'tags': [{"Key": "ecs", "Value": "longvideoapi.prod"}]
-}
-
-# 机器配置_hangzhou_k
-instance_config_k = {
-    # 使用的镜像信息
-    'image_id': 'm-bp12bkuvg20k6ueqmb4v',
-    # 设置实例规格
-    'instance_type': 'ecs.c6.2xlarge',
-    # 选择的交换机
-    'vswitch_id': 'vsw-bp14e4xu6uzte9nyn6nvr',
-    # 当前VPC类型的安全组
-    'security_group_id': 'sg-bp1irhrkr4vfj272hk4y',
-    # 硬盘的大小,单位:G
-    'disk_size': '200',
-    # 服务器命名
-    'instance_name': 'ESS-longvideoapi-alb-[1,2]',
-    # 服务器所在区域
-    'zone_id': 'cn-hangzhou-k',
-    # 磁盘类型:云盘
-    'disk_category': 'cloud_efficiency',
-    # 密钥
-    'key_pair_name': 'stuuudy',
-    # tag
-    'tags': [{"Key": "ecs", "Value": "longvideoapi.prod"}]
-}
-
-# 机器配置_hangzhou_k alb
-instance_config_k_alb = {
-    # 使用的镜像信息
-    'image_id': 'm-bp12bkuvg20k6ueqmb4v',
-    # 设置实例规格
-    'instance_type': 'ecs.c6.2xlarge',
-    # 选择的交换机
-    'vswitch_id': 'vsw-bp14e4xu6uzte9nyn6nvr',
-    # 当前VPC类型的安全组
-    'security_group_id': 'sg-bp1irhrkr4vfj272hk4y',
-    # 硬盘的大小,单位:G
-    'disk_size': '200',
-    # 服务器命名
-    'instance_name': 'ESS-vlogapi-alb-[1,2]',
-    # 服务器所在区域
-    'zone_id': 'cn-hangzhou-k',
-    # 磁盘类型:云盘
-    'disk_category': 'cloud_efficiency',
-    # 密钥
-    'key_pair_name': 'stuuudy',
-    # tag
-    'tags': [{"Key": "ecs", "Value": "longvideoapi.prod"}]
-}
-
-
-
-
-# 服务启动脚本
-start_sh_dir = os.path.dirname(os.path.realpath(__file__))
-start_sh_filename = 'longvideo_start.sh'
-with open(file=os.path.join(start_sh_dir, start_sh_filename), mode='r', encoding='utf-8') as rf:
-    file_content = rf.read()
-    logging.info(f"start sh file content: {file_content}")
-start_sh = {
-    'target_dir': '/home/piaoquan_server_sh',
-    'name': start_sh_filename,
-    'content': file_content,
-}

+ 0 - 191
longvideoapi_grayscale_update.py

@@ -1,191 +0,0 @@
-import asyncio
-import sys
-import time
-import requests
-import utils
-import logging
-import os
-import docker
-import longvideoapi_config
-
-from concurrent.futures import ThreadPoolExecutor
-
-health_instances = []
-ess_instances = []
-remove_container_instances = []
-
-
-def server_health_check(ecs_client, instance_id):
-    """
-    服务健康检查
-    :param ecs_client: 客户端连接
-    :param instance_id: instanceId
-    :return:
-    """
-    global health_instances
-    ip_address = utils.get_ip_address(ecs_client=ecs_client, instance_id=instance_id)
-    while True:
-        health_check_url = f"http://{ip_address}:8080/longvideoapi/test"
-        try:
-            http_code = requests.get(health_check_url).status_code
-        except:
-            logging.info(f"images is downloading ip:{ip_address}")
-            http_code = 0
-
-        if http_code == 200:
-            health_instances.append((instance_id, ip_address))
-            logging.info(f"health check success, instance: {instance_id}/{ip_address}")
-            break
-        else:
-            time.sleep(10)
-
-
-def remove_container_image(ecs_client, instance_id, container_name_list):
-    """
-    移除旧容器并删除旧镜像
-    :param ecs_client: 客户端连接
-    :param instance_id: instanceId type-string
-    :param container_name_list: 容器名称 type-list
-    :return:
-    """
-    ip_address = utils.get_ip_address(ecs_client=ecs_client, instance_id=instance_id)
-    logging.info(f"服务器信息:{instance_id}/{ip_address}")
-    client = docker.DockerClient(base_url=f'tcp://{ip_address}:2375', timeout=60)
-
-    # 移除旧的容器
-    container_remove_retry = 3
-    i = 0
-    while True:
-        if i >= container_remove_retry:
-            logging.error(f"容器不存在或者无法删除当前容器, instance = {instance_id}/{ip_address}")
-            sys.exit()
-        try:
-            flag = False
-            for container_name in container_name_list:
-                try:
-                    container_id = client.containers.get(container_name)
-                    container_id.remove(force=True)
-                    flag = True
-                    break
-                except:
-                    continue
-            if flag:
-                break
-        except Exception as e:
-            i += 1
-
-    # 删除旧镜像
-    images_remove_retry = 3
-    j = 0
-    while True:
-        if j >= images_remove_retry:
-            logging.error(f"镜像不存在,无法获取到镜像ID, instance = {instance_id}/{ip_address}")
-            sys.exit()
-        try:
-            images = client.images.list()
-            for image in images:
-                client.images.remove(force=True, image=image.tags[0])
-                time.sleep(2)
-            global remove_container_instances
-            remove_container_instances.append(instance_id)
-            break
-        except Exception as e:
-            j += 1
-
-def update_instance(ecs_client, alb_client, instance_id, version, port):
-    """
-    线上机器更新
-    :param ecs_client:
-    :param alb_client: alb客户端连接
-    :param instance_id: instanceId
-    :param version: 版本标记
-    :param port: 后端服务器使用的端口
-    :return:
-    """
-    logging.info(f"update instance: {instance_id}")
-    # 1. 摘流量,将权重降为0
-    # health_instance_ids = [instance_id]
-    weight_list = [(0, 20)]  # 设置权重为0,等待20秒
-    utils.update_server_group_servers_attribute(alb_client,
-                                               longvideoapi_config.server_group_id_list,
-                                               instance_id_list=instance_id,
-                                               weight_list=weight_list,
-                                                port=port)
-    logging.info(f"Set weight to 0 for instance: {instance_id}")
-
-    # 2. 移除旧容器并删除旧镜像
-    global remove_container_instances
-    remove_container_instances = []
-    container_name_list = ['vlogapi', 'longvideoapi']
-    remove_container_image(ecs_client, instance_id, container_name_list)
-    logging.info(f"remove container & images finished, instance: {remove_container_instances},"
-                 f" count: {len(remove_container_instances)}")
-    if len(remove_container_instances) == 0:
-        logging.error(f"remove container image failed|")
-        sys.exit()
-
-    # 3. 发送启动脚本到机器上
-    utils.send_file_to_ecs(ecs_client=ecs_client, instance_id_list=[instance_id], **longvideoapi_config.start_sh)
-    logging.info(f"send start shell file finished, instance: {instance_id}")
-
-    # 4. 启动服务
-    server_start_sh = os.path.join(longvideoapi_config.start_sh['target_dir'], longvideoapi_config.start_sh['name'])
-    server_start_command = f"sh {server_start_sh} {version}"
-    utils.run_command(ecs_client=ecs_client, instance_ids=[instance_id], command=server_start_command)
-
-    # 5. 探活
-    global health_instances
-    health_instances = []
-    server_health_check(ecs_client, instance_id)
-    logging.info(f"health instances: {health_instances}, count: {len(health_instances)}")
-
-    # 6. 挂载流量
-    if len(health_instances) == 0:
-        logging.info(f"health instances: {health_instances}, count: {len(health_instances)}")
-        sys.exit()
-    # 机器探活成功
-    time.sleep(20)
-
-    add_weight_list = [(10, 5), (20, 5), (40, 5), (60, 5), (80, 5), (100, 5)]
-    utils.update_server_group_servers_attribute(alb_client,
-                                               longvideoapi_config.server_group_id_list,
-                                               instance_id_list=health_instances,
-                                               weight_list=add_weight_list,
-                                                port=port)
-    logging.info(f"finished instances: {health_instances}, count: {len(health_instances)}")
-
-
-def main():
-    try:
-        version = sys.argv[1]
-        alb_client = utils.connect_alb_client(
-            access_key_id=longvideoapi_config.alb_client_params['access_key_id'],
-            access_key_secret=longvideoapi_config.alb_client_params['access_key_secret'],
-            endpoint=longvideoapi_config.alb_client_params['endpoint']
-        )
-
-        ecs_client = utils.connect_client(access_key_id=longvideoapi_config.ecs_client_params['access_key_id'],
-                                             access_key_secret=longvideoapi_config.ecs_client_params[
-                                                 'access_key_secret'],
-                                             region_id=longvideoapi_config.ecs_client_params['region_id'])
-
-        # 1. 获取ALB下所有机器
-        online_instance_ids = utils.list_server_group_servers(alb_client=alb_client,
-                                                     server_group_id=longvideoapi_config.server_group_id_list[0])
-        online_instance_count = len(online_instance_ids)
-        logging.info(f"online instance count: {online_instance_count}.")
-        logging.info(f"online instance ids: {online_instance_ids}")
-
-        # 2. 对其中一台机器进行更新
-        instance_id = online_instance_ids[0]
-        logging.info(f"update instance start ...")
-        update_instance(ecs_client=ecs_client, alb_client=alb_client, instance_id=instance_id, version=version, port=longvideoapi_config.port)
-        logging.info(f"update instances end!")
-
-    except Exception as e:
-        logging.error(e)
-        sys.exit()
-
-
-if __name__ == '__main__':
-    main()

+ 0 - 120
longvideoapi_reduce_with_count.py

@@ -1,120 +0,0 @@
-import sys
-import time
-import utils
-import longvideoapi_config
-import logging
-
-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 remove_instances(ecs_client, alb_client, instance_ids, port):
-    """
-    停止并释放机器
-    :param ecs_client: 创建客户端
-    :param alb_client: ALB 客户端
-    :param instance_ids: instanceId 类型列表
-    :param port: 后端服务器使用的端口
-    :return: None
-    """
-    # 1. 摘除流量
-    weight_list = [(0, 20)]  # 设置权重为0,等待20秒
-    try:
-        utils.update_server_group_servers_attribute(alb_client,
-                                                   longvideoapi_config.server_group_id_list,
-                                                   instance_id_list=instance_ids,
-                                                   weight_list=weight_list,
-                                                   port=port)
-    except Exception as e:
-        logging.error(f"Failed to set instance weight: {e}")
-        sys.exit()
-
-    # 等待 ALB 更新权重
-    time.sleep(20)
-
-    # 2. 从 ALB 服务器组中移除实例
-    for server_group_id in longvideoapi_config.server_group_id_list:
-        try:
-            utils.remove_servers_from_server_group(alb_client=alb_client, server_group_id=server_group_id,
-                                                   instance_ids=instance_ids, port=port)
-            logging.info(f"Successfully removed instances from server group {server_group_id}.")
-        except Exception as e:
-            logging.error(f"Failed to remove instances from server group {server_group_id}: {e}")
-
-    logging.info(f"Remove from ALB finished, instances: {instance_ids}")
-
-    # 3. 停止机器
-    stop_response = utils.stop_instances(ecs_client=ecs_client, instance_ids=instance_ids)
-    if stop_response.get('Code') is None:
-        logging.info(f"Instances stop finished, instances: {instance_ids}")
-    else:
-        logging.error(f"Failed to stop instances: {stop_response}")
-        sys.exit()
-
-    # 4. 判断机器运行状态是否为 Stopped
-    while True:
-        response = utils.get_instances_status(ecs_client=ecs_client, instance_ids=instance_ids)
-        if response.get('Code') is None:
-            instances_list = response.get('InstanceStatuses').get('InstanceStatus')
-            stopped_instances = [instance.get('InstanceId') for instance in instances_list if
-                                 instance.get('Status') == 'Stopped']
-            if len(stopped_instances) == len(instance_ids):
-                logging.info(f"Instances stopped status set success, instances: {stopped_instances}")
-                break
-            else:
-                logging.info(f"Stopped instances count = {len(stopped_instances)}, instances: {stopped_instances}")
-                time.sleep(5)
-        else:
-            logging.error(response)
-            sys.exit()
-
-    # 5. 释放机器
-    release_response = utils.release_instances(ecs_client=ecs_client, instance_ids=stopped_instances)
-    if release_response.get('Code') is None:
-        logging.info(f"Release instances finished, instances: {stopped_instances}")
-    else:
-        logging.error(f"Release instances fail!!!")
-        sys.exit()
-
-
-def main():
-    try:
-        alb_client = utils.connect_alb_client(
-            access_key_id=longvideoapi_config.alb_client_params['access_key_id'],
-            access_key_secret=longvideoapi_config.alb_client_params['access_key_secret'],
-            endpoint=longvideoapi_config.alb_client_params['endpoint']
-        )
-
-        ecs_client = utils.connect_client(
-            access_key_id=longvideoapi_config.ecs_client_params['access_key_id'],
-            access_key_secret=longvideoapi_config.ecs_client_params['access_key_secret'],
-            region_id=longvideoapi_config.ecs_client_params['region_id']
-        )
-
-        # 获取指定释放的机器数量
-        reduce_count = int(sys.argv[1])
-        logging.info(f"reduce instances count: {reduce_count}")
-
-        # 获取 ALB 下所有机器
-        online_instance_ids = utils.list_server_group_servers(alb_client=alb_client, server_group_id=longvideoapi_config.server_group_id_list[0])
-        online_instance_count = len(online_instance_ids)
-        logging.info(f"online instance count: {online_instance_count}.")
-        logging.info(f"online instance ids: {online_instance_ids}")
-
-        # 获取前 count 台机器进行释放
-        reduce_instance_ids = online_instance_ids[:reduce_count]
-        logging.info(f"reduce instances: {reduce_instance_ids}")
-
-        # 停止并释放机器
-        remove_instances(ecs_client=ecs_client, alb_client=alb_client, instance_ids=reduce_instance_ids, port=longvideoapi_config.port)
-        logging.info(f"stop & release instances end!")
-    except Exception as e:
-        logging.error(e)
-        sys.exit()
-
-
-
-if __name__ == '__main__':
-    main()
-

+ 0 - 82
longvideoapi_restart.py

@@ -1,82 +0,0 @@
-import logging
-import time
-import docker
-import longvideoapi_config
-import utils
-from longvideoapi_update_k import server_health_check
-
-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 server_restart(ecs_client, alb_client, instance_id, image_name, port):
-    try:
-        logging.info(f"Restarting instance: {instance_id}")
-        # 获取ip
-        ip_address = utils.get_ip_address(ecs_client=ecs_client, instance_id=instance_id)
-        logging.info(f"IP address: {instance_id}/{ip_address}")
-
-        # 摘流量
-        utils.update_server_group_servers_attribute(alb_client=alb_client,
-                                                   server_group_id_list=longvideoapi_config.server_group_id_list,
-                                                   instance_id_list=instance_id,
-                                                   weight_list=[(0, 20)],
-                                                   port=port)
-        logging.info(f"Set weight to 0 for instance: {instance_id}")
-
-        # 连接 Docker 客户端并重启容器
-        docker_client = docker.DockerClient(base_url=f'tcp://{ip_address}:2375', timeout=60)
-        container = docker_client.containers.get(image_name)
-        container.restart()
-        logging.info("Docker restart finished.")
-
-        # 探活
-        server_health_check(ecs_client, instance_id)
-        time.sleep(20)
-        logging.info("Health check finished.")
-
-        # 设置权重
-        add_weight_list = [(10, 5), (20, 5), (40, 5), (60, 5), (80, 5), (100, 5)]
-        utils.update_server_group_servers_attribute(alb_client,
-                                                   server_group_id_list=longvideoapi_config.server_group_id_list,
-                                                   instance_id_list=instance_id,
-                                                   weight_list=add_weight_list,
-                                                   port=port)
-        logging.info(f"Server restart finished, instance: {instance_id}/{ip_address}")
-    except Exception as e:
-        logging.error(f"Server restart failed, instance: {instance_id}")
-        logging.error(e)
-
-
-def main():
-    try:
-        ecs_client = utils.connect_client(access_key_id=longvideoapi_config.ecs_client_params['access_key_id'],
-                                          access_key_secret=longvideoapi_config.ecs_client_params['access_key_secret'],
-                                          region_id=longvideoapi_config.ecs_client_params['region_id'])
-
-        alb_client = utils.connect_alb_client(
-            access_key_id=longvideoapi_config.alb_client_params['access_key_id'],
-            access_key_secret=longvideoapi_config.alb_client_params['access_key_secret'],
-            endpoint=longvideoapi_config.alb_client_params['endpoint']
-        )
-
-        # 获取 ALB 下所有机器
-        online_instance_ids = utils.list_server_group_servers(alb_client=alb_client,
-                                                     server_group_id=longvideoapi_config.server_group_id_list[0])
-        online_instance_count = len(online_instance_ids)
-        logging.info(f"Online instance count: {online_instance_count}.")
-        logging.info(f"Online instance ids: {online_instance_ids}")
-
-        # 逐台重启
-        image_name = 'longvideoapi'
-        for i, instance_id in enumerate(online_instance_ids):
-            server_restart(ecs_client=ecs_client, alb_client=alb_client, instance_id=instance_id, image_name=image_name, port=longvideoapi_config.port)
-            logging.info(f"Restart progress: {i + 1}/{online_instance_count}")
-        logging.info("All servers restarted successfully!")
-    except Exception as e:
-        logging.error("An error occurred during the main execution.")
-        logging.error(e)
-
-
-if __name__ == '__main__':
-    main()

+ 0 - 130
longvideoapi_scaling_k_count.py

@@ -1,130 +0,0 @@
-import sys
-import os
-import asyncio
-import logging
-import time
-import requests
-
-import utils
-import longvideoapi_config
-from concurrent.futures import ThreadPoolExecutor
-
-health_instances = []
-
-
-def longvideoapi_health_check(ecs_client, instance_id, max_wait_time=None):
-    """
-    服务健康检查
-    :param ecs_client: 客户端连接
-    :param instance_id: instanceId
-    :param max_wait_time: 最长等待时间,单位:s
-    :return:
-    """
-    global health_instances
-    start_time = time.time()
-    ip_address = utils.get_ip_address(ecs_client=ecs_client, instance_id=instance_id)
-    while True:
-        health_check_url = f"http://{ip_address}:8080/longvideoapi/test"
-        try:
-            http_code = requests.get(health_check_url).status_code
-        except:
-            logging.info(f"images is downloading ip: {ip_address}")
-            http_code = 0
-
-        if http_code == 200:
-            health_instances.append((instance_id, ip_address))
-            logging.info(f"health check success, instance: {instance_id}/{ip_address}")
-            break
-        elif max_wait_time is not None:
-            now = time.time()
-            if (now - start_time) >= max_wait_time:
-                logging.info(f"health check error, instance: {instance_id}/{ip_address}")
-                break
-            else:
-                time.sleep(10)
-        else:
-            time.sleep(10)
-
-
-async def ess_instance(ecs_client, alb_client, ess_count, max_workers, port):
-    """
-    扩容机器并运行新服务
-    :param ecs_client: 购买机器客户端连接
-    :param alb_client: 修改负载均衡权限
-    :param ess_count: 扩容数量
-    :param max_workers: 线程数
-    :param port: 后端服务器使用的端口
-    :return:
-    """
-    # 1. 购买机器并启动
-    ess_instance_ids = utils.create_multiple_instances(
-        amount=ess_count,
-        ecs_client=ecs_client,
-        **longvideoapi_config.instance_config_k,
-    )
-    time.sleep(60)
-
-    # 2. 发送启动脚本到机器上
-    utils.send_file_to_ecs(ecs_client=ecs_client, instance_id_list=ess_instance_ids, **longvideoapi_config.start_sh)
-    logging.info(f"send start shell file finished, instances: {ess_instance_ids}")
-    # 3. 启动服务
-    start_sh_param = "latest"
-    server_start_sh = os.path.join(longvideoapi_config.start_sh['target_dir'], longvideoapi_config.start_sh['name'])
-    server_start_commend = f"sh {server_start_sh} {start_sh_param}"
-    utils.run_command(ecs_client=ecs_client, instance_ids=ess_instance_ids, command=server_start_commend)
-    # 4. 异步探活
-    global health_instances
-    health_instances = []
-    max_wait_time = 180
-    loop = asyncio.get_running_loop()
-    executor = ThreadPoolExecutor(max_workers=max_workers)
-    tasks = [
-        loop.run_in_executor(executor, longvideoapi_health_check, *args) for args in
-        [(alb_client, instance_id, max_wait_time) for instance_id in ess_instance_ids]
-    ]
-    await asyncio.wait(tasks)
-    logging.info(f"health instances count: {len(health_instances)}, {health_instances}")
-
-    # 5. 挂载流量到ALB
-    if len(health_instances) > 0:
-        # 所有机器探活成功
-        time.sleep(20)
-        for instance_id, ip in health_instances:
-            for server_group_id in longvideoapi_config.server_group_id_list:
-                utils.add_servers_to_server_group(alb_client, server_group_id, instance_id, weight=100, port=port)
-        logging.info(f"ess count: {ess_count}, "
-                     f"create count: {len(ess_instance_ids)}, "
-                     f"finished count: {len(health_instances)}")
-    else:
-        logging.info(f"ess count: {ess_count}, "
-                     f"create count: {len(ess_instance_ids)}, "
-                     f"health count: {len(health_instances)}")
-        sys.exit()
-
-
-
-def main():
-    try:
-        ecs_client = utils.connect_client(access_key_id=longvideoapi_config.ecs_client_params['access_key_id'],
-                                             access_key_secret=longvideoapi_config.ecs_client_params['access_key_secret'],
-                                             region_id=longvideoapi_config.ecs_client_params['region_id'])
-        alb_client = utils.connect_alb_client(
-            access_key_id=longvideoapi_config.alb_client_params['access_key_id'],
-            access_key_secret=longvideoapi_config.alb_client_params['access_key_secret'],
-            endpoint=longvideoapi_config.alb_client_params['endpoint']
-        )
-        # 获取批量创建ECS实例的数量
-        ess_instance_count = int(sys.argv[1])
-        # 扩容机器并启动服务
-        logging.info(f"ess instances start ...")
-        logging.info(f"ess instance count: {ess_instance_count}")
-        asyncio.run(ess_instance(ecs_client=ecs_client,
-                                 alb_client=alb_client,
-                                 ess_count=ess_instance_count, max_workers=2, port=longvideoapi_config.port))
-        logging.info(f"ess instances end!")
-    except Exception as e:
-        logging.error(e)
-
-
-if __name__ == '__main__':
-    main()

+ 0 - 0
util/__init__.py


+ 0 - 0
utils.py → util/utils.py