AWS CloudWatch : monitorer ses applications et infrastructures

CloudWatch est le service d’observabilité natif d’AWS. Il collecte métriques, logs et traces de tous vos services AWS, et peut ingérer vos propres métriques applicatives. Pour une infrastructure AWS, c’est souvent le premier outil à maîtriser avant d’envisager des outils externes.

Métriques custom : monitorer ce qu’AWS ne mesure pas

AWS publie automatiquement des métriques pour EC2, RDS, Lambda, etc. Mais les métriques métier — nombre de commandes par minute, taille de la queue interne, taux de conversion — doivent être publiées manuellement.

import boto3

cloudwatch = boto3.client('cloudwatch', region_name='eu-west-1')

def publish_business_metrics(orders_count: int, error_count: int):
    cloudwatch.put_metric_data(
        Namespace='MyApp/Business',
        MetricData=[
            {
                'MetricName': 'OrdersProcessed',
                'Value': orders_count,
                'Unit': 'Count',
                'Dimensions': [
                    {'Name': 'Environment', 'Value': 'production'},
                    {'Name': 'Region', 'Value': 'eu-west-1'},
                ]
            },
            {
                'MetricName': 'ProcessingErrors',
                'Value': error_count,
                'Unit': 'Count',
                'Dimensions': [
                    {'Name': 'Environment', 'Value': 'production'},
                ]
            }
        ]
    )

Publiez ces métriques depuis votre application (à chaque traitement, ou toutes les minutes via un cron) et elles apparaissent dans CloudWatch comme n’importe quelle métrique AWS native.

Alarmes : de la métrique à l’alerte

Une alarme CloudWatch surveille une métrique et change d’état quand elle franchit un seuil. Trois états possibles : OK, ALARM, INSUFFICIENT_DATA.

cloudwatch.put_metric_alarm(
    AlarmName='HighErrorRate-Production',
    AlarmDescription='Taux d erreur > 5% sur 5 minutes',
    MetricName='ProcessingErrors',
    Namespace='MyApp/Business',
    Statistic='Sum',
    Period=300,           # fenêtre de 5 minutes
    EvaluationPeriods=2,  # 2 périodes consécutives avant ALARM
    Threshold=10,
    ComparisonOperator='GreaterThanThreshold',
    Dimensions=[{'Name': 'Environment', 'Value': 'production'}],
    AlarmActions=[
        'arn:aws:sns:eu-west-1:123456789:ops-alerts'  # SNS → Slack/PagerDuty
    ],
    OKActions=[
        'arn:aws:sns:eu-west-1:123456789:ops-alerts'  # notification retour à la normale
    ],
    TreatMissingData='breaching',  # si pas de données : considérer comme ALARM
)

CloudWatch Agent : collecter les métriques système

Les métriques EC2 natives (CPU, réseau) sont limitées. L’agent CloudWatch collecte mémoire, disque, processus — ce que l’hyperviseur ne voit pas.

{
  "metrics": {
    "namespace": "CWAgent",
    "metrics_collected": {
      "mem": {
        "measurement": ["mem_used_percent"],
        "metrics_collection_interval": 60
      },
      "disk": {
        "measurement": ["used_percent", "inodes_free"],
        "resources": ["/", "/data"],
        "metrics_collection_interval": 60
      },
      "cpu": {
        "totalcpu": true,
        "metrics_collection_interval": 30
      }
    }
  }
}

# Installer et démarrer l'agent
sudo yum install amazon-cloudwatch-agent
sudo /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl \
    -a fetch-config -m ec2 -c file:/opt/aws/config.json -s

Log Insights : requêter ses logs comme une base de données

CloudWatch Log Insights permet d’interroger vos logs avec un langage de requête propre — bien plus puissant que grep sur les logs bruts.

# Trouver les 10 endpoints les plus lents sur les 24 dernières heures
fields @timestamp, endpoint, duration_ms
| filter duration_ms > 1000
| stats avg(duration_ms) as avg_duration, count() as count by endpoint
| sort avg_duration desc
| limit 10

# Compter les erreurs 5xx par heure
fields @timestamp, status_code
| filter status_code >= 500
| stats count() as errors by bin(1h)
| sort @timestamp asc

# Identifier les IPs qui génèrent des erreurs 401
fields @timestamp, client_ip, path
| filter status_code = 401
| stats count() as attempts by client_ip
| sort attempts desc
| limit 20

Dashboards : vue consolidée multi-services

# Créer un dashboard via l'API
cloudwatch.put_dashboard(
    DashboardName='Production-Overview',
    DashboardBody=json.dumps({
        "widgets": [
            {
                "type": "metric",
                "properties": {
                    "title": "Orders per minute",
                    "metrics": [["MyApp/Business", "OrdersProcessed",
                                 "Environment", "production"]],
                    "period": 60,
                    "stat": "Sum",
                    "view": "timeSeries"
                }
            },
            {
                "type": "alarm",
                "properties": {
                    "title": "Active Alarms",
                    "alarms": ["arn:aws:cloudwatch:eu-west-1:123:alarm:HighErrorRate-Production"]
                }
            }
        ]
    })
)

Synthetics : monitorer depuis l’extérieur

CloudWatch Synthetics exécute des scripts (canaries) qui simulent des parcours utilisateur depuis différentes régions AWS, et alerte si une page ne répond plus ou si un flux métier est cassé.

# Un canary qui vérifie que la page de paiement répond en < 3s
async def handler(event, context):
    page = await synthetics.getPage()
    await page.goto('https://myapp.com/checkout')
    await page.waitForSelector('#payment-form')
    # Si ça dépasse 3s ou si le sélecteur n'existe pas → alarme automatique

Notre formation AWS couvre CloudWatch en profondeur avec des ateliers Terraform sur des comptes AWS réels.