

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.

# HTTP
<a name="https-rule-action"></a>

L'action HTTPS (`http`) envoie les données d'un message MQTT à un point de terminaison HTTPS, qui peut pointer vers une application ou un service Web.

## Exigences
<a name="https-rule-action-requirements"></a>

Ce rôle d’action possède les critères suivants :
+ Vous devez confirmer et activer les points de terminaison HTTPS avant que le moteur de règles puisse les utiliser. Pour de plus amples informations, veuillez consulter [Destinations d'action HTTP](http-action-destination.md).

## Parameters
<a name="https-rule-action-parameters"></a>

Lorsque vous créez une AWS IoT règle avec cette action, vous devez spécifier les informations suivantes :

`url`  
Point de terminaison HTTPS à l'endroit où le message est envoyé à l'aide de la méthode HTTP POST. Si vous utilisez une adresse IP à la place d'un nom d'hôte, il doit s'agir d'une IPv4 adresse. IPv6 les adresses ne sont pas prises en charge.  
Prend en charge les [modèles de substitution](iot-substitution-templates.md) : Oui

`confirmationUrl`  
(Facultatif) Si cela est spécifié, AWS IoT utilise l'URL de confirmation pour créer une destination de règle de sujet correspondante. Vous devez activer la destination de l'action HTTP avant de l'utiliser dans une action HTTP. Pour de plus amples informations, veuillez consulter [Destinations d'action HTTP](http-action-destination.md). Si vous utilisez des modèles de substitution, vous devez créer manuellement une destination d'action HTTP avant de pouvoir utiliser l'`http`action. `confirmationUrl`doit être un préfixe de. `url`  
La relation entre `url` et `confirmationUrl` est décrite par les éléments suivants :  
+ S'il `url` est codé en dur et n'`confirmationUrl`est pas fourni, nous traitons implicitement le `url` champ comme le. `confirmationUrl` AWS IoT crée une destination de règle de sujet pour`url`.
+ Si `url` et `confirmationUrl` sont codés en dur, cela `url` doit commencer `confirmationUrl` par. AWS IoT crée une destination de règle de sujet pour`confirmationUrl`.
+ Si `url` contient un modèle de substitution, vous devez spécifier `confirmationUrl` et `url` doit commencer par `confirmationUrl`. S'il `confirmationUrl` contient des modèles de substitution, vous devez créer manuellement une destination d'action HTTP avant de pouvoir utiliser l'`http`action. S'il `confirmationUrl` ne contient pas de modèles de substitution, AWS IoT crée une destination de règle de sujet pour`confirmationUrl`.
Prend en charge les [modèles de substitution](iot-substitution-templates.md) : Oui

`headers`  
(Facultatif) La liste des en-têtes à inclure dans les requêtes HTTP adressées au point de terminaison. Chaque entête doit contenir les informations suivantes.    
`key`  
La clé de l'en-tête.  
Prend en charge les [modèles de substitution](iot-substitution-templates.md): Non  
`value`  
Valeur de l'en-tête.  
Prend en charge les [modèles de substitution](iot-substitution-templates.md): Oui
Le type de contenu par défaut est application/json lorsque la charge utile est au format JSON. Sinon, il s'agit de application/octet-stream. Vous pouvez le remplacer en spécifiant le type de contenu exact dans l'en-tête avec le type de contenu clé (insensible à la casse). 

`auth`  
(Facultatif) L'authentification utilisée par le moteur de règles pour se connecter à l'URL du point final spécifié dans `url` l'argument. Actuellement, Signature Version 4 est le seul type d'authentification pris en charge. Pour de plus amples informations, veuillez consulter [Autorisation HTTP](https://docs.aws.amazon.com/iot/latest/apireference/API_HttpAuthorization.html).  
Prend en charge les [modèles de substitution](iot-substitution-templates.md) : Non

`enableBatching`  
(Facultatif) S'il faut traiter les messages d'action HTTP en une seule demande pour une URL donnée. La valeur peut être vraie ou fausse. Pour plus d'informations sur le traitement par lots, consultez la section Traitement par [lots des messages d'action HTTP](http_batching.md).  
Valeur booléenne  
Prend en charge les [modèles de substitution](iot-substitution-templates.md) : Non

`batchConfig`  
(Facultatif) Paramètres de configuration pour le traitement par lots. Une fois activé, `batchConfig` les paramètres doivent être spécifiés. Si aucun `batchConfig` paramètre n'est spécifié, les valeurs par défaut seront utilisées.    
`maxBatchOpenMs`  
Durée maximale (en millisecondes) pendant laquelle un message sortant attend que d'autres messages créent le lot. Plus le paramètre est élevé, plus la latence de l'action HTTP par lots est longue.  
Valeur minimale : 5 ms. Valeur maximale : 200 ms.  
Valeur par défaut : 20 ms  
Prend en charge les [modèles de substitution](iot-substitution-templates.md) : Non  
`maxBatchSize`  
Le nombre maximal de messages qui sont regroupés par lots lors de l'exécution d'une seule action.  
Prend en charge les [modèles de substitution](iot-substitution-templates.md) : Non  
Valeur minimale : 2 messages. Valeur maximale : 10 messages  
Valeur par défaut : 10 messages  
`maxBatchSizeBytes`  
Taille maximale d'un lot de messages, en octets.  
Valeur minimale : 100 octets. Valeur maximale : 131 072 octets  
Valeur par défaut : 5 120 octets  
Prend en charge les [modèles de substitution](iot-substitution-templates.md) : Non
Le type de contenu par défaut est application/json lorsque la charge utile est au format JSON. Sinon, il s'agit de application/octet-stream. Vous pouvez le remplacer en spécifiant le type de contenu exact dans l'en-tête avec le type de contenu clé (insensible à la casse). 

## Exemples
<a name="https-rule-action-examples"></a>

L'exemple JSON suivant définit une AWS IoT règle avec une action HTTP.

```
{
    "topicRulePayload": {
        "sql": "SELECT * FROM 'some/topic'", 
        "ruleDisabled": false,
        "awsIotSqlVersion": "2016-03-23", 
        "actions": [
            { 
                "http": { 
                    "url": "https://www.example.com/subpath",
                    "confirmationUrl": "https://www.example.com", 
                    "headers": [
                        { 
                            "key": "static_header_key", 
                            "value": "static_header_value" 
                        },
                        { 
                            "key": "substitutable_header_key", 
                            "value": "${value_from_payload}" 
                        }
                    ] 
                } 
            }
        ]
    }
}
```

```
"http": { 
    "url": "https://www.example.com/subpath",
    "confirmationUrl": "https://www.example.com", 
    "headers": [
        { 
            "key": "Content-Type",
            "value": "application/json"
          }
    ],
    "enableBatching": true, 
    "batchConfig": {     
      "maxBatchOpenMs": 123, 
      "maxBatchSize": 5, 
      "maxBatchSizeBytes": 131072,
     }
 },
 "errorAction": { 
        "http": { 
            "url": "https://www.example.com/subpath",
            "confirmationUrl": "https://www.example.com"
            // batchConfig is not allowed here
        }
}
```

## Logique de nouvelle tentative d'action HTTP
<a name="https-rule-action-retry-logic"></a>

Le moteur de AWS IoT règles tente à nouveau l'action HTTP conformément aux règles suivantes :
+ Le moteur de règles essaie d'envoyer un message au moins une fois.
+ Le moteur de règles effectue au plus deux nouvelles tentatives. Le nombre maximum de nouvelles tentatives est trois.
+ Le moteur de règles n'effectue pas de nouvelle tentative si :
  + L'essai précédent a fourni une réponse de plus de 16 384 octets.
  + Le service web ou l'application en aval ferme la connexion TCP après la tentative.
  + Le temps total d'exécution d'une demande avec tentatives a dépassé la limite de temporisation de la demande.
  + La requête renvoie un code d'état HTTP autre que 429, 500-599.

**Note**  
[Les coûts standard de transfert de données](https://aws.amazon.com/ec2/pricing/on-demand/) s'appliquent aux nouvelles tentatives.

## Consultez aussi
<a name="https-rule-action-see-also"></a>
+ [Traitement par lots de messages d’action HTTP](http_batching.md)
+ [Destinations d'action HTTP](http-action-destination.md)
+ [Acheminez les données directement depuis AWS IoT Core vos services Web](https://aws.amazon.com/blogs/iot/route-data-directly-from-iot-core-to-your-web-services/) dans l'*Internet des objets sur le AWS* blog

# Traitement par lots de messages d’action HTTP
<a name="http_batching"></a>

Vous pouvez utiliser le traitement par lots pour envoyer plusieurs messages d'action HTTP en une seule demande.

## Présentation de
<a name="batching_overview"></a>

Le traitement par lots vous permet d'envoyer des messages par lots depuis AWS IoT Core Rules Engine à vos points de terminaison HTTP. Cette fonctionnalité peut vous aider à réduire vos coûts en réduisant le nombre d'exécutions d'actions HTTP et en améliorant l'efficacité en réduisant les frais associés à l'établissement de nouvelles connexions.

**Note**  
L'action HTTP par lots est mesurée comme une action unique. Vous êtes mesuré par incréments de 5 Ko, en fonction de la taille de la charge utile sortante par lots émise par le moteur de AWS IoT Core règles vers le service en aval. Pour plus d'informations, consultez la page de tarification [AWS IoT Core](https://aws.amazon.com/iot-core/pricing/).

Lorsque vous activez le traitement par lots dans la définition de votre action de règle IoT, les paramètres suivants seront disponibles pour la configuration :

`maxBatchOpenMs`  
Durée maximale (en millisecondes) pendant laquelle un message sortant attend que d'autres messages créent le lot. Plus le paramètre est élevé, plus la latence de l'action HTTP par lots est longue.  
Valeur minimale : 5 ms. Valeur maximale : 200 ms.  
Valeur par défaut : 20 ms  
Prend en charge les [modèles de substitution](iot-substitution-templates.md) : Non

`maxBatchSize`  
Nombre maximal de messages regroupés lors de l'exécution d'une seule action de règle IoT.  
Valeur minimale : 2 messages. Valeur maximale : 10 messages  
Valeur par défaut : 10 messages  
Prend en charge les [modèles de substitution](iot-substitution-templates.md) : Non

`maxBatchSizeBytes`  
Taille maximale d'un lot de messages, en octets.  
Valeur minimale : 100 octets. Valeur maximale : 131 072 octets  
Valeur par défaut : 5120 octets  
Prend en charge les [modèles de substitution](iot-substitution-templates.md) : Non

**Important**  
Lorsque vous spécifiez plusieurs paramètres de lot, le traitement par lots est terminé lorsque la première limite est atteinte. Par exemple, si vous spécifiez 100 ms comme durée maximale d'ouverture du lot et 5 Ko comme taille de lot maximale, et que Rules Engine ne traite que 2 Ko dans un délai de 100 ms, un lot de 2 Ko sera créé et envoyé.

## Utilisation d'en-têtes HTTP dans un lot
<a name="batching_http_headers"></a>

Lorsque vous utilisez des en-têtes dans votre action HTTP, la requête groupée utilise la valeur d'en-tête du dernier message ajouté au lot (pas nécessairement le dernier message que vous avez publié). Nous vous recommandons d'utiliser des valeurs d'en-tête qui sont soit :
+ Identique pour tous les messages du lot
+ Applicable à tous les messages (par exemple, les informations d'authentification)

Les en-têtes sont envoyés avec la requête HTTP et ne font pas partie du corps du message.

**Note**  
Lorsque le traitement par lots est activé :  
La demande groupée inclut automatiquement l'`Content-Type: application/json`en-tête, car le lot est envoyé sous forme de tableau JSON.
Nous ne pouvons pas garantir que le dernier message du lot soit le dernier que vous avez publié. C'est le dernier message qui a été inclus dans le lot.

## Exemple de charge utile
<a name="batching_payload"></a>

L'exemple suivant montre la structure d'une charge utile de message par lots envoyée à votre point de terminaison HTTP :

```
[
  {
    "user_id": "user1",
    "steps_today": 1000
  },
  {
    "user_id": "user2",
    "steps_today": 21000
  },
  {
    "user_id": "user8",
    "steps_today": 1500
  },
  ...
]
```

## Limitations
<a name="batching_limitations"></a>

Les restrictions relatives au traitement par lots sont les suivantes :
+ AWS IoT Core ne garantit pas l'ordre général des messages. Le traitement par lots est effectué localement sur chaque hôte, ce qui peut entraîner le traitement des messages d'un lot dans un ordre différent de celui dans lequel ils ont été reçus.
+ AWS IoT Core ne fournit pas de support pour le traitement des messages du côté du récepteur. Il vous incombe de vous assurer que votre service en aval est configuré pour accepter et traiter les données par lots.
+ Le traitement par lots entre comptes n'est pas pris en charge, même si les messages sont destinés au même identifiant de ressource (URL HTTP ou ARN de ressource).
+ AWS IoT Core ne garantit pas que la taille du lot correspondra à la configuration que vous avez spécifiée. Les lots peuvent être inférieurs aux limites que vous avez configurées en fonction du calendrier et du flux de messages.
+ Lorsque le traitement par lots est activé, les charges utiles binaires (données non UTF-8) ne sont pas prises en charge. Seules les charges utiles de texte UTF-8 (telles que JSON) sont acceptées. Pour envoyer des données binaires, codez-les en base64 avant de les envoyer à l'action HTTP, puis décodez-les sur votre point de terminaison de réception. Par exemple, vous pouvez utiliser la [fonction d'encodage](iot-sql-functions.html#iot-function-encode) dans les règles de l'IoT pour coder la charge utile binaire. Vous pouvez également encoder la charge utile binaire dans votre appareil IoT et la publier sur. AWS IoT Core

## Actions d'erreur liées au traitement par lots
<a name="batching_errors"></a>

Vous ne serez pas en mesure de définir une logique de traitement par lots distincte dans votre définition d'action d'erreur. Toutefois, votre action d'erreur prendra en charge le traitement par lots si vous avez défini une logique de traitement par lots dans votre action principale.

Lorsqu'une demande par lots échoue, le moteur de AWS IoT Core règles suit la [logique de nouvelle tentative d'action HTTP](https-rule-action.md#https-rule-action-retry-logic). Après la dernière tentative, une action d'erreur sera invoquée pour l'ensemble du lot ayant échoué.

Voici un exemple de message d'action d'erreur lorsque le traitement par lots est activé :

```
{
    "ruleName": "FailedTopicRule",
    "topic": "topic/rulesengine",
    "payloadsWithMetadata": [
        {
            "id": 1,
            "cloudwatchTraceId": "bebd6d93-6d4a-899e-9e40-56e82252d2be",
            "clientId": "Test",
            "sourceIp": "10.0.0.0",
            "base64OriginalPayload": "eyJ1c2VyX2lkIjogInVzZXI1NjQ3IiwgInN0ZXBzX3RvZGF5IjogMTMzNjUsICJ0aW1lc3RhbXAiOiAiMjAyNS0xMC0wOVQwNzoyMjo1OC45ODQ3OTAxNzZaIn0="
        },
        {
            "id": 2,
            "cloudwatchTraceId": "af94d3b8-0b18-1dbf-2c7d-513f5cb9e2e1",
            "clientId": "Test",
            "sourceIp": "10.0.0.0",
            "base64OriginalPayload": "eyJ1c2VyX2lkIjogInVzZXI1NjQ3IiwgInN0ZXBzX3RvZGF5IjogMTMzNjUsICJ0aW1lc3RhbXAiOiAiMjAyNS0xMC0wOVQwNzoyMjo1OC45ODQ3OTAxNzZaIn0="
        },
        {
            "id": 3,
            "cloudwatchTraceId": "ca441266-c2ce-c916-6aee-b9e5c7831675",
            "clientId": "Test",
            "sourceIp": "10.0.0.0",
            "base64OriginalPayload": "eyJ1c2VyX2lkIjogInVzZXI1NjQ3IiwgInN0ZXBzX3RvZGF5IjogMTMzNjUsICJ0aW1lc3RhbXAiOiAiMjAyNS0xMC0wOVQwNzoyMjo1OC45ODQ3OTAxNzZaIn0="
        }
    ],
    "failures": [
        {
            "affectedIds": [
                1,
                2,
                3
            ],
            "failedAction": "HttpAction",
            "failedResource": "https://example.foobar.com/HttpAction",
            "errorMessage": "HttpAction failed to make a request to the specified endpoint. StatusCode: 500. Reason: Internal Server Error."
        },
        {
            "affectedIds": [
                3
            ],
            "failedAction": "S3Action",
            "failedResource": "amzn-s3-demo-bucket",
            "errorMessage": "Failed to put S3 object. The error received was The specified bucket does not exist"
        },
        {
            "affectedIds": [
                3
            ],
            "failedAction": "LambdaAction",
            "failedResource": "arn:aws:lambda:us-west-2:123456789012:function:dummy",
            "errorMessage": "Failed to invoke lambda function. Received Server error from Lambda. The error code is 403"
        }
    ]
}
```

**Note**  
Les échecs d'action par lots génèrent également des charges utiles d'actions d'erreur plus importantes, ce qui peut augmenter la probabilité d'échec des actions d'erreur en raison de leur taille. Vous pouvez surveiller les échecs liés aux actions d'erreur à l'aide de la `ErrorActionFailure` métrique. Pour plus d’informations, consultez [Métriques d'action de règle](metrics_dimensions.md#rule-action-metrics).

## Regrouper les messages d'action HTTP à l'aide du AWS CLI
<a name="batching_procedure"></a>

### Création ou mise à jour d'une action de règle avec traitement par lots
<a name="batching_create_update_rule"></a>

1. Utilisez la AWS CLI commande appropriée pour créer ou mettre à jour une règle :
   + Pour créer une nouvelle règle, utilisez la [create-topic-rule](https://docs.aws.amazon.com/cli/latest/reference/iot/create-topic-rule.html)commande :

     ```
     aws iot create-topic-rule --rule-name myrule --topic-rule-payload file://myrule.json
     ```
   + Pour mettre à jour une règle existante, utilisez la [replace-topic-rule](https://docs.aws.amazon.com/cli/latest/reference/iot/replace-topic-rule.html)commande :

     ```
     aws iot replace-topic-rule --rule-name myrule --topic-rule-payload file://myrule.json
     ```

1. Activez les fonctionnalités de traitement par lots en définissant le paramètre EnableBatching sur true dans la charge utile de votre règle de sujet :

   ```
   {
           "topicRulePayload": {
           "sql": "SELECT * FROM 'some/topic'", 
           "ruleDisabled": false,
           "awsIotSqlVersion": "2016-03-23", 
           "actions": [
               { 
                   "http": { 
                       "url": "https://www.example.com/subpath",
                       "confirmationUrl": "https://www.example.com", 
                       "headers": [
                           { 
                               "key": "static_header_key", 
                               "value": "static_header_value" 
                           },
                           { 
                               "key": "substitutable_header_key", 
                               "value": "${value_from_payload}" 
                            }
                       ],
                       "enableBatching": true,
                       "batchConfig": {
                          "maxBatchOpenMs": 100,
                          "maxBatchSize": 5,
                          "maxBatchSizeBytes": 1024
                       }
                   }
               }
         ]
   }
   ```

1. Configurez les paramètres de traitement par lots. Il n'est pas nécessaire de spécifier tous les paramètres du lot. Vous pouvez choisir de spécifier 1, 2 ou les 3 paramètres de lot. Si vous ne spécifiez aucun paramètre de lot, Rules Engine met à jour ce paramètre avec les valeurs par défaut. Pour plus d'informations sur les paramètres de traitement par lots et leurs valeurs par défaut, consultez la section [Paramètres HTTP](https-rule-action.md#https-rule-action-parameters).

# Destinations d'action HTTP
<a name="http-action-destination"></a>

Une destination d'action HTTP est un service Web vers lequel le moteur de règles peut acheminer les données d'une règle de rubrique. Une AWS IoT Core ressource décrit le service Web pour AWS IoT. Les ressources de destination peuvent être partagées selon différentes règles.

Avant de AWS IoT Core pouvoir envoyer des données à un autre service Web, celui-ci doit confirmer qu'il peut accéder au point de terminaison du service.

## Présentation de
<a name="http-action-destination-overview"></a>

Une destination d'action HTTP fait référence à un service Web qui prend en charge une URL de confirmation et une ou plusieurs collectes de données URLs. La ressource de destination contient l'URL de confirmation de votre service Web. Lorsque vous configurez une action HTTP, vous spécifiez l'URL réelle du point de terminaison qui doit recevoir les données ainsi que l'URL de confirmation du service Web. Une fois votre destination confirmée, la règle du sujet envoie le résultat de l'instruction SQL au point de terminaison HTTPS (et non à l'URL de confirmation).

Une destination d'action HTTP peut se trouver dans l'un des états suivants :

ENABLED  
La destination a été confirmée et peut être utilisée par une action de règle. L'état d'une destination doit être `ENABLED` (ACTIVÉ) pour qu'elle soit utilisée dans une règle. Vous pouvez uniquement activer une destination dont l'état est DISABLED (DÉSACTIVÉ).

DISABLED  
La destination a été confirmée mais elle ne peut pas être utilisée par une action de règle. Cet état est utile si vous souhaitez empêcher temporairement le trafic vers votre point de terminaison sans avoir à passer à nouveau par le processus de confirmation. Vous pouvez uniquement désactiver une destination dont l'état est ENABLED (ACTIVÉ).

EN\$1COURS  
La confirmation de la destination est en cours.

ERROR  
La confirmation de la destination a expiré.

Une fois qu'une destination d'action HTTP a été confirmée et activée, elle peut être utilisée avec n'importe quelle règle de votre compte.

## Gestion des destinations d'action HTTP
<a name="http-action-destination-managing"></a>

Vous pouvez utiliser les opérations suivantes pour gérer vos destinations d'actions HTTP.

### Création de destinations d'action HTTP
<a name="http-action-destination-creating"></a>

Vous créez une destination d'action HTTP en appelant l'`CreateTopicRuleDestination`opération ou en utilisant la AWS IoT console.

Après avoir créé une destination, AWS IoT envoie une demande de confirmation à l'URL de confirmation. Le format de la demande de confirmation est le suivant :

```
HTTP POST {confirmationUrl}/?confirmationToken={confirmationToken}
Headers:
x-amz-rules-engine-message-type: DestinationConfirmation
x-amz-rules-engine-destination-arn:"arn:aws:iot:us-east-1:123456789012:ruledestination/http/7a280e37-b9c6-47a2-a751-0703693f46e4"
Content-Type: application/json
Body:
{
    "arn":"arn:aws:iot:us-east-1:123456789012:ruledestination/http/7a280e37-b9c6-47a2-a751-0703693f46e4",  
    "confirmationToken": "AYADeMXLrPrNY2wqJAKsFNn-…NBJndA",
    "enableUrl": "https://iot.us-east-1.amazonaws.com/confirmdestination/AYADeMXLrPrNY2wqJAKsFNn-…NBJndA",
    "messageType": "DestinationConfirmation"
}
```

Le contenu de la demande de confirmation comprend les informations suivantes :

arn  
Le nom de ressource Amazon (ARN) pour la destination de l'action HTTP à confirmer.

confirmationToken  
Le jeton de confirmation envoyé par AWS IoT Core. Dans l'exemple, le jeton est tronqué. Votre jeton sera plus long. Vous aurez besoin de ce jeton pour confirmer votre destination AWS IoT Core.

enableUrl  
L'URL à laquelle vous accédez pour confirmer la destination d'une règle de rubrique.

messageType  
Type du message.

### Confirmation des destinations d'action HTTP
<a name="http-action-destination-confirming"></a>

Pour terminer le processus de confirmation du point de terminaison, si vous utilisez le AWS CLI, vous devez effectuer les étapes suivantes une fois que votre URL de confirmation a reçu la demande de confirmation.

1. 

**Vérifiez que la destination est prête à recevoir des messages**  
Pour confirmer que la destination de l'action HTTP est prête à recevoir des messages IoT, appelez-la `enableUrl` dans la demande de confirmation ou effectuez l'opération `ConfirmTopicRuleDestination` API et transmettez le contenu `confirmationToken` de la demande de confirmation.

1. 

**Définir le statut des règles du sujet sur Activé**  
Après avoir confirmé que la destination peut recevoir des messages, vous devez exécuter l'opération d'`UpdateTopicRuleDestination`API pour définir le statut de la règle du sujet sur`ENABLED`.

Si vous utilisez la AWS IoT console, copiez-la `confirmationToken` et collez-la dans la boîte de dialogue de confirmation de la destination dans la AWS IoT console. Vous pouvez ensuite activer la règle du sujet.

### Envoi d'une nouvelle demande de confirmation
<a name="trigger-confirm"></a>

Pour activer un nouveau message de confirmation pour une destination, appelez `UpdateTopicRuleDestination` et réglez le statut de la règle de thème destination sur `IN_PROGRESS`. 

Répétez le processus de confirmation après avoir envoyé une nouvelle demande de confirmation.

### Désactivation et suppression d'une destination d'action HTTP
<a name="http-action-destination-deleting"></a>

Pour désactiver une destination, appelez `UpdateTopicRuleDestination` et définissez l'état de la destination de règle de rubrique sur `DISABLED`. Une règle de rubrique à l'état DÉSACTIVÉ peut être réactivée sans qu'il soit nécessaire d'envoyer une nouvelle demande de confirmation.

Pour supprimer une destination d'action HTTP, appelez`DeleteTopicRuleDestination`.

## Support aux autorités de certification
<a name="http-action-destination-certificates"></a>

**Note**  
Les certificats auto-signés ne sont pas pris en charge. 

 Les points de terminaison HTTPS d'une destination d'action HTTP prennent en charge les certificats émis à la fois par [AWS Private Certificate Authority](https://www.amazontrust.com/repository/) et par [Lets Encrypt](https://letsencrypt.org/certificates/). 