Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Lambda Hooks
Per utilizzare un AWS Lambda Hook nel tuo account, devi prima *attivare* l'Hook per l'account e la regione in cui desideri utilizzarlo. L'attivazione di un Hook lo rende utilizzabile nelle operazioni di pila nell'account e nella regione in cui è attivato.
Quando attivi un Lambda Hook, CloudFormation crea una voce nel registro del tuo account per l'Hook attivato come Hook privato. Ciò consente di impostare tutte le proprietà di configurazione incluse nell'Hook. Le proprietà di configurazione definiscono come l'Hook è configurato per una determinata Account AWS regione.
**Topics**
+ [AWS CLI comandi per lavorare con Lambda Hooks](#commonly-used-commands-lambda-hooks)
+ [Crea funzioni Lambda per valutare le risorse per Lambda Hooks](lambda-hooks-create-lambda-function.md)
+ [Preparati a creare un Lambda Hook](lambda-hooks-prepare-to-create-hook.md)
+ [Attiva un Lambda Hook nel tuo account](lambda-hooks-activate-hooks.md)
+ [Visualizza i log dei Lambda Hooks nel tuo account](lambda-hooks-view-logs.md)
+ [Elimina Lambda Hooks dal tuo account](lambda-hooks-delete-hooks.md)
## AWS CLI comandi per lavorare con Lambda Hooks
I AWS CLI comandi per lavorare con Lambda Hooks includono:
+ [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/activate-type.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/activate-type.html)per avviare il processo di attivazione di un Lambda Hook.
+ [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/set-type-configuration.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/set-type-configuration.html)per specificare i dati di configurazione per un Hook nel tuo account.
+ [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-types.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-types.html)per elencare gli Hooks presenti nel tuo account.
+ [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-type.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-type.html)per restituire informazioni dettagliate su uno specifico Hook o una versione specifica di Hook, inclusi i dati di configurazione correnti.
+ [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deactivate-type.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deactivate-type.html)per rimuovere un Hook precedentemente attivato dal tuo account.
# Crea funzioni Lambda per valutare le risorse per Lambda Hooks
CloudFormation Lambda Hooks consente di eseguire valutazioni CloudFormation e AWS Cloud Control API operazioni in base al proprio codice personalizzato. Hook può bloccare l'esecuzione di un'operazione o inviare un avviso al chiamante e consentire all'operazione di continuare. Quando crei un Lambda Hook, puoi configurarlo per intercettare e valutare le seguenti operazioni: CloudFormation
+ Operazioni sulle risorse
+ Operazioni di stack
+ Operazioni di modifica del set
**Topics**
+ [Sviluppo di un Lambda Hook](#lambda-hooks-create-lambda-function-develop)
+ [Valutazione delle operazioni relative alle risorse con Lambda Hooks](#lambda-hooks-create-lambda-function-resource)
+ [Valutazione delle operazioni degli stack con Lambda Hooks](#lambda-hooks-create-lambda-function-stack)
+ [Valutazione delle operazioni relative ai set di modifiche con Lambda Hooks](#lambda-hooks-create-lambda-function-change-set)
## Sviluppo di un Lambda Hook
Quando gli Hooks richiamano la tua Lambda, aspetteranno fino a 30 secondi affinché Lambda valuti l'input. Lambda restituirà una risposta JSON che indica se l'Hook è riuscito o meno.
**Topics**
+ [Richiedi input](#lambda-hooks-create-lambda-function-request-input)
+ [Input di risposta](#lambda-hooks-create-lambda-function-request-response)
+ [Esempi](#lambda-hooks-create-lambda-function-request-example)
### Richiedi input
L'input passato alla funzione Lambda dipende dall'operazione di destinazione Hook (esempi: stack, resource o change set).
### Input di risposta
Per comunicare a Hooks se la richiesta è riuscita o meno, la funzione Lambda deve restituire una risposta JSON.
Di seguito è riportato un esempio di forma della risposta che Hooks si aspetta:
```
{
"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
Lo stato dell'Hook. Questo è un campo obbligatorio.
*Valori validi*: (`SUCCESS`\$1 `FAILED` \$1`IN_PROGRESS`)
Un Hook può tornare `IN_PROGRESS` 3 volte. Se non viene restituito alcun risultato, l'Hook fallirà. Per un Lambda Hook, ciò significa che la funzione Lambda può essere richiamata fino a 3 volte.
errorCode
Indica se l'operazione è stata valutata e ritenuta non valida o se si sono verificati errori all'interno dell'Hook che hanno impedito la valutazione. Questo campo è obbligatorio se l'Hook fallisce.
*Valori validi*: (`NonCompliant`\$1`InternalFailure`)
message
Il messaggio al chiamante che indica il motivo per cui l'Hook ha avuto esito positivo o negativo.
Durante la valutazione CloudFormation delle operazioni, questo campo viene troncato a 4096 caratteri.
Quando si valutano le operazioni dell'API Cloud Control, questo campo viene troncato a 1024 caratteri.
clientRequestToken
Il token di richiesta che è stato fornito come input alla richiesta Hook. Questo è un campo obbligatorio.
CallbackContext
Se indichi che `hookStatus` è`IN_PROGRESS`, passi un contesto aggiuntivo che viene fornito come input quando la funzione Lambda viene reinvocata.
callbackDelaySeconds
Quanto tempo devono aspettare gli Hook per richiamare nuovamente questo Hook.
annotations
Una serie di oggetti di annotazione che forniscono ulteriori dettagli e indicazioni per la correzione.
Nome dell'annotazione
Un identificatore per l'annotazione.
status
Lo stato di invocazione di Hook. Ciò è utile quando le annotazioni rappresentano una logica con una valutazione pass/fail simile a una regola Guard.
*Valori validi*: (\$1 \$1) `PASSED` `FAILED` `SKIPPED`
statusMessage
Spiegazione dello stato specifico.
Messaggio di riparazione
Suggerimento per correggere uno stato. `FAILED` Ad esempio, se in una risorsa manca la crittografia, puoi indicare come aggiungere la crittografia alla configurazione della risorsa.
Link di riparazione
Un URL HTTP per ulteriori indicazioni sulla riparazione.
severityLevel
Definisce il rischio relativo associato a qualsiasi violazione di questo tipo. Quando si assegnano i livelli di gravità ai risultati della chiamata Hook, è possibile fare riferimento al [framework di AWS Security Hub CSPM gravità](https://docs.aws.amazon.com/securityhub/latest/userguide/asff-required-attributes.html#Severity) come esempio di come strutturare categorie di gravità significative.
*Valori validi*: (`INFORMATIONAL`\$1 \$1 \$1 \$1`LOW`) `MEDIUM` `HIGH` `CRITICAL`
### Esempi
Di seguito è riportato un esempio di risposta riuscita:
```
{
"hookStatus": "SUCCESS",
"message": "compliant",
"clientRequestToken": "123avjdjk31"
}
```
Di seguito è riportato un esempio di risposta non riuscita:
```
{
"hookStatus": "FAILED",
"errorCode": "NonCompliant",
"message": "S3 Bucket Versioning must be enabled.",
"clientRequestToken": "123avjdjk31"
}
```
## Valutazione delle operazioni relative alle risorse con Lambda Hooks
Ogni volta che crei, aggiorni o elimini una risorsa, questa viene considerata un'operazione relativa alle risorse. Ad esempio, se esegui l'aggiornamento di uno CloudFormation stack che crea una nuova risorsa, hai completato un'operazione sulla risorsa. Quando crei, aggiorni o elimini una risorsa utilizzando l'API Cloud Control, anche questa viene considerata un'operazione relativa alle risorse. Puoi configurare il tuo CloudFormation Lambda Hook per la destinazione `RESOURCE` e `CLOUD_CONTROL` le operazioni nella configurazione Hook`TargetOperations`.
**Nota**
Il gestore `delete` Hook viene richiamato solo quando una risorsa viene eliminata utilizzando un trigger operativo dall'API Cloud Control o. `delete-resource` CloudFormation `delete-stack`
**Topics**
+ [Sintassi di input delle risorse Lambda Hook](#lambda-hooks-create-lambda-function-resource-input)
+ [Esempio di input per la modifica delle risorse Lambda Hook](#lambda-hooks-create-lambda-function-resource-example)
+ [Esempio di funzione Lambda per le operazioni sulle risorse](#lambda-hooks-create-lambda-function-resource-example-function)
### Sintassi di input delle risorse Lambda Hook
Quando la tua Lambda viene richiamata per un'operazione su una risorsa, riceverai un input JSON contenente le proprietà della risorsa, le proprietà proposte e il contesto attorno alla chiamata di Hook.
Di seguito è riportato un esempio di forma dell'input 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": {
"invocazione": 1,
"CallbackContext": null
}
}
```
`awsAccountId`
L'ID del Account AWS contenitore della risorsa da valutare.
`stackId`
L'ID dello stack di cui CloudFormation fa parte questa operazione. Questo campo è vuoto se il chiamante è Cloud Control API.
`changeSetId`
L'ID del set di modifiche che ha avviato la chiamata di Hook. Questo valore è vuoto se la modifica delle risorse è stata avviata dall'API Cloud Control o dalle operazioni, o. `create-stack` `update-stack` `delete-stack`
`hookTypeName`
Il nome dell'Hook in esecuzione.
`hookTypeVersion`
La versione dell'Hook in esecuzione.
`hookModel`
`LambdaFunction`
L'attuale Lambda ARN richiamato dall'Hook.
`actionInvocationPoint`
Il punto esatto della logica di provisioning in cui viene eseguito l'Hook.
*Valori validi*: (`CREATE_PRE_PROVISION`\$1 `UPDATE_PRE_PROVISION` \$1`DELETE_PRE_PROVISION`)
`requestData`
`targetName`
Il tipo di oggetto da valutare, ad esempio,`AWS::S3::Bucket`.
`targetType`
Il tipo di oggetto da valutare, ad esempio. `AWS::S3::Bucket` Per le risorse fornite con l'API Cloud Control, questo valore sarà. `RESOURCE`
`targetLogicalId`
L'ID logico della risorsa da valutare. Se l'origine dell'invocazione di Hook è CloudFormation, questo sarà l'ID della risorsa logica definito nel modello. CloudFormation Se l'origine di questa chiamata di Hook è l'API Cloud Control, questo sarà un valore costruito.
`targetModel`
`resourceProperties`
Le proprietà proposte della risorsa da modificare. Se la risorsa viene eliminata, questo valore sarà vuoto.
`previousResourceProperties`
Le proprietà attualmente associate alla risorsa da modificare. Se la risorsa viene creata, questo valore sarà vuoto.
`requestContext`
invocazione
L'attuale tentativo di eseguire l'Hook.
CallbackContext
Se Hook è stato impostato su ed è `callbackContext` stato restituito`IN_PROGRESS`, sarà qui dopo la reinvocazione.
### Esempio di input per la modifica delle risorse Lambda Hook
L'input di esempio seguente mostra un Lambda Hook che riceverà la definizione della `AWS::DynamoDB::Table` risorsa da aggiornare, dove l'`ReadCapacityUnits`of `ProvisionedThroughput` viene modificato da 3 a 10. Questi sono i dati a disposizione di Lambda per la valutazione.
```
{
"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
}
}
```
Per visualizzare tutte le proprietà disponibili per il tipo di risorsa, consulta [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).
### Esempio di funzione Lambda per le operazioni sulle risorse
Di seguito è riportata una semplice funzione che fallisce qualsiasi aggiornamento delle risorse a DynamoDB, che tenta di impostare of su un `ReadCapacity` valore `ProvisionedThroughput` maggiore di 10. Se l'Hook ha successo, al chiamante verrà visualizzato il messaggio "ReadCapacity è configurato correttamente». Se la richiesta non viene convalidata, l'Hook avrà esito negativo e lo stato «ReadCapacity non può essere superiore a 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
```
------
## Valutazione delle operazioni degli stack con Lambda Hooks
Ogni volta che crei, aggiorni o elimini uno stack con un nuovo modello, puoi configurare il tuo CloudFormation Lambda Hook per iniziare a valutare il nuovo modello e potenzialmente bloccare il proseguimento dell'operazione dello stack. Puoi configurare il tuo CloudFormation Lambda Hook per eseguire `STACK` operazioni mirate nella configurazione Hook`TargetOperations`.
**Topics**
+ [Sintassi di input dello stack Lambda Hook](#lambda-hooks-create-lambda-function-stack-input)
+ [Esempio di input per la modifica dello stack Lambda Hook](#lambda-hooks-create-lambda-function-stack-example)
+ [Esempio di funzione Lambda per operazioni in pila](#lambda-hooks-create-lambda-function-stack-example-function)
### Sintassi di input dello stack Lambda Hook
Quando la tua Lambda viene richiamata per un'operazione stack, riceverai una richiesta JSON contenente il contesto di invocazione Hook e il contesto di richiesta. `actionInvocationPoint` A causa delle dimensioni dei CloudFormation modelli e della dimensione di input limitata accettata dalle funzioni Lambda, i modelli effettivi vengono archiviati in un oggetto Amazon S3. L'input di `requestData` include un URL rassegnato di Amazon S3 a un altro oggetto, che contiene la versione attuale e precedente del modello.
Di seguito è riportato un esempio di forma dell'input 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`
Il token di richiesta fornito come input alla richiesta Hook. Questo è un campo obbligatorio.
`awsAccountId`
L'ID dello stack Account AWS contenente lo stack da valutare.
`stackID`
L'ID dello stack. CloudFormation
`changeSetId`
L'ID del set di modifiche che ha avviato l'invocazione di Hook. Questo valore è vuoto se la modifica dello stack è stata avviata dall'API Cloud Control o dalle operazioni,, or. `create-stack` `update-stack` `delete-stack`
`hookTypeName`
Il nome dell'Hook in esecuzione.
`hookTypeVersion`
La versione dell'Hook in esecuzione.
`hookModel`
`LambdaFunction`
L'attuale Lambda ARN richiamato dall'Hook.
`actionInvocationPoint`
Il punto esatto della logica di provisioning in cui viene eseguito l'Hook.
*Valori validi*: (`CREATE_PRE_PROVISION`\$1 `UPDATE_PRE_PROVISION` \$1`DELETE_PRE_PROVISION`)
`requestData`
`targetName`
Questo valore sarà`STACK`.
`targetType`
Questo valore sarà`STACK`.
`targetLogicalId`
Il nome dello stack.
`payload`
L'URL predefinito di Amazon S3 contenente un oggetto JSON con le definizioni del modello correnti e precedenti.
`requestContext`
Se l'Hook viene reinvocato, questo oggetto verrà impostato.
`invocation`
L'attuale tentativo di eseguire l'Hook.
`callbackContext`
Se l'Hook è stato impostato su `IN_PROGRESS` ed `callbackContext` è stato restituito, sarà qui dopo la reinvocazione.
La `payload` proprietà nei dati della richiesta è un URL che il codice deve recuperare. Una volta ricevuto l'URL, si ottiene un oggetto con lo schema seguente:
```
{
"template": String,
"previousTemplate": String
}
```
`template`
Il CloudFormation modello completo fornito a `create-stack` or`update-stack`. Può essere una stringa JSON o YAML a seconda di ciò che è stato fornito. CloudFormation
Nelle `delete-stack` operazioni, questo valore sarà vuoto.
`previousTemplate`
Il CloudFormation modello precedente. Può essere una stringa JSON o YAML a seconda di cosa è stata fornita. CloudFormation
Nelle `delete-stack` operazioni, questo valore sarà vuoto.
### Esempio di input per la modifica dello stack Lambda Hook
Di seguito è riportato un esempio di input per la modifica dello stack. Hook sta valutando una modifica che aggiorna `ObjectLockEnabled` a true e aggiunge una coda 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
}
}
```
Questo è un esempio `payload` di: `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}}}}"
}
```
### Esempio di funzione Lambda per operazioni in pila
L'esempio seguente è una semplice funzione che scarica il payload dell'operazione stack, analizza il modello JSON e restituisce. `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 ]
Per usare Python, devi importare la `requests` libreria. A tale scopo, è necessario includere la libreria nel pacchetto di distribuzione durante la creazione della funzione Lambda. *Per ulteriori informazioni, consulta [Creazione di un pacchetto di distribuzione.zip con dipendenze](https://docs.aws.amazon.com/lambda/latest/dg/python-package.html#python-package-create-dependencies) nella Guida per gli AWS Lambda sviluppatori.*
```
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
```
------
## Valutazione delle operazioni relative ai set di modifiche con Lambda Hooks
Ogni volta che crei un set di modifiche, puoi configurare il tuo CloudFormation Lambda Hook per valutare prima il nuovo set di modifiche e potenzialmente bloccarne l'esecuzione. Puoi configurare il tuo CloudFormation Lambda Hook per eseguire `CHANGE_SET` operazioni mirate nella configurazione Hook`TargetOperations`.
**Topics**
+ [Sintassi di input del set di modifiche Lambda Hook](#lambda-hooks-create-lambda-function-change-set-input)
+ [Esempio di input di modifica del set di modifiche Lambda Hook](#lambda-hooks-create-lambda-function-change-set-example)
+ [Esempio di funzione Lambda per le operazioni sui set di modifiche](#lambda-hooks-create-lambda-function-change-set-example-function)
### Sintassi di input del set di modifiche Lambda Hook
L'input per le operazioni sui set di modifiche è simile alle operazioni sullo stack, ma il payload del set include `requestData` anche un elenco di modifiche alle risorse introdotte dal set di modifiche.
Di seguito è riportato un esempio di forma dell'input 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`
Il token di richiesta fornito come input alla richiesta Hook. Questo è un campo obbligatorio.
`awsAccountId`
L'ID dello stack Account AWS contenente lo stack da valutare.
`stackID`
L'ID dello stack. CloudFormation
`changeSetId`
L'ID del set di modifiche che ha avviato l'invocazione di Hook.
`hookTypeName`
Il nome dell'Hook in esecuzione.
`hookTypeVersion`
La versione dell'Hook in esecuzione.
`hookModel`
`LambdaFunction`
L'attuale Lambda ARN richiamato dall'Hook.
`requestData`
`targetName`
Questo valore sarà. `CHANGE_SET`
`targetType`
Questo valore sarà`CHANGE_SET`.
`targetLogicalId`
Il set di modifiche ARN..
`payload`
L'URL predefinito di Amazon S3 contenente un oggetto JSON con il modello corrente e un elenco di modifiche introdotte da questo set di modifiche.
`requestContext`
Se l'Hook viene reinvocato, questo oggetto verrà impostato.
`invocation`
L'attuale tentativo di eseguire l'Hook.
`callbackContext`
Se l'Hook è stato impostato su `IN_PROGRESS` ed `callbackContext` è stato restituito, sarà qui dopo la reinvocazione.
La `payload` proprietà nei dati della richiesta è un URL che il codice deve recuperare. Una volta ricevuto l'URL, si ottiene un oggetto con lo schema seguente:
```
{
"template": String,
"changedResources": [
{
"action": String,
"beforeContext": JSON String,
"afterContext": JSON String,
"lineNumber": Integer,
"logicalResourceId": String,
"resourceType": String
}
]
}
```
`template`
Il CloudFormation modello completo fornito a `create-stack` or`update-stack`. Può essere una stringa JSON o YAML a seconda di ciò che è stato fornito. CloudFormation
`changedResources`
Un elenco di risorse modificate.
`action`
Il tipo di modifica applicata alla risorsa.
*Valori validi*: (`CREATE`\$1 `UPDATE` \$1`DELETE`)
`beforeContext`
Una stringa JSON delle proprietà della risorsa prima della modifica. Questo valore è nullo quando la risorsa viene creata. Tutti i valori booleani e numerici in questa stringa JSON sono STRINGS.
`afterContext`
Una stringa JSON delle proprietà delle risorse se questo set di modifiche viene eseguito. Questo valore è nullo quando la risorsa viene eliminata. Tutti i valori booleani e numerici in questa stringa JSON sono STRINGS.
`lineNumber`
Il numero di riga del modello che ha causato questa modifica. Se l'azione è, `DELETE` questo valore sarà nullo.
`logicalResourceId`
L'ID della risorsa logica della risorsa da modificare.
`resourceType`
Il tipo di risorsa che viene modificata.
### Esempio di input di modifica del set di modifiche Lambda Hook
Di seguito è riportato un esempio di input di modifica del set di modifiche. Nell'esempio seguente, è possibile visualizzare le modifiche introdotte dal set di modifiche. La prima modifica consiste nell'eliminare una coda chiamata. `CoolQueue` La seconda modifica consiste nell'aggiungere una nuova coda chiamata. `NewCoolQueue` L'ultima modifica è un aggiornamento di`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
}
}
```
Questo è un esempio `payload` di`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"}]}}'
}
]
}
```
### Esempio di funzione Lambda per le operazioni sui set di modifiche
L'esempio seguente è una semplice funzione che scarica il payload dell'operazione Change Set, esegue un ciclo su ogni modifica e quindi stampa le proprietà before e after prima di restituire 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 ]
Per usare Python, devi importare la `requests` libreria. A tale scopo, è necessario includere la libreria nel pacchetto di distribuzione durante la creazione della funzione Lambda. *Per ulteriori informazioni, consulta [Creazione di un pacchetto di distribuzione.zip con dipendenze](https://docs.aws.amazon.com/lambda/latest/dg/python-package.html#python-package-create-dependencies) nella Guida per gli AWS Lambda sviluppatori.*
```
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
```
------
# Preparati a creare un Lambda Hook
Prima di creare un Lambda Hook, devi completare i seguenti prerequisiti:
+ È necessario aver già creato una funzione Lambda. Per ulteriori informazioni, consulta [Crea funzioni Lambda per Hooks](lambda-hooks-create-lambda-function.md).
+ L'utente o il ruolo che crea l'Hook deve disporre di autorizzazioni sufficienti per attivare gli Hook. Per ulteriori informazioni, consulta [Concedi le autorizzazioni IAM per gli CloudFormation Hooks](grant-iam-permissions-for-hooks.md).
+ Per utilizzare AWS CLI o un SDK per creare un Lambda Hook, devi creare manualmente un ruolo di esecuzione con autorizzazioni IAM e una policy di fiducia per CloudFormation consentire di richiamare un Lambda Hook.
## Creare un ruolo di esecuzione per un Lambda Hook
Un Hook utilizza un ruolo di esecuzione per le autorizzazioni necessarie per richiamare quell'Hook nel tuo. Account AWS
Questo ruolo può essere creato automaticamente se crei un Lambda Hook da Console di gestione AWS; in caso contrario, devi crearlo tu stesso.
La sezione seguente mostra come configurare le autorizzazioni per creare il tuo Lambda Hook.
### Autorizzazioni richieste
Segui le indicazioni riportate in [Creare un ruolo utilizzando policy di attendibilità personalizzate](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html) nella *Guida per l’utente IAM* per creare un ruolo con una policy di attendibilità personalizzata.
Quindi, completa i seguenti passaggi per configurare le tue autorizzazioni:
1. Allega la seguente politica di privilegi minimi al ruolo IAM che desideri utilizzare per creare il Lambda Hook.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-west-2:123456789012:function:MyFunction"
}
]
}
```
------
1. Concedi al tuo Hook il permesso di assumere il ruolo aggiungendo una policy di fiducia al ruolo. Di seguito viene mostrato un esempio di politica di fiducia che è possibile utilizzare.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"hooks.cloudformation.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
# Attiva un Lambda Hook nel tuo account
L'argomento seguente mostra come attivare un Lambda Hook nel tuo account, il che lo rende utilizzabile nell'account e nella regione in cui è stato attivato.
**Topics**
+ [Attiva un Lambda Hook (console)](#lambda-hooks-activate-hook-console)
+ [Attiva un Lambda Hook ()AWS CLI](#lambda-hooks-activate-hooks-cli)
+ [Risorse correlate](#related-resources-lambda-hooks)
## Attiva un Lambda Hook (console)
**Per attivare un Lambda Hook da utilizzare nel tuo account**
1. Accedi Console di gestione AWS e apri la CloudFormation console all'indirizzo [https://console.aws.amazon.com/cloudformazione.](https://console.aws.amazon.com/cloudformation/)
1. Nella barra di navigazione nella parte superiore dello schermo, scegli Regione AWS dove vuoi creare l'Hook in.
1. Se *non hai* creato una funzione Lambda per l'Hook, procedi come segue:
+ Aprire la [pagina Functions (Funzioni)](https://console.aws.amazon.com/lambda/home#/functions) nella console Lambda.
+ Crea la funzione Lambda che utilizzerai con questo Hook, quindi torna a questa procedura. Per ulteriori informazioni, consulta [Crea funzioni Lambda per valutare le risorse per Lambda Hooks](lambda-hooks-create-lambda-function.md).
Se hai già creato la tua funzione Lambda, procedi al passaggio successivo.
1. Nel riquadro di navigazione a sinistra, scegli **Hooks**.
1. Nella pagina **Hooks**, scegli **Crea un hook**, quindi scegli **Con Lambda**.
1. Per **Hook name**, scegli una delle seguenti opzioni:
+ Fornisci un nome breve e descrittivo che verrà aggiunto dopo`Private::Lambda::`. Ad esempio, se inserisci*`MyTestHook`*, il nome completo di Hook diventa`Private::Lambda::MyTestHook`.
+ Fornite il nome completo dell'Hook (chiamato anche alias) utilizzando questo formato: `Provider::ServiceName::HookName`
1. Per la funzione **Lambda, fornisci la funzione** Lambda da utilizzare con questo Hook. È possibile utilizzare:
+ L'Amazon Resource Name (ARN) completo senza suffisso.
+ Un ARN qualificato con un suffisso di versione o alias.
1. Per **gli obiettivi Hook**, scegli cosa valutare:
+ **Pile**: valuta i modelli di stack quando gli utenti creano, aggiornano o eliminano gli stack.
+ **Risorse**: valuta le modifiche delle singole risorse quando gli utenti aggiornano gli stack.
+ **Set di modifiche**: valuta gli aggiornamenti pianificati quando gli utenti creano set di modifiche.
+ **API Cloud Control**: valuta le operazioni di creazione, aggiornamento o eliminazione avviate dall'API [Cloud](https://docs.aws.amazon.com/cloudcontrolapi/latest/userguide/what-is-cloudcontrolapi.html) Control.
1. Per **Actions**, scegli quali azioni (creazione, aggiornamento, eliminazione) richiameranno il tuo Hook.
1. Per la **modalità Hook**, scegli come risponde l'Hook quando la funzione Lambda richiamata dall'Hook restituisce una risposta: `FAILED`
+ **Avvisa: invia avvisi** agli utenti ma consente il proseguimento delle azioni. Ciò è utile per convalide non critiche o controlli informativi.
+ **Fallito**: impedisce il proseguimento dell'azione. Ciò è utile per applicare rigorose politiche di conformità o sicurezza.
1. Per il **ruolo Execution**, scegli il ruolo IAM che Hook assume per richiamare la tua funzione Lambda. Puoi consentire la creazione automatica CloudFormation di un ruolo di esecuzione per te oppure puoi specificare un ruolo che hai creato.
1. Scegli **Next (Successivo)**.
1. (Facoltativo) Per **i filtri Hook**, procedi come segue:
1. Per il **filtro Resource**, specifica quali tipi di risorse possono richiamare l'Hook. Ciò garantisce che l'Hook venga richiamato solo per le risorse pertinenti.
1. Per i **criteri di filtraggio**, scegli la logica per applicare i filtri del nome dello stack e del ruolo dello stack:
+ **Tutti i nomi degli stack e i ruoli dello stack**: l'Hook verrà richiamato solo quando tutti i filtri specificati corrispondono.
+ **Qualsiasi nome dello stack e ruolo dello stack**: l'Hook verrà richiamato se almeno uno dei filtri specificati corrisponde.
**Nota**
Per le operazioni dell'API Cloud Control, tutti i filtri **dei nomi degli stack e dei ruoli dello** **stack vengono ignorati**.
1. Per i **nomi Stack**, includi o escludi stack specifici dalle invocazioni di Hook.
+ Per **Include**, specificate i nomi degli stack da includere. Usalo quando hai un piccolo set di pile specifiche a cui vuoi rivolgerti. Solo gli stack specificati in questo elenco richiameranno l'Hook.
+ Per **Exclude**, specifica i nomi degli stack da escludere. Usalo quando vuoi invocare l'Hook sulla maggior parte degli stack ma escluderne alcuni specifici. Tutti gli stack tranne quelli elencati qui invocheranno l'Hook.
1. Per i **ruoli Stack**, includi o escludi stack specifici dalle invocazioni di Hook in base ai ruoli IAM associati.
+ Per **Include**, specifica uno o più ruoli IAM ARNs per indirizzare gli stack associati a questi ruoli. Solo le operazioni di stack avviate da questi ruoli richiameranno l'Hook.
+ Per **Exclude**, specifica uno o più ruoli IAM ARNs per gli stack che desideri escludere. L'Hook verrà richiamato su tutti gli stack ad eccezione di quelli avviati dai ruoli specificati.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Rivedi e attiva**, rivedi le tue scelte. Per apportare modifiche, scegli **Modifica** nella sezione da modificare.
1. Quando sei pronto per procedere, scegli **Activate Hook**.
## Attiva un Lambda Hook ()AWS CLI
Prima di continuare, conferma di aver creato la funzione Lambda e il ruolo di esecuzione che utilizzerai con questo Hook. Per ulteriori informazioni, consultare [Crea funzioni Lambda per valutare le risorse per Lambda Hooks](lambda-hooks-create-lambda-function.md) e [Creare un ruolo di esecuzione per un Lambda Hook](lambda-hooks-prepare-to-create-hook.md#lambda-hooks-create-execution-role).
**Per attivare un Lambda Hook da utilizzare nel tuo account ()AWS CLI**
1. Per iniziare ad attivare un Hook, usa il seguente [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, sostituendo i segnaposto con i tuoi valori specifici. Questo comando autorizza l'Hook a utilizzare un ruolo di esecuzione specificato dal tuo. Account 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. Per completare l'attivazione dell'Hook, è necessario configurarlo utilizzando un file di configurazione JSON.
Usa il **cat** comando per creare un file JSON con la seguente struttura. Per ulteriori informazioni, consulta [Riferimento alla sintassi dello schema di configurazione dell’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`: Impostato per `ENABLED` abilitare l'Hook.
+ `TargetOperations`: Specificate le operazioni che l'Hook valuterà.
+ `FailureMode`: impostare su `FAIL` o su `WARN`.
+ `LambdaFunction`: Specificare l'ARN della funzione Lambda.
+ `TargetFilters`: Specificate i tipi di azioni che richiameranno l'Hook.
1. Usa il [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 seguente, insieme al file JSON che hai creato, per applicare la configurazione. Sostituisci i segnaposto con i tuoi valori specifici.
```
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
```
## Risorse correlate
Forniamo esempi di modelli che puoi utilizzare per capire come dichiarare un Lambda Hook in CloudFormation un modello di pila. Per ulteriori informazioni, consulta [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) nella *Guida per l'utente di AWS CloudFormation *.
# Visualizza i log dei Lambda Hooks nel tuo account
Quando si utilizza un Lambda Hook, il file di registro del rapporto di output di convalida si trova nella console Lambda.
## Visualizza i log di Lambda Hook nella console Lambda
**Per visualizzare il file di registro di output di Lambda Hook**
1. Accedi alla console Lambda.
1. Nella barra di navigazione nella parte superiore dello schermo, scegli la Regione AWS.
1. **Scegli Funzioni.**
1. Scegli la funzione Lambda desiderata.
1. Seleziona la scheda **Test**.
1. Scegli **CloudWatch Logs Live Trail**
1. Scegli il menu a discesa e seleziona i gruppi di log che desideri visualizzare.
1. Scegli **Avvia**. Il registro verrà visualizzato nella finestra **CloudWatch Logs Live Trail.** Scegli **Visualizza in colonne** o **Visualizza in testo semplice** a seconda delle tue preferenze.
+ Puoi aggiungere altri filtri ai risultati aggiungendoli nel campo **Aggiungi modello di filtro**. Questo campo consente di filtrare i risultati per includere solo gli eventi che corrispondono al modello specificato.
Per ulteriori informazioni sulla visualizzazione dei log per le funzioni Lambda, [vedere CloudWatch Visualizzazione dei log per](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-cloudwatchlogs-view.html) le funzioni Lambda.
# Elimina Lambda Hooks dal tuo account
Quando non hai più bisogno di un Lambda Hook attivato, utilizza le seguenti procedure per eliminarlo dal tuo account.
Per disabilitare temporaneamente un Hook anziché eliminarlo, consulta. [Disabilita e abilita gli CloudFormation Hooks](hooks-disable-enable.md)
**Topics**
+ [Elimina un Lambda Hook nel tuo account (console)](#lambda-hooks-delete-hook-console)
+ [Elimina un Lambda Hook nel tuo account ()AWS CLI](#lambda-hooks-delete-hook-cli)
## Elimina un Lambda Hook nel tuo account (console)
**Per eliminare un Lambda Hook dal tuo account**
1. Accedi Console di gestione AWS e apri la CloudFormation console all'indirizzo [https://console.aws.amazon.com/cloudformazione.](https://console.aws.amazon.com/cloudformation/)
1. Nella barra di navigazione nella parte superiore dello schermo, scegli Regione AWS dove si trova l'Hook.
1. Dal pannello di navigazione, scegli **Hooks.**
1. Nella pagina **Hooks**, trova il Lambda Hook che desideri eliminare.
1. **Seleziona la casella di controllo accanto al tuo Hook e scegli Elimina.**
1. **Quando viene richiesta la conferma, digita il nome dell'Hook per confermare l'eliminazione dell'Hook specificato, quindi scegli Elimina.**
## Elimina un Lambda Hook nel tuo account ()AWS CLI
**Nota**
Prima di poter eliminare l'Hook, devi prima disabilitarlo. Per ulteriori informazioni, consulta [Disattiva e abilita un Hook nel tuo account ()AWS CLI](hooks-disable-enable.md#hooks-disable-enable-cli).
Usa il seguente [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 per disattivare un Hook, che lo rimuove dal tuo account. Sostituisci i segnaposto con i tuoi valori specifici.
```
aws cloudformation deactivate-type \
--type-arn "arn:aws:cloudformation:us-west-2:123456789012:type/hook/MyTestHook" \
--region us-west-2
```