update utils

gateway_update.py

@@ -10,7 +10,7 @@ import time
 from aliyunsdkcore import client
 from aliyunsdkecs.request.v20140526.DescribeNetworkInterfacesRequest import DescribeNetworkInterfacesRequest
 import gateway_config
-import alb_utils
+import utils
 
 # 从配置文件中获取应用程序名称和容器仓库地址
 apps = gateway_config.apps
@@ -46,7 +46,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 +69,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 +80,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 +95,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 +112,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 +133,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,
+            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)

longvideoapi/longvideoapi_update_k.py

@@ -1,349 +0,0 @@
-import asyncio
-import sys
-import time
-import requests
-import alb_utils
-import logging
-import os
-import docker
-import longvideoapi_config
-
-from concurrent.futures import ThreadPoolExecutor
-
-from gateway.gateway_config import server_group_id_list
-
-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 = alb_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)
-
-
-async def ess_instance(ecs_client, alb_client, ess_count, max_workers, version, port):
-    """
-    扩容机器并运行新服务
-    :param ecs_client: 购买机器客户端连接
-    :param alb_client: 修改负载均衡权限
-    :param ess_count: 扩容数量
-    :param max_workers: 线程数
-    :param version: 版本标记
-    :param port: 后端服务器使用的端口
-    :return:
-    """
-    # 1. 购买机器并启动
-    ess_instance_ids = alb_utils.create_multiple_instances(
-        amount=ess_count,
-        ecs_client=ecs_client,
-        **longvideoapi_config.instance_config_k,
-    )
-    time.sleep(60)
-
-    # 2. 发送启动脚本到机器上
-    alb_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. 启动服务
-    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} {version}"
-    alb_utils.run_command(ecs_client=ecs_client, instance_ids=ess_instance_ids, command=server_start_commend)
-    # 4. 异步探活
-    global health_instances
-    health_instances = []
-    loop = asyncio.get_running_loop()
-    executor = ThreadPoolExecutor(max_workers=max_workers)
-    tasks = [
-        loop.run_in_executor(executor, server_health_check, *args) for args in
-        [(alb_client, instance_id) for instance_id in ess_instance_ids]
-    ]
-    await asyncio.wait(tasks)
-    logging.info(f"health instances count: {len(health_instances)}, {health_instances}")
-    # 5. 挂载流量
-    if len(health_instances) == len(ess_instance_ids):
-        # 所有机器探活成功
-        time.sleep(20)
-        health_instance_ids = [instance_id for instance_id, _ in health_instances]
-        for server_group_id in longvideoapi_config.server_group_id_list:
-            for instance_id in health_instance_ids:
-                alb_utils.add_servers_to_server_group(alb_client, server_group_id, instance_id, weight=0, port=port)
-                logging.info(f"Successfully added instance {instance_id} to server group {server_group_id}.")
-
-        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=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}, "
-                     f"create count: {len(ess_instance_ids)}, "
-                     f"finished count: {len(health_instance_ids)}")
-    else:
-        logging.info(f"ess count: {ess_count}, "
-                     f"create count: {len(ess_instance_ids)}, "
-                     f"health count: {len(health_instances)}")
-        sys.exit()
-
-
-def remove_container_image(ecs_client, instance_id, container_name_list):
-    """
-    移除旧容器并删除旧镜像
-    :param ecs_client: 客户端连接
-    :param instance_id: instanceId type-string
-    :param container_name: 容器名称 type-string
-    :return:
-    """
-    ip_address = alb_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:
-            i += 1
-
-
-async def update_instance(ecs_client, alb_client, instance_ids, max_workers, version, port):
-    """
-    线上机器更新
-    :param ecs_client:
-    :param alb_client: alb客户端连接
-    :param instance_ids: instanceId type-list
-    :param max_workers:
-    :param version: 版本标记
-    :param port: 后端服务器使用的端口
-    :return:
-    """
-    media_index = len(instance_ids)//2
-    instance_ids_group = [instance_ids[:media_index], instance_ids[media_index:]]
-    update_finished_count = 0
-    for instance_id_list in instance_ids_group:
-        logging.info(f"update instances: {instance_id_list}")
-        # 1. 摘流量
-        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_list,
-                                                    weight_list=[(0, 20)],
-                                                    port=port)
-        logging.info(f"set weight with 0 finished, instances: {instance_id_list}")
-        # 2. 异步移除旧容器并删除旧镜像
-        global remove_container_instances
-        remove_container_instances = []
-        # container_name = 'longvideoapi'
-        container_name_list = ['vlogapi', 'longvideoapi']
-        loop = asyncio.get_running_loop()
-        executor = ThreadPoolExecutor(max_workers=max_workers)
-        tasks = [
-            loop.run_in_executor(executor, remove_container_image, *args) for args in
-            [(alb_client, instance_id, container_name_list) for instance_id in instance_id_list]
-        ]
-        await asyncio.wait(tasks)
-        logging.info(f"remove container & images finished, instances: {remove_container_instances},"
-                     f" count: {len(remove_container_instances)}")
-        if len(remove_container_instances) < len(instance_id_list):
-            logging.error(f"remove container image failed| "
-                          f"request count: {len(instance_id_list)}, removed count: {len(remove_container_instances)}")
-            sys.exit()
-        # 3. 发送启动脚本到机器上
-        alb_utils.send_file_to_ecs(ecs_client=ecs_client, instance_id_list=instance_id_list, **longvideoapi_config.start_sh)
-        logging.info(f"send start shell file finished, instances: {instance_id_list}, count: {len(instance_id_list)}")
-        # 4. 启动服务
-        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} {version}"
-        alb_utils.run_command(ecs_client=ecs_client, instance_ids=instance_id_list, command=server_start_commend)
-        # 5. 异步探活
-        global health_instances
-        health_instances = []
-        loop = asyncio.get_running_loop()
-        executor = ThreadPoolExecutor(max_workers=max_workers)
-        tasks = [
-            loop.run_in_executor(executor, server_health_check, *args) for args in
-            [(alb_client, instance_id) for instance_id in instance_id_list]
-        ]
-        await asyncio.wait(tasks)
-        logging.info(f"health instances: {health_instances}, count: {len(health_instances)}")
-        # 6. 挂载流量
-        if len(health_instances) == len(instance_id_list):
-            # 所有机器探活成功
-            time.sleep(10)
-            health_instance_ids = [instance_id for instance_id, _ in health_instances]
-
-            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=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)}")
-        else:
-            logging.info(f"health instances: {health_instances}, count: {len(health_instances)}")
-            sys.exit()
-
-
-def remove_instances(ecs_client, alb_client, instance_ids, port):
-    """
-    停止并释放机器
-    :param ecs_client:
-    :param alb_client:
-    :param instance_ids: instanceId type-list
-    :param port: 后端服务器使用的端口
-    :return: None
-    """
-    # 1. 摘流量
-    weight_list = [(0, 20)]  # 设置权重为0，等待20秒
-    try:
-        alb_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)
-    except Exception as e:
-        logging.error(f"Failed to set instance weight: {e}")
-        sys.exit()
-
-    time.sleep(10)
-    # 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,
-                                                   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 = alb_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 = alb_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 = alb_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:
-        version = sys.argv[1]
-        alb_client = alb_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['access_key_secret'],
-                                             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_count = len(online_instance_ids)
-        logging.info(f"online instance count: {online_instance_count}.")
-        logging.info(f"online instance ids: {online_instance_ids}")
-
-        # 2. 扩容机器并启动新服务 扩容数量：线上机器数量//2
-        logging.info(f"ess instances start ...")
-        ess_instance_count = online_instance_count // 2
-        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, version=version, port=longvideoapi_config.port))
-        logging.info(f"ess instances end!")
-
-        # 3. 原有机器进行更新
-        logging.info(f"update online instances start ...")
-        asyncio.run(update_instance(ecs_client=ecs_client, alb_client=alb_client,
-                                    instance_ids=online_instance_ids, max_workers=8, version=version, port=longvideoapi_config.port))
-        logging.info(f"update online instances end!")
-
-        # 4. 停止并释放扩容机器
-        logging.info(f"stop & release instances start ...")
-        remove_instances(ecs_client=ecs_client, alb_client=alb_client, instance_ids=ess_instances, port=longvideoapi_config.port)
-        logging.info(f"stop & release instances end!")
-    except Exception as e:
-        logging.error(e)
-        sys.exit()
-
-
-if __name__ == '__main__':
-    main()

longvideoapi_grayscale_update.py

@@ -2,7 +2,7 @@ import asyncio
 import sys
 import time
 import requests
-import alb_utils
+import utils
 import logging
 import os
 import docker
@@ -23,7 +23,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 +48,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,7 +106,7 @@ 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,
+    utils.update_server_group_servers_attribute(alb_client,
                                                longvideoapi_config.server_group_id_list,
                                                instance_id_list=instance_id,
                                                weight_list=weight_list,
@@ -125,13 +125,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,7 +147,7 @@ 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,
+    utils.update_server_group_servers_attribute(alb_client,
                                                longvideoapi_config.server_group_id_list,
                                                instance_id_list=health_instances,
                                                weight_list=add_weight_list,
@@ -158,19 +158,19 @@ 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'],
+        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 = alb_utils.list_server_group_servers(alb_client=alb_client,
+        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}.")

longvideoapi_reduce_with_count.py

@@ -1,6 +1,6 @@
 import sys
 import time
-import alb_utils
+import utils
 import longvideoapi_config
 import logging
 
@@ -21,7 +21,7 @@ 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,
+        utils.update_server_group_servers_attribute(alb_client,
                                                    longvideoapi_config.server_group_id_list,
                                                    instance_id_list=instance_ids,
                                                    weight_list=weight_list,
@@ -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}")

longvideoapi_restart.py

@@ -2,7 +2,7 @@ import logging
 import time
 import docker
 import longvideoapi_config
-import alb_utils
+import utils
 from longvideoapi_update_k import server_health_check
 
 logging.basicConfig(level=logging.INFO,
@@ -13,11 +13,11 @@ 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,
+        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)],
@@ -37,7 +37,7 @@ 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,
+        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,
@@ -50,18 +50,18 @@ 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,
+        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}.")

longvideoapi_scaling_k_count.py

@@ -5,7 +5,7 @@ import logging
 import time
 import requests
 
-import alb_utils
+import utils
 import longvideoapi_config
 
 from concurrent.futures import ThreadPoolExecutor
@@ -25,7 +25,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 +60,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 +68,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 +94,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 +108,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'],
+        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']

longvideoapi_update_k.py

@@ -2,7 +2,7 @@ import asyncio
 import sys
 import time
 import requests
-import alb_utils
+import utils
 import logging
 import os
 import docker
@@ -25,7 +25,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:
@@ -54,7 +54,7 @@ async def ess_instance(ecs_client, alb_client, ess_count, max_workers, version,
     :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,
@@ -62,12 +62,12 @@ async def ess_instance(ecs_client, alb_client, ess_count, max_workers, version,
     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. 启动服务
     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} {version}"
-    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 = []
@@ -86,11 +86,11 @@ async def ess_instance(ecs_client, alb_client, ess_count, max_workers, version,
         health_instance_ids = [instance_id for instance_id, _ in health_instances]
         for server_group_id in longvideoapi_config.server_group_id_list:
             for instance_id in health_instance_ids:
-                alb_utils.add_servers_to_server_group(alb_client, server_group_id, instance_id, weight=0, port=port)
+                utils.add_servers_to_server_group(alb_client, server_group_id, instance_id, weight=0, port=port)
                 logging.info(f"Successfully added instance {instance_id} to server group {server_group_id}.")
 
         add_weight_list = [(10, 5), (20, 5), (40, 5), (60, 5), (80, 5), (100, 5)]
-        alb_utils.update_server_group_servers_attribute(alb_client,
+        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,
@@ -115,7 +115,7 @@ def remove_container_image(ecs_client, instance_id, container_name_list):
     :param container_name: 容器名称 type-string
     :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)
     # 移除旧的容器
@@ -176,7 +176,7 @@ async def update_instance(ecs_client, alb_client, instance_ids, max_workers, ver
     for instance_id_list in instance_ids_group:
         logging.info(f"update instances: {instance_id_list}")
         # 1. 摘流量
-        alb_utils.update_server_group_servers_attribute(alb_client=alb_client,
+        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_list,
                                                     weight_list=[(0, 20)],
@@ -201,12 +201,12 @@ async def update_instance(ecs_client, alb_client, instance_ids, max_workers, ver
                           f"request count: {len(instance_id_list)}, removed count: {len(remove_container_instances)}")
             sys.exit()
         # 3. 发送启动脚本到机器上
-        alb_utils.send_file_to_ecs(ecs_client=ecs_client, instance_id_list=instance_id_list, **longvideoapi_config.start_sh)
+        utils.send_file_to_ecs(ecs_client=ecs_client, instance_id_list=instance_id_list, **longvideoapi_config.start_sh)
         logging.info(f"send start shell file finished, instances: {instance_id_list}, count: {len(instance_id_list)}")
         # 4. 启动服务
         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} {version}"
-        alb_utils.run_command(ecs_client=ecs_client, instance_ids=instance_id_list, command=server_start_commend)
+        utils.run_command(ecs_client=ecs_client, instance_ids=instance_id_list, command=server_start_commend)
         # 5. 异步探活
         global health_instances
         health_instances = []
@@ -225,7 +225,7 @@ async def update_instance(ecs_client, alb_client, instance_ids, max_workers, ver
             health_instance_ids = [instance_id for instance_id, _ in health_instances]
 
             add_weight_list = [(10, 5), (20, 5), (40, 5), (60, 5), (80, 5), (100, 5)]
-            alb_utils.update_server_group_servers_attribute(alb_client,
+            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,
@@ -250,7 +250,7 @@ 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,
+        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,
@@ -263,7 +263,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:
@@ -272,7 +272,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:
@@ -281,7 +281,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
@@ -296,7 +296,7 @@ def remove_instances(ecs_client, alb_client, instance_ids, port):
             logging.error(response)
             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:
@@ -307,17 +307,17 @@ def remove_instances(ecs_client, alb_client, instance_ids, 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'],
+        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 = 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}")