Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Enlaces de Lambda
Para usar un AWS Lambda Hook en tu cuenta, primero debes *activar* el Hook para la cuenta y la región en la que quieras usarlo. Al activar un Hook, podrás utilizarlo en las operaciones de apilamiento en la cuenta y la región en las que esté activado.
Cuando activas un Hook Lambda, CloudFormation crea una entrada en el registro de tu cuenta para el Hook activado como Hook privado. Esto le permite establecer cualquier propiedad de configuración que incluya el Hook. Las propiedades de configuración definen cómo se configura el Hook para una región determinada Cuenta de AWS .
**Topics**
+ [AWS CLI comandos para trabajar con Lambda Hooks](#commonly-used-commands-lambda-hooks)
+ [Cree funciones Lambda para evaluar los recursos de Lambda Hooks](lambda-hooks-create-lambda-function.md)
+ [Prepárese para crear un Hook Lambda](lambda-hooks-prepare-to-create-hook.md)
+ [Active un Lambda Hook en su cuenta](lambda-hooks-activate-hooks.md)
+ [Ver los registros de los Lambda Hooks de su cuenta](lambda-hooks-view-logs.md)
+ [Elimine Lambda Hooks de su cuenta](lambda-hooks-delete-hooks.md)
## AWS CLI comandos para trabajar con Lambda Hooks
Los AWS CLI comandos para trabajar con Lambda Hooks incluyen:
+ [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/activate-type.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/activate-type.html)para iniciar el proceso de activación de una 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)para especificar los datos de configuración de un Hook en su cuenta.
+ [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-types.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-types.html)para incluir los Hooks de tu cuenta.
+ [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-type.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-type.html)para obtener información detallada sobre un Hook específico o una versión específica de Hook, incluidos los datos de configuración actuales.
+ [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deactivate-type.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deactivate-type.html)para eliminar un Hook previamente activado de tu cuenta.
# Cree funciones Lambda para evaluar los recursos de Lambda Hooks
CloudFormation Lambda Hooks le permite evaluar CloudFormation y realizar API de control de nube de AWS operaciones con su propio código personalizado. Su Hook puede impedir que se lleve a cabo una operación o emitir una advertencia a la persona que llama y permitir que la operación continúe. Al crear un Hook Lambda, puede configurarlo para interceptar y evaluar las siguientes operaciones: CloudFormation
+ Operaciones de recursos
+ Operaciones de apilamiento
+ Operaciones del conjunto de cambios
**Topics**
+ [Desarrollo de un gancho Lambda](#lambda-hooks-create-lambda-function-develop)
+ [Evaluación de las operaciones de recursos con Lambda Hooks](#lambda-hooks-create-lambda-function-resource)
+ [Evaluación de las operaciones de apilamiento con Lambda Hooks](#lambda-hooks-create-lambda-function-stack)
+ [Evaluación de las operaciones de los conjuntos de cambios con Lambda Hooks](#lambda-hooks-create-lambda-function-change-set)
## Desarrollo de un gancho Lambda
Cuando Hooks invoque tu Lambda, esperará hasta 30 segundos para que la Lambda evalúe la entrada. La Lambda devolverá una respuesta JSON que indica si el Hook se realizó correctamente o no.
**Topics**
+ [Solicita una entrada](#lambda-hooks-create-lambda-function-request-input)
+ [Entrada de respuesta](#lambda-hooks-create-lambda-function-request-response)
+ [Ejemplos](#lambda-hooks-create-lambda-function-request-example)
### Solicita una entrada
La entrada que se pasa a la función Lambda depende de la operación de destino de Hook (por ejemplo: pila, recurso o conjunto de cambios).
### Entrada de respuesta
Para poder comunicar a Hooks si tu solicitud se ha realizado correctamente o no, tu función Lambda debe devolver una respuesta JSON.
El siguiente es un ejemplo de la forma de la respuesta que espera Hooks:
```
{
"HookStatus": "SUCCESS" or "FAILED" or "IN_PROGRESS",
"errorCode": "NonCompliant" or "InternalFailure"
"message": String,
"clientRequestToken": String,
"CallbackContext": 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"
}
]
}
```
HookStatus
El estado del Hook. Este campo es obligatorio.
*Valores válidos*: (`SUCCESS`\$1 `FAILED` \$1`IN_PROGRESS`)
Un Hook puede volver `IN_PROGRESS` 3 veces. Si no se devuelve ningún resultado, el Hook fallará. En el caso de un Lambda Hook, esto significa que la función Lambda se puede invocar hasta 3 veces.
errorCode
Muestra si la operación se evaluó y se determinó que no era válida, o si se produjeron errores en el Hook que impidieron la evaluación. Este campo es obligatorio si el Hook falla.
*Valores válidos*: (`NonCompliant`\$1`InternalFailure`)
message
El mensaje a la persona que llama en el que se indica por qué el Hook tuvo éxito o falló.
Al evaluar CloudFormation las operaciones, este campo se trunca a 4096 caracteres.
Al evaluar las operaciones de la API de Cloud Control, este campo se trunca a 1024 caracteres.
clientRequestToken
El token de solicitud que se proporcionó como entrada a la solicitud de Hook. Este campo es obligatorio.
CallbackContext
Si lo indica, pasa un contexto adicional que `hookStatus` se `IN_PROGRESS` proporciona como entrada cuando se vuelve a invocar la función Lambda.
callbackDelaySeconds
Cuánto tiempo debe esperar Hooks para volver a invocar este Hook.
annotations
Un conjunto de objetos de anotación que proporcionan más detalles y una guía de corrección.
Nombre de anotación
Un identificador de la anotación.
status
El estado de invocación de Hook. Esto resulta útil cuando las anotaciones representan una lógica con una evaluación de aprobación o rechazo similar a la de una regla de Guard.
*Valores válidos*: (\$1 \$1) `PASSED` `FAILED` `SKIPPED`
statusMessage
Explicación del estado específico.
Mensaje de remediación
Sugerencia para corregir un `FAILED` estado. Por ejemplo, si falta el cifrado de un recurso, puede indicar cómo añadir el cifrado a la configuración del recurso.
Enlace de remediación
Una URL HTTP para obtener instrucciones de corrección adicionales.
severityLevel
Define el riesgo relativo asociado a cualquier infracción de este tipo. Al asignar niveles de gravedad a los resultados de la invocación de Hook, puedes hacer referencia al [marco de AWS Security Hub CSPM gravedad](https://docs.aws.amazon.com/securityhub/latest/userguide/asff-required-attributes.html#Severity) como ejemplo de cómo estructurar categorías de gravedad significativas.
*Valores válidos*: (`INFORMATIONAL`\$1 \$1 \$1 `LOW` `MEDIUM` \$1`HIGH`) `CRITICAL`
### Ejemplos
A continuación se muestra un ejemplo de una respuesta correcta:
```
{
"hookStatus": "SUCCESS",
"message": "compliant",
"clientRequestToken": "123avjdjk31"
}
```
El siguiente es un ejemplo de una respuesta fallida:
```
{
"hookStatus": "FAILED",
"errorCode": "NonCompliant",
"message": "S3 Bucket Versioning must be enabled.",
"clientRequestToken": "123avjdjk31"
}
```
## Evaluación de las operaciones de recursos con Lambda Hooks
Cada vez que se crea, actualiza o elimina un recurso, se considera una operación de recurso. Por ejemplo, si ejecutas la actualización de una CloudFormation pila que crea un recurso nuevo, habrás completado una operación de recursos. Cuando creas, actualizas o eliminas un recurso mediante la API de Cloud Control, también se considera una operación de recursos. Puede configurar su CloudFormation Lambda Hook para el destino `RESOURCE` y `CLOUD_CONTROL` las operaciones en la configuración de Hook`TargetOperations`.
**nota**
El controlador `delete` Hook solo se invoca cuando se elimina un recurso mediante un activador de operaciones de la API `delete-resource` de Cloud Control o. CloudFormation `delete-stack`
**Topics**
+ [Sintaxis de entrada de recursos de Lambda Hook](#lambda-hooks-create-lambda-function-resource-input)
+ [Ejemplo de entrada de cambio de recursos de Lambda Hook](#lambda-hooks-create-lambda-function-resource-example)
+ [Ejemplo de función Lambda para operaciones de recursos](#lambda-hooks-create-lambda-function-resource-example-function)
### Sintaxis de entrada de recursos de Lambda Hook
Cuando se invoque su Lambda para una operación de recursos, recibirá una entrada JSON que contiene las propiedades del recurso, las propiedades propuestas y el contexto en torno a la invocación de Hook.
A continuación, se muestra un ejemplo de la forma de la entrada 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": {
"invocación": 1,
"CallbackContext": null
}
}
```
`awsAccountId`
El ID Cuenta de AWS que contiene el recurso que se está evaluando.
`stackId`
El ID de pila de la CloudFormation pila de la que forma parte esta operación. Este campo está vacío si la persona que llama es Cloud Control API.
`changeSetId`
El ID del conjunto de cambios que inició la invocación de Hook. Este valor está vacío si el cambio de recurso lo inició la API de Cloud Control o `create-stack` las `update-stack` `delete-stack` operaciones u.
`hookTypeName`
El nombre del Hook que se está ejecutando.
`hookTypeVersion`
La versión del Hook que se está ejecutando.
`hookModel`
`LambdaFunction`
El ARN de Lambda actual invocado por el Hook.
`actionInvocationPoint`
El punto exacto de la lógica de aprovisionamiento en el que se ejecuta el Hook.
*Valores válidos*: (`CREATE_PRE_PROVISION`\$1 `UPDATE_PRE_PROVISION` \$1`DELETE_PRE_PROVISION`)
`requestData`
`targetName`
El tipo de objetivo que se está evaluando, por ejemplo,`AWS::S3::Bucket`.
`targetType`
El tipo de objetivo que se está evaluando, por ejemplo`AWS::S3::Bucket`. En el caso de los recursos aprovisionados con la API de Cloud Control, este valor será`RESOURCE`.
`targetLogicalId`
El ID lógico del recurso que se está evaluando. Si el origen de la invocación de Hook es CloudFormation, será el ID de recurso lógico definido en la CloudFormation plantilla. Si el origen de esta invocación de Hook es la API de Cloud Control, será un valor generado.
`targetModel`
`resourceProperties`
Las propiedades propuestas del recurso que se está modificando. Si se elimina el recurso, este valor estará vacío.
`previousResourceProperties`
Las propiedades que están asociadas actualmente al recurso que se está modificando. Si se está creando el recurso, este valor estará vacío.
`requestContext`
invocación
El intento actual de ejecutar el Hook.
CallbackContext
Si el Hook se configuró en y `callbackContext` se devolvió`IN_PROGRESS`, estará aquí después de volver a invocarlo.
### Ejemplo de entrada de cambio de recursos de Lambda Hook
El siguiente ejemplo de entrada muestra un Hook Lambda que recibirá la definición del `AWS::DynamoDB::Table` recurso que `ProvisionedThroughput` se va a actualizar, donde el valor `ReadCapacityUnits` de cambia de 3 a 10. Estos son los datos de los que dispone Lambda para su evaluación.
```
{
"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
}
}
```
Para ver todas las propiedades disponibles para el tipo de recurso, consulte [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).
### Ejemplo de función Lambda para operaciones de recursos
La siguiente es una función sencilla que produce errores en cualquier actualización de recursos de DynamoDB, que intenta establecer `ReadCapacity` el valor `ProvisionedThroughput` de en un valor superior a 10. Si el Hook funciona correctamente, la persona que llama verá el mensaje «ReadCapacity está correctamente configurado». Si la solicitud no pasa la validación, el Hook fallará con el estado «ReadCapacity no puede ser más de 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
```
------
## Evaluación de las operaciones de apilamiento con Lambda Hooks
Cada vez que cree, actualice o elimine una pila con una plantilla nueva, puede configurar su CloudFormation Lambda Hook para que comience por evaluar la nueva plantilla y, potencialmente, bloquear la operación de apilamiento para que no continúe. Puede configurar su CloudFormation Lambda Hook para que se dirija a `STACK` las operaciones en la configuración de Hook`TargetOperations`.
**Topics**
+ [Sintaxis de entrada de la pila Lambda Hook](#lambda-hooks-create-lambda-function-stack-input)
+ [Ejemplo de entrada de cambio de pila de Lambda Hook](#lambda-hooks-create-lambda-function-stack-example)
+ [Ejemplo de función Lambda para operaciones de apilamiento](#lambda-hooks-create-lambda-function-stack-example-function)
### Sintaxis de entrada de la pila Lambda Hook
Cuando se invoque su Lambda para una operación de apilamiento, recibirá una solicitud JSON que contiene el contexto de invocación de Hook y el contexto de solicitud. `actionInvocationPoint` Debido al tamaño de las CloudFormation plantillas y al tamaño de entrada limitado que aceptan las funciones de Lambda, las plantillas reales se almacenan en un objeto de Amazon S3. La entrada `requestData` incluye una URL resignada de Amazon S3 a otro objeto, que contiene la versión de la plantilla actual y la anterior.
El siguiente es un ejemplo de la forma de la entrada 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`
El token de solicitud que se proporcionó como entrada a la solicitud de Hook. Este campo es obligatorio.
`awsAccountId`
El ID del elemento Cuenta de AWS que contiene la pila que se está evaluando.
`stackID`
El ID de pila de la CloudFormation pila.
`changeSetId`
El ID del conjunto de cambios que inició la invocación de Hook. Este valor está vacío si el cambio de pila lo inició la API de Cloud Control o las `delete-stack` operaciones `create-stack``update-stack`, o.
`hookTypeName`
El nombre del Hook que se está ejecutando.
`hookTypeVersion`
La versión del Hook que se está ejecutando.
`hookModel`
`LambdaFunction`
El ARN de Lambda actual invocado por el Hook.
`actionInvocationPoint`
El punto exacto de la lógica de aprovisionamiento en el que se ejecuta el Hook.
*Valores válidos*: (`CREATE_PRE_PROVISION`\$1 `UPDATE_PRE_PROVISION` \$1`DELETE_PRE_PROVISION`)
`requestData`
`targetName`
Este valor será `STACK`.
`targetType`
Este valor será `STACK`.
`targetLogicalId`
El nombre de la pila.
`payload`
La URL prefirmada de Amazon S3 que contiene un objeto JSON con las definiciones de plantilla actuales y anteriores.
`requestContext`
Si se vuelve a invocar el Hook, se establecerá este objeto.
`invocation`
El intento actual de ejecutar el Hook.
`callbackContext`
Si el Hook estaba activado `IN_PROGRESS` y `callbackContext` se devolvió, estará aquí al volver a invocarlo.
La `payload` propiedad de los datos de la solicitud es una URL que el código debe recuperar. Una vez que haya recibido la URL, obtendrás un objeto con el siguiente esquema:
```
{
"template": String,
"previousTemplate": String
}
```
`template`
La CloudFormation plantilla completa que se proporcionó a `create-stack` o`update-stack`. Puede ser una cadena JSON o YAML en función de lo que se haya proporcionado a CloudFormation.
En `delete-stack` las operaciones, este valor estará vacío.
`previousTemplate`
La CloudFormation plantilla anterior. Puede ser una cadena JSON o YAML en función de lo que se le CloudFormation haya proporcionado.
En `delete-stack` las operaciones, este valor estará vacío.
### Ejemplo de entrada de cambio de pila de Lambda Hook
El siguiente es un ejemplo de entrada de cambio de pila. The Hook está evaluando un cambio que lo actualiza `ObjectLockEnabled` a verdadero y añade una cola de 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
}
}
```
Este es un ejemplo `payload` de lo siguiente: `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}}}}"
}
```
### Ejemplo de función Lambda para operaciones de apilamiento
El siguiente ejemplo es una función sencilla que descarga la carga útil de la operación de apilado, analiza el JSON de la plantilla y devuelve la información. `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 ]
Para usar Python, tendrás que importar la `requests` biblioteca. Para ello, tendrá que incluir la biblioteca en el paquete de despliegue al crear la función Lambda. *Para obtener más información, consulte [Creación de un paquete de despliegue en formato.zip con dependencias](https://docs.aws.amazon.com/lambda/latest/dg/python-package.html#python-package-create-dependencies) en la AWS Lambda Guía para desarrolladores.*
```
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
```
------
## Evaluación de las operaciones de los conjuntos de cambios con Lambda Hooks
Cada vez que cree un conjunto de cambios, puede configurar su CloudFormation Lambda Hook para que evalúe primero el nuevo conjunto de cambios y, potencialmente, bloquee su ejecución. Puede configurar su CloudFormation Lambda Hook para que se dirija a `CHANGE_SET` las operaciones en la configuración de Hook`TargetOperations`.
**Topics**
+ [Sintaxis de entrada del conjunto de cambios de Lambda Hook](#lambda-hooks-create-lambda-function-change-set-input)
+ [Ejemplo de entrada de cambio de conjunto de cambios de Lambda Hook](#lambda-hooks-create-lambda-function-change-set-example)
+ [Ejemplo de función Lambda para operaciones de conjuntos de cambios](#lambda-hooks-create-lambda-function-change-set-example-function)
### Sintaxis de entrada del conjunto de cambios de Lambda Hook
La entrada para las operaciones del conjunto de cambios es similar a la de las operaciones de apilamiento, pero la carga útil del conjunto de cambios `requestData` también incluye una lista de los cambios de recursos introducidos por el conjunto de cambios.
A continuación se muestra un ejemplo de la forma de la entrada 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`
El token de solicitud que se proporcionó como entrada a la solicitud de Hook. Este campo es obligatorio.
`awsAccountId`
El ID del elemento Cuenta de AWS que contiene la pila que se está evaluando.
`stackID`
El ID de pila de la CloudFormation pila.
`changeSetId`
El ID del conjunto de cambios que inició la invocación de Hook.
`hookTypeName`
El nombre del Hook que se está ejecutando.
`hookTypeVersion`
La versión del Hook que se está ejecutando.
`hookModel`
`LambdaFunction`
El ARN de Lambda actual invocado por el Hook.
`requestData`
`targetName`
Este valor será `CHANGE_SET`.
`targetType`
Este valor será `CHANGE_SET`.
`targetLogicalId`
El conjunto de cambios ARN..
`payload`
La URL prefirmada de Amazon S3 que contiene un objeto JSON con la plantilla actual, así como una lista de los cambios introducidos por este conjunto de cambios.
`requestContext`
Si se vuelve a invocar el Hook, se establecerá este objeto.
`invocation`
El intento actual de ejecutar el Hook.
`callbackContext`
Si el Hook estaba activado `IN_PROGRESS` y `callbackContext` se devolvió, estará aquí al volver a invocarlo.
La `payload` propiedad de los datos de la solicitud es una URL que el código debe recuperar. Una vez que haya recibido la URL, obtendrás un objeto con el siguiente esquema:
```
{
"template": String,
"changedResources": [
{
"action": String,
"beforeContext": JSON String,
"afterContext": JSON String,
"lineNumber": Integer,
"logicalResourceId": String,
"resourceType": String
}
]
}
```
`template`
La CloudFormation plantilla completa que se proporcionó a `create-stack` o`update-stack`. Puede ser una cadena JSON o YAML en función de lo que se haya proporcionado a CloudFormation.
`changedResources`
Una lista de los recursos modificados.
`action`
El tipo de cambio aplicado al recurso.
*Valores válidos*: (`CREATE`\$1 `UPDATE` \$1`DELETE`)
`beforeContext`
Una cadena JSON de las propiedades del recurso antes del cambio. Este valor es nulo cuando se crea el recurso. Todos los valores booleanos y numéricos de esta cadena JSON son CADENAS.
`afterContext`
Una cadena JSON de las propiedades de los recursos si se ejecuta este conjunto de cambios. Este valor es nulo cuando se elimina el recurso. Todos los valores booleanos y numéricos de esta cadena JSON son CADENAS.
`lineNumber`
El número de línea de la plantilla que provocó este cambio. Si la acción es, `DELETE` este valor será nulo.
`logicalResourceId`
El identificador de recurso lógico del recurso que se va a cambiar.
`resourceType`
El tipo de recurso que se va a cambiar.
### Ejemplo de entrada de cambio de conjunto de cambios de Lambda Hook
A continuación se muestra un ejemplo de entrada de cambio de conjunto. En el siguiente ejemplo, puede ver los cambios introducidos por el conjunto de cambios. El primer cambio consiste en eliminar una cola llamada`CoolQueue`. El segundo cambio consiste en añadir una nueva cola llamada. `NewCoolQueue` El último cambio es una actualización de`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
}
}
```
Este es un ejemplo `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"}]}}'
}
]
}
```
### Ejemplo de función Lambda para operaciones de conjuntos de cambios
El siguiente ejemplo es una función sencilla que descarga la carga útil de la operación del conjunto de cambios, recorre cada cambio y, a continuación, imprime las propiedades anteriores y posteriores antes de devolver 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 ]
Para usar Python, tendrás que importar la `requests` biblioteca. Para ello, tendrá que incluir la biblioteca en el paquete de despliegue al crear la función Lambda. *Para obtener más información, consulte [Creación de un paquete de despliegue en formato.zip con dependencias](https://docs.aws.amazon.com/lambda/latest/dg/python-package.html#python-package-create-dependencies) en la AWS Lambda Guía para desarrolladores.*
```
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
```
------
# Prepárese para crear un Hook Lambda
Antes de crear un Hook Lambda, debe cumplir los siguientes requisitos previos:
+ Debe haber creado ya una función Lambda. Para obtener más información, consulte la [Creación de funciones Lambda para Hooks](lambda-hooks-create-lambda-function.md).
+ El usuario o rol que crea el Hook debe tener permisos suficientes para activar los Hooks. Para obtener más información, consulte [Otorgue permisos de IAM para Hooks CloudFormation](grant-iam-permissions-for-hooks.md).
+ Para usar el AWS CLI o un SDK para crear un enlace de Lambda, debe crear manualmente un rol de ejecución con permisos de IAM y una política de confianza que permita CloudFormation invocar un enlace de Lambda.
## Crear un rol de ejecución para un Hook Lambda
Un Hook usa un rol de ejecución para los permisos que necesita para invocar ese Hook en tu cuenta. Cuenta de AWS
Este rol se puede crear automáticamente si crea un Lambda Hook desde el Consola de administración de AWS; de lo contrario, debe crear este rol usted mismo.
En la siguiente sección, se muestra cómo configurar los permisos para crear su Lambda Hook.
### Permisos necesarios
Siga las instrucciones sobre cómo [crear un rol mediante políticas de confianza personalizadas](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html) de la *Guía del usuario de IAM* para crear un rol con una política de confianza personalizada.
A continuación, complete los siguientes pasos para configurar los permisos:
1. Adjunte la siguiente política de privilegios mínimos a la función de IAM que desee utilizar para crear el Lambda Hook.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-west-2:123456789012:function:MyFunction"
}
]
}
```
------
1. Dale permiso a tu Hook para que asuma la función añadiendo una política de confianza a la función. A continuación, se muestra un ejemplo de política de confianza que puedes usar.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"hooks.cloudformation.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
# Active un Lambda Hook en su cuenta
En el siguiente tema, se muestra cómo activar un Lambda Hook en su cuenta para que pueda utilizarse en la cuenta y la región en las que se activó.
**Topics**
+ [Activar un Lambda Hook (consola)](#lambda-hooks-activate-hook-console)
+ [Activar un gancho Lambda ()AWS CLI](#lambda-hooks-activate-hooks-cli)
+ [Recursos relacionados](#related-resources-lambda-hooks)
## Activar un Lambda Hook (consola)
**Para activar un Lambda Hook para usarlo en su cuenta**
1. Inicie sesión en Consola de administración de AWS [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/) y abra la CloudFormation consola.
1. En la barra de navegación de la parte superior de la pantalla, elige el Región de AWS lugar donde quieres crear el Hook in.
1. Si *no ha* creado una función Lambda para el Hook, haga lo siguiente:
+ Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
+ Cree la función Lambda que utilizará con este Hook y, a continuación, vuelva a este procedimiento. Para obtener más información, consulte [Cree funciones Lambda para evaluar los recursos de Lambda Hooks](lambda-hooks-create-lambda-function.md).
Si ya ha creado la función Lambda, continúe con el paso siguiente.
1. En el panel de navegación de la izquierda, selecciona **Hooks.**
1. En la página **Hooks**, elija **Crear un Hook** y, a continuación, elija **Con Lambda**.
1. En **Nombre del gancho**, elija una de las siguientes opciones:
+ Proporcione un nombre breve y descriptivo que se añadirá después`Private::Lambda::`. Por ejemplo, si escribes*`MyTestHook`*, el nombre completo de Hook pasa a ser`Private::Lambda::MyTestHook`.
+ Introduce el nombre completo del Hook (también denominado alias) con este formato: `Provider::ServiceName::HookName`
1. Para la función **Lambda, proporcione la función** Lambda que se utilizará con este Hook. Puede usar:
+ El nombre completo del recurso de Amazon (ARN) sin sufijo.
+ Un ARN cualificado con una versión o un sufijo de alias.
1. En el caso de **los objetivos de Hook**, elige qué quieres evaluar:
+ **Pilas**: evalúa las plantillas de pilas cuando los usuarios crean, actualizan o eliminan pilas.
+ **Recursos**: evalúa los cambios en los recursos individuales cuando los usuarios actualizan las pilas.
+ **Conjuntos de cambios**: evalúa las actualizaciones planificadas cuando los usuarios crean conjuntos de cambios.
+ **API de Cloud Control**: evalúa las operaciones de creación, actualización o eliminación iniciadas por la API de [Cloud Control](https://docs.aws.amazon.com/cloudcontrolapi/latest/userguide/what-is-cloudcontrolapi.html).
1. En **Acciones**, elige qué acciones (crear, actualizar, eliminar) invocarán tu Hook.
1. Para el **modo Hook**, elija cómo responde el Hook cuando la función Lambda invocada por el Hook devuelva una `FAILED` respuesta:
+ **Advertir**: emite advertencias a los usuarios, pero permite que las acciones continúen. Esto resulta útil para validaciones o comprobaciones informativas no críticas.
+ **Error**: impide que la acción continúe. Esto resulta útil para aplicar políticas estrictas de conformidad o seguridad.
1. En **la función de ejecución**, elija la función de IAM que asume el Hook para invocar la función Lambda. Puedes CloudFormation permitir que se cree automáticamente un rol de ejecución para ti o puedes especificar un rol que hayas creado.
1. Elija **Siguiente**.
1. (Opcional) Para **los filtros Hook**, haga lo siguiente:
1. En el **filtro de recursos**, especifique qué tipos de recursos pueden invocar el Hook. Esto garantiza que el Hook solo se invoque para los recursos relevantes.
1. En cuanto a **los criterios de filtrado**, elige la lógica para aplicar los filtros de nombre y rol de la pila:
+ **Todos los nombres y roles de las pilas**: The Hook solo se invocará cuando coincidan todos los filtros especificados.
+ **Cualquier nombre y función de pila**: se invocará el Hook si al menos uno de los filtros especificados coincide.
**nota**
En el caso de las operaciones de la API de Cloud Control, se **ignoran todos los filtros de nombres** y **roles de las pilas**.
1. En el **caso de los nombres de pila**, incluye o excluye pilas específicas de las invocaciones de Hook.
+ En **Include**, especifique los nombres de las pilas que desee incluir. Úselo cuando desee segmentar un conjunto pequeño de pilas específicas. Solo las pilas especificadas en esta lista invocarán el Hook.
+ En **Exclude**, especifique los nombres de las pilas que se van a excluir. Úselo cuando quiera invocar el Hook en la mayoría de las pilas, pero excluya algunas específicas. Todas las acumulaciones, excepto las que aparecen aquí, invocarán el Hook.
1. En el caso de **las funciones de Stack**, incluya o excluya pilas específicas de las invocaciones de Hook en función de sus funciones de IAM asociadas.
+ En **Include**, especifique una o más funciones de IAM ARNs para centrarse en las pilas asociadas a estas funciones. Solo las operaciones de apilamiento iniciadas por estos roles invocarán el Hook.
+ En **Excluir**, especifique una o más funciones de IAM ARNs para las pilas que desee excluir. El Hook se invocará en todas las pilas, excepto en las iniciadas por los roles especificados.
1. Elija **Siguiente**.
1. En la página **Revisar y activar**, revisa tus opciones. Para realizar cambios, elija **Editar** en la sección correspondiente.
1. Cuando estés listo para continuar, selecciona **Activar Hook**.
## Activar un gancho Lambda ()AWS CLI
Antes de continuar, confirme que ha creado la función Lambda y el rol de ejecución que utilizará con este Hook. Para obtener más información, consulte [Cree funciones Lambda para evaluar los recursos de Lambda Hooks](lambda-hooks-create-lambda-function.md) y [Crear un rol de ejecución para un Hook Lambda](lambda-hooks-prepare-to-create-hook.md#lambda-hooks-create-execution-role).
**Para activar un Lambda Hook para usarlo en su cuenta ()AWS CLI**
1. Para empezar a activar un Hook, utilice el siguiente [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/activate-type.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/activate-type.html)comando y sustituya los marcadores de posición por sus valores específicos. Este comando autoriza al Hook a utilizar una función de ejecución específica suya. Cuenta de 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. Para terminar de activar el Hook, debes configurarlo mediante un archivo de configuración JSON.
Usa el **cat** comando para crear un archivo JSON con la siguiente estructura. Para obtener más información, consulte [Referencia a la sintaxis del esquema de la configuración del enlace](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`: `ENABLED` Configúrelo en para habilitar el Hook.
+ `TargetOperations`: especifique las operaciones que evaluará el Hook.
+ `FailureMode`: se establece en `FAIL` o `WARN`.
+ `LambdaFunction`: especifique el ARN de la función Lambda.
+ `TargetFilters`: especifique los tipos de acciones que invocarán el Hook.
1. Usa el siguiente [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)comando, junto con el archivo JSON que has creado, para aplicar la configuración. Sustituya los marcadores de posición por sus valores específicos.
```
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
```
## Recursos relacionados
Proporcionamos ejemplos de plantillas que puede utilizar para entender cómo declarar un Hook de Lambda en una plantilla de CloudFormation pila. Para obtener más información, consulte [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) en la *Guía del usuario de AWS CloudFormation *.
# Ver los registros de los Lambda Hooks de su cuenta
Si utiliza un Lambda Hook, el archivo de registro del informe de resultados de validación se encuentra en la consola de Lambda.
## Ver los registros de Lambda Hook en la consola de Lambda
**Para ver el archivo de registro de resultados de Lambda Hook**
1. Inicie sesión en la consola Lambda.
1. En la barra de navegación de la parte superior de la pantalla, elija la Región de AWS.
1. Elija **Funciones**.
1. Elija la función Lambda deseada.
1. Elija la pestaña **Prueba**.
1. Elija **CloudWatch Logs Live Trail**
1. Elija el menú desplegable y seleccione los grupos de registros que desee ver.
1. Elija **Iniciar**. El registro se mostrará en la ventana **CloudWatch Logs Live Trail**. Elija **Ver en columnas** o **Ver en texto plano** según sus preferencias.
+ Puede añadir más filtros a los resultados añadiéndolos en el campo **Añadir patrón de filtro**. Este campo le permite filtrar los resultados para incluir solo los eventos que coincidan con el patrón especificado.
Para obtener más información sobre la visualización de registros de funciones de Lambda, consulte [Visualización de CloudWatch registros de funciones de Lambda](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-cloudwatchlogs-view.html).
# Elimine Lambda Hooks de su cuenta
Cuando ya no necesite un Lambda Hook activado, utilice los siguientes procedimientos para eliminarlo de su cuenta.
Para deshabilitar temporalmente un Hook en lugar de eliminarlo, consulte[Desactivar y activar CloudFormation Hooks](hooks-disable-enable.md).
**Topics**
+ [Eliminar un Lambda Hook de su cuenta (consola)](#lambda-hooks-delete-hook-console)
+ [Eliminar un Lambda Hook de su cuenta ()AWS CLI](#lambda-hooks-delete-hook-cli)
## Eliminar un Lambda Hook de su cuenta (consola)
**Para eliminar un Lambda Hook de su cuenta**
1. Inicie sesión en Consola de administración de AWS [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/) y abra la CloudFormation consola.
1. En la barra de navegación de la parte superior de la pantalla, selecciona la Región de AWS ubicación del Hook.
1. En el panel de navegación, selecciona **Hooks**.
1. En la página **Hooks**, busca el Hook Lambda que deseas eliminar.
1. Selecciona la casilla de verificación situada junto a tu Hook y selecciona **Eliminar**.
1. Cuando se te pida confirmación, escribe el nombre del Hook para confirmar la eliminación del Hook especificado y, a continuación, selecciona **Eliminar**.
## Eliminar un Lambda Hook de su cuenta ()AWS CLI
**nota**
Antes de poder eliminar el Hook, primero debe deshabilitarlo. Para obtener más información, consulte [Desactiva y activa un Hook en tu cuenta (AWS CLI)](hooks-disable-enable.md#hooks-disable-enable-cli).
Usa el siguiente [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deactivate-type.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deactivate-type.html)comando para desactivar un Hook, lo que lo eliminará de tu cuenta. Sustituye los marcadores de posición por tus valores específicos.
```
aws cloudformation deactivate-type \
--type-arn "arn:aws:cloudformation:us-west-2:123456789012:type/hook/MyTestHook" \
--region us-west-2
```