Funktion aufrufen AWS Lambda

Sie können Amazon S3 Batch Operations verwenden, um umfangreiche Batch-Vorgänge für Amazon-S3-Objekte durchzuführen. Der Vorgang Batch Operations der AWS Lambda Funktion aufrufen initiiert AWS Lambda Funktionen zur Ausführung benutzerdefinierter Aktionen für Objekte, die in einem Manifest aufgeführt sind. In diesem Abschnitt wird beschrieben, wie Sie eine Lambda-Funktion zur Verwendung mit S3-Batch-Vorgänge erstellen und wie Sie einen Auftrag zum Aufrufen der Funktion erstellen. Die S3-Batch-Vorgängeaufgabe verwendet die LambdaInvoke-Operation, um eine Lambda-Funktion für jedes in einem Manifest aufgeführte Objekt auszuführen.

Sie können mit S3 Batch Operations arbeiten, indem Sie die Amazon S3 S3-Konsole AWS Command Line Interface (AWS CLI) oder die Amazon S3 S3-REST-API verwenden. AWS SDKs Weitere Informationen zur Verwendung von Lambda finden Sie unter Getting started with AWS Lambda(Erste Schritte mit Lambda) im AWS Lambda -Entwicklerhandbuch.

In den folgenden Abschnitten werden die ersten Schritte mit S3-Batch-Vorgänge mit Lambda erläutert.

Verwenden von Lambda mit Batch Operations

Wenn Sie S3 Batch Operations mit verwenden AWS Lambda, müssen Sie neue Lambda-Funktionen speziell für die Verwendung mit S3 Batch Operations erstellen. Sie können vorhandene ereignisbasierte Funktionen von Amazon S3 nicht mit S3-Batch-Vorgänge wiederverwenden. Ereignisfunktionen können Nachrichten lediglich erhalten und nicht zurückgeben. Die Lambda-Funktionen, die mit S3-Batch-Vorgänge verwendet werden, müssen Nachrichten akzeptieren und zurückgeben. Weitere Informationen zur Verwendung von Lambda mit Amazon S3-Ereignissen finden Sie unter Using AWS Lambda with Amazon S3 im AWS Lambda Developer Guide.

Sie erstellen einen S3-Batchoperations-Auftrag, der Ihre Lambda-Funktion aufruft. Der Auftrag führt dieselbe Lambda-Funktion für alle in Ihrem Manifest aufgeführten Objekte aus. Sie können steuern, welche Versionen Ihrer Lambda-Funktion während der Verarbeitung der Objekte in Ihrem Manifest verwendet werden sollen. S3 Batch Operations unterstützt unqualifizierte Amazon-Ressourcennamen (ARNs), Aliase und bestimmte Versionen. Weitere Informationen finden Sie unter Einführung in die AWS Lambda Versionierung im Entwicklerhandbuch.AWS Lambda

Wenn Sie dem S3-Batchoperations-Auftrag mit einem Funktion-ARN zur Verfügung stellen, der einen Alias oder den-$LATEST Qualifizierer verwendet, und dann die Version aktualisieren, auf die einer davon verweist, beginnt S3-Batch-Vorgänge mit dem Aufruf der neuen Version Ihrer Lambda-Funktion. Dies kann nützlich sein, wenn Sie mitten in der Ausführung einer großen Aufgabe Funktionen aktualisieren möchten. Wenn Sie nicht möchten, dass S3 Batch Operations die verwendete Version ändert, geben Sie die spezifische Version im FunctionARN-Parameter an, wenn Sie Ihren Auftrag erstellen.

Ein einziger AWS Lambda Job mit S3 Batch Operations kann ein Manifest mit bis zu 20 Milliarden Objekten unterstützen.

Verwenden von Lambda und Batch Operations mit Verzeichnis-Buckets

Verzeichnis-Buckets sind eine Art von Amazon-S3-Buckets, die für Workloads oder leistungskritische Anwendungen entwickelt wurden, die eine konstante Latenzzeit im einstelligen Millisekundenbereich erfordern. Weitere Informationen finden Sie unter Verzeichnis-Buckets.

Für die Verwendung von Batch Operations zum Aufrufen von Lambda-Funktionen, die auf Verzeichnis-Buckets wirken, gelten besondere Anforderungen. Beispielsweise müssen Sie Ihre Lambda-Anfrage mithilfe eines aktualisierten JSON-Schemas strukturieren und InvocationSchemaVersion 2.0 angeben (nicht 1.0), wenn Sie den Auftrag erstellen. Mit diesem aktualisierten Schema können Sie optionale Schlüssel-Wert-Paare für UserArguments angeben, mit denen Sie bestimmte Parameter vorhandener Lambda-Funktionen ändern können. Weitere Informationen finden Sie unter Automatisieren der Objektverarbeitung in Amazon S3 S3-Verzeichnis-Buckets mit S3 Batch Operations und AWS Lambda im AWS Storage-Blog.

Antwort- und Ergebniscodes

S3 Batch Operations ruft die Lambda-Funktion mit einem oder mehreren Schlüsseln auf, mit denen jeweils eine TaskID verknüpft ist. S3 Batch Operations erwartet von Lambda-Funktionen einen Ergebniscode pro Schlüssel. Jede in der Anfrage IDs gesendete Aufgabe, die nicht mit einem Ergebniscode pro Schlüssel zurückgegeben wird, erhält den Ergebniscode aus dem treatMissingKeysAs Feld. treatMissingKeysAsist ein optionales Anforderungsfeld und hat standardmäßig den Wert. TemporaryFailure Die folgende Tabelle enthält die anderen möglichen Ergebniscodes und Werte für das treatMissingKeysAs-Feld.

Erstellen einer Lambda-Funktion zur Verwendung mit S3-BatchVorgänge

Dieser Abschnitt enthält Beispielberechtigungen AWS Identity and Access Management (IAM), die Sie mit Ihrer Lambda-Funktion verwenden müssen. Er enthält auch eine Beispiel-Lambda-Funktion zur Verwendung mit S3-BatchVorgänge. Wenn Sie noch nie eine Lambda-Funktion erstellt haben, finden Sie weitere Informationen unter Tutorial: Using AWS Lambda with Amazon S3 im AWS Lambda Developer Guide.

Sie müssen Lambda-Funktionen speziell für die Verwendung mit S3-Batch-Vorgänge erstellen. Sie können vorhandene ereignisbasierte Lambda-Funktionen von Amazon S3 nicht wiederverwenden, da Lambda-Funktionen, die für S3 Batch Operations verwendet werden, spezielle Datenfelder akzeptieren und zurückgeben müssen.

Beispiele für IAM-Berechtigungen

Im Folgenden finden Sie Beispiele für die IAM-Berechtigungen, die für die Verwendung einer Lambda-Funktion mit S3-Batch-Vorgänge erforderlich sind.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "batchoperations.s3.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "BatchOperationsLambdaPolicy",
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:GetObjectVersion",
                "s3:PutObject",
                "lambda:InvokeFunction"
            ],
            "Resource": "*"
        }
    ]
}

Beispiel: Anforderung und Antwort

Dieser Abschnitt bietet Beispiele für Anforderungen und Antworten für die Lambda-Funktion.

{
    "invocationSchemaVersion": "1.0",
    "invocationId": "YXNkbGZqYWRmaiBhc2RmdW9hZHNmZGpmaGFzbGtkaGZza2RmaAo",
    "job": {
        "id": "f3cc4f60-61f6-4a2b-8a21-d07600c373ce"
    },
    "tasks": [
        {
            "taskId": "dGFza2lkZ29lc2hlcmUK",
            "s3Key": "customerImage1.jpg",
            "s3VersionId": "1",
            "s3BucketArn": "arn:aws:s3:us-east-1:0123456788:amzn-s3-demo-bucket1"
        }
    ]
}

{
  "invocationSchemaVersion": "1.0",
  "treatMissingKeysAs" : "PermanentFailure",
  "invocationId" : "YXNkbGZqYWRmaiBhc2RmdW9hZHNmZGpmaGFzbGtkaGZza2RmaAo",
  "results": [
    {
      "taskId": "dGFza2lkZ29lc2hlcmUK",
      "resultCode": "Succeeded",
      "resultString": "[\"Mary Major", \"John Stiles\"]"
    }
  ]
}

Beispiel für eine Lambda-Funktion für S3-BatchVorgänge

Im folgenden Beispiel entfernt Python Lambda eine Löschmarkierung von einem versionierten Objekt.

Wie das Beispiel zeigt, sind Schlüssel aus S3-Batch-Vorgänge URL-codiert. Um Amazon S3 mit anderen AWS Diensten zu verwenden, ist es wichtig, dass Sie den Schlüssel, der von S3 Batch Operations übergeben wird, per URL dekodieren.

import logging
from urllib import parse
import boto3
from botocore.exceptions import ClientError

logger = logging.getLogger(__name__)
logger.setLevel("INFO")

s3 = boto3.client("s3")


def lambda_handler(event, context):
    """
    Removes a delete marker from the specified versioned object.

    :param event: The S3 batch event that contains the ID of the delete marker
                  to remove.
    :param context: Context about the event.
    :return: A result structure that Amazon S3 uses to interpret the result of the
             operation. When the result code is TemporaryFailure, S3 retries the
             operation.
    """
    # Parse job parameters from Amazon S3 batch operations
    invocation_id = event["invocationId"]
    invocation_schema_version = event["invocationSchemaVersion"]

    results = []
    result_code = None
    result_string = None

    task = event["tasks"][0]
    task_id = task["taskId"]

    try:
        obj_key = parse.unquote(task["s3Key"], encoding="utf-8")
        obj_version_id = task["s3VersionId"]
        bucket_name = task["s3BucketArn"].split(":")[-1]

        logger.info(
            "Got task: remove delete marker %s from object %s.", obj_version_id, obj_key
        )

        try:
            # If this call does not raise an error, the object version is not a delete
            # marker and should not be deleted.
            response = s3.head_object(
                Bucket=bucket_name, Key=obj_key, VersionId=obj_version_id
            )
            result_code = "PermanentFailure"
            result_string = (
                f"Object {obj_key}, ID {obj_version_id} is not " f"a delete marker."
            )

            logger.debug(response)
            logger.warning(result_string)
        except ClientError as error:
            delete_marker = error.response["ResponseMetadata"]["HTTPHeaders"].get(
                "x-amz-delete-marker", "false"
            )
            if delete_marker == "true":
                logger.info(
                    "Object %s, version %s is a delete marker.", obj_key, obj_version_id
                )
                try:
                    s3.delete_object(
                        Bucket=bucket_name, Key=obj_key, VersionId=obj_version_id
                    )
                    result_code = "Succeeded"
                    result_string = (
                        f"Successfully removed delete marker "
                        f"{obj_version_id} from object {obj_key}."
                    )
                    logger.info(result_string)
                except ClientError as error:
                    # Mark request timeout as a temporary failure so it will be retried.
                    if error.response["Error"]["Code"] == "RequestTimeout":
                        result_code = "TemporaryFailure"
                        result_string = (
                            f"Attempt to remove delete marker from  "
                            f"object {obj_key} timed out."
                        )
                        logger.info(result_string)
                    else:
                        raise
            else:
                raise ValueError(
                    f"The x-amz-delete-marker header is either not "
                    f"present or is not 'true'."
                )
    except Exception as error:
        # Mark all other exceptions as permanent failures.
        result_code = "PermanentFailure"
        result_string = str(error)
        logger.exception(error)
    finally:
        results.append(
            {
                "taskId": task_id,
                "resultCode": result_code,
                "resultString": result_string,
            }
        )
    return {
        "invocationSchemaVersion": invocation_schema_version,
        "treatMissingKeysAs": "PermanentFailure",
        "invocationId": invocation_id,
        "results": results,
    }



                

Erstellen eines S3-Batchoperations-Auftrags, der eine Lambda-Funktion aufruft

Wenn Sie einen S3-Batchoperations-Auftrag erstellen, um eine Lambda-Funktion aufzurufen, müssen Sie Folgendes angeben:

Weitere Informationen zum Erstellen eines S3-Batchoperations-Auftrags finden Sie unter Erstellen eines S3-Batch-Vorgangsauftrags und Von S3 Batch Operations unterstützte Vorgänge.

Im folgenden Beispiel wird ein S3-Batch-Operations-Auftrag erstellt, der eine Lambda-Funktion mit der AWS CLI aufruft. Wenn Sie dieses Beispiel verwenden möchten, ersetzen Sie die user input placeholders (Platzhalter für Benutzereingaben) durch Ihre Informationen.

aws s3control create-job
    --account-id account-id
    --operation  '{"LambdaInvoke": { "FunctionArn": "arn:aws:lambda:region:account-id:function:LambdaFunctionName" } }'
    --manifest '{"Spec":{"Format":"S3BatchOperations_CSV_20180820","Fields":["Bucket","Key"]},"Location":{"ObjectArn":"arn:aws:s3:::amzn-s3-demo-manifest-bucket","ETag":"ManifestETag"}}'
    --report '{"Bucket":"arn:aws:s3:::amzn-s3-demo-bucket","Format":"Report_CSV_20180820","Enabled":true,"Prefix":"ReportPrefix","ReportScope":"AllTasks"}'
    --priority 2
    --role-arn arn:aws:iam::account-id:role/BatchOperationsRole
    --region region
    --description "Lambda Function"

Bereitstellen von Informationen auf Aufgabenebene in Lambda-Manifesten

Wenn Sie AWS Lambda Funktionen mit S3 Batch Operations verwenden, benötigen Sie möglicherweise zusätzliche Daten für jede Aufgabe oder Taste, an der gearbeitet wird. Möglicherweise möchten Sie, dass sowohl ein Quellobjektschlüssel als auch ein neuer Objektschlüssel bereitgestellt wird. Ihre Lambda-Funktion kann in einem solchen Fall den Quellschlüssel in einen neuen S3-Bucket unter einem neuen Namen speichern. Standardmäßig können Sie mit Batch Operations nur den Ziel-Bucket und eine Liste von Quellschlüsseln im Eingabemanifest für Ihrer Aufgabe angeben. Die nachfolgenden Beispiele beschrieben, wie Sie weitere Daten in Ihr Manifest aufnehmen können, sodass Sie komplexere Lambda-Funktionen ausführen können.

Zum Angeben von Pro-Schlüssel-Parametern in Ihrem S3-BatchVorgängemanifest zur Verwendung im Code der Lambda-Funktion verwenden Sie das folgende URL-kodierte JSON-Format. Das key-Feld wird an Ihre Lambda-Funktion übergeben, als wäre es ein Amazon S3-Objektschlüssel. Es kann jedoch von der Lambda-Funktion so interpretiert werden, dass es andere Werte oder mehrere Schlüssel enthält, wie in den folgenden Beispielen gezeigt.

amzn-s3-demo-bucket,{"origKey": "object1key", "newKey": "newObject1Key"}
amzn-s3-demo-bucket,{"origKey": "object2key", "newKey": "newObject2Key"}
amzn-s3-demo-bucket,{"origKey": "object3key", "newKey": "newObject3Key"}

amzn-s3-demo-bucket,%7B%22origKey%22%3A%20%22object1key%22%2C%20%22newKey%22%3A%20%22newObject1Key%22%7D
amzn-s3-demo-bucket,%7B%22origKey%22%3A%20%22object2key%22%2C%20%22newKey%22%3A%20%22newObject2Key%22%7D
amzn-s3-demo-bucket,%7B%22origKey%22%3A%20%22object3key%22%2C%20%22newKey%22%3A%20%22newObject3Key%22%7D

amzn-s3-demo-bucket,object1key%7Clower
amzn-s3-demo-bucket,object2key%7Cupper
amzn-s3-demo-bucket,object3key%7Creverse
amzn-s3-demo-bucket,object4key%7Cdelete

import logging
from urllib import parse
import boto3
from botocore.exceptions import ClientError

logger = logging.getLogger(__name__)
logger.setLevel("INFO")

s3 = boto3.resource("s3")


def lambda_handler(event, context):
    """
    Applies the specified revision to the specified object.

    :param event: The Amazon S3 batch event that contains the ID of the object to
                  revise and the revision type to apply.
    :param context: Context about the event.
    :return: A result structure that Amazon S3 uses to interpret the result of the
             operation.
    """
    # Parse job parameters from Amazon S3 batch operations
    invocation_id = event["invocationId"]
    invocation_schema_version = event["invocationSchemaVersion"]

    results = []
    result_code = None
    result_string = None

    task = event["tasks"][0]
    task_id = task["taskId"]
    # The revision type is packed with the object key as a pipe-delimited string.
    obj_key, revision = parse.unquote(task["s3Key"], encoding="utf-8").split("|")
    bucket_name = task["s3BucketArn"].split(":")[-1]

    logger.info("Got task: apply revision %s to %s.", revision, obj_key)

    try:
        stanza_obj = s3.Bucket(bucket_name).Object(obj_key)
        stanza = stanza_obj.get()["Body"].read().decode("utf-8")
        if revision == "lower":
            stanza = stanza.lower()
        elif revision == "upper":
            stanza = stanza.upper()
        elif revision == "reverse":
            stanza = stanza[::-1]
        elif revision == "delete":
            pass
        else:
            raise TypeError(f"Can't handle revision type '{revision}'.")

        if revision == "delete":
            stanza_obj.delete()
            result_string = f"Deleted stanza {stanza_obj.key}."
        else:
            stanza_obj.put(Body=bytes(stanza, "utf-8"))
            result_string = (
                f"Applied revision type '{revision}' to " f"stanza {stanza_obj.key}."
            )

        logger.info(result_string)
        result_code = "Succeeded"
    except ClientError as error:
        if error.response["Error"]["Code"] == "NoSuchKey":
            result_code = "Succeeded"
            result_string = (
                f"Stanza {obj_key} not found, assuming it was deleted "
                f"in an earlier revision."
            )
            logger.info(result_string)
        else:
            result_code = "PermanentFailure"
            result_string = (
                f"Got exception when applying revision type '{revision}' "
                f"to {obj_key}: {error}."
            )
            logger.exception(result_string)
    finally:
        results.append(
            {
                "taskId": task_id,
                "resultCode": result_code,
                "resultString": result_string,
            }
        )
    return {
        "invocationSchemaVersion": invocation_schema_version,
        "treatMissingKeysAs": "PermanentFailure",
        "invocationId": invocation_id,
        "results": results,
    }



 

Tutorial zu S3-Batchvorgängen

Das folgende Tutorial enthält vollständige end-to-end Verfahren für einige Batch-Operationsaufgaben mit Lambda. In diesem Tutorial erfahren Sie, wie Sie Batch Operations einrichten, um eine Lambda-Funktion zum Batch-Transcodieren von Videos aufzurufen, die in einem S3-Quell-Bucket gespeichert sind. Die Lambda-Funktion ruft AWS Elemental MediaConvert auf, um die Videos zu transkodieren.