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.
# Hooks Lambda
Pour utiliser un AWS Lambda Hook dans votre compte, vous devez d'abord *activer* le Hook pour le compte et la région dans lesquels vous souhaitez l'utiliser. L'activation d'un Hook le rend utilisable dans les opérations de stack du compte et de la région où il est activé.
Lorsque vous activez un Lambda Hook, CloudFormation crée une entrée dans le registre de votre compte pour le Hook activé en tant que Hook privé. Cela vous permet de définir toutes les propriétés de configuration incluses dans le Hook. Les propriétés de configuration définissent la manière dont le Hook est configuré pour une région Compte AWS et une région données.
**Topics**
+ [
## AWS CLI commandes pour travailler avec les Hooks Lambda
](#commonly-used-commands-lambda-hooks)
+ [
# Créez des fonctions Lambda pour évaluer les ressources pour les Lambda Hooks
](lambda-hooks-create-lambda-function.md)
+ [
# Préparez-vous à créer un crochet Lambda
](lambda-hooks-prepare-to-create-hook.md)
+ [
# Activez un Lambda Hook dans votre compte
](lambda-hooks-activate-hooks.md)
+ [
# Afficher les journaux des Lambda Hooks dans votre compte
](lambda-hooks-view-logs.md)
+ [
# Supprimer les Lambda Hooks de votre compte
](lambda-hooks-delete-hooks.md)
## AWS CLI commandes pour travailler avec les Hooks Lambda
Les AWS CLI commandes permettant d'utiliser les Hooks Lambda sont les suivantes :
+ [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/activate-type.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/activate-type.html)pour démarrer le processus d'activation d'un Lambda Hook.
+ [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/set-type-configuration.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/set-type-configuration.html)pour spécifier les données de configuration d'un Hook dans votre compte.
+ [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-types.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-types.html)pour répertorier les Hooks de votre compte.
+ [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-type.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-type.html)pour renvoyer des informations détaillées sur un Hook spécifique ou une version spécifique de Hook, y compris les données de configuration actuelles.
+ [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deactivate-type.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deactivate-type.html)pour supprimer un Hook précédemment activé de votre compte.
# Créez des fonctions Lambda pour évaluer les ressources pour les Lambda Hooks
CloudFormation Lambda Hooks vous permet d'évaluer CloudFormation et d'effectuer API de commande du Cloud AWS des opérations par rapport à votre propre code personnalisé. Votre Hook peut bloquer le déroulement d'une opération ou envoyer un avertissement à l'appelant et autoriser le déroulement de l'opération. Lorsque vous créez un Lambda Hook, vous pouvez le configurer pour intercepter et évaluer les opérations suivantes : CloudFormation
+ Opérations de ressources
+ Opérations de pile
+ Modifier les opérations du set
**Topics**
+ [
## Développement d'un hook Lambda
](#lambda-hooks-create-lambda-function-develop)
+ [
## Évaluation des opérations sur les ressources avec les Lambda Hooks
](#lambda-hooks-create-lambda-function-resource)
+ [
## Évaluation des opérations de stack avec les Lambda Hooks
](#lambda-hooks-create-lambda-function-stack)
+ [
## Évaluation des opérations relatives aux ensembles de modifications avec les Lambda Hooks
](#lambda-hooks-create-lambda-function-change-set)
## Développement d'un hook Lambda
Lorsque les Hooks invoquent votre Lambda, le Lambda attend jusqu'à 30 secondes pour évaluer l'entrée. Le Lambda renverra une réponse JSON indiquant si le Hook a réussi ou échoué.
**Topics**
+ [
### Demande d'entrée
](#lambda-hooks-create-lambda-function-request-input)
+ [
### Entrée de réponse
](#lambda-hooks-create-lambda-function-request-response)
+ [
### Exemples
](#lambda-hooks-create-lambda-function-request-example)
### Demande d'entrée
L'entrée transmise à votre fonction Lambda dépend de l'opération cible Hook (exemples : stack, resource ou change set).
### Entrée de réponse
Afin de communiquer à Hooks si votre demande a réussi ou échoué, votre fonction Lambda doit renvoyer une réponse JSON.
Voici un exemple de forme de la réponse attendue par Hooks :
```
{
"État du crochet": "SUCCESS" or "FAILED" or "IN_PROGRESS",
"errorCode": "NonCompliant" or "InternalFailure"
"message": String,
"clientRequestToken": String,
"Contexte de rappel": None,
"callbackDelaySeconds": Integer,
"annotations": [
{
"annotationName": String,
"status": "PASSED" or "FAILED" or "SKIPPED",
"statusMessage": String,
"remediationMessage": String,
"remediationLink": String,
"severityLevel": "INFORMATIONAL" or "LOW" or "MEDIUM" or "HIGH" or "CRITICAL"
}
]
}
```
État du crochet
L'état du Hook. Ce champ est obligatoire.
*Valeurs valides* : (`SUCCESS`\$1 `FAILED` \$1`IN_PROGRESS`)
Un Hook peut revenir `IN_PROGRESS` 3 fois. Si aucun résultat n'est renvoyé, le Hook échouera. Pour un Lambda Hook, cela signifie que votre fonction Lambda peut être invoquée jusqu'à 3 fois.
errorCode
Indique si l'opération a été évaluée et jugée non valide, ou si des erreurs se sont produites dans le Hook, empêchant l'évaluation. Ce champ est obligatoire en cas d'échec du Hook.
*Valeurs valides* : (`NonCompliant`\$1`InternalFailure`)
message
Le message envoyé à l'appelant expliquant pourquoi le Hook a réussi ou échoué.
Lors de l'évaluation CloudFormation des opérations, ce champ est tronqué à 4 096 caractères.
Lors de l'évaluation des opérations de l'API Cloud Control, ce champ est tronqué à 1024 caractères.
clientRequestToken
Le jeton de demande qui a été fourni en entrée de la demande Hook. Ce champ est obligatoire.
Contexte de rappel
Si vous indiquez que `hookStatus` c'est le cas, `IN_PROGRESS` vous transmettez un contexte supplémentaire fourni en entrée lorsque la fonction Lambda est réinvoquée.
callbackDelaySeconds
Combien de temps les Hooks doivent-ils attendre pour invoquer à nouveau ce Hook ?
annotations
Un ensemble d'objets d'annotation qui fournissent des informations supplémentaires et des conseils de correction.
Nom de l'annotation
Identifiant de l'annotation.
status
Le statut d'invocation de Hook. Cela est utile lorsque les annotations représentent une logique avec une évaluation de réussite ou d'échec similaire à une règle Guard.
*Valeurs valides* : (`PASSED`\$1 `FAILED` \$1`SKIPPED`)
statusMessage
Explication du statut spécifique.
Message de correction
Suggestion pour fixer un `FAILED` statut. Par exemple, si le chiffrement d'une ressource n'est pas chiffré, vous pouvez indiquer comment ajouter le chiffrement à la configuration de la ressource.
Lien vers l'assainissement
Une URL HTTP pour des conseils de correction supplémentaires.
severityLevel
Définit le risque relatif associé à toute violation de ce type. Lorsque vous attribuez des niveaux de gravité aux résultats de votre appel Hook, vous pouvez vous référer au [cadre de AWS Security Hub CSPM gravité](https://docs.aws.amazon.com/securityhub/latest/userguide/asff-required-attributes.html#Severity) comme exemple de la manière de structurer des catégories de gravité significatives.
*Valeurs valides* : (`INFORMATIONAL`\$1 `LOW` \$1 `MEDIUM` \$1 `HIGH` \$1`CRITICAL`)
### Exemples
Voici un exemple de réponse réussie :
```
{
"hookStatus": "SUCCESS",
"message": "compliant",
"clientRequestToken": "123avjdjk31"
}
```
Voici un exemple d'échec de réponse :
```
{
"hookStatus": "FAILED",
"errorCode": "NonCompliant",
"message": "S3 Bucket Versioning must be enabled.",
"clientRequestToken": "123avjdjk31"
}
```
## Évaluation des opérations sur les ressources avec les Lambda Hooks
Chaque fois que vous créez, mettez à jour ou supprimez une ressource, cela est considéré comme une opération de ressource. Par exemple, si vous exécutez la mise à jour d'une CloudFormation pile qui crée une nouvelle ressource, vous avez terminé une opération sur la ressource. Lorsque vous créez, mettez à jour ou supprimez une ressource à l'aide de l'API Cloud Control, cela est également considéré comme une opération de ressource. Vous pouvez configurer votre CloudFormation Lambda Hook en fonction du ciblage `RESOURCE` et `CLOUD_CONTROL` des opérations dans la configuration du Hook`TargetOperations`.
**Note**
Le gestionnaire `delete` Hook n'est invoqué que lorsqu'une ressource est supprimée à l'aide d'un déclencheur d'opération de l'API Cloud Control `delete-resource` ou CloudFormation `delete-stack`.
**Topics**
+ [
### Syntaxe d'entrée des ressources Lambda Hook
](#lambda-hooks-create-lambda-function-resource-input)
+ [
### Exemple d'entrée de modification de ressource Lambda Hook
](#lambda-hooks-create-lambda-function-resource-example)
+ [
### Exemple de fonction Lambda pour les opérations sur les ressources
](#lambda-hooks-create-lambda-function-resource-example-function)
### Syntaxe d'entrée des ressources Lambda Hook
Lorsque votre Lambda est invoqué pour une opération sur une ressource, vous recevez une entrée JSON contenant les propriétés de la ressource, les propriétés proposées et le contexte de l'invocation de Hook.
Voici un exemple de forme de l'entrée JSON :
```
{
"awsAccountId": String,
"stackId": String,
"changeSetId": String,
"hookTypeName": String,
"hookTypeVersion": String,
"hookModel": {
"LambdaFunction": String
},
"actionInvocationPoint": "CREATE_PRE_PROVISION" or "UPDATE_PRE_PROVISION" or "DELETE_PRE_PROVISION"
"requestData": {
"targetName": String,
"targetType": String,
"targetLogicalId": String,
"targetModel": {
"resourceProperties": {...},
"previousResourceProperties": {...}
}
},
"requestContext": {
"invocation": 1,
"Contexte de rappel": null
}
}
```
`awsAccountId`
ID du Compte AWS contenant la ressource en cours d'évaluation.
`stackId`
L'ID de pile de la CloudFormation pile dont cette opération fait partie. Ce champ est vide si l'appelant est Cloud Control API.
`changeSetId`
L'ID de l'ensemble de modifications qui a initié l'invocation de Hook. Cette valeur est vide si le changement de ressource a été initié par l'API Cloud Control ou par les `delete-stack` opérations `create-stack``update-stack`, ou.
`hookTypeName`
Le nom du Hook en cours d'exécution.
`hookTypeVersion`
Version du Hook en cours d'exécution.
`hookModel`
`LambdaFunction`
L'ARN Lambda actuel invoqué par le Hook.
`actionInvocationPoint`
Point exact de la logique de provisionnement où le Hook s'exécute.
*Valeurs valides* : (`CREATE_PRE_PROVISION`\$1 `UPDATE_PRE_PROVISION` \$1`DELETE_PRE_PROVISION`)
`requestData`
`targetName`
Le type de cible évalué, par exemple,`AWS::S3::Bucket`.
`targetType`
Le type de cible évalué, par exemple`AWS::S3::Bucket`. Pour les ressources fournies avec l'API Cloud Control, cette valeur sera`RESOURCE`.
`targetLogicalId`
ID logique de la ressource en cours d'évaluation. Si l'origine de l'invocation de Hook est CloudFormation, il s'agira de l'ID de ressource logique défini dans votre CloudFormation modèle. Si l'origine de cette invocation de Hook est l'API Cloud Control, il s'agira d'une valeur construite.
`targetModel`
`resourceProperties`
Les propriétés proposées pour la ressource en cours de modification. Si la ressource est supprimée, cette valeur sera vide.
`previousResourceProperties`
Les propriétés actuellement associées à la ressource en cours de modification. Si la ressource est créée, cette valeur sera vide.
`requestContext`
invocation
La tentative actuelle d'exécution du Hook.
Contexte de rappel
Si le Hook a été réglé sur `IN_PROGRESS` et `callbackContext` a été renvoyé, il sera là après sa révocation.
### Exemple d'entrée de modification de ressource Lambda Hook
L'exemple d'entrée suivant montre un Lambda Hook qui recevra la définition de la `AWS::DynamoDB::Table` ressource à mettre à jour, le nombre `ReadCapacityUnits` de `ProvisionedThroughput` passant de 3 à 10. Il s'agit des données dont Lambda dispose pour évaluation.
```
{
"awsAccountId": "123456789012",
"stackId": "arn:aws:cloudformation:us-west-2:123456789012:stack/MyStack/1a2345b6-0000-00a0-a123-00abc0abc000",
"hookTypeName": "my::lambda::resourcehookfunction",
"hookTypeVersion": "00000008",
"hookModel": {
"LambdaFunction": "arn:aws:lambda:us-west-2:123456789012:function:MyFunction"
},
"actionInvocationPoint": "UPDATE_PRE_PROVISION",
"requestData": {
"targetName": "AWS::DynamoDB::Table",
"targetType": "AWS::DynamoDB::Table",
"targetLogicalId": "DDBTable",
"targetModel": {
"resourceProperties": {
"AttributeDefinitions": [
{
"AttributeType": "S",
"AttributeName": "Album"
},
{
"AttributeType": "S",
"AttributeName": "Artist"
}
],
"ProvisionedThroughput": {
"WriteCapacityUnits": 5,
"ReadCapacityUnits": 10
},
"KeySchema": [
{
"KeyType": "HASH",
"AttributeName": "Album"
},
{
"KeyType": "RANGE",
"AttributeName": "Artist"
}
]
},
"previousResourceProperties": {
"AttributeDefinitions": [
{
"AttributeType": "S",
"AttributeName": "Album"
},
{
"AttributeType": "S",
"AttributeName": "Artist"
}
],
"ProvisionedThroughput": {
"WriteCapacityUnits": 5,
"ReadCapacityUnits": 5
},
"KeySchema": [
{
"KeyType": "HASH",
"AttributeName": "Album"
},
{
"KeyType": "RANGE",
"AttributeName": "Artist"
}
]
}
}
},
"requestContext": {
"invocation": 1,
"callbackContext": null
}
}
```
Pour voir toutes les propriétés disponibles pour le type de ressource, consultez [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-dynamodb-table.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-dynamodb-table.html).
### Exemple de fonction Lambda pour les opérations sur les ressources
Voici une fonction simple qui échoue à toute mise à jour des ressources vers DynamoDB, qui essaie de définir une valeur supérieure à 10 à `ReadCapacity` la valeur `ProvisionedThroughput` de. Si le Hook réussit, le message « ReadCapacity est correctement configuré » s'affichera pour l'appelant. Si la demande échoue à la validation, le Hook échouera avec le statut « ReadCapacity ne peut pas être supérieur à 10 ».
------
#### [ Node.js ]
```
export const handler = async (event, context) => {
var targetModel = event?.requestData?.targetModel;
var targetName = event?.requestData?.targetName;
var response = {
"hookStatus": "SUCCESS",
"message": "ReadCapacity is correctly configured.",
"clientRequestToken": event.clientRequestToken
};
if (targetName == "AWS::DynamoDB::Table") {
var readCapacity = targetModel?.resourceProperties?.ProvisionedThroughput?.ReadCapacityUnits;
if (readCapacity > 10) {
response.hookStatus = "FAILED";
response.errorCode = "NonCompliant";
response.message = "ReadCapacity must be cannot be more than 10.";
}
}
return response;
};
```
------
#### [ Python ]
```
import json
def lambda_handler(event, context):
# Using dict.get() for safe access to nested dictionary values
request_data = event.get('requestData', {})
target_model = request_data.get('targetModel', {})
target_name = request_data.get('targetName', '')
response = {
"hookStatus": "SUCCESS",
"message": "ReadCapacity is correctly configured.",
"clientRequestToken": event.get('clientRequestToken')
}
if target_name == "AWS::DynamoDB::Table":
# Safely navigate nested dictionary
resource_properties = target_model.get('resourceProperties', {})
provisioned_throughput = resource_properties.get('ProvisionedThroughput', {})
read_capacity = provisioned_throughput.get('ReadCapacityUnits')
if read_capacity and read_capacity > 10:
response['hookStatus'] = "FAILED"
response['errorCode'] = "NonCompliant"
response['message'] = "ReadCapacity must be cannot be more than 10."
return response
```
------
## Évaluation des opérations de stack avec les Lambda Hooks
Chaque fois que vous créez, mettez à jour ou supprimez une pile avec un nouveau modèle, vous pouvez configurer votre CloudFormation Lambda Hook pour commencer par évaluer le nouveau modèle et éventuellement bloquer le déroulement de l'opération de pile. Vous pouvez configurer votre CloudFormation Lambda Hook pour cibler les `STACK` opérations dans la configuration Hook`TargetOperations`.
**Topics**
+ [
### Syntaxe d'entrée Lambda Hook Stack
](#lambda-hooks-create-lambda-function-stack-input)
+ [
### Exemple d'entrée de modification de la pile Lambda Hook
](#lambda-hooks-create-lambda-function-stack-example)
+ [
### Exemple de fonction Lambda pour les opérations de stack
](#lambda-hooks-create-lambda-function-stack-example-function)
### Syntaxe d'entrée Lambda Hook Stack
Lorsque votre Lambda est invoqué pour une opération de stack, vous recevez une requête JSON contenant le contexte d'invocation Hook et le contexte de la demande. `actionInvocationPoint` En raison de la taille des CloudFormation modèles et de la taille d'entrée limitée acceptée par les fonctions Lambda, les modèles réels sont stockés dans un objet Amazon S3. La saisie `requestData` inclut une URL abandonnée d'Amazon S3 vers un autre objet, qui contient la version actuelle et précédente du modèle.
Voici un exemple de forme de l'entrée JSON :
```
{
"clientRequesttoken": String,
"awsAccountId": String,
"stackID": String,
"changeSetId": String,
"hookTypeName": String,
"hookTypeVersion": String,
"hookModel": {
"LambdaFunction":String
},
"actionInvocationPoint": "CREATE_PRE_PROVISION" or "UPDATE_PRE_PROVISION" or "DELETE_PRE_PROVISION"
"requestData": {
"targetName": "STACK",
"targetType": "STACK",
"targetLogicalId": String,
"payload": String (S3 Presigned URL)
},
"requestContext": {
"invocation": Integer,
"callbackContext": String
}
}
```
`clientRequesttoken`
Le jeton de demande qui a été fourni en entrée de la demande Hook. Ce champ est obligatoire.
`awsAccountId`
ID du Compte AWS contenant la pile en cours d'évaluation.
`stackID`
ID de pile de la CloudFormation pile.
`changeSetId`
L'ID de l'ensemble de modifications qui a initié l'invocation de Hook. Cette valeur est vide si le changement de pile a été initié par l'API Cloud Control ou par les `delete-stack` opérations `create-stack``update-stack`, ou.
`hookTypeName`
Le nom du Hook en cours d'exécution.
`hookTypeVersion`
Version du Hook en cours d'exécution.
`hookModel`
`LambdaFunction`
L'ARN Lambda actuel invoqué par le Hook.
`actionInvocationPoint`
Point exact de la logique de provisionnement où le Hook s'exécute.
*Valeurs valides* : (`CREATE_PRE_PROVISION`\$1 `UPDATE_PRE_PROVISION` \$1`DELETE_PRE_PROVISION`)
`requestData`
`targetName`
Cette valeur sera`STACK`.
`targetType`
Cette valeur sera`STACK`.
`targetLogicalId`
Nom de la pile.
`payload`
URL présignée Amazon S3 contenant un objet JSON avec les définitions de modèles actuelles et précédentes.
`requestContext`
Si le Hook est réinvoqué, cet objet sera défini.
`invocation`
La tentative actuelle d'exécution du Hook.
`callbackContext`
Si le Hook a été réglé sur `IN_PROGRESS` et `callbackContext` a été renvoyé, il sera présent lors de sa révocation.
La `payload` propriété contenue dans les données de demande est une URL que votre code doit récupérer. Une fois qu'il a reçu l'URL, vous obtenez un objet avec le schéma suivant :
```
{
"template": String,
"previousTemplate": String
}
```
`template`
Le CloudFormation modèle complet qui a été fourni à `create-stack` ou`update-stack`. Il peut s'agir d'une chaîne JSON ou YAML en fonction de ce qui a été fourni. CloudFormation
Dans `delete-stack` les opérations, cette valeur sera vide.
`previousTemplate`
Le CloudFormation modèle précédent. Il peut s'agir d'une chaîne JSON ou YAML en fonction de ce qui a été fourni. CloudFormation
Dans `delete-stack` les opérations, cette valeur sera vide.
### Exemple d'entrée de modification de la pile Lambda Hook
Voici un exemple d'entrée de changement de pile. The Hook évalue une modification qui met le à jour `ObjectLockEnabled` à true et ajoute une file d'attente Amazon SQS :
```
{
"clientRequestToken": "f8da6d11-b23f-48f4-814c-0fb6a667f50e",
"awsAccountId": "123456789012",
"stackId": "arn:aws:cloudformation:us-west-2:123456789012:stack/MyStack/1a2345b6-0000-00a0-a123-00abc0abc000",
"changeSetId": null,
"hookTypeName": "my::lambda::stackhook",
"hookTypeVersion": "00000008",
"hookModel": {
"LambdaFunction": "arn:aws:lambda:us-west-2:123456789012:function:MyFunction"
},
"actionInvocationPoint": "UPDATE_PRE_PROVISION",
"requestData": {
"targetName": "STACK",
"targetType": "STACK",
"targetLogicalId": "my-cloudformation-stack",
"payload": "https://s3......"
},
"requestContext": {
"invocation": 1,
"callbackContext": null
}
}
```
Voici un exemple `payload` de `requestData` :
```
{
"template": "{\"Resources\":{\"S3Bucket\":{\"Type\":\"AWS::S3::Bucket\",\"Properties\":{\"ObjectLockEnabled\":true}},\"SQSQueue\":{\"Type\":\"AWS::SQS::Queue\",\"Properties\":{\"QueueName\":\"NewQueue\"}}}}",
"previousTemplate": "{\"Resources\":{\"S3Bucket\":{\"Type\":\"AWS::S3::Bucket\",\"Properties\":{\"ObjectLockEnabled\":false}}}}"
}
```
### Exemple de fonction Lambda pour les opérations de stack
L'exemple suivant est une fonction simple qui télécharge la charge utile de l'opération de pile, analyse le modèle JSON et le renvoie. `SUCCESS`
------
#### [ Node.js ]
```
export const handler = async (event, context) => {
var targetType = event?.requestData?.targetType;
var payloadUrl = event?.requestData?.payload;
var response = {
"hookStatus": "SUCCESS",
"message": "Stack update is compliant",
"clientRequestToken": event.clientRequestToken
};
try {
const templateHookPayloadRequest = await fetch(payloadUrl);
const templateHookPayload = await templateHookPayloadRequest.json()
if (templateHookPayload.template) {
// Do something with the template templateHookPayload.template
// JSON or YAML
}
if (templateHookPayload.previousTemplate) {
// Do something with the template templateHookPayload.previousTemplate
// JSON or YAML
}
} catch (error) {
console.log(error);
response.hookStatus = "FAILED";
response.message = "Failed to evaluate stack operation.";
response.errorCode = "InternalFailure";
}
return response;
};
```
------
#### [ Python ]
Pour utiliser Python, vous devez importer la `requests` bibliothèque. Pour ce faire, vous devez inclure la bibliothèque dans votre package de déploiement lors de la création de votre fonction Lambda. Pour plus d'informations, consultez la section [Création d'un package de déploiement .zip avec dépendances](https://docs.aws.amazon.com/lambda/latest/dg/python-package.html#python-package-create-dependencies) dans le *Guide du AWS Lambda développeur*.
```
import json
import requests
def lamnbda_handler(event, context):
# Safely access nested dictionary values
request_data = event.get('requestData', {})
target_type = request_data.get('targetType')
payload_url = request_data.get('payload')
response = {
"hookStatus": "SUCCESS",
"message": "Stack update is compliant",
"clientRequestToken": event.get('clientRequestToken')
}
try:
# Fetch the payload
template_hook_payload_request = requests.get(payload_url)
template_hook_payload_request.raise_for_status() # Raise an exception for bad responses
template_hook_payload = template_hook_payload_request.json()
if 'template' in template_hook_payload:
# Do something with the template template_hook_payload['template']
# JSON or YAML
pass
if 'previousTemplate' in template_hook_payload:
# Do something with the template template_hook_payload['previousTemplate']
# JSON or YAML
pass
except Exception as error:
print(error)
response['hookStatus'] = "FAILED"
response['message'] = "Failed to evaluate stack operation."
response['errorCode'] = "InternalFailure"
return response
```
------
## Évaluation des opérations relatives aux ensembles de modifications avec les Lambda Hooks
Chaque fois que vous créez un ensemble de modifications, vous pouvez configurer votre CloudFormation Lambda Hook pour d'abord évaluer le nouvel ensemble de modifications et éventuellement bloquer son exécution. Vous pouvez configurer votre CloudFormation Lambda Hook pour cibler les `CHANGE_SET` opérations dans la configuration Hook`TargetOperations`.
**Topics**
+ [
### Lambda Hook modifie la syntaxe d'entrée du set
](#lambda-hooks-create-lambda-function-change-set-input)
+ [
### Exemple : Lambda Hook change Set, change d'entrée
](#lambda-hooks-create-lambda-function-change-set-example)
+ [
### Exemple de fonction Lambda pour les opérations d'ensemble de modifications
](#lambda-hooks-create-lambda-function-change-set-example-function)
### Lambda Hook modifie la syntaxe d'entrée du set
L'entrée pour les opérations d'ensemble de modifications est similaire à celle des opérations de pile, mais la charge utile des opérations inclut `requestData` également une liste des modifications de ressources introduites par l'ensemble de modifications.
Voici un exemple de forme de l'entrée JSON :
```
{
"clientRequesttoken": String,
"awsAccountId": String,
"stackID": String,
"changeSetId": String,
"hookTypeName": String,
"hookTypeVersion": String,
"hookModel": {
"LambdaFunction":String
},
"requestData": {
"targetName": "CHANGE_SET",
"targetType": "CHANGE_SET",
"targetLogicalId": String,
"payload": String (S3 Presigned URL)
},
"requestContext": {
"invocation": Integer,
"callbackContext": String
}
}
```
`clientRequesttoken`
Le jeton de demande qui a été fourni en entrée de la demande Hook. Ce champ est obligatoire.
`awsAccountId`
ID du Compte AWS contenant la pile en cours d'évaluation.
`stackID`
ID de pile de la CloudFormation pile.
`changeSetId`
L'ID de l'ensemble de modifications qui a initié l'invocation de Hook.
`hookTypeName`
Le nom du Hook en cours d'exécution.
`hookTypeVersion`
Version du Hook en cours d'exécution.
`hookModel`
`LambdaFunction`
L'ARN Lambda actuel invoqué par le Hook.
`requestData`
`targetName`
Cette valeur sera`CHANGE_SET`.
`targetType`
Cette valeur sera`CHANGE_SET`.
`targetLogicalId`
La modification a défini l'ARN.
`payload`
L'URL présignée Amazon S3 contenant un objet JSON avec le modèle actuel, ainsi qu'une liste des modifications apportées par cet ensemble de modifications.
`requestContext`
Si le Hook est réinvoqué, cet objet sera défini.
`invocation`
La tentative actuelle d'exécution du Hook.
`callbackContext`
Si le Hook a été réglé sur `IN_PROGRESS` et `callbackContext` a été renvoyé, il sera présent lors de sa révocation.
La `payload` propriété contenue dans les données de demande est une URL que votre code doit récupérer. Une fois qu'il a reçu l'URL, vous obtenez un objet avec le schéma suivant :
```
{
"template": String,
"changedResources": [
{
"action": String,
"beforeContext": JSON String,
"afterContext": JSON String,
"lineNumber": Integer,
"logicalResourceId": String,
"resourceType": String
}
]
}
```
`template`
Le CloudFormation modèle complet qui a été fourni à `create-stack` ou`update-stack`. Il peut s'agir d'une chaîne JSON ou YAML en fonction de ce qui a été fourni. CloudFormation
`changedResources`
Liste des ressources modifiées.
`action`
Type de modification appliqué à la ressource.
*Valeurs valides* : (`CREATE`\$1 `UPDATE` \$1`DELETE`)
`beforeContext`
Chaîne JSON contenant les propriétés de la ressource avant la modification. Cette valeur est nulle lors de la création de la ressource. Toutes les valeurs booléennes et numériques de cette chaîne JSON sont des CHAÎNES.
`afterContext`
Une chaîne JSON contenant les propriétés des ressources si cet ensemble de modifications est exécuté. Cette valeur est nulle lorsque la ressource est supprimée. Toutes les valeurs booléennes et numériques de cette chaîne JSON sont des CHAÎNES.
`lineNumber`
Numéro de ligne du modèle à l'origine de cette modification. Si c'est le cas, `DELETE` cette valeur sera nulle.
`logicalResourceId`
ID de ressource logique de la ressource en cours de modification.
`resourceType`
Type de ressource en cours de modification.
### Exemple : Lambda Hook change Set, change d'entrée
Voici un exemple d'entrée de modification d'ensemble de modifications. Dans l'exemple suivant, vous pouvez voir les modifications introduites par l'ensemble de modifications. La première modification consiste à supprimer une file d'attente appelée`CoolQueue`. La deuxième modification consiste à ajouter une nouvelle file d'attente appelée`NewCoolQueue`. La dernière modification est une mise à jour du`DynamoDBTable`.
```
{
"clientRequestToken": "f8da6d11-b23f-48f4-814c-0fb6a667f50e",
"awsAccountId": "123456789012",
"stackId": "arn:aws:cloudformation:us-west-2:123456789012:stack/MyStack/1a2345b6-0000-00a0-a123-00abc0abc000",
"changeSetId": "arn:aws:cloudformation:us-west-2:123456789012:changeSet/SampleChangeSet/1a2345b6-0000-00a0-a123-00abc0abc000",
"hookTypeName": "my::lambda::changesethook",
"hookTypeVersion": "00000008",
"hookModel": {
"LambdaFunction": "arn:aws:lambda:us-west-2:123456789012:function:MyFunction"
},
"actionInvocationPoint": "CREATE_PRE_PROVISION",
"requestData": {
"targetName": "CHANGE_SET",
"targetType": "CHANGE_SET",
"targetLogicalId": "arn:aws:cloudformation:us-west-2:123456789012:changeSet/SampleChangeSet/1a2345b6-0000-00a0-a123-00abc0abc000",
"payload": "https://s3......"
},
"requestContext": {
"invocation": 1,
"callbackContext": null
}
}
```
Voici un exemple `payload` de `requestData.payload` :
```
{
template: 'Resources:\n' +
' DynamoDBTable:\n' +
' Type: AWS::DynamoDB::Table\n' +
' Properties:\n' +
' AttributeDefinitions:\n' +
' - AttributeName: "PK"\n' +
' AttributeType: "S"\n' +
' BillingMode: "PAY_PER_REQUEST"\n' +
' KeySchema:\n' +
' - AttributeName: "PK"\n' +
' KeyType: "HASH"\n' +
' PointInTimeRecoverySpecification:\n' +
' PointInTimeRecoveryEnabled: false\n' +
' NewSQSQueue:\n' +
' Type: AWS::SQS::Queue\n' +
' Properties:\n' +
' QueueName: "NewCoolQueue"',
changedResources: [
{
logicalResourceId: 'SQSQueue',
resourceType: 'AWS::SQS::Queue',
action: 'DELETE',
lineNumber: null,
beforeContext: '{"Properties":{"QueueName":"CoolQueue"}}',
afterContext: null
},
{
logicalResourceId: 'NewSQSQueue',
resourceType: 'AWS::SQS::Queue',
action: 'CREATE',
lineNumber: 14,
beforeContext: null,
afterContext: '{"Properties":{"QueueName":"NewCoolQueue"}}'
},
{
logicalResourceId: 'DynamoDBTable',
resourceType: 'AWS::DynamoDB::Table',
action: 'UPDATE',
lineNumber: 2,
beforeContext: '{"Properties":{"BillingMode":"PAY_PER_REQUEST","AttributeDefinitions":[{"AttributeType":"S","AttributeName":"PK"}],"KeySchema":[{"KeyType":"HASH","AttributeName":"PK"}]}}',
afterContext: '{"Properties":{"BillingMode":"PAY_PER_REQUEST","PointInTimeRecoverySpecification":{"PointInTimeRecoveryEnabled":"false"},"AttributeDefinitions":[{"AttributeType":"S","AttributeName":"PK"}],"KeySchema":[{"KeyType":"HASH","AttributeName":"PK"}]}}'
}
]
}
```
### Exemple de fonction Lambda pour les opérations d'ensemble de modifications
L'exemple suivant est une fonction simple qui télécharge la charge utile de l'opération d'ensemble de modifications, passe en revue chaque modification, puis imprime les propriétés avant et après avant de renvoyer un`SUCCESS`.
------
#### [ Node.js ]
```
export const handler = async (event, context) => {
var payloadUrl = event?.requestData?.payload;
var response = {
"hookStatus": "SUCCESS",
"message": "Change set changes are compliant",
"clientRequestToken": event.clientRequestToken
};
try {
const changeSetHookPayloadRequest = await fetch(payloadUrl);
const changeSetHookPayload = await changeSetHookPayloadRequest.json();
const changes = changeSetHookPayload.changedResources || [];
for(const change of changes) {
var beforeContext = {};
var afterContext = {};
if(change.beforeContext) {
beforeContext = JSON.parse(change.beforeContext);
}
if(change.afterContext) {
afterContext = JSON.parse(change.afterContext);
}
console.log(beforeContext)
console.log(afterContext)
// Evaluate Change here
}
} catch (error) {
console.log(error);
response.hookStatus = "FAILED";
response.message = "Failed to evaluate change set operation.";
response.errorCode = "InternalFailure";
}
return response;
};
```
------
#### [ Python ]
Pour utiliser Python, vous devez importer la `requests` bibliothèque. Pour ce faire, vous devez inclure la bibliothèque dans votre package de déploiement lors de la création de votre fonction Lambda. Pour plus d'informations, consultez la section [Création d'un package de déploiement .zip avec dépendances](https://docs.aws.amazon.com/lambda/latest/dg/python-package.html#python-package-create-dependencies) dans le *Guide du AWS Lambda développeur*.
```
import json
import requests
def lambda_handler(event, context):
payload_url = event.get('requestData', {}).get('payload')
response = {
"hookStatus": "SUCCESS",
"message": "Change set changes are compliant",
"clientRequestToken": event.get('clientRequestToken')
}
try:
change_set_hook_payload_request = requests.get(payload_url)
change_set_hook_payload_request.raise_for_status() # Raises an HTTPError for bad responses
change_set_hook_payload = change_set_hook_payload_request.json()
changes = change_set_hook_payload.get('changedResources', [])
for change in changes:
before_context = {}
after_context = {}
if change.get('beforeContext'):
before_context = json.loads(change['beforeContext'])
if change.get('afterContext'):
after_context = json.loads(change['afterContext'])
print(before_context)
print(after_context)
# Evaluate Change here
except requests.RequestException as error:
print(error)
response['hookStatus'] = "FAILED"
response['message'] = "Failed to evaluate change set operation."
response['errorCode'] = "InternalFailure"
except json.JSONDecodeError as error:
print(error)
response['hookStatus'] = "FAILED"
response['message'] = "Failed to parse JSON payload."
response['errorCode'] = "InternalFailure"
return response
```
------
# Préparez-vous à créer un crochet Lambda
Avant de créer un Lambda Hook, vous devez remplir les conditions préalables suivantes :
+ Vous devez déjà avoir créé une fonction Lambda. Pour de plus amples informations, veuillez consulter [Création de fonctions Lambda pour les Hooks](lambda-hooks-create-lambda-function.md).
+ L'utilisateur ou le rôle qui crée le Hook doit disposer des autorisations suffisantes pour activer les Hooks. Pour de plus amples informations, veuillez consulter [Accorder des autorisations IAM pour les Hooks CloudFormation](grant-iam-permissions-for-hooks.md).
+ Pour utiliser le AWS CLI ou un SDK pour créer un Lambda Hook, vous devez créer manuellement un rôle d'exécution avec des autorisations IAM et une politique de confiance CloudFormation permettant d'invoquer un Lambda Hook.
## Création d'un rôle d'exécution pour un Lambda Hook
Un Hook utilise un rôle d'exécution pour les autorisations dont il a besoin pour invoquer ce Hook dans votre Compte AWS.
Ce rôle peut être créé automatiquement si vous créez un Lambda Hook à partir du AWS Management Console ; sinon, vous devez créer ce rôle vous-même.
La section suivante explique comment configurer les autorisations pour créer votre Lambda Hook.
### Autorisations requises
Suivez les instructions de la section [Créer un rôle à l’aide de stratégies de confiance personnalisées](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html) dans le *Guide de l’utilisateur IAM* pour créer un rôle avec une stratégie de confiance personnalisée.
Suivez ensuite les étapes suivantes pour configurer vos autorisations :
1. Associez la politique de privilèges minimaux suivante au rôle IAM que vous souhaitez utiliser pour créer le Lambda Hook.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-west-2:123456789012:function:MyFunction"
}
]
}
```
------
1. Donnez à votre Hook l'autorisation d'assumer le rôle en ajoutant une politique de confiance au rôle. Voici un exemple de politique de confiance que vous pouvez utiliser.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"hooks.cloudformation.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
# Activez un Lambda Hook dans votre compte
La rubrique suivante explique comment activer un Lambda Hook dans votre compte, afin de le rendre utilisable dans le compte et la région dans lesquels il a été activé.
**Topics**
+ [
## Activer un Lambda Hook (console)
](#lambda-hooks-activate-hook-console)
+ [
## Activer un crochet Lambda ()AWS CLI
](#lambda-hooks-activate-hooks-cli)
+ [
## Ressources connexes
](#related-resources-lambda-hooks)
## Activer un Lambda Hook (console)
**Pour activer un Lambda Hook à utiliser sur votre compte**
1. Connectez-vous à la CloudFormation console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Dans la barre de navigation en haut de l'écran, choisissez l' Région AWS endroit où vous souhaitez créer le Hook in.
1. Si vous *n'avez pas* créé de fonction Lambda pour le Hook, procédez comme suit :
+ Ouvrez la [page Functions (Fonctions)](https://console.aws.amazon.com/lambda/home#/functions) sur la console Lambda.
+ Créez la fonction Lambda que vous utiliserez avec ce Hook, puis revenez à cette procédure. Pour de plus amples informations, veuillez consulter [Créez des fonctions Lambda pour évaluer les ressources pour les Lambda Hooks](lambda-hooks-create-lambda-function.md).
Si vous avez déjà créé votre fonction Lambda, passez à l'étape suivante.
1. Dans le volet de navigation de gauche, choisissez **Hooks**.
1. Sur la page **Hooks**, choisissez **Create a Hook**, puis choisissez **With Lambda**.
1. Pour le **nom du crochet**, choisissez l'une des options suivantes :
+ Entrez un nom court et descriptif qui sera ajouté par la suite`Private::Lambda::`. Par exemple, si vous entrez*`MyTestHook`*, le nom complet du Hook devient`Private::Lambda::MyTestHook`.
+ Fournissez le nom complet du Hook (également appelé alias) en utilisant le format suivant : `Provider::ServiceName::HookName`
1. Pour la fonction **Lambda, indiquez la fonction** Lambda à utiliser avec ce Hook. Vous pouvez utiliser :
+ Le nom complet de la ressource Amazon (ARN) sans suffixe.
+ Un ARN qualifié avec un suffixe de version ou d'alias.
1. Pour les **cibles Hook**, choisissez les éléments à évaluer :
+ **Piles : évalue les modèles de pile lorsque les utilisateurs créent, mettent à jour ou suppriment des piles**.
+ **Ressources** — Évalue les modifications individuelles des ressources lorsque les utilisateurs mettent à jour les piles.
+ **Ensembles de modifications** : évalue les mises à jour planifiées lorsque les utilisateurs créent des ensembles de modifications.
+ **API Cloud Control** — Évalue les opérations de création, de mise à jour ou de suppression initiées par l'[API Cloud Control](https://docs.aws.amazon.com/cloudcontrolapi/latest/userguide/what-is-cloudcontrolapi.html).
1. Pour **Actions**, choisissez les actions (créer, mettre à jour, supprimer) qui appelleront votre Hook.
1. Pour le **mode Hook**, choisissez la façon dont le Hook répond lorsque la fonction Lambda invoquée par le Hook renvoie une `FAILED` réponse :
+ **Avertir** — Émet des avertissements aux utilisateurs mais autorise la poursuite des actions. Cela est utile pour les validations non critiques ou les contrôles informatifs.
+ **Echec** : empêche le déroulement de l'action. Cela est utile pour appliquer des politiques de conformité ou de sécurité strictes.
1. Pour le **rôle d'exécution**, choisissez le rôle IAM que le Hook suppose pour appeler votre fonction Lambda. Vous pouvez soit CloudFormation autoriser la création automatique d'un rôle d'exécution pour vous, soit spécifier un rôle que vous avez créé.
1. Choisissez **Suivant**.
1. (Facultatif) Pour **les filtres Hook**, procédez comme suit :
1. Pour le **filtre de ressources**, spécifiez les types de ressources qui peuvent appeler le Hook. Cela garantit que le Hook n'est invoqué que pour les ressources pertinentes.
1. Pour les **critères de filtrage**, choisissez la logique d'application des filtres de nom de pile et de rôle de pile :
+ **Tous les noms de pile et tous les rôles** de pile — Le Hook ne sera invoqué que lorsque tous les filtres spécifiés correspondent.
+ **Tous les noms de pile et rôles** de pile — Le Hook sera invoqué si au moins l'un des filtres spécifiés correspond.
**Note**
Pour les opérations de l'API Cloud Control, tous les filtres **relatifs aux noms** de **pile et aux rôles** de pile sont ignorés.
1. Pour les **noms de pile**, incluez ou excluez des piles spécifiques des invocations Hook.
+ Pour **Inclure**, spécifiez les noms des piles à inclure. Utilisez-le lorsque vous souhaitez cibler un petit ensemble de piles spécifiques. Seules les piles spécifiées dans cette liste invoqueront le Hook.
+ Pour **Exclure**, spécifiez les noms des piles à exclure. Utilisez-le lorsque vous souhaitez invoquer le Hook sur la plupart des piles, mais en exclure quelques unes en particulier. Toutes les piles, à l'exception de celles répertoriées ici, invoqueront le Hook.
1. Pour les **rôles Stack**, incluez ou excluez des piles spécifiques des invocations Hook en fonction de leurs rôles IAM associés.
+ Pour **Inclure**, spécifiez un ou plusieurs rôles IAM ARNs pour cibler les piles associées à ces rôles. Seules les opérations de stack initiées par ces rôles invoqueront le Hook.
+ Pour **Exclure**, spécifiez un ou plusieurs rôles IAM ARNs pour les piles que vous souhaitez exclure. Le Hook sera invoqué sur toutes les piles sauf celles initiées par les rôles spécifiés.
1. Choisissez **Suivant**.
1. Sur la page **Vérifier et activer**, passez en revue vos choix. Pour apporter des modifications, sélectionnez **Modifier** dans la section correspondante.
1. Lorsque vous êtes prêt à continuer, choisissez **Activate Hook**.
## Activer un crochet Lambda ()AWS CLI
Avant de continuer, vérifiez que vous avez créé la fonction Lambda et le rôle d'exécution que vous allez utiliser avec ce Hook. Pour plus d’informations, consultez [Créez des fonctions Lambda pour évaluer les ressources pour les Lambda Hooks](lambda-hooks-create-lambda-function.md) et [Création d'un rôle d'exécution pour un Lambda Hook](lambda-hooks-prepare-to-create-hook.md#lambda-hooks-create-execution-role).
**Pour activer un Lambda Hook à utiliser dans votre compte ()AWS CLI**
1. Pour commencer à activer un Hook, utilisez la [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/activate-type.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/activate-type.html)commande suivante en remplaçant les espaces réservés par vos valeurs spécifiques. Cette commande autorise le Hook à utiliser un rôle d'exécution spécifié par votre Compte AWS.
```
aws cloudformation activate-type --type HOOK \
--type-name AWS::Hooks::LambdaHook \
--publisher-id aws-hooks \
--execution-role-arn arn:aws:iam::123456789012:role/my-execution-role \
--type-name-alias Private::Lambda::MyTestHook \
--region us-west-2
```
1. Pour terminer l'activation du Hook, vous devez le configurer à l'aide d'un fichier de configuration JSON.
Utilisez la **cat** commande pour créer un fichier JSON avec la structure suivante. Pour de plus amples informations, veuillez consulter [Référence syntaxique du schéma de configuration Hook](hook-configuration-schema.md).
```
$ cat > config.json
{
"CloudFormationConfiguration": {
"HookConfiguration": {
"HookInvocationStatus": "ENABLED",
"TargetOperations": [
"CLOUD_CONTROL"
],
"FailureMode": "WARN",
"Properties": {
"LambdaFunction": "arn:aws:lambda:us-west-2:123456789012:function:MyFunction"
},
"TargetFilters": {
"Actions": [
"CREATE",
"UPDATE",
"DELETE"
]
}
}
}
}
```
+ `HookInvocationStatus`: défini sur `ENABLED` pour activer le Hook.
+ `TargetOperations`: Spécifiez les opérations que le Hook évaluera.
+ `FailureMode` : Définissez sur `FAIL` ou `WARN`.
+ `LambdaFunction`: Spécifiez l'ARN de la fonction Lambda.
+ `TargetFilters`: Spécifiez les types d'actions qui appelleront le Hook.
1. Utilisez la [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/set-type-configuration.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/set-type-configuration.html)commande suivante, ainsi que le fichier JSON que vous avez créé, pour appliquer la configuration. Remplacez les espaces réservés par vos valeurs spécifiques.
```
aws cloudformation set-type-configuration \
--configuration file://config.json \
--type-arn "arn:aws:cloudformation:us-west-2:123456789012:type/hook/MyTestHook" \
--region us-west-2
```
## Ressources connexes
Nous fournissons des exemples de modèles que vous pouvez utiliser pour comprendre comment déclarer un Lambda Hook dans un modèle de CloudFormation pile. Pour plus d’informations, consultez [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-lambdahook.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-lambdahook.html) dans le *Guide de l’utilisateur AWS CloudFormation *.
# Afficher les journaux des Lambda Hooks dans votre compte
Lorsque vous utilisez un Lambda Hook, le fichier journal de votre rapport de sortie de validation se trouve dans la console Lambda.
## Afficher les journaux Lambda Hook dans la console Lambda
**Pour consulter le fichier journal de sortie du Lambda Hook**
1. Connectez-vous à la console Lambda.
1. Dans la barre de navigation, en haut de l’écran, sélectionnez votre Région AWS.
1. Choisissez **Functions**.
1. Choisissez la fonction Lambda souhaitée.
1. Choisissez l’onglet **Test**.
1. Choisissez **CloudWatch Logs Live Trail**
1. Choisissez le menu déroulant et sélectionnez les groupes de journaux que vous souhaitez consulter.
1. Sélectionnez **Démarrer**. Le journal s'affichera dans la fenêtre **CloudWatch Logs Live Trail**. Choisissez **Afficher en colonnes** ou **Afficher en texte brut** selon vos préférences.
+ Vous pouvez ajouter d'autres filtres aux résultats en les ajoutant dans le champ **Ajouter un modèle de filtre**. Ce champ vous permet de filtrer les résultats pour n'inclure que les événements correspondant au modèle spécifié.
Pour plus d'informations sur l'affichage des journaux des fonctions Lambda, consultez la section [Affichage CloudWatch des journaux des fonctions Lambda](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-cloudwatchlogs-view.html).
# Supprimer les Lambda Hooks de votre compte
Lorsque vous n'avez plus besoin d'un Lambda Hook activé, suivez les procédures suivantes pour le supprimer de votre compte.
Pour désactiver temporairement un Hook au lieu de le supprimer, consultez[Désactiver et activer les CloudFormation Hooks](hooks-disable-enable.md).
**Topics**
+ [
## Supprimer un Lambda Hook dans votre compte (console)
](#lambda-hooks-delete-hook-console)
+ [
## Supprimer un Lambda Hook dans votre compte ()AWS CLI
](#lambda-hooks-delete-hook-cli)
## Supprimer un Lambda Hook dans votre compte (console)
**Pour supprimer un Lambda Hook de votre compte**
1. Connectez-vous à la CloudFormation console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Dans la barre de navigation en haut de l'écran, choisissez l' Région AWS emplacement du crochet.
1. Dans le volet de navigation, choisissez **Hooks**.
1. Sur la page **Hooks**, recherchez le hook Lambda que vous souhaitez supprimer.
1. Cochez la case à côté de votre Hook et choisissez **Supprimer**.
1. Lorsque vous êtes invité à confirmer, saisissez le nom du crochet pour confirmer la suppression du crochet spécifié, puis choisissez **Supprimer**.
## Supprimer un Lambda Hook dans votre compte ()AWS CLI
**Note**
Avant de pouvoir supprimer le Hook, vous devez d'abord le désactiver. Pour de plus amples informations, veuillez consulter [Désactiver et activer un Hook dans votre compte (AWS CLI)](hooks-disable-enable.md#hooks-disable-enable-cli).
Utilisez la [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deactivate-type.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deactivate-type.html)commande suivante pour désactiver un Hook, ce qui le supprimera de votre compte. Remplacez les espaces réservés par vos valeurs spécifiques.
```
aws cloudformation deactivate-type \
--type-arn "arn:aws:cloudformation:us-west-2:123456789012:type/hook/MyTestHook" \
--region us-west-2
```