Cloud Monitor:Automate O&M based on ECS instance state change events

import os

class Conf:
    endpoint = 'http://<id>.mns.<region>.aliyuncs.com/'
    access_key = os.environ['ALIBABA_CLOUD_ACCESS_KEY_ID']
    access_key_secret = os.environ['ALIBABA_CLOUD_ACCESS_KEY_SECRET']
    region_id = 'cn-beijing'
    queue_name = 'ecs-cms-event'
    vserver_group_id = '<your-vserver-group-id>'

# -*- coding: utf-8 -*-
import json
import logging
from mns.mns_exception import MNSExceptionBase
from mns.account import Account
from . import Conf

class MNSClient(object):
    def __init__(self):
        self.account = Account(Conf.endpoint, Conf.access_key, Conf.access_key_secret)
        self.queue_name = Conf.queue_name
        self.listeners = dict()

    def regist_listener(self, listener, eventname='Instance:StateChange'):
        if eventname in self.listeners.keys():
            self.listeners.get(eventname).append(listener)
        else:
            self.listeners[eventname] = [listener]

    def run(self):
        queue = self.account.get_queue(self.queue_name)
        while True:
            try:
                message = queue.receive_message(wait_seconds=5)
                event = json.loads(message.message_body)
                if event['name'] in self.listeners:
                    for listener in self.listeners.get(event['name']):
                        listener.process(event)
                queue.delete_message(receipt_handle=message.receipt_handle)
            except MNSExceptionBase as e:
                if e.type == 'QueueNotExist':
                    logging.error('Queue %s not exist, please create queue before receive message.', self.queue_name)
                else:
                    logging.error('No Message, continue waiting')

class BasicListener(object):
    def process(self, event):
        pass

Structure de la charge utile de l'événement

Les événements de changement d'état utilisent la structure suivante :

Créer l'écouteur

# -*- coding: utf-8 -*-
import logging
from .mns_client import BasicListener

class ListenerLog(BasicListener):
    def process(self, event):
        state = event['content']['state']
        resource_id = event['content']['resourceId']
        if state == 'Created':
            logging.info(f'The instance {resource_id} state is {state}')
        elif state == 'Deleted':
            logging.info(f'The instance {resource_id} state is {state}')

Exécuter le consommateur

mns_client = MNSClient()

mns_client.regist_listener(ListenerLog())

mns_client.run()

Vérifier le résultat

1. Créez ou libérez une instance ECS dans la console.

2. Vérifiez les journaux du consommateur pour un message tel que The instance i-bp1abc... state is Created.

En production, stockez les événements dans une base de données ou Simple Log Service (SLS) au lieu de les journaliser sur stdout. Cela permet de rechercher et d'auditer les données historiques du cycle de vie des instances.

Créer l'écouteur

Réutilisez le consommateur MNS de l'étape 2 et enregistrez un nouvel écouteur :

# -*- coding: utf-8 -*-
import logging

from alibabacloud_ecs20140526.client import Client as Ecs20140526Client
from alibabacloud_ecs20140526.models import StartInstanceRequest
from alibabacloud_tea_openapi.models import Config

from .config import Conf
from .mns_client import BasicListener

class ECSClient(object):
    def __init__(self, client):
        self.client = client

    def start_instance(self, instance_id):
        logging.info(f'Start instance {instance_id} ...')
        request = StartInstanceRequest(
            instance_id=instance_id
        )
        self.client.start_instance(request)

class ListenerStart(BasicListener):
    def __init__(self):
        ecs_config = Config(
            access_key_id=Conf.access_key,
            access_key_secret=Conf.access_key_secret,
            endpoint=f'ecs.{Conf.region_id}.aliyuncs.com'
        )
        client = Ecs20140526Client(ecs_config)
        self.ecs_client = ECSClient(client)

    def process(self, event):
        detail = event['content']
        instance_id = detail['resourceId']
        if detail['state'] == 'Stopped':
            self.ecs_client.start_instance(instance_id)

Exécuter le consommateur

mns_client = MNSClient()

mns_client.regist_listener(ListenerStart())

mns_client.run()

Vérifier le résultat

1. Arrêtez manuellement une instance ECS en cours d'exécution.

2. Vérifiez les journaux du consommateur pour Start instance i-bp1abc... ....

3. Confirmez que l'état de l'instance revient à Running dans la console ECS.

En production, surveillez les transitions d'état ultérieures ( Starting , Running ou Stopped ) après l'émission de la commande de démarrage. Utilisez des minuteurs et des compteurs de nouvelles tentatives pour gérer les cas où le redémarrage échoue.

Créer l'écouteur

Réutilisez le consommateur MNS de l'étape 2 et enregistrez un écouteur pour l'événement d'interruption d'instance spot :

# -*- coding: utf-8 -*-
from alibabacloud_slb20140515.client import Client as Slb20140515Client
from alibabacloud_slb20140515.models import RemoveVServerGroupBackendServersRequest
from alibabacloud_tea_openapi.models import Config

from .config import Conf
from .mns_client import BasicListener

class SLBClient(object):
    def __init__(self):
        self.client = self.create_client()

    def create_client(self):
        config = Config()
        config.access_key_id = Conf.access_key
        config.access_key_secret = Conf.access_key_secret
        config.endpoint = 'slb.aliyuncs.com'
        return Slb20140515Client(config)

    def remove_vserver_group_backend_servers(self, vserver_group_id, instance_id):
        request = RemoveVServerGroupBackendServersRequest(
            region_id=Conf.region_id,
            vserver_group_id=vserver_group_id,
            backend_servers="[{'ServerId':'" + instance_id + "','Port':'80','Weight':'100'}]"
        )
        response = self.client.remove_vserver_group_backend_servers(request)
        return response

class ListenerSLB(BasicListener):
    def __init__(self, vserver_group_id):
        self.slb_caller = SLBClient()
        self.vserver_group_id = Conf.vserver_group_id

    def process(self, event):
        detail = event['content']
        instance_id = detail['instanceId']
        if detail['action'] == 'delete':
            self.slb_caller.remove_vserver_group_backend_servers(self.vserver_group_id, instance_id)

mns_client = MNSClient()

mns_client.regist_listener(ListenerSLB(Conf.vserver_group_id), 'Instance:PreemptibleInstanceInterruption')

mns_client.run()

Structure de l'événement d'interruption d'instance spot

Les événements d'interruption d'instance spot utilisent des noms de champs différents de ceux des événements de changement d'état :

Vérifier le résultat

1. Attendez un événement d'interruption d'instance spot (ou simulez-en un dans un environnement de test).

2. Confirmez que l'instance est supprimée du groupe de serveurs virtuels SLB avant la libération.

En production, demandez une instance spot de remplacement et attachez-la immédiatement à l'instance SLB pour maintenir la disponibilité du service.

mns_client = MNSClient()

# Scenario 1: Log lifecycle events
mns_client.regist_listener(ListenerLog())

# Scenario 2: Auto-restart stopped instances
mns_client.regist_listener(ListenerStart())

# Scenario 3: Remove spot instances from SLB before release
mns_client.regist_listener(ListenerSLB(Conf.vserver_group_id), 'Instance:PreemptibleInstanceInterruption')

mns_client.run()