Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Lambda-Hook
Um einen AWS Lambda Hook in Ihrem Konto verwenden zu können, müssen Sie zuerst den Hook für das Konto und die Region *aktivieren*, in der Sie ihn verwenden möchten. Wenn Sie einen Hook aktivieren, kann er für Stack-Operationen in dem Konto und der Region verwendet werden, in der er aktiviert ist.
Wenn Sie einen Lambda-Hook aktivieren, CloudFormation erstellt er einen Eintrag in der Registrierung Ihres Kontos für den aktivierten Hook als privaten Hook. Auf diese Weise können Sie alle Konfigurationseigenschaften festlegen, die der Hook enthält. Die Konfigurationseigenschaften definieren, wie der Hook für eine bestimmte AWS-Konto Region konfiguriert wird.
**Topics**
+ [AWS CLI Befehle für die Arbeit mit Lambda Hooks](#commonly-used-commands-lambda-hooks)
+ [Erstellen Sie Lambda-Funktionen, um Ressourcen für Lambda Hooks auszuwerten](lambda-hooks-create-lambda-function.md)
+ [Bereiten Sie sich darauf vor, einen Lambda-Hook zu erstellen](lambda-hooks-prepare-to-create-hook.md)
+ [Aktiviere einen Lambda Hook in deinem Konto](lambda-hooks-activate-hooks.md)
+ [Logs für die Lambda Hooks in Ihrem Konto anzeigen](lambda-hooks-view-logs.md)
+ [Löschen Sie Lambda Hooks in Ihrem Konto](lambda-hooks-delete-hooks.md)
## AWS CLI Befehle für die Arbeit mit Lambda Hooks
Zu den AWS CLI Befehlen für die Arbeit mit Lambda Hooks gehören:
+ [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/activate-type.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/activate-type.html)um den Aktivierungsprozess für einen Lambda Hook zu starten.
+ [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)um die Konfigurationsdaten für einen Hook in Ihrem Konto anzugeben.
+ [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-types.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-types.html)um die Hooks in Ihrem Konto aufzulisten.
+ [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-type.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-type.html)um detaillierte Informationen über einen bestimmten Hook oder eine bestimmte Hook-Version zurückzugeben, einschließlich aktueller Konfigurationsdaten.
+ [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deactivate-type.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deactivate-type.html)um einen zuvor aktivierten Hook aus Ihrem Konto zu entfernen.
# Erstellen Sie Lambda-Funktionen, um Ressourcen für Lambda Hooks auszuwerten
CloudFormation Mit Lambda Hooks können Sie Ihren eigenen benutzerdefinierten Code auswerten CloudFormation und anhand dessen AWS -Cloud-Control- API arbeiten. Ihr Hook kann den Fortgang eines Vorgangs blockieren oder eine Warnung an den Aufrufer ausgeben, sodass der Vorgang fortgesetzt werden kann. Wenn Sie einen Lambda-Hook erstellen, können Sie ihn so konfigurieren, dass er die folgenden CloudFormation Operationen abfängt und auswertet:
+ Ressourcenvorgänge
+ Operationen stapeln
+ Set-Operationen ändern
**Topics**
+ [Entwicklung eines Lambda-Hooks](#lambda-hooks-create-lambda-function-develop)
+ [Evaluierung von Ressourcenoperationen mit Lambda Hooks](#lambda-hooks-create-lambda-function-resource)
+ [Auswertung von Stack-Operationen mit Lambda Hooks](#lambda-hooks-create-lambda-function-stack)
+ [Evaluierung von Change-Set-Vorgängen mit Lambda Hooks](#lambda-hooks-create-lambda-function-change-set)
## Entwicklung eines Lambda-Hooks
Wenn Hooks Ihr Lambda aufrufen, wartet es bis zu 30 Sekunden, bis das Lambda die Eingabe ausgewertet hat. Das Lambda gibt eine JSON-Antwort zurück, die angibt, ob der Hook erfolgreich war oder fehlgeschlagen ist.
**Topics**
+ [Eingabe anfordern](#lambda-hooks-create-lambda-function-request-input)
+ [Eingabe der Antwort](#lambda-hooks-create-lambda-function-request-response)
+ [Beispiele](#lambda-hooks-create-lambda-function-request-example)
### Eingabe anfordern
Die an Ihre Lambda-Funktion übergebene Eingabe hängt von der Hook-Zieloperation ab (Beispiele: Stack, Ressource oder Änderungssatz).
### Eingabe der Antwort
Um Hooks mitzuteilen, ob Ihre Anfrage erfolgreich war oder fehlgeschlagen ist, muss Ihre Lambda-Funktion eine JSON-Antwort zurückgeben.
Das Folgende ist ein Beispiel für die Form der Antwort, die Hooks erwartet:
```
{
"HookStatus": "SUCCESS" or "FAILED" or "IN_PROGRESS",
"errorCode": "NonCompliant" or "InternalFailure"
"Nachricht": String,
"clientRequestToken": String,
"Callback-Kontext": None,
"callbackDelaySeconds": Integer,
"Anmerkungen": [
{
"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
Der Status des Hooks. Dies ist ein Pflichtfeld.
*Gültige Werte*: (`SUCCESS`\$1 `FAILED` \$1`IN_PROGRESS`)
Ein Hook kann `IN_PROGRESS` dreimal zurückkehren. Wenn kein Ergebnis zurückgegeben wird, schlägt der Hook fehl. Für einen Lambda-Hook bedeutet dies, dass Ihre Lambda-Funktion bis zu dreimal aufgerufen werden kann.
errorCode
Zeigt an, ob der Vorgang ausgewertet und für ungültig befunden wurde oder ob innerhalb des Hooks Fehler aufgetreten sind, die die Auswertung verhindert haben. Dieses Feld ist erforderlich, wenn der Hook fehlschlägt.
*Gültige Werte*: (`NonCompliant`\$1`InternalFailure`)
Nachricht
Die Nachricht an den Aufrufer, die angibt, warum der Hook erfolgreich war oder fehlgeschlagen ist.
Bei der Auswertung von CloudFormation Vorgängen wird dieses Feld auf 4096 Zeichen gekürzt.
Bei der Auswertung von Cloud Control API-Vorgängen wird dieses Feld auf 1024 Zeichen gekürzt.
clientRequestToken
Das Anforderungstoken, das als Eingabe für die Hook-Anfrage bereitgestellt wurde. Dies ist ein Pflichtfeld.
Callback-Kontext
Wenn Sie angeben, dass das `hookStatus` ist, übergeben `IN_PROGRESS` Sie einen zusätzlichen Kontext, der als Eingabe bereitgestellt wird, wenn die Lambda-Funktion erneut aufgerufen wird.
callbackDelaySeconds
Wie lange Hooks warten sollten, um diesen Hook erneut aufzurufen.
Anmerkungen
Eine Reihe von Annotationsobjekten, die weitere Details und Anleitungen zur Problembehebung enthalten.
Name der Anmerkung
Ein Bezeichner für die Anmerkung.
Status
Der Status des Hook-Aufrufs. Dies ist hilfreich, wenn Anmerkungen eine Logik mit Pass/Fail-Bewertung darstellen, die einer Guard-Regel ähnelt.
*Gültige Werte*: (\$1 \$1) `PASSED` `FAILED` `SKIPPED`
Statusmeldung
Erklärung für den spezifischen Status.
Meldung zur Behebung
Vorschlag zur Korrektur eines `FAILED` Status. Wenn bei einer Ressource beispielsweise die Verschlüsselung fehlt, können Sie angeben, wie die Verschlüsselung zur Ressourcenkonfiguration hinzugefügt werden soll.
Link zur Behebung
Eine HTTP-URL für zusätzliche Anleitungen zur Problembehebung.
severityLevel
Definiert das relative Risiko, das mit Verstößen dieser Art verbunden ist. Wenn Sie Ihren Hook-Aufrufergebnissen Schweregrade zuweisen, können Sie sich auf das AWS Security Hub CSPM [Schweregradschema als Beispiel für](https://docs.aws.amazon.com/securityhub/latest/userguide/asff-required-attributes.html#Severity) die Strukturierung aussagekräftiger Schweregradkategorien beziehen.
*Gültige Werte*: (`INFORMATIONAL`\$1 \$1 `LOW` \$1 `MEDIUM` \$1`HIGH`) `CRITICAL`
### Beispiele
Im Folgenden finden Sie ein Beispiel für eine erfolgreiche Antwort:
```
{
"hookStatus": "SUCCESS",
"message": "compliant",
"clientRequestToken": "123avjdjk31"
}
```
Das Folgende ist ein Beispiel für eine fehlgeschlagene Antwort:
```
{
"hookStatus": "FAILED",
"errorCode": "NonCompliant",
"message": "S3 Bucket Versioning must be enabled.",
"clientRequestToken": "123avjdjk31"
}
```
## Evaluierung von Ressourcenoperationen mit Lambda Hooks
Jedes Mal, wenn Sie eine Ressource erstellen, aktualisieren oder löschen, wird dies als Ressourcenvorgang betrachtet. Wenn Sie beispielsweise die Aktualisierung eines CloudFormation Stacks ausführen, der eine neue Ressource erstellt, haben Sie einen Ressourcenvorgang abgeschlossen. Wenn Sie eine Ressource mithilfe der Cloud Control API erstellen, aktualisieren oder löschen, wird dies ebenfalls als Ressourcenvorgang betrachtet. Sie können Ihren CloudFormation Lambda-Hook für Ziele `RESOURCE` und `CLOUD_CONTROL` Operationen in der `TargetOperations` Hook-Konfiguration konfigurieren.
**Anmerkung**
Der `delete` Hook-Handler wird nur aufgerufen, wenn eine Ressource mithilfe eines Operationstriggers von der Cloud Control API `delete-resource` oder gelöscht wird. CloudFormation `delete-stack`
**Topics**
+ [Eingabesyntax für Lambda-Hook-Ressourcen](#lambda-hooks-create-lambda-function-resource-input)
+ [Beispiel für eine Eingabe zur Änderung der Lambda-Hook-Ressource](#lambda-hooks-create-lambda-function-resource-example)
+ [Beispiel für eine Lambda-Funktion für Ressourcenoperationen](#lambda-hooks-create-lambda-function-resource-example-function)
### Eingabesyntax für Lambda-Hook-Ressourcen
Wenn Ihr Lambda für einen Ressourcenvorgang aufgerufen wird, erhalten Sie eine JSON-Eingabe, die die Ressourceneigenschaften, die vorgeschlagenen Eigenschaften und den Kontext rund um den Hook-Aufruf enthält.
Im Folgenden finden Sie ein Beispiel für die Form der JSON-Eingabe:
```
{
"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": {
"Aufruf": 1,
"CallbackContext": null
}
}
```
`awsAccountId`
Die ID der Ressource AWS-Konto , die ausgewertet wird, enthält.
`stackId`
Die Stack-ID des CloudFormation Stacks, zu dem diese Operation gehört. Dieses Feld ist leer, wenn der Aufrufer die Cloud Control API ist.
`changeSetId`
Die ID des Änderungssatzes, der den Hook-Aufruf initiiert hat. Dieser Wert ist leer, wenn die Ressourcenänderung durch die Cloud Control API oder die `create-stack` `delete-stack` Operationen, oder initiiert wurde. `update-stack`
`hookTypeName`
Der Name des Hooks, der gerade läuft.
`hookTypeVersion`
Die Version des Hooks, der ausgeführt wird.
`hookModel`
`LambdaFunction`
Der aktuelle Lambda-ARN, der vom Hook aufgerufen wird.
`actionInvocationPoint`
Der genaue Punkt in der Bereitstellungslogik, an dem der Hook ausgeführt wird.
*Gültige Werte*: (`CREATE_PRE_PROVISION`\$1 `UPDATE_PRE_PROVISION` \$1`DELETE_PRE_PROVISION`)
`requestData`
`targetName`
Der Zieltyp, der ausgewertet wird, zum Beispiel`AWS::S3::Bucket`.
`targetType`
Der Zieltyp, der ausgewertet wird, zum Beispiel`AWS::S3::Bucket`. Für Ressourcen, die mit der Cloud Control API bereitgestellt wurden, lautet dieser Wert. `RESOURCE`
`targetLogicalId`
Die logische ID der Ressource, die ausgewertet wird. Wenn der Ursprung des Hook-Aufrufs ist CloudFormation, ist dies die logische Ressourcen-ID, die in Ihrer CloudFormation Vorlage definiert ist. Wenn der Ursprung dieses Hook-Aufrufs die Cloud Control API ist, handelt es sich um einen konstruierten Wert.
`targetModel`
`resourceProperties`
Die vorgeschlagenen Eigenschaften der Ressource, die geändert werden soll. Wenn die Ressource gelöscht wird, ist dieser Wert leer.
`previousResourceProperties`
Die Eigenschaften, die derzeit der Ressource zugeordnet sind, die geändert wird. Wenn die Ressource erstellt wird, ist dieser Wert leer.
`requestContext`
Aufruf
Der aktuelle Versuch, den Hook auszuführen.
CallbackContext
Wenn der Hook auf gesetzt war und zurückgegeben `callbackContext` wurde`IN_PROGRESS`, ist er nach dem erneuten Aufruf wieder da.
### Beispiel für eine Eingabe zur Änderung der Lambda-Hook-Ressource
Die folgende Beispieleingabe zeigt einen Lambda-Hook, der die Definition der zu aktualisierenden `AWS::DynamoDB::Table` Ressource empfängt, wobei `ReadCapacityUnits` der Wert von 3 auf 10 geändert `ProvisionedThroughput` wird. Dies sind die Daten, die Lambda zur Auswertung zur Verfügung stehen.
```
{
"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
}
}
```
Alle für den Ressourcentyp verfügbaren Eigenschaften finden Sie unter [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).
### Beispiel für eine Lambda-Funktion für Ressourcenoperationen
Die folgende einfache Funktion schlägt bei jeder Ressourcenaktualisierung für DynamoDB fehl, bei der versucht wird, den Wert `ReadCapacity` von auf einen Wert größer als 10 `ProvisionedThroughput` zu setzen. Wenn der Hook erfolgreich ist, wird dem Aufrufer die Meldung "ReadCapacity ist korrekt konfiguriert“ angezeigt. Wenn die Anforderung nicht validiert werden kann, schlägt der Hook mit dem Status "ReadCapacity nicht mehr als 10“ fehl.
------
#### [ 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
```
------
## Auswertung von Stack-Operationen mit Lambda Hooks
Jedes Mal, wenn Sie einen Stack mit einer neuen Vorlage erstellen, aktualisieren oder löschen, können Sie Ihren CloudFormation Lambda-Hook so konfigurieren, dass er zunächst die neue Vorlage auswertet und möglicherweise die Fortsetzung des Stack-Vorgangs blockiert. Sie können Ihren CloudFormation Lambda-Hook in der `TargetOperations` Hook-Konfiguration so konfigurieren, dass er auf `STACK` Operationen abzielt.
**Topics**
+ [Lambda Hook-Stack-Eingabesyntax](#lambda-hooks-create-lambda-function-stack-input)
+ [Beispiel für eine Lambda-Hook-Stack-Änderungseingabe](#lambda-hooks-create-lambda-function-stack-example)
+ [Beispiel für eine Lambda-Funktion für Stack-Operationen](#lambda-hooks-create-lambda-function-stack-example-function)
### Lambda Hook-Stack-Eingabesyntax
Wenn Ihr Lambda für einen Stack-Vorgang aufgerufen wird, erhalten Sie eine JSON-Anfrage, die den Hook-Aufrufkontext und den Anforderungskontext enthält. `actionInvocationPoint` Aufgrund der Größe der CloudFormation Vorlagen und der begrenzten Eingabegröße, die von Lambda-Funktionen akzeptiert wird, werden die tatsächlichen Vorlagen in einem Amazon S3 S3-Objekt gespeichert. Die Eingabe von `requestData` beinhaltet eine von Amazon S3 signierte URL zu einem anderen Objekt, das die aktuelle und vorherige Vorlagenversion enthält.
Das Folgende ist ein Beispiel für die Form der JSON-Eingabe:
```
{
"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`
Das Anforderungstoken, das als Eingabe für die Hook-Anfrage bereitgestellt wurde. Dies ist ein Pflichtfeld.
`awsAccountId`
Die ID des Stacks AWS-Konto , der den ausgewerteten Stapel enthält.
`stackID`
Die Stack-ID des CloudFormation Stacks.
`changeSetId`
Die ID des Änderungssatzes, der den Hook-Aufruf initiiert hat. Dieser Wert ist leer, wenn die Stack-Änderung durch die Cloud Control API oder die `delete-stack` Operationen `create-stack``update-stack`, oder initiiert wurde.
`hookTypeName`
Der Name des Hooks, der gerade läuft.
`hookTypeVersion`
Die Version des Hooks, der ausgeführt wird.
`hookModel`
`LambdaFunction`
Der aktuelle Lambda-ARN, der vom Hook aufgerufen wird.
`actionInvocationPoint`
Der genaue Punkt in der Bereitstellungslogik, an dem der Hook ausgeführt wird.
*Gültige Werte*: (`CREATE_PRE_PROVISION`\$1 `UPDATE_PRE_PROVISION` \$1`DELETE_PRE_PROVISION`)
`requestData`
`targetName`
Dieser Wert wird sein`STACK`.
`targetType`
Dieser Wert wird sein`STACK`.
`targetLogicalId`
Der Name des Stacks.
`payload`
Die vorsignierte Amazon S3 S3-URL, die ein JSON-Objekt mit den aktuellen und vorherigen Vorlagendefinitionen enthält.
`requestContext`
Wenn der Hook erneut aufgerufen wird, wird dieses Objekt gesetzt.
`invocation`
Der aktuelle Versuch, den Hook auszuführen.
`callbackContext`
Wenn der Hook auf gesetzt war `IN_PROGRESS` und zurückgegeben `callbackContext` wurde, wird er beim erneuten Aufruf hier angezeigt.
Die `payload` Eigenschaft in den Anforderungsdaten ist eine URL, die Ihr Code abrufen muss. Sobald es die URL erhalten hat, erhalten Sie ein Objekt mit dem folgenden Schema:
```
{
"template": String,
"previousTemplate": String
}
```
`template`
Die vollständige CloudFormation Vorlage, die für `create-stack` oder bereitgestellt wurde`update-stack`. Je nachdem, wofür bereitgestellt wurde, kann es sich um CloudFormation eine JSON- oder YAML-Zeichenfolge handeln.
Bei `delete-stack` Operationen ist dieser Wert leer.
`previousTemplate`
Die vorherige CloudFormation Vorlage. Es kann sich um eine JSON- oder YAML-Zeichenfolge handeln, je nachdem, was bereitgestellt wurde. CloudFormation
Bei `delete-stack` Operationen ist dieser Wert leer.
### Beispiel für eine Lambda-Hook-Stack-Änderungseingabe
Im Folgenden finden Sie ein Beispiel für eine Stack-Change-Eingabe. Der Hook evaluiert eine Änderung, die das `ObjectLockEnabled` auf true aktualisiert und eine Amazon SQS SQS-Warteschlange hinzufügt:
```
{
"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
}
}
```
Dies ist ein Beispiel `payload` für: `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}}}}"
}
```
### Beispiel für eine Lambda-Funktion für Stack-Operationen
Das folgende Beispiel ist eine einfache Funktion, die die Nutzdaten der Stack-Operation herunterlädt, die JSON-Vorlage analysiert und zurückgibt. `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 ]
Um Python verwenden zu können, müssen Sie die `requests` Bibliothek importieren. Dazu müssen Sie die Bibliothek bei der Erstellung Ihrer Lambda-Funktion in Ihr Bereitstellungspaket aufnehmen. Weitere Informationen finden Sie unter [Erstellen eines ZIP-Bereitstellungspakets mit Abhängigkeiten](https://docs.aws.amazon.com/lambda/latest/dg/python-package.html#python-package-create-dependencies) im *AWS Lambda Entwicklerhandbuch*.
```
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
```
------
## Evaluierung von Change-Set-Vorgängen mit Lambda Hooks
Jedes Mal, wenn Sie einen Änderungssatz erstellen, können Sie Ihren CloudFormation Lambda Hook so konfigurieren, dass er zuerst den neuen Änderungssatz auswertet und möglicherweise seine Ausführung blockiert. Sie können Ihren CloudFormation Lambda-Hook in der `TargetOperations` Hook-Konfiguration so konfigurieren, dass er auf `CHANGE_SET` Operationen abzielt.
**Topics**
+ [Lambda Hook Change Set-Eingabesyntax](#lambda-hooks-create-lambda-function-change-set-input)
+ [Beispiel für eine Lambda-Hook-Change-Set-Änderungseingabe](#lambda-hooks-create-lambda-function-change-set-example)
+ [Beispiel für eine Lambda-Funktion für Change-Set-Operationen](#lambda-hooks-create-lambda-function-change-set-example-function)
### Lambda Hook Change Set-Eingabesyntax
Die Eingabe für Änderungssatz-Operationen ähnelt Stack-Operationen, aber die Nutzlast von umfasst `requestData` auch eine Liste von Ressourcenänderungen, die durch den Änderungssatz eingeführt wurden.
Im Folgenden finden Sie ein Beispiel für die Form der JSON-Eingabe:
```
{
"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`
Das Anforderungstoken, das als Eingabe für die Hook-Anfrage bereitgestellt wurde. Dies ist ein Pflichtfeld.
`awsAccountId`
Die ID des Stacks AWS-Konto , der den ausgewerteten Stapel enthält.
`stackID`
Die Stack-ID des CloudFormation Stacks.
`changeSetId`
Die ID des Änderungssatzes, der den Hook-Aufruf initiiert hat.
`hookTypeName`
Der Name des Hooks, der gerade läuft.
`hookTypeVersion`
Die Version des Hooks, der ausgeführt wird.
`hookModel`
`LambdaFunction`
Der aktuelle Lambda-ARN, der vom Hook aufgerufen wird.
`requestData`
`targetName`
Dieser Wert wird sein. `CHANGE_SET`
`targetType`
Dieser Wert wird sein`CHANGE_SET`.
`targetLogicalId`
Der Änderungssatz ARN..
`payload`
Die vorsignierte Amazon S3 S3-URL, die ein JSON-Objekt mit der aktuellen Vorlage sowie eine Liste der durch diesen Änderungssatz eingeführten Änderungen enthält.
`requestContext`
Wenn der Hook erneut aufgerufen wird, wird dieses Objekt gesetzt.
`invocation`
Der aktuelle Versuch, den Hook auszuführen.
`callbackContext`
Wenn der Hook auf gesetzt war `IN_PROGRESS` und zurückgegeben `callbackContext` wurde, wird er beim erneuten Aufruf hier angezeigt.
Die `payload` Eigenschaft in den Anforderungsdaten ist eine URL, die Ihr Code abrufen muss. Sobald es die URL erhalten hat, erhalten Sie ein Objekt mit dem folgenden Schema:
```
{
"template": String,
"changedResources": [
{
"action": String,
"beforeContext": JSON String,
"afterContext": JSON String,
"lineNumber": Integer,
"logicalResourceId": String,
"resourceType": String
}
]
}
```
`template`
Die vollständige CloudFormation Vorlage, die für `create-stack` oder bereitgestellt wurde`update-stack`. Je nachdem, wofür bereitgestellt wurde, kann es sich um CloudFormation eine JSON- oder YAML-Zeichenfolge handeln.
`changedResources`
Eine Liste der geänderten Ressourcen.
`action`
Die Art der Änderung, die auf die Ressource angewendet wurde.
*Gültige Werte*: (`CREATE`\$1 `UPDATE` \$1`DELETE`)
`beforeContext`
Eine JSON-Zeichenfolge der Ressourceneigenschaften vor der Änderung. Dieser Wert ist Null, wenn die Ressource erstellt wird. Alle booleschen Werte und Zahlenwerte in dieser JSON-Zeichenfolge sind STRINGS.
`afterContext`
Eine JSON-Zeichenfolge der Ressourceneigenschaften, falls dieser Änderungssatz ausgeführt wird. Dieser Wert ist Null, wenn die Ressource gelöscht wird. Alle booleschen Werte und Zahlenwerte in dieser JSON-Zeichenfolge sind STRINGS.
`lineNumber`
Die Zeilennummer in der Vorlage, die diese Änderung verursacht hat. Wenn die Aktion ist, ist `DELETE` dieser Wert Null.
`logicalResourceId`
Die logische Ressourcen-ID der Ressource, die geändert wird.
`resourceType`
Der Ressourcentyp, der geändert wird.
### Beispiel für eine Lambda-Hook-Change-Set-Änderungseingabe
Im Folgenden finden Sie ein Beispiel für eine Änderungseingabe für einen Änderungssatz. Im folgenden Beispiel sehen Sie die Änderungen, die durch den Änderungssatz eingeführt wurden. Die erste Änderung ist das Löschen einer Warteschlange namens`CoolQueue`. Die zweite Änderung ist das Hinzufügen einer neuen Warteschlange namens`NewCoolQueue`. Die letzte Änderung ist ein Update für`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
}
}
```
Dies ist ein Beispiel `payload` für`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"}]}}'
}
]
}
```
### Beispiel für eine Lambda-Funktion für Change-Set-Operationen
Das folgende Beispiel ist eine einfache Funktion, die die Nutzdaten der Change-Set-Operation herunterlädt, jede Änderung durchläuft und dann die Vorher-Nachher-Eigenschaften ausgibt, bevor sie eine zurückgibt. `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 ]
Um Python verwenden zu können, müssen Sie die `requests` Bibliothek importieren. Dazu müssen Sie die Bibliothek bei der Erstellung Ihrer Lambda-Funktion in Ihr Bereitstellungspaket aufnehmen. Weitere Informationen finden Sie unter [Erstellen eines ZIP-Bereitstellungspakets mit Abhängigkeiten](https://docs.aws.amazon.com/lambda/latest/dg/python-package.html#python-package-create-dependencies) im *AWS Lambda Entwicklerhandbuch*.
```
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
```
------
# Bereiten Sie sich darauf vor, einen Lambda-Hook zu erstellen
Bevor Sie einen Lambda-Hook erstellen, müssen Sie die folgenden Voraussetzungen erfüllen:
+ Sie müssen bereits eine Lambda-Funktion erstellt haben. Weitere Informationen hierzu finden Sie unter [Lambda-Funktionen für Hooks erstellen](lambda-hooks-create-lambda-function.md).
+ Der Benutzer oder die Rolle, die den Hook erstellt, muss über ausreichende Berechtigungen verfügen, um Hooks zu aktivieren. Weitere Informationen finden Sie unter [Erteilen Sie IAM-Berechtigungen für Hooks CloudFormation](grant-iam-permissions-for-hooks.md).
+ Um das AWS CLI oder ein SDK zum Erstellen eines Lambda-Hooks zu verwenden, müssen Sie manuell eine Ausführungsrolle mit IAM-Berechtigungen und einer Vertrauensrichtlinie erstellen, um einen Lambda-Hook aufrufen CloudFormation zu können.
## Erstellen Sie eine Ausführungsrolle für einen Lambda-Hook
Ein Hook verwendet eine Ausführungsrolle für die Berechtigungen, die er benötigt, um diesen Hook in Ihrem aufzurufen. AWS-Konto
Diese Rolle kann automatisch erstellt werden, wenn Sie aus dem einen Lambda-Hook erstellen. AWS-Managementkonsole Andernfalls müssen Sie diese Rolle selbst erstellen.
Im folgenden Abschnitt erfahren Sie, wie Sie Berechtigungen für die Erstellung Ihres Lambda-Hooks einrichten.
### Erforderliche Berechtigungen
Folgen Sie der Anleitung unter [Erstellen einer Rolle mit benutzerdefinierten Vertrauensrichtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html) im *IAM-Benutzerhandbuch* zum Erstellen einer Rolle mit einer benutzerdefinierten Vertrauensrichtlinie.
Führen Sie dann die folgenden Schritte aus, um Ihre Berechtigungen einzurichten:
1. Fügen Sie der IAM-Rolle, die Sie zum Erstellen des Lambda-Hooks verwenden möchten, die folgende Richtlinie für Mindestberechtigungen hinzu.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-west-2:123456789012:function:MyFunction"
}
]
}
```
------
1. Erteilen Sie Ihrem Hook die Erlaubnis, die Rolle zu übernehmen, indem Sie der Rolle eine Vertrauensrichtlinie hinzufügen. Im Folgenden finden Sie ein Beispiel für eine Vertrauensrichtlinie, die Sie verwenden können.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"hooks.cloudformation.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
# Aktiviere einen Lambda Hook in deinem Konto
Das folgende Thema zeigt Ihnen, wie Sie einen Lambda Hook in Ihrem Konto aktivieren, sodass er in dem Konto und der Region, in der er aktiviert wurde, verwendet werden kann.
**Topics**
+ [Aktiviere einen Lambda Hook (Konsole)](#lambda-hooks-activate-hook-console)
+ [Aktiviere einen Lambda-Hook ()AWS CLI](#lambda-hooks-activate-hooks-cli)
+ [Zugehörige Ressourcen](#related-resources-lambda-hooks)
## Aktiviere einen Lambda Hook (Konsole)
**Um einen Lambda Hook zur Verwendung in Ihrem Konto zu aktivieren**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CloudFormation Konsole unter [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Wählen Sie in der Navigationsleiste oben auf dem Bildschirm die AWS-Region Stelle aus, an der Sie den Hook-In erstellen möchten.
1. Wenn Sie *keine Lambda-Funktion für den Hook erstellt haben*, gehen Sie wie folgt vor:
+ Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
+ Erstellen Sie die Lambda-Funktion, die Sie mit diesem Hook verwenden werden, und kehren Sie dann zu dieser Prozedur zurück. Weitere Informationen finden Sie unter [Erstellen Sie Lambda-Funktionen, um Ressourcen für Lambda Hooks auszuwerten](lambda-hooks-create-lambda-function.md).
Wenn Sie Ihre Lambda-Funktion bereits erstellt haben, fahren Sie mit dem nächsten Schritt fort.
1. Wählen Sie im Navigationsbereich auf der linken Seite **Hooks** aus.
1. Wählen Sie auf der Seite **Hooks** die Option **Create a Hook** und dann **With Lambda** aus.
1. Wählen Sie **unter Hook-Name** eine der folgenden Optionen aus:
+ Geben Sie einen kurzen, aussagekräftigen Namen ein, der danach `Private::Lambda::` hinzugefügt wird. Wenn Sie beispielsweise eingeben*`MyTestHook`*, wird der vollständige Hook-Name zu`Private::Lambda::MyTestHook`.
+ Geben Sie den vollständigen Hook-Namen (auch Alias genannt) in diesem Format an: `Provider::ServiceName::HookName`
1. Geben Sie für die **Lambda-Funktion** die Lambda-Funktion an, die mit diesem Hook verwendet werden soll. Sie können Folgendes verwenden:
+ Der vollständige Amazon-Ressourcenname (ARN) ohne Suffix.
+ Ein qualifizierter ARN mit einem Versions- oder Alias-Suffix.
1. Wählen Sie für **Hook-Ziele** aus, was ausgewertet werden soll:
+ **Stacks** — Wertet Stack-Vorlagen aus, wenn Benutzer Stacks erstellen, aktualisieren oder löschen.
+ **Ressourcen** — Wertet einzelne Ressourcenänderungen aus, wenn Benutzer Stacks aktualisieren.
+ **Änderungssätze** — Wertet geplante Aktualisierungen aus, wenn Benutzer Änderungssätze erstellen.
+ **Cloud Control API** — Evaluiert Erstellungs-, Aktualisierungs- oder Löschvorgänge, die von der [Cloud Control](https://docs.aws.amazon.com/cloudcontrolapi/latest/userguide/what-is-cloudcontrolapi.html) API initiiert wurden.
1. Wählen Sie **unter Aktionen** aus, welche Aktionen (Erstellen, Aktualisieren, Löschen) Ihren Hook aufrufen sollen.
1. Wählen Sie für den **Hook-Modus** aus, wie der Hook reagiert, wenn die vom Hook aufgerufene Lambda-Funktion eine `FAILED` Antwort zurückgibt:
+ **Warnen** — Gibt Warnungen an Benutzer aus, ermöglicht aber die Fortsetzung der Aktionen. Dies ist nützlich für unkritische Validierungen oder Informationsprüfungen.
+ **Fehlgeschlagen** — verhindert, dass die Aktion fortgesetzt wird. Dies ist hilfreich für die Durchsetzung strenger Compliance- oder Sicherheitsrichtlinien.
1. Wählen Sie für die **Ausführungsrolle** die IAM-Rolle aus, von der der Hook annimmt, um Ihre Lambda-Funktion aufzurufen. Sie können entweder zulassen CloudFormation , dass automatisch eine Ausführungsrolle für Sie erstellt wird, oder Sie können eine Rolle angeben, die Sie erstellt haben.
1. Wählen Sie **Weiter** aus.
1. (Optional) Gehen Sie für **Hook-Filter** wie folgt vor:
1. Geben Sie **unter Ressourcenfilter** an, welche Ressourcentypen den Hook aufrufen können. Dadurch wird sichergestellt, dass der Hook nur für relevante Ressourcen aufgerufen wird.
1. Wählen Sie **unter Filterkriterien** die Logik für die Anwendung von Stacknamen- und Stack-Rollenfiltern aus:
+ **Alle Stack-Namen und Stack-Rollen** — Der Hook wird nur aufgerufen, wenn alle angegebenen Filter übereinstimmen.
+ **Beliebige Stack-Namen und Stack-Rollen** — Der Hook wird aufgerufen, wenn mindestens einer der angegebenen Filter übereinstimmt.
**Anmerkung**
Bei Cloud Control API-Vorgängen werden alle Filter für **Stack-Namen** und **Stack-Rollen** ignoriert.
1. Schließen Sie bei **Stack-Namen** bestimmte Stacks in Hook-Aufrufe ein oder aus.
+ Geben Sie für **Include** die Stack-Namen an, die eingeschlossen werden sollen. Verwenden Sie dies, wenn Sie über eine kleine Gruppe bestimmter Stacks verfügen, auf die Sie abzielen möchten. Nur die in dieser Liste angegebenen Stapel rufen den Hook auf.
+ Geben Sie für **Exclude** die Stack-Namen an, die ausgeschlossen werden sollen. Verwenden Sie dies, wenn Sie den Hook für die meisten Stacks aufrufen, aber einige bestimmte ausschließen möchten. Alle Stapel außer den hier aufgeführten rufen den Hook auf.
1. Schließen Sie bei **Stack-Rollen** je nach den zugehörigen IAM-Rollen bestimmte Stacks in Hook-Aufrufe ein oder aus.
+ Geben Sie für **Include** eine oder mehrere IAM-Rollen an, die auf Stacks abzielen ARNs sollen, die diesen Rollen zugeordnet sind. Nur Stack-Operationen, die von diesen Rollen initiiert wurden, rufen den Hook auf.
+ Geben Sie für **Exclude** eine oder mehrere IAM-Rollen ARNs für Stacks an, die Sie ausschließen möchten. Der Hook wird für alle Stacks aufgerufen, mit Ausnahme der Stacks, die von den angegebenen Rollen initiiert wurden.
1. Wählen Sie **Weiter** aus.
1. Überprüfen Sie auf der Seite **Überprüfen und aktivieren** Ihre Auswahl. Um Änderungen vorzunehmen, wählen Sie **Bearbeiten** in dem entsprechenden Abschnitt.
1. Wenn du bereit bist, fortzufahren, wähle **Hook aktivieren**.
## Aktiviere einen Lambda-Hook ()AWS CLI
Bevor Sie fortfahren, vergewissern Sie sich, dass Sie die Lambda-Funktion und die Ausführungsrolle, die Sie mit diesem Hook verwenden werden, erstellt haben. Weitere Informationen erhalten Sie unter [Erstellen Sie Lambda-Funktionen, um Ressourcen für Lambda Hooks auszuwerten](lambda-hooks-create-lambda-function.md) und [Erstellen Sie eine Ausführungsrolle für einen Lambda-Hook](lambda-hooks-prepare-to-create-hook.md#lambda-hooks-create-execution-role).
**Um einen Lambda Hook zur Verwendung in Ihrem Konto zu aktivieren ()AWS CLI**
1. Verwenden Sie den folgenden [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/activate-type.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/activate-type.html)Befehl, um mit der Aktivierung eines Hooks zu beginnen. Ersetzen Sie dabei die Platzhalter durch Ihre spezifischen Werte. Dieser Befehl autorisiert den Hook, eine angegebene Ausführungsrolle von Ihnen zu verwenden. AWS-Konto
```
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. Um die Aktivierung des Hooks abzuschließen, müssen Sie ihn mithilfe einer JSON-Konfigurationsdatei konfigurieren.
Verwenden Sie den **cat** Befehl, um eine JSON-Datei mit der folgenden Struktur zu erstellen. Weitere Informationen finden Sie unter [Referenz der Syntax des Hook-Konfigurationsschemas](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`: Auf setzen, `ENABLED` um den Hook zu aktivieren.
+ `TargetOperations`: Geben Sie die Operationen an, die der Hook auswerten soll.
+ `FailureMode`: Festlegung entweder auf `FAIL` oder `WARN`.
+ `LambdaFunction`: Geben Sie den ARN der Lambda-Funktion an.
+ `TargetFilters`: Geben Sie die Arten von Aktionen an, die den Hook aufrufen.
1. Verwenden Sie den folgenden [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)Befehl zusammen mit der von Ihnen erstellten JSON-Datei, um die Konfiguration anzuwenden. Ersetzen Sie die Platzhalter durch Ihre spezifischen Werte.
```
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
```
## Zugehörige Ressourcen
Wir stellen Vorlagenbeispiele zur Verfügung, anhand derer Sie verstehen können, wie ein Lambda-Hook in einer CloudFormation Stack-Vorlage deklariert wird. Weitere Informationen finden Sie unter [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) im *AWS CloudFormation -Benutzerhandbuch*.
# Logs für die Lambda Hooks in Ihrem Konto anzeigen
Wenn Sie einen Lambda-Hook verwenden, finden Sie die Protokolldatei Ihres Validierungsausgabeberichts in der Lambda-Konsole.
## Lambda Hook-Logs in der Lambda-Konsole anzeigen
**So zeigen Sie die Lambda Hook-Ausgabelogdatei an**
1. Melden Sie sich bei der Lambda-Konsole an.
1. Wählen Sie in der Navigationsleiste am oberen Rand des Bildschirms Ihren AWS-Region.
1. **Wählen Sie Funktionen.**
1. Wählen Sie die gewünschte Lambda-Funktion aus.
1. Wählen Sie die Registerkarte **Test**.
1. Wählen Sie **CloudWatch Logs Live Trail**
1. Wählen Sie das Dropdownmenü und wählen Sie die Protokollgruppen aus, die Sie anzeigen möchten.
1. Wählen Sie **Starten**. Das Protokoll wird im Fenster **CloudWatch Logs Live Trail** angezeigt. Wählen Sie je nach Wunsch „**In Spalten** **anzeigen“ oder „Im Klartext** anzeigen“.
+ Sie können den Ergebnissen weitere Filter hinzufügen, indem Sie sie im Feld **Filtermuster hinzufügen hinzufügen**. In diesem Feld können Sie Ergebnisse so filtern, dass sie nur Ereignisse enthalten, die dem angegebenen Muster entsprechen.
Weitere Informationen zum Anzeigen von Protokollen für Lambda-Funktionen finden Sie unter [ CloudWatch Protokolle für Lambda-Funktionen anzeigen](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-cloudwatchlogs-view.html).
# Löschen Sie Lambda Hooks in Ihrem Konto
Wenn Sie einen aktivierten Lambda Hook nicht mehr benötigen, verwenden Sie die folgenden Verfahren, um ihn in Ihrem Konto zu löschen.
Wie Sie einen Hook vorübergehend deaktivieren, anstatt ihn zu löschen, finden Sie unter[CloudFormation Hooks deaktivieren und aktivieren](hooks-disable-enable.md).
**Topics**
+ [Löschen Sie einen Lambda Hook in Ihrem Konto (Konsole)](#lambda-hooks-delete-hook-console)
+ [Lösche einen Lambda Hook in deinem Konto ()AWS CLI](#lambda-hooks-delete-hook-cli)
## Löschen Sie einen Lambda Hook in Ihrem Konto (Konsole)
**Um einen Lambda Hook in Ihrem Konto zu löschen**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CloudFormation Konsole unter [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Wählen Sie in der Navigationsleiste oben auf dem Bildschirm aus, AWS-Region wo sich der Hook befindet.
1. Wählen Sie im Navigationsbereich **Hooks** aus.
1. Suchen Sie auf der Seite **Hooks** den Lambda-Hook, den Sie löschen möchten.
1. Aktivieren Sie das Kontrollkästchen neben Ihrem Hook und wählen Sie **Löschen**.
1. Wenn Sie zur Bestätigung aufgefordert werden, geben Sie den Hook-Namen ein, um das Löschen des angegebenen Hooks zu bestätigen, und wählen Sie dann **Löschen**.
## Lösche einen Lambda Hook in deinem Konto ()AWS CLI
**Anmerkung**
Bevor Sie den Hook löschen können, müssen Sie ihn zuerst deaktivieren. Weitere Informationen finden Sie unter [Deaktiviere und aktiviere einen Hook in deinem Konto (AWS CLI)](hooks-disable-enable.md#hooks-disable-enable-cli).
Verwenden Sie den folgenden [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deactivate-type.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deactivate-type.html)Befehl, um einen Hook zu deaktivieren, wodurch er aus Ihrem Konto entfernt wird. Ersetze Platzhalter durch deine spezifischen Werte.
```
aws cloudformation deactivate-type \
--type-arn "arn:aws:cloudformation:us-west-2:123456789012:type/hook/MyTestHook" \
--region us-west-2
```