As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Lambda Hooks
Para usar um AWS Lambda Hook em sua conta, você deve primeiro *ativar* o Hook para a conta e a região em que deseja usá-lo. A ativação de um Hook o torna utilizável em operações de pilha na conta e na região em que está ativado.
Quando você ativa um Lambda Hook, CloudFormation cria uma entrada no registro da sua conta para o Hook ativado como um Hook privado. Isso permite que você defina todas as propriedades de configuração que o Hook inclui. As propriedades de configuração definem como o Hook é configurado para uma determinada Conta da AWS região.
**Topics**
+ [AWS CLI comandos para trabalhar com Lambda Hooks](#commonly-used-commands-lambda-hooks)
+ [Crie funções Lambda para avaliar recursos para Lambda Hooks](lambda-hooks-create-lambda-function.md)
+ [Prepare-se para criar um Lambda Hook](lambda-hooks-prepare-to-create-hook.md)
+ [Ative um Lambda Hook em sua conta](lambda-hooks-activate-hooks.md)
+ [Visualize os registros dos Lambda Hooks em sua conta](lambda-hooks-view-logs.md)
+ [Exclua Lambda Hooks em sua conta](lambda-hooks-delete-hooks.md)
## AWS CLI comandos para trabalhar com Lambda Hooks
Os AWS CLI comandos para trabalhar com Lambda Hooks incluem:
+ [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 o processo de ativação de um 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 os dados de configuração de um Hook em sua conta.
+ [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 listar os Hooks em sua conta.
+ [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 retornar informações detalhadas sobre um Hook específico ou uma versão específica do Hook, incluindo dados de configuração atuais.
+ [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 remover um Hook ativado anteriormente da sua conta.
# Crie funções Lambda para avaliar recursos para Lambda Hooks
CloudFormation O Lambda Hooks permite que você CloudFormation avalie e AWS API Cloud Control opere com base em seu próprio código personalizado. Seu Hook pode impedir que uma operação continue, ou emitir um aviso para o chamador e permitir que a operação continue. Ao criar um Lambda Hook, você pode configurá-lo para interceptar e avaliar as seguintes operações: CloudFormation
+ Operações de recurso
+ Operações de empilhamento
+ Alterar as operações do conjunto
**Topics**
+ [Desenvolvendo um Lambda Hook](#lambda-hooks-create-lambda-function-develop)
+ [Avaliando as operações de recursos com Lambda Hooks](#lambda-hooks-create-lambda-function-resource)
+ [Avaliação de operações de pilha com Lambda Hooks](#lambda-hooks-create-lambda-function-stack)
+ [Avaliando as operações do conjunto de alterações com Lambda Hooks](#lambda-hooks-create-lambda-function-change-set)
## Desenvolvendo um Lambda Hook
Quando Hooks invocam seu Lambda, ele espera até 30 segundos para que o Lambda avalie a entrada. O Lambda retornará uma resposta JSON que indica se o Hook foi bem-sucedido ou falhou.
**Topics**
+ [Solicitar entrada](#lambda-hooks-create-lambda-function-request-input)
+ [Entrada de resposta](#lambda-hooks-create-lambda-function-request-response)
+ [Exemplos](#lambda-hooks-create-lambda-function-request-example)
### Solicitar entrada
A entrada passada para sua função Lambda depende da operação de destino do Hook (exemplos: pilha, recurso ou conjunto de alterações).
### Entrada de resposta
Para se comunicar com Hooks se sua solicitação foi bem-sucedida ou falhou, sua função Lambda precisa retornar uma resposta JSON.
A seguir está um exemplo da forma da resposta que Hooks espera:
```
{
"Status do gancho": "SUCCESS" or "FAILED" or "IN_PROGRESS",
"errorCode": "NonCompliant" or "InternalFailure"
"message": String,
"clientRequestToken": String,
"Contexto de retorno de chamada": None,
"callbackDelaySeconds": Integer,
"anotações": [
{
"annotationName": String,
"status": "PASSED" or "FAILED" or "SKIPPED",
"statusMessage": String,
"remediationMessage": String,
"remediationLink": String,
"severityLevel": "INFORMATIONAL" or "LOW" or "MEDIUM" or "HIGH" or "CRITICAL"
}
]
}
```
Status do gancho
O status do Hook. Este é um campo obrigatório.
*Valores válidos*: (`SUCCESS`\$1 `FAILED` \$1`IN_PROGRESS`)
Um gancho pode retornar `IN_PROGRESS` 3 vezes. Se nenhum resultado for retornado, o Hook falhará. Para um Lambda Hook, isso significa que sua função Lambda pode ser invocada até 3 vezes.
errorCode
Mostra se a operação foi avaliada e determinada como inválida ou se ocorreram erros no Hook, impedindo a avaliação. Esse campo é obrigatório se o Hook falhar.
*Valores válidos*: (`NonCompliant`\$1`InternalFailure`)
message
A mensagem para o chamador informando por que o Hook foi bem-sucedido ou falhou.
Ao avaliar CloudFormation as operações, esse campo é truncado para 4096 caracteres.
Ao avaliar as operações da Cloud Control API, esse campo é truncado para 1024 caracteres.
clientRequestToken
O token de solicitação que foi fornecido como entrada para a solicitação do Hook. Este é um campo obrigatório.
Contexto de retorno de chamada
Se você indicar que `hookStatus` é, `IN_PROGRESS` você passa um contexto adicional que é fornecido como entrada quando a função Lambda é invocada novamente.
callbackDelaySeconds
Quanto tempo os Hooks devem esperar para invocar esse Hook novamente.
anotações
Uma variedade de objetos de anotação que fornecem mais detalhes e orientações de remediação.
Nome da anotação
Um identificador para a anotação.
status
O status de invocação do Hook. Isso é útil quando as anotações representam uma lógica com avaliação de aprovação/reprovação semelhante a uma regra do Guard.
*Valores válidos*: (`PASSED`\$1 `FAILED` \$1`SKIPPED`)
statusMessage
Explicação do status específico.
Mensagem de remediação
Sugestão para corrigir um `FAILED` status. Por exemplo, se um recurso não tiver criptografia, você pode indicar como adicionar criptografia à configuração do recurso.
Link de remediação
Um URL HTTP para orientação adicional sobre remediação.
severityLevel
Define o risco relativo associado a qualquer violação desse tipo. Ao atribuir níveis de severidade aos resultados da invocação do Hook, você pode consultar a [estrutura de AWS Security Hub CSPM severidade](https://docs.aws.amazon.com/securityhub/latest/userguide/asff-required-attributes.html#Severity) como um exemplo de como estruturar categorias de severidade significativas.
*Valores válidos*: (`INFORMATIONAL`\$1 `LOW` \$1 `MEDIUM` \$1 `HIGH` \$1`CRITICAL`)
### Exemplos
Veja a seguir um exemplo de resposta bem-sucedida:
```
{
"hookStatus": "SUCCESS",
"message": "compliant",
"clientRequestToken": "123avjdjk31"
}
```
Veja a seguir um exemplo de falha na resposta:
```
{
"hookStatus": "FAILED",
"errorCode": "NonCompliant",
"message": "S3 Bucket Versioning must be enabled.",
"clientRequestToken": "123avjdjk31"
}
```
## Avaliando as operações de recursos com Lambda Hooks
Sempre que você cria, atualiza ou exclui um recurso, isso é considerado uma operação de recurso. Por exemplo, se você executar a atualização de uma CloudFormation pilha que cria um novo recurso, você concluiu uma operação de recurso. Quando você cria, atualiza ou exclui um recurso usando a Cloud Control API, isso também é considerado uma operação de recurso. Você pode configurar seu CloudFormation Lambda Hook para destinos `RESOURCE` e `CLOUD_CONTROL` operações na configuração do Hook`TargetOperations`.
**nota**
O manipulador `delete` Hook só é invocado quando um recurso é excluído usando um gatilho de operação da Cloud Control API `delete-resource` ou. CloudFormation `delete-stack`
**Topics**
+ [Sintaxe de entrada de recursos do Lambda Hook](#lambda-hooks-create-lambda-function-resource-input)
+ [Exemplo de entrada de alteração de recursos do Lambda Hook](#lambda-hooks-create-lambda-function-resource-example)
+ [Exemplo de função Lambda para operações de recursos](#lambda-hooks-create-lambda-function-resource-example-function)
### Sintaxe de entrada de recursos do Lambda Hook
Quando seu Lambda for invocado para uma operação de recurso, você receberá uma entrada JSON contendo as propriedades do recurso, as propriedades propostas e o contexto em torno da invocação do Hook.
Veja a seguir um exemplo de formato da 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": {
"invocação": 1,
"Contexto de retorno de chamada": null
}
}
```
`awsAccountId`
O ID do Conta da AWS que contém o recurso que está sendo avaliado.
`stackId`
O ID da pilha da CloudFormation qual essa operação faz parte. Esse campo estará vazio se o chamador for a Cloud Control API.
`changeSetId`
O ID do conjunto de alterações que iniciou a invocação do Hook. Esse valor ficará vazio se a alteração do recurso tiver sido iniciada pela Cloud Control API ou pelas `delete-stack` operações `create-stack``update-stack`, ou.
`hookTypeName`
O nome do Hook que está funcionando.
`hookTypeVersion`
A versão do Hook que está sendo executada.
`hookModel`
`LambdaFunction`
O ARN atual do Lambda invocado pelo Hook.
`actionInvocationPoint`
O ponto exato na lógica de provisionamento em que o Hook é executado.
*Valores válidos*: (`CREATE_PRE_PROVISION`\$1 `UPDATE_PRE_PROVISION` \$1`DELETE_PRE_PROVISION`)
`requestData`
`targetName`
O tipo de alvo que está sendo avaliado, por exemplo,`AWS::S3::Bucket`.
`targetType`
O tipo de alvo que está sendo avaliado, por exemplo`AWS::S3::Bucket`. Para recursos provisionados com a Cloud Control API, esse valor será. `RESOURCE`
`targetLogicalId`
O ID lógico do recurso que está sendo avaliado. Se a origem da invocação do Hook for CloudFormation, esse será o ID lógico do recurso definido em seu CloudFormation modelo. Se a origem dessa invocação do Hook for a Cloud Control API, esse será um valor construído.
`targetModel`
`resourceProperties`
As propriedades propostas do recurso que está sendo modificado. Se o recurso estiver sendo excluído, esse valor ficará vazio.
`previousResourceProperties`
As propriedades atualmente associadas ao recurso que está sendo modificado. Se o recurso estiver sendo criado, esse valor ficará vazio.
`requestContext`
invocação
A tentativa atual de executar o Hook.
Contexto de retorno de chamada
Se o Hook foi configurado para `IN_PROGRESS` e `callbackContext` foi devolvido, ele estará aqui após a reinvocação.
### Exemplo de entrada de alteração de recursos do Lambda Hook
O exemplo de entrada a seguir mostra um Lambda Hook que receberá a definição do `AWS::DynamoDB::Table` recurso a ser atualizado, em que o `ReadCapacityUnits` of `ProvisionedThroughput` é alterado de 3 para 10. Esses são os dados disponíveis para a Lambda para avaliação.
```
{
"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 as propriedades disponíveis para o 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).
### Exemplo de função Lambda para operações de recursos
Veja a seguir uma função simples que falha em qualquer atualização de recurso para o DynamoDB, que tenta definir `ReadCapacity` o `ProvisionedThroughput` of como algo maior que 10. Se o Hook for bem-sucedido, a mensagem “ReadCapacity está configurado corretamente” será exibida para o chamador. Se a solicitação falhar na validação, o Hook falhará com o status “ReadCapacity não pode ser maior que 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
```
------
## Avaliação de operações de pilha com Lambda Hooks
Sempre que você cria, atualiza ou exclui uma pilha com um novo modelo, você pode configurar seu CloudFormation Lambda Hook para começar avaliando o novo modelo e potencialmente impedir que a operação da pilha continue. Você pode configurar seu CloudFormation Lambda Hook para direcionar `STACK` operações na configuração do Hook`TargetOperations`.
**Topics**
+ [Sintaxe de entrada da pilha Lambda Hook](#lambda-hooks-create-lambda-function-stack-input)
+ [Exemplo de entrada de alteração de pilha do Lambda Hook](#lambda-hooks-create-lambda-function-stack-example)
+ [Exemplo de função Lambda para operações de pilha](#lambda-hooks-create-lambda-function-stack-example-function)
### Sintaxe de entrada da pilha Lambda Hook
Quando seu Lambda for invocado para uma operação de pilha, você receberá uma solicitação JSON contendo o contexto de invocação do Hook e o contexto da solicitação. `actionInvocationPoint` Devido ao tamanho dos CloudFormation modelos e ao tamanho limitado de entrada aceito pelas funções do Lambda, os modelos reais são armazenados em um objeto Amazon S3. A entrada do `requestData` inclui uma URL resignada do Amazon S3 para outro objeto, que contém a versão atual e anterior do modelo.
Veja a seguir um exemplo de formato da 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`
O token de solicitação que foi fornecido como entrada para a solicitação do Hook. Este é um campo obrigatório.
`awsAccountId`
O ID do Conta da AWS que contém a pilha que está sendo avaliada.
`stackID`
O ID da pilha. CloudFormation
`changeSetId`
O ID do conjunto de alterações que iniciou a invocação do Hook. Esse valor ficará vazio se a alteração da pilha tiver sido iniciada pela Cloud Control API ou pelas `delete-stack` operações `create-stack``update-stack`, ou.
`hookTypeName`
O nome do Hook que está funcionando.
`hookTypeVersion`
A versão do Hook que está sendo executada.
`hookModel`
`LambdaFunction`
O ARN atual do Lambda invocado pelo Hook.
`actionInvocationPoint`
O ponto exato na lógica de provisionamento em que o Hook é executado.
*Valores válidos*: (`CREATE_PRE_PROVISION`\$1 `UPDATE_PRE_PROVISION` \$1`DELETE_PRE_PROVISION`)
`requestData`
`targetName`
Esse valor será `STACK`.
`targetType`
Esse valor será `STACK`.
`targetLogicalId`
O nome da pilha.
`payload`
A URL pré-assinada do Amazon S3 contendo um objeto JSON com as definições de modelo atuais e anteriores.
`requestContext`
Se o Hook estiver sendo invocado novamente, esse objeto será definido.
`invocation`
A tentativa atual de executar o Hook.
`callbackContext`
Se o Hook foi configurado `IN_PROGRESS` e `callbackContext` foi devolvido, ele estará aqui após a reinvocação.
A `payload` propriedade nos dados da solicitação é uma URL que seu código precisa buscar. Depois de receber a URL, você obtém um objeto com o seguinte esquema:
```
{
"template": String,
"previousTemplate": String
}
```
`template`
O CloudFormation modelo completo que foi fornecido para `create-stack` ou`update-stack`. Ela pode ser uma string JSON ou YAML, dependendo do que foi fornecido. CloudFormation
Nas `delete-stack` operações, esse valor estará vazio.
`previousTemplate`
O CloudFormation modelo anterior. Ela pode ser uma string JSON ou YAML, dependendo do que foi fornecido. CloudFormation
Nas `delete-stack` operações, esse valor estará vazio.
### Exemplo de entrada de alteração de pilha do Lambda Hook
Veja a seguir um exemplo de entrada de alteração de pilha. O Hook está avaliando uma alteração que atualiza o `ObjectLockEnabled` para true e adiciona uma fila do 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 é um exemplo `payload` do`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}}}}"
}
```
### Exemplo de função Lambda para operações de pilha
O exemplo a seguir é uma função simples que baixa a carga útil da operação de pilha, analisa o modelo JSON e retorna. `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 o Python, você precisará importar a `requests` biblioteca. Para fazer isso, você precisará incluir a biblioteca em seu pacote de implantação ao criar sua função Lambda. Para obter mais informações, consulte [Criação de um pacote de implantação .zip com dependências](https://docs.aws.amazon.com/lambda/latest/dg/python-package.html#python-package-create-dependencies) no Guia do *AWS Lambda desenvolvedor*.
```
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
```
------
## Avaliando as operações do conjunto de alterações com Lambda Hooks
Sempre que criar um conjunto de alterações, você pode configurar seu CloudFormation Lambda Hook para avaliar primeiro o novo conjunto de alterações e potencialmente bloquear sua execução. Você pode configurar seu CloudFormation Lambda Hook para direcionar `CHANGE_SET` operações na configuração do Hook`TargetOperations`.
**Topics**
+ [Sintaxe de entrada do conjunto de alterações do Lambda Hook](#lambda-hooks-create-lambda-function-change-set-input)
+ [Exemplo de entrada de alteração do conjunto de alterações do Lambda Hook](#lambda-hooks-create-lambda-function-change-set-example)
+ [Exemplo de função Lambda para operações de conjunto de alterações](#lambda-hooks-create-lambda-function-change-set-example-function)
### Sintaxe de entrada do conjunto de alterações do Lambda Hook
A entrada para as operações do conjunto de alterações é semelhante às operações de pilha, mas a carga útil do `requestData` também inclui uma lista de alterações de recursos introduzidas pelo conjunto de alterações.
Veja a seguir um exemplo de formato da 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`
O token de solicitação que foi fornecido como entrada para a solicitação do Hook. Este é um campo obrigatório.
`awsAccountId`
O ID do Conta da AWS que contém a pilha que está sendo avaliada.
`stackID`
O ID da pilha. CloudFormation
`changeSetId`
O ID do conjunto de alterações que iniciou a invocação do Hook.
`hookTypeName`
O nome do Hook que está funcionando.
`hookTypeVersion`
A versão do Hook que está sendo executada.
`hookModel`
`LambdaFunction`
O ARN atual do Lambda invocado pelo Hook.
`requestData`
`targetName`
Esse valor será `CHANGE_SET`.
`targetType`
Esse valor será `CHANGE_SET`.
`targetLogicalId`
O conjunto de alterações ARN..
`payload`
A URL pré-assinada do Amazon S3 contendo um objeto JSON com o modelo atual, bem como uma lista das alterações introduzidas por esse conjunto de alterações.
`requestContext`
Se o Hook estiver sendo invocado novamente, esse objeto será definido.
`invocation`
A tentativa atual de executar o Hook.
`callbackContext`
Se o Hook foi configurado `IN_PROGRESS` e `callbackContext` foi devolvido, ele estará aqui após a reinvocação.
A `payload` propriedade nos dados da solicitação é uma URL que seu código precisa buscar. Depois de receber a URL, você obtém um objeto com o seguinte esquema:
```
{
"template": String,
"changedResources": [
{
"action": String,
"beforeContext": JSON String,
"afterContext": JSON String,
"lineNumber": Integer,
"logicalResourceId": String,
"resourceType": String
}
]
}
```
`template`
O CloudFormation modelo completo que foi fornecido para `create-stack` ou`update-stack`. Ela pode ser uma string JSON ou YAML, dependendo do que foi fornecido. CloudFormation
`changedResources`
Uma lista dos recursos alterados.
`action`
O tipo de alteração aplicada ao recurso.
*Valores válidos*: (`CREATE`\$1 `UPDATE` \$1`DELETE`)
`beforeContext`
Uma string JSON das propriedades do recurso antes da alteração. Esse valor é nulo quando o recurso está sendo criado. Todos os valores booleanos e numéricos nessa string JSON são STRINGS.
`afterContext`
Uma string JSON das propriedades dos recursos se esse conjunto de alterações for executado. Esse valor é nulo quando o recurso está sendo excluído. Todos os valores booleanos e numéricos nessa string JSON são STRINGS.
`lineNumber`
O número da linha no modelo que causou essa alteração. Se a ação for, `DELETE` esse valor será nulo.
`logicalResourceId`
O ID lógico do recurso que está sendo alterado.
`resourceType`
O tipo de recurso que está sendo alterado.
### Exemplo de entrada de alteração do conjunto de alterações do Lambda Hook
Veja a seguir um exemplo de entrada de alteração do conjunto de alterações. No exemplo a seguir, você pode ver as alterações introduzidas pelo conjunto de alterações. A primeira alteração é excluir uma fila chamada. `CoolQueue` A segunda mudança é adicionar uma nova fila chamada`NewCoolQueue`. A última alteração é uma atualização do`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 é um exemplo `payload` do`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"}]}}'
}
]
}
```
### Exemplo de função Lambda para operações de conjunto de alterações
O exemplo a seguir é uma função simples que baixa a carga útil da operação do conjunto de alterações, percorre cada alteração e, em seguida, imprime as propriedades antes e depois antes de retornar a. `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 o Python, você precisará importar a `requests` biblioteca. Para fazer isso, você precisará incluir a biblioteca em seu pacote de implantação ao criar sua função Lambda. Para obter mais informações, consulte [Criação de um pacote de implantação .zip com dependências](https://docs.aws.amazon.com/lambda/latest/dg/python-package.html#python-package-create-dependencies) no Guia do *AWS Lambda desenvolvedor*.
```
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
```
------
# Prepare-se para criar um Lambda Hook
Antes de criar um Lambda Hook, você deve preencher os seguintes pré-requisitos:
+ Você já deve ter criado uma função Lambda. Para obter mais informações, consulte o [Crie funções Lambda para Hooks](lambda-hooks-create-lambda-function.md).
+ O usuário ou a função que cria o Hook deve ter permissões suficientes para ativar os Hooks. Para obter mais informações, consulte [Conceda permissões do IAM para CloudFormation Hooks](grant-iam-permissions-for-hooks.md).
+ Para usar o AWS CLI ou um SDK para criar um Lambda Hook, você deve criar manualmente uma função de execução com permissões do IAM e uma política de confiança para CloudFormation permitir a invocação de um Lambda Hook.
## Crie uma função de execução para um Lambda Hook
Um Hook usa uma função de execução para as permissões necessárias para invocar esse Hook em seu Conta da AWS.
Essa função pode ser criada automaticamente se você criar um Lambda Hook a partir do Console de gerenciamento da AWS; caso contrário, você mesmo deverá criar essa função.
A seção a seguir mostra como configurar permissões para criar seu Lambda Hook.
### Permissões obrigatórias
Siga as orientações em [Criar um perfil usando políticas de confiança personalizadas](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html) no *Guia do usuário do IAM* para criar um perfil com uma política de confiança personalizada.
Em seguida, conclua as etapas a seguir para configurar suas permissões:
1. Anexe a seguinte política de privilégios mínimos à função do IAM que você deseja usar para criar o Lambda Hook.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-west-2:123456789012:function:MyFunction"
}
]
}
```
------
1. Dê permissão ao seu Hook para assumir a função adicionando uma política de confiança à função. Veja a seguir um exemplo de política de confiança que você pode usar.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"hooks.cloudformation.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
# Ative um Lambda Hook em sua conta
O tópico a seguir mostra como ativar um Lambda Hook em sua conta, o que o torna utilizável na conta e na região em que foi ativado.
**Topics**
+ [Ativar um Lambda Hook (console)](#lambda-hooks-activate-hook-console)
+ [Ativar um gancho Lambda ()AWS CLI](#lambda-hooks-activate-hooks-cli)
+ [Recursos relacionados](#related-resources-lambda-hooks)
## Ativar um Lambda Hook (console)
**Para ativar um Lambda Hook para uso em sua conta**
1. Faça login no Console de gerenciamento da AWS e abra o CloudFormation console em [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Na barra de navegação na parte superior da tela, escolha Região da AWS onde você deseja criar o Hook in.
1. Se você *não* criou uma função Lambda para o Hook, faça o seguinte:
+ Abra a [página Functions (Funções)](https://console.aws.amazon.com/lambda/home#/functions) no console do Lambda.
+ Crie a função Lambda que você usará com esse Hook e, em seguida, retorne a esse procedimento. Para obter mais informações, consulte [Crie funções Lambda para avaliar recursos para Lambda Hooks](lambda-hooks-create-lambda-function.md).
Se você já criou sua função Lambda, vá para a próxima etapa.
1. No painel de navegação à esquerda, escolha **Ganchos**.
1. Na página **Hooks**, escolha **Create a Hook** e, em seguida, escolha **With Lambda**.
1. Em **Nome do gancho**, escolha uma das seguintes opções:
+ Forneça um nome curto e descritivo que será adicionado depois`Private::Lambda::`. Por exemplo, se você inserir*`MyTestHook`*, o nome completo do Hook será`Private::Lambda::MyTestHook`.
+ Forneça o nome completo do Hook (também chamado de alias) usando este formato: `Provider::ServiceName::HookName`
1. Para a função **Lambda, forneça a função** Lambda a ser usada com este Hook. Você pode usar:
+ O Amazon Resource Name (ARN) completo sem um sufixo.
+ Um ARN qualificado com um sufixo de versão ou alias.
1. Para **alvos de Hook**, escolha o que avaliar:
+ **Pilhas** — avalia os modelos de pilha quando os usuários criam, atualizam ou excluem pilhas.
+ **Recursos** — avalia as alterações de recursos individuais quando os usuários atualizam as pilhas.
+ **Conjuntos de alterações** — avalia as atualizações planejadas quando os usuários criam conjuntos de alterações.
+ **API Cloud Control** — avalia as operações de criação, atualização ou exclusão iniciadas pela [API Cloud Control](https://docs.aws.amazon.com/cloudcontrolapi/latest/userguide/what-is-cloudcontrolapi.html).
1. Em **Ações**, escolha quais ações (criar, atualizar, excluir) invocarão seu Hook.
1. Para o **modo Hook**, escolha como o Hook responde quando a função Lambda invocada pelo Hook retorna uma resposta: `FAILED`
+ **Avisar** — Emite avisos aos usuários, mas permite que as ações continuem. Isso é útil para validações não críticas ou verificações de informações.
+ **Falha** — Impede que a ação prossiga. Isso é útil para aplicar políticas rígidas de conformidade ou segurança.
1. Para **a função Execution**, escolha a função do IAM que o Hook assume para invocar sua função Lambda. Você pode permitir CloudFormation a criação automática de uma função de execução para você ou especificar uma função que você criou.
1. Escolha **Próximo**.
1. (Opcional) Para **filtros Hook**, faça o seguinte:
1. Em **Filtro de recursos**, especifique quais tipos de recursos podem invocar o Hook. Isso garante que o Hook seja invocado apenas para recursos relevantes.
1. Em **Critérios de filtragem**, escolha a lógica para aplicar filtros de nome e função da pilha:
+ **Todos os nomes e funções da pilha** — O Hook só será invocado quando todos os filtros especificados corresponderem.
+ **Qualquer nome de pilha e função de pilha** — O Hook será invocado se pelo menos um dos filtros especificados corresponder.
**nota**
Para operações da Cloud Control API, todos os filtros de **nomes de pilha** e **papéis de pilha** são ignorados.
1. Para **nomes de pilhas**, inclua ou exclua pilhas específicas das invocações de Hook.
+ Em **Incluir**, especifique os nomes das pilhas a serem incluídas. Use isso quando você tiver um pequeno conjunto de pilhas específicas que deseja atingir. Somente as pilhas especificadas nesta lista invocarão o Hook.
+ Em **Excluir**, especifique os nomes das pilhas a serem excluídas. Use isso quando quiser invocar o Hook na maioria das pilhas, mas exclua algumas específicas. Todas as pilhas, exceto as listadas aqui, invocarão o Hook.
1. Para **funções do Stack**, inclua ou exclua pilhas específicas das invocações do Hook com base nas funções do IAM associadas.
+ Em **Include**, especifique uma ou mais funções do IAM ARNs para direcionar as pilhas associadas a essas funções. Somente as operações de pilha iniciadas por essas funções invocarão o Hook.
+ Em **Excluir**, especifique uma ou mais funções do IAM ARNs para as pilhas que você deseja excluir. O Hook será invocado em todas as pilhas, exceto aquelas iniciadas pelas funções especificadas.
1. Escolha **Próximo**.
1. Na página **Revisar e ativar**, revise suas escolhas. Para fazer alterações, escolha **Editar** na seção relacionada.
1. Quando estiver pronto para continuar, escolha **Ativar gancho**.
## Ativar um gancho Lambda ()AWS CLI
Antes de continuar, confirme se você criou a função Lambda e a função de execução que você usará com este Hook. Para obter mais informações, consulte [Crie funções Lambda para avaliar recursos para Lambda Hooks](lambda-hooks-create-lambda-function.md) e [Crie uma função de execução para um Lambda Hook](lambda-hooks-prepare-to-create-hook.md#lambda-hooks-create-execution-role).
**Para ativar um Lambda Hook para uso em sua conta ()AWS CLI**
1. Para começar a ativar um Hook, use o [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 a seguir, substituindo os espaços reservados por seus valores específicos. Este comando autoriza o Hook a usar uma função de execução especificada de seu Conta da 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 finalizar a ativação do Hook, você deve configurá-lo usando um arquivo de configuração JSON.
Use o **cat** comando para criar um arquivo JSON com a estrutura a seguir. Para obter mais informações, consulte [Referência de sintaxe de esquema de configuração de 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`: Defina como `ENABLED` para ativar o Hook.
+ `TargetOperations`: especifique as operações que o Hook avaliará.
+ `FailureMode`: defina como `FAIL` ou `WARN`.
+ `LambdaFunction`: especifique o ARN da função Lambda.
+ `TargetFilters`: especifique os tipos de ações que invocarão o Hook.
1. Use o [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 a seguir, junto com o arquivo JSON que você criou, para aplicar a configuração. Substitua os espaços reservados por seus 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
Fornecemos exemplos de modelos que você pode usar para entender como declarar um Lambda Hook em CloudFormation um modelo de pilha. Consulte mais informações em [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) no *Guia de Usuário AWS CloudFormation *.
# Visualize os registros dos Lambda Hooks em sua conta
Ao usar um Lambda Hook, seu arquivo de log do relatório de saída de validação pode ser encontrado no console Lambda.
## Veja os registros do Lambda Hook no console Lambda
**Para visualizar o arquivo de log de saída do Lambda Hook**
1. Faça login no console Lambda.
1. Na barra de navegação na parte superior da tela, escolha sua Região da AWS.
1. Selecione **Funções**.
1. Escolha a função Lambda desejada.
1. Selecione a guia **Testar**.
1. Escolha **CloudWatch Logs Live Trail**
1. Escolha o menu suspenso e selecione os grupos de registros que você deseja visualizar.
1. Escolha **Iniciar**. O registro será exibido na janela **CloudWatch Logs Live Trail**. Escolha **Exibir em colunas** ou **Exibir em texto sem formatação**, dependendo da sua preferência.
+ Você pode adicionar mais filtros aos resultados adicionando-os no campo **Adicionar padrão de filtro**. Esse campo permite filtrar os resultados para incluir somente eventos que correspondam ao padrão especificado.
Para obter mais informações sobre a visualização de registros de funções do Lambda, consulte [Visualização de CloudWatch registros de funções do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-cloudwatchlogs-view.html).
# Exclua Lambda Hooks em sua conta
Quando você não precisar mais de um Lambda Hook ativado, use os procedimentos a seguir para excluí-lo da sua conta.
Para desativar temporariamente um Hook em vez de excluí-lo, consulte[Desativar e ativar CloudFormation ganchos](hooks-disable-enable.md).
**Topics**
+ [Exclua um Lambda Hook em sua conta (console)](#lambda-hooks-delete-hook-console)
+ [Exclua um Lambda Hook em sua conta ()AWS CLI](#lambda-hooks-delete-hook-cli)
## Exclua um Lambda Hook em sua conta (console)
**Para excluir um Lambda Hook em sua conta**
1. Faça login no Console de gerenciamento da AWS e abra o CloudFormation console em [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Na barra de navegação na parte superior da tela, escolha Região da AWS onde o Hook está localizado.
1. No painel de navegação, escolha **Hooks**.
1. Na página **Hooks**, encontre o Lambda Hook que você deseja excluir.
1. Marque a caixa de seleção ao lado do Gancho e escolha **Excluir**.
1. **Quando solicitada a confirmação, digite o nome do Gancho para confirmar a exclusão do Gancho especificado e escolha Excluir.**
## Exclua um Lambda Hook em sua conta ()AWS CLI
**nota**
Antes de excluir o Hook, você deve primeiro desativá-lo. Para obter mais informações, consulte [Desative e ative um Hook em sua conta (AWS CLI)](hooks-disable-enable.md#hooks-disable-enable-cli).
Use o [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 a seguir para desativar um Hook, que o remove da sua conta. Substitua os espaços reservados por seus valores específicos.
```
aws cloudformation deactivate-type \
--type-arn "arn:aws:cloudformation:us-west-2:123456789012:type/hook/MyTestHook" \
--region us-west-2
```