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.

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:

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.

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"
    }
  ]
}

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.

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
    }
} 

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 AWS::DynamoDB::Table.

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.

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
    }
}

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
}

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 zu verwenden, 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 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.

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
    }
}

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
        }
    ]
}

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 namensCoolQueue. Die zweite Änderung ist das Hinzufügen einer neuen Warteschlange namensNewCoolQueue. Die letzte Änderung ist ein Update fürDynamoDBTable.

{
    "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ürrequestData.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 zu verwenden, 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 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