Envoyer des alarmes CloudWatch à Slack via AWS Lambda

Introduction

L’un des facteurs clés pour maintenir la disponibilité de la production est la mise en œuvre de systèmes efficaces de surveillance et d’alerte. L’intégration d’AWS CloudWatch à Slack à l’aide d’AWS Lambda vous permet de recevoir des alertes en temps réel sur vos canaux Slack, gardant ainsi votre équipe informée et réactive. Ce blog vous guidera dans cette intégration à l’aide d’une fonction AWS Lambda pour envoyer des alarmes AWS CloudWatch à Slack.

Objectif

L’article explique la configuration d’un webhook entrant dans votre espace de travail Slack pour recevoir des messages d’AWS et comment créer une fonction AWS Lambda pour traiter les alarmes CloudWatch et envoyer des notifications formatées au canal Slack via l’URL du webhook.

Conditions préalables

Procédure étape par étape –

1. Création d’un sujet SNS

Cloudwatch utilise des sujets SNS pour publier des messages. Ainsi, dans votre console AWS, visitez Simple Notification Service, puis entrez le nom du sujet que vous souhaitez créer et cliquez sur Étape suivante sous le nom du sujet.

Note: Sélectionnez le type comme Standard et le nom du sujet que vous avez entré précédemment doit être visible dans la section Nom, confirmez-le et créez un sujet.

2. Création de la chaîne Slack et de l’application Slack

Maintenant, créez un canal Slack pour recevoir des alertes cloudwatch. Donnons-lui un nom Test et choisissons la visibilité selon vos besoins.

Pour créer une application Slack, visitez https://api.slack.com/apps et cliquez sur Créer une application. Choisir De zéro option pour créer une application Slack

Donnez un nom à votre application et sélectionnez le même espace de travail dans lequel vous avez créé le canal de réception des alertes pour développer votre application.

Nous utiliserons des webhooks pour recevoir des alertes de cloudwatch. Alors, allons activer les webhooks entrants et le webhook vers votre chaîne sur laquelle vous souhaitez recevoir des alertes.

Aller à Informations de base et donnez des détails de base comme le Icône de l’application et description à votre application. C’est une étape facultative

3. Création de la fonction Lambda

Allez au Console de gestion AWS et accédez à Lambda et cliquez Créer une fonctionet choisissez Auteur à partir de zéro. Fournissez des détails de base sur votre fonction lambda et sélectionnez Python3.9 runtime car il s’agit de la version python que notre fonction lambda utilisera.

Après la création du Lambda, nous avons besoin d’un déclencheur pour appeler notre fonction lambda chaque fois qu’un événement Cloudwatch a lieu.

Sélectionnez le sujet que nous avons créé précédemment pour envoyer des alertes à Slack. AWS ajoutera une stratégie basée sur les ressources à la fonction et ajoutera un abonnement au sujet.

Maintenant, remplacez la fonction pré-écrite ci-dessous par la fonction ci-dessous et donnez l’URL de votre webhook à slack_url variable, donnez votre région à région variable et déployer la fonction.

import urllib3
import urllib3
import json
import logging

slack_url = "Your WebHook URL"
http = urllib3.PoolManager()

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger()

def get_alarm_attributes(sns_message):
    alarm = dict()
    
    alarm['name'] = sns_message['AlarmName']
    alarm['description'] = sns_message.get('AlarmDescription', 'No description provided.')
    alarm['reason'] = sns_message['NewStateReason']
    alarm['region'] = sns_message['Region']
    alarm['state'] = sns_message['NewStateValue']
    alarm['previous_state'] = sns_message['OldStateValue']
    alarm['timestamp'] = sns_message['StateChangeTime']

    # Use the correct AWS region code
    region = "us-east-1"
    alarm_name = sns_message['AlarmName']
    alarm['link'] = f"https://{region}.console.aws.amazon.com/cloudwatch/home?region={region}#alarmsV2:alarm/{alarm_name}"

    return alarm

def register_alarm(alarm):
    return {
        "blocks": [
            {
                "type": "header",
                "text": {
                    "type": "plain_text",
                    "text": ":warning: " + alarm['name'] + " alarm was registered"
                }
            },
            {
                "type": "divider"
            },
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": f"*Alarm Name:* {alarm['name']}\n\n*Description:* {alarm['description']}"
                }
            },
            {
                "type": "section",
                "fields": [
                    {"type": "mrkdwn", "text": f"*Region:* {alarm['region']}"},
                    {"type": "mrkdwn", "text": f"*Timestamp:* {alarm['timestamp']}"}
                ]
            },
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": f""
                }
            }
        ]
    }

def activate_alarm(alarm):
    return {
        "blocks": [
            {
                "type": "header",
                "text": {
                    "type": "plain_text",
                    "text": ":red_circle: Alarm: " + alarm['name'],
                }
            },
            {
                "type": "divider"
            },
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": f"*Alarm Name:* {alarm['name']}\n\n*Description:* {alarm['description']}"
                }
            },
            {
                "type": "section",
                "fields": [
                    {"type": "mrkdwn", "text": f"*Region:* {alarm['region']}"},
                    {"type": "mrkdwn", "text": f"*Timestamp:* {alarm['timestamp']}"}
                ]
            },
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": f""
                }
            }
        ]
    }

def resolve_alarm(alarm):
    return {
        "blocks": [
            {
                "type": "header",
                "text": {
                    "type": "plain_text",
                    "text": ":large_green_circle: Alarm: " + alarm['name'] + " was resolved",
                }
            },
            {
                "type": "divider"
            },
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": f"*Alarm Name:* {alarm['name']}\n\n*Description:* {alarm['description']}"
                }
            },
            {
                "type": "section",
                "fields": [
                    {"type": "mrkdwn", "text": f"*Region:* {alarm['region']}"},
                    {"type": "mrkdwn", "text": f"*Timestamp:* {alarm['timestamp']}"}
                ]
            },
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": f""
                }
            }
        ]
    }

def insufficient_data_alarm(alarm):
    return {
        "blocks": [
            {
                "type": "header",
                "text": {
                    "type": "plain_text",
                    "text": ":grey_question: Alarm: " + alarm['name'] + " is in INSUFFICIENT_DATA state",
                }
            },
            {
                "type": "divider"
            },
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": f"*Alarm Name:* {alarm['name']}\n\n*Description:* {alarm['description']}"
                }
            },
            {
                "type": "section",
                "fields": [
                    {"type": "mrkdwn", "text": f"*Region:* {alarm['region']}"},
                    {"type": "mrkdwn", "text": f"*Timestamp:* {alarm['timestamp']}"}
                ]
            },
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": f""
                }
            }
        ]
    }

def lambda_handler(event, context):
    sns_message = json.loads(event["Records"][0]["Sns"]["Message"])
    alarm = get_alarm_attributes(sns_message)

    msg = str()

    if alarm['previous_state'] == "INSUFFICIENT_DATA" and alarm['state'] == 'OK':
        msg = register_alarm(alarm)
    elif alarm['previous_state'] == 'OK' and alarm['state'] == 'ALARM':
        msg = activate_alarm(alarm)
    elif alarm['previous_state'] == 'ALARM' and alarm['state'] == 'OK':
        msg = resolve_alarm(alarm)
    elif alarm['state'] == 'INSUFFICIENT_DATA':
        msg = insufficient_data_alarm(alarm)
    elif alarm['previous_state'] == 'INSUFFICIENT_DATA' and alarm['state'] == 'ALARM':
        msg = activate_alarm(alarm)

    encoded_msg = json.dumps(msg).encode("utf-8")
    try:
        resp = http.request("POST", slack_url, body=encoded_msg, headers={'Content-Type': 'application/json'})
        logger.info(
            {
                "message": msg,
                "status_code": resp.status,
                "response": resp.data,
            }
        )
    except Exception as e:
        logger.error(f"Error sending message to Slack: {e}")

        

Remarque : Vous pouvez trouver l’URL de votre webhook dans le Webhooks entrants dans votre application Slack.

4. Créer une alarme Cloudwatch

Maintenant, créez une alarme CloudWatch et configurez-la pour envoyer des notifications à la fonction Lambda via une rubrique SNS.

Accédez à la console AWS CloudWatch et accédez à la section Alarmes. Cliquez sur « Créer une alarme » et choisissez la métrique appropriée à votre cas d’utilisation (par exemple, utilisation du processeur, utilisation de la mémoire ou métriques personnalisées).

Définissez le seuil souhaité et configurez le comportement de l’alarme (par exemple, envoyer une notification lorsque la métrique dépasse une certaine valeur).

Sous « Envoyer une notification à », sélectionnez « Sujet SNS » et choisissez le sujet SNS que vous avez créé lors des étapes précédentes.

Vérifiez la configuration de l’alarme et cliquez sur « Créer une alarme ».

Pour tester l’utilisation du processeur, l’utilitaire Stress Linux peut être utilisé. Installez-le en exécutant sudo apt install stress, puis pour le tester, exécutez stress –cpu 2.

Conclusion

Vous avez maintenant configuré avec succès une fonction AWS Lambda pour envoyer des alarmes CloudWatch à un canal Slack. Cette intégration vous permet de rester informé de l’état et des performances de vos ressources AWS en temps réel, directement sur le canal Slack de votre équipe.

N’hésitez pas à personnaliser davantage la fonction Lambda en fonction de vos besoins spécifiques. Par exemple, vous pouvez ajouter plus de détails aux messages Slack, gérer différemment différents types d’alertes ou intégrer d’autres outils de surveillance.