Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Répondre aux CloudWatch événements d'Amazon EMR
<a name="emr-events-response"></a>

[Cette section décrit les différentes manières de répondre aux événements exploitables émis par Amazon CloudWatch EMR sous forme de messages d'événement.](emr-manage-cloudwatch-events.md) Les moyens de réagir aux événements incluent la création de règles, le paramétrage d'alarmes et d'autres réponses. Les sections qui suivent incluent des liens vers des procédures et des réponses recommandées à des événements courants.

**Topics**
+ [Création de règles pour les événements Amazon EMR avec CloudWatch](emr-events-cloudwatch-console.md)
+ [Configuration d'alarmes sur CloudWatch les métriques d'Amazon EMR](UsingEMR_ViewingMetrics_Alarm.md)
+ [Réponse aux événements liés à une capacité d'instance insuffisante du cluster Amazon EMR](emr-events-response-insuff-capacity.md)
+ [Répondre aux événements d'expiration liés au redimensionnement de la flotte d'instances du cluster Amazon EMR](emr-events-response-timeout-events.md)

# Création de règles pour les événements Amazon EMR avec CloudWatch
<a name="emr-events-cloudwatch-console"></a>

Amazon EMR envoie automatiquement les événements vers un flux d' CloudWatch événements. Vous pouvez créer des règles qui correspondent à des événements selon un modèle spécifié, et acheminer les événements vers des cibles pour prendre des mesures, comme envoyer une notification par e-mail. Les modèles sont mis en correspondance avec l'objet JSON d'événement. Pour plus d'informations sur les événements Amazon EMR, consultez les événements Amazon [EMR dans le guide de l'utilisateur](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#emr_event_type) *Amazon CloudWatch * Events.

Pour plus d'informations sur la configuration des règles relatives aux CloudWatch événements, consultez la section [Création d'une CloudWatch règle déclenchant un événement](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/Create-CloudWatch-Events-Rule.html).

# Configuration d'alarmes sur CloudWatch les métriques d'Amazon EMR
<a name="UsingEMR_ViewingMetrics_Alarm"></a>

Amazon EMR transmet les métriques à Amazon. CloudWatch En réponse, vous pouvez CloudWatch définir des alarmes sur vos métriques Amazon EMR. Par exemple, vous pouvez configurer une alarme pour vous CloudWatch envoyer un e-mail chaque fois que l'utilisation du HDFS dépasse 80 %. Pour obtenir des instructions détaillées, consultez la section [Créer ou modifier une CloudWatch alarme](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ConsoleAlarms.html) dans le *guide de CloudWatch l'utilisateur Amazon*. 

# Réponse aux événements liés à une capacité d'instance insuffisante du cluster Amazon EMR
<a name="emr-events-response-insuff-capacity"></a>

## Présentation de
<a name="emr-events-response-insuff-capacity-overview"></a>

Les clusters Amazon EMR renvoient le code d'événement `EC2 provisioning - Insufficient Instance Capacity` lorsque la zone de disponibilité sélectionnée n'a pas une capacité suffisante pour répondre à votre demande de démarrage ou de redimensionnement de cluster. L'événement est émis régulièrement, à la fois pour les groupes d'instances et les flottes d'instances, si Amazon EMR rencontre à plusieurs reprises des exceptions de capacité insuffisante et ne parvient pas à répondre à votre demande de mise en service pour une opération de démarrage ou de redimensionnement de cluster.

Cette page décrit la meilleure façon de répondre à ce type d'événement lorsqu'il se produit pour votre cluster EMR.

## Réponse recommandée en cas d'insuffisance de capacité
<a name="emr-events-response-insuff-capacity-rec"></a>

En cas de capacité insuffisante, nous vous recommandons de réagir de l'une des manières suivantes :
+ Attendez que la capacité soit rétablie. La capacité change fréquemment, ainsi, une exception de capacité insuffisante peut se résoudre elle-même. Le redimensionnement de vos clusters commencera ou se terminera dès que la capacité Amazon EC2 sera disponible.
+ Vous pouvez également mettre fin à votre cluster, modifier les configurations de type d'instance et créer un nouveau cluster avec la demande de configuration de cluster mise à jour. Pour de plus amples informations, veuillez consulter [Flexibilité de la zone de disponibilité pour un cluster Amazon EMR](emr-flexibility.md).

En cas de capacité insuffisante, vous pouvez également configurer des règles ou des réponses automatisées, comme décrit dans la section suivante.

## Restauration automatique en cas d'insuffisance de capacité
<a name="emr-events-response-insuff-capacity-ex"></a>

Vous pouvez créer une automatisation en réponse aux événements Amazon EMR, tels que ceux comportant un code d'événement `EC2 provisioning - Insufficient Instance Capacity`. Par exemple, la AWS Lambda fonction suivante met fin à un cluster EMR avec un groupe d'instances qui utilise des instances à la demande, puis crée un nouveau cluster EMR avec un groupe d'instances contenant des types d'instances différents de ceux de la demande d'origine.

Les conditions suivantes déclenchent le processus automatisé :
+ L'événement de capacité insuffisante est émis pour les nœuds principaux ou primaires depuis plus de 20 minutes.
+ Le cluster n'est pas dans un état **PRÊT** ou **EN ATTENTE**. Pour de plus amples informations sur les états des clusters EMR, consultez [Présentation du cycle de vie du cluster](emr-overview.md#emr-overview-cluster-lifecycle).

**Note**  
Lorsque vous créez un processus automatisé pour une exception de capacité insuffisante, vous devez considérer que l'événement de capacité insuffisante est récupérable. La capacité change souvent et vos clusters reprendront leur redimensionnement ou commenceront à fonctionner dès que la capacité Amazon EC2 sera disponible.

**Example Fonctionnalité pour répondre aux insuffisances de capacité**  

```
// Lambda code with Python 3.10 and handler is lambda_function.lambda_handler
// Note: related IAM role requires permission to use Amazon EMR

import json
import boto3
import datetime
from datetime import timezone

INSUFFICIENT_CAPACITY_EXCEPTION_DETAIL_TYPE = "EMR Instance Group Provisioning"
INSUFFICIENT_CAPACITY_EXCEPTION_EVENT_CODE = (
    "EC2 provisioning - Insufficient Instance Capacity"
)
ALLOWED_INSTANCE_TYPES_TO_USE = [
    "m5.xlarge",
    "c5.xlarge",
    "m5.4xlarge",
    "m5.2xlarge",
    "t3.xlarge",
]
CLUSTER_START_ACCEPTABLE_STATES = ["WAITING", "RUNNING"]
CLUSTER_START_SLA = 20

CLIENT = boto3.client("emr", region_name="us-east-1")

# checks if the incoming event is 'EMR Instance Fleet Provisioning' with eventCode 'EC2 provisioning - Insufficient Instance Capacity'
def is_insufficient_capacity_event(event):
    if not event["detail"]:
        return False
    else:
        return (
            event["detail-type"] == INSUFFICIENT_CAPACITY_EXCEPTION_DETAIL_TYPE
            and event["detail"]["eventCode"]
            == INSUFFICIENT_CAPACITY_EXCEPTION_EVENT_CODE
        )


# checks if the cluster is eligible for termination
def is_cluster_eligible_for_termination(event, describeClusterResponse):
    # instanceGroupType could be CORE, MASTER OR TASK
    instanceGroupType = event["detail"]["instanceGroupType"]
    clusterCreationTime = describeClusterResponse["Cluster"]["Status"]["Timeline"][
        "CreationDateTime"
    ]
    clusterState = describeClusterResponse["Cluster"]["Status"]["State"]

    now = datetime.datetime.now()
    now = now.replace(tzinfo=timezone.utc)
    isClusterStartSlaBreached = clusterCreationTime < now - datetime.timedelta(
        minutes=CLUSTER_START_SLA
    )

    # Check if instance group receiving Insufficient capacity exception is CORE or PRIMARY (MASTER),
    # and it's been more than 20 minutes since cluster was created but the cluster state and the cluster state is not updated to RUNNING or WAITING
    if (
        (instanceGroupType == "CORE" or instanceGroupType == "MASTER")
        and isClusterStartSlaBreached
        and clusterState not in CLUSTER_START_ACCEPTABLE_STATES
    ):
        return True
    else:
        return False


# Choose item from the list except the exempt value
def choice_excluding(exempt):
    for i in ALLOWED_INSTANCE_TYPES_TO_USE:
        if i != exempt:
            return i


# Create a new cluster by choosing different InstanceType.
def create_cluster(event):
    # instanceGroupType cloud be CORE, MASTER OR TASK
    instanceGroupType = event["detail"]["instanceGroupType"]

    # Following two lines assumes that the customer that created the cluster already knows which instance types they use in original request
    instanceTypesFromOriginalRequestMaster = "m5.xlarge"
    instanceTypesFromOriginalRequestCore = "m5.xlarge"

    # Select new instance types to include in the new createCluster request
    instanceTypeForMaster = (
        instanceTypesFromOriginalRequestMaster
        if instanceGroupType != "MASTER"
        else choice_excluding(instanceTypesFromOriginalRequestMaster)
    )
    instanceTypeForCore = (
        instanceTypesFromOriginalRequestCore
        if instanceGroupType != "CORE"
        else choice_excluding(instanceTypesFromOriginalRequestCore)
    )

    print("Starting to create cluster...")
    instances = {
        "InstanceGroups": [
            {
                "InstanceRole": "MASTER",
                "InstanceCount": 1,
                "InstanceType": instanceTypeForMaster,
                "Market": "ON_DEMAND",
                "Name": "Master",
            },
            {
                "InstanceRole": "CORE",
                "InstanceCount": 1,
                "InstanceType": instanceTypeForCore,
                "Market": "ON_DEMAND",
                "Name": "Core",
            },
        ]
    }
    response = CLIENT.run_job_flow(
        Name="Test Cluster",
        Instances=instances,
        VisibleToAllUsers=True,
        JobFlowRole="EMR_EC2_DefaultRole",
        ServiceRole="EMR_DefaultRole",
        ReleaseLabel="emr-6.10.0",
    )

    return response["JobFlowId"]


# Terminated the cluster using clusterId received in an event
def terminate_cluster(event):
    print("Trying to terminate cluster, clusterId: " + event["detail"]["clusterId"])
    response = CLIENT.terminate_job_flows(JobFlowIds=[event["detail"]["clusterId"]])
    print(f"Terminate cluster response: {response}")


def describe_cluster(event):
    response = CLIENT.describe_cluster(ClusterId=event["detail"]["clusterId"])
    return response


def lambda_handler(event, context):
    if is_insufficient_capacity_event(event):
        print(
            "Received insufficient capacity event for instanceGroup, clusterId: "
            + event["detail"]["clusterId"]
        )

        describeClusterResponse = describe_cluster(event)

        shouldTerminateCluster = is_cluster_eligible_for_termination(
            event, describeClusterResponse
        )
        if shouldTerminateCluster:
            terminate_cluster(event)

            clusterId = create_cluster(event)
            print("Created a new cluster, clusterId: " + clusterId)
        else:
            print(
                "Cluster is not eligible for termination, clusterId: "
                + event["detail"]["clusterId"]
            )

    else:
        print("Received event is not insufficient capacity event, skipping")
```

# Répondre aux événements d'expiration liés au redimensionnement de la flotte d'instances du cluster Amazon EMR
<a name="emr-events-response-timeout-events"></a>

## Présentation de
<a name="emr-events-response-timeout-events-overview"></a>

Lors de l'exécution de l'opération de redimensionnement pour les clusters de flotte d'instances, les clusters Amazon EMR émettent des [événements](emr-manage-cloudwatch-events.md#emr-cloudwatch-instance-fleet-resize-events). Les événements liés au délai de mise en service sont émis lorsqu'Amazon EMR arrête de fournir de la capacité Spot ou à la demande pour la flotte après l'expiration du délai. La durée du délai d'expiration peut être configurée par l'utilisateur dans le cadre des [spécifications de redimensionnement](https://docs.aws.amazon.com/emr/latest/APIReference/API_InstanceFleetResizingSpecifications.html) des flottes d'instances. Dans les scénarios de redimensionnement consécutifs pour la même flotte d'instances, Amazon EMR émet les événements `Spot provisioning timeout - continuing resize` ou `On-Demand provisioning timeout - continuing resize` lorsque le délai d'expiration est dépassé pour l'opération de redimensionnement en cours. Amazon EMR commence ensuite à fournir la capacité pour la prochaine opération de redimensionnement de la flotte.

## Répondre aux événements liés au redimensionnement de la flotte d'instances
<a name="emr-events-response-timeout-events-rec"></a>

Lors d'un événement d'expiration de délai, nous vous recommandons de réagir de l'une des manières suivantes :
+ Consultez les [spécifications de redimensionnement](https://docs.aws.amazon.com/emr/latest/APIReference/API_InstanceFleetResizingSpecifications.html) et réessayez l'opération de redimensionnement. Comme la capacité change fréquemment, vos clusters seront redimensionnés avec succès dès que la capacité Amazon EC2 sera disponible. Nous recommandons aux clients de configurer des valeurs inférieures pour le délai d'expiration pour les tâches nécessitant des mesures plus strictesSLAs.
+ Vous pouvez également :
  + Lancer un nouveau cluster avec des types d'instances diversifiés en fonction des [meilleures pratiques pour les instances et de la flexibilité de la zone de disponibilité](emr-flexibility.md#emr-flexibility-types), ou
  + Lancement d'un cluster avec une capacité à la demande
+ En ce qui concerne l'événement relatif au délai d'expiration de la mise en service et au redimensionnement continu, vous pouvez également attendre que les opérations de redimensionnement soient traitées. Amazon EMR continuera de traiter les opérations de redimensionnement déclenchées pour la flotte de manière séquentielle, en respectant les spécifications de redimensionnement configurées.

Vous pouvez également configurer des règles ou des réponses automatisées à cet événement, comme décrit dans la section suivante.

## Restauration automatique après un événement d'expiration de la mise en service
<a name="emr-events-response-timeout-events-ex"></a>

Vous pouvez créer une automatisation en réponse aux événements Amazon EMR avec le code d'événement `Spot Provisioning timeout`. Par exemple, la fonction AWS Lambda suivante met fin à un cluster EMR avec une flotte d'instances qui utilise des instances Spot pour les nœuds de tâches, puis crée un nouveau cluster EMR avec une flotte d'instances contenant des types d'instances plus diversifiés que ceux de la demande initiale. Dans cet exemple, l'événement `Spot Provisioning timeout` émis pour les nœuds de tâches déclenchera l'exécution de la fonction Lambda.

**Example Exemple de fonction pour répondre à un événement `Spot Provisioning timeout`**  

```
// Lambda code with Python 3.10 and handler is lambda_function.lambda_handler
// Note: related IAM role requires permission to use Amazon EMR
 
import json
import boto3
import datetime
from datetime import timezone
 
SPOT_PROVISIONING_TIMEOUT_EXCEPTION_DETAIL_TYPE = "EMR Instance Fleet Resize"
SPOT_PROVISIONING_TIMEOUT_EXCEPTION_EVENT_CODE = (
    "Spot Provisioning timeout"
)
 
CLIENT = boto3.client("emr", region_name="us-east-1")
 
# checks if the incoming event is 'EMR Instance Fleet Resize' with eventCode 'Spot provisioning timeout'
def is_spot_provisioning_timeout_event(event):
    if not event["detail"]:
        return False
    else:
        return (
            event["detail-type"] == SPOT_PROVISIONING_TIMEOUT_EXCEPTION_DETAIL_TYPE
            and event["detail"]["eventCode"]
            == SPOT_PROVISIONING_TIMEOUT_EXCEPTION_EVENT_CODE
        )
 
 
# checks if the cluster is eligible for termination
def is_cluster_eligible_for_termination(event, describeClusterResponse):
    # instanceFleetType could be CORE, MASTER OR TASK
    instanceFleetType = event["detail"]["instanceFleetType"]
 
    # Check if instance fleet receiving Spot provisioning timeout event is TASK
    if (instanceFleetType == "TASK"):
        return True
    else:
        return False
 
 
# create a new cluster by choosing different InstanceType.
def create_cluster(event):
    # instanceFleetType cloud be CORE, MASTER OR TASK
    instanceFleetType = event["detail"]["instanceFleetType"]
 
    # the following two lines assumes that the customer that created the cluster already knows which instance types they use in original request
    instanceTypesFromOriginalRequestMaster = "m5.xlarge"
    instanceTypesFromOriginalRequestCore = "m5.xlarge"
   
    # select new instance types to include in the new createCluster request
    instanceTypesForTask = [
        "m5.xlarge",
        "m5.2xlarge",
        "m5.4xlarge",
        "m5.8xlarge",
        "m5.12xlarge"
    ]
    
    print("Starting to create cluster...")
    instances = {
        "InstanceFleets": [
            {
                "InstanceFleetType":"MASTER",
                "TargetOnDemandCapacity":1,
                "TargetSpotCapacity":0,
                "InstanceTypeConfigs":[
                    {
                        'InstanceType': instanceTypesFromOriginalRequestMaster,
                        "WeightedCapacity":1,
                    }
                ]
            },
            {
                "InstanceFleetType":"CORE",
                "TargetOnDemandCapacity":1,
                "TargetSpotCapacity":0,
                "InstanceTypeConfigs":[
                    {
                        'InstanceType': instanceTypesFromOriginalRequestCore,
                        "WeightedCapacity":1,
                    }
                ]
            },
            {
                "InstanceFleetType":"TASK",
                "TargetOnDemandCapacity":0,
                "TargetSpotCapacity":100,
                "LaunchSpecifications":{},
                "InstanceTypeConfigs":[
                    {
                        'InstanceType': instanceTypesForTask[0],
                        "WeightedCapacity":1,
                    },
                    {
                        'InstanceType': instanceTypesForTask[1],
                        "WeightedCapacity":2,
                    },
                    {
                        'InstanceType': instanceTypesForTask[2],
                        "WeightedCapacity":4,
                    },
                    {
                        'InstanceType': instanceTypesForTask[3],
                        "WeightedCapacity":8,
                    },
                    {
                        'InstanceType': instanceTypesForTask[4],
                        "WeightedCapacity":12,
                    }
                ],
                "ResizeSpecifications": {
                    "SpotResizeSpecification": {
                        "TimeoutDurationMinutes": 30
                    }
                }
            }
        ]
    }
    response = CLIENT.run_job_flow(
        Name="Test Cluster",
        Instances=instances,
        VisibleToAllUsers=True,
        JobFlowRole="EMR_EC2_DefaultRole",
        ServiceRole="EMR_DefaultRole",
        ReleaseLabel="emr-6.10.0",
    )
 
    return response["JobFlowId"]
 
 
# terminated the cluster using clusterId received in an event
def terminate_cluster(event):
    print("Trying to terminate cluster, clusterId: " + event["detail"]["clusterId"])
    response = CLIENT.terminate_job_flows(JobFlowIds=[event["detail"]["clusterId"]])
    print(f"Terminate cluster response: {response}")
 
 
def describe_cluster(event):
    response = CLIENT.describe_cluster(ClusterId=event["detail"]["clusterId"])
    return response
 
 
def lambda_handler(event, context):
    if is_spot_provisioning_timeout_event(event):
        print(
            "Received spot provisioning timeout event for instanceFleet, clusterId: "
            + event["detail"]["clusterId"]
        )
 
        describeClusterResponse = describe_cluster(event)
 
        shouldTerminateCluster = is_cluster_eligible_for_termination(
            event, describeClusterResponse
        )
        if shouldTerminateCluster:
            terminate_cluster(event)
 
            clusterId = create_cluster(event)
            print("Created a new cluster, clusterId: " + clusterId)
        else:
            print(
                "Cluster is not eligible for termination, clusterId: "
                + event["detail"]["clusterId"]
            )
 
    else:
        print("Received event is not spot provisioning timeout event, skipping")
```