Funktion aufrufen AWS Lambda

Sie können Amazon S3 Batch Operations verwenden, um umfangreiche Batch-Operationen an Amazon S3 S3-Objekten 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-Konsole, AWS Command Line Interface (AWS CLI) AWS SDKs, oder Amazon S3 verwenden RESTAPI. 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.

Lambda mit Batch-Operationen verwenden

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 Batch Operations-Job eine Funktion zur Verfügung stellenARN, die einen Alias oder den $LATEST Qualifier verwendet, und Sie die Version aktualisieren, auf die einer dieser beiden verweist, beginnt S3 Batch Operations, die neue Version Ihrer Lambda-Funktion aufzurufen. 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 Job erstellen.

Verwenden von Lambda- und Batch-Operationen mit Verzeichnis-Buckets

Verzeichnis-Buckets sind eine Art von Amazon S3 S3-Bucket, die für Workloads oder leistungskritische Anwendungen konzipiert sind, die eine konsistente Latenz 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 Folgendes angeben InvocationSchemaVersion2.0 (nicht 1.0), wenn Sie den Job erstellen. Dieses aktualisierte Schema ermöglicht Ihnen die Angabe optionaler Schlüssel-Wert-Paare für UserArguments, mit dem 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, denen jeweils ein Schlüssel TaskID zugeordnet 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 Feld. treatMissingKeysAs 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 bestehende 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 von IAM-Berechtigungen

Im Folgenden finden Sie Beispiele für die IAM Berechtigungen, die für die Verwendung einer Lambda-Funktion mit S3 Batch Operations 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 Operations URL codiert. Um Amazon S3 mit anderen AWS Diensten zu verwenden, ist es wichtig, dass Sie den Schlüssel URL dekodieren, der von S3 Batch Operations übergeben wird.

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-Vorgänge unterstützte Vorgänge.

Im folgenden Beispiel wird ein S3-Auftrag für Batch Operations erstellt, der mithilfe von eine Lambda-Funktion aufruft. AWS CLI Um dieses Beispiel zu verwenden, ersetzen Sie Platzhalter für Benutzereingaben mit Ihren eigenen 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. Beispielsweise möchten Sie möglicherweise, dass sowohl ein Quellobjektschlüssel als auch ein neuer Objektschlüssel bereitgestellt werden. 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 Ihren Job angeben. In den folgenden Beispielen wird beschrieben, wie Sie zusätzliche Daten in Ihr Manifest aufnehmen können, um komplexere Lambda-Funktionen auszuführen.

Verwenden Sie das folgende URL -kodierte Format, um Schlüsselparameter in Ihrem S3-Batch-Operations-Manifest anzugeben, die im Code Ihrer Lambda-Funktion verwendet werden sollen. JSON 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-Operationen einrichten, um eine Lambda-Funktion für die Batch-Transcodierung von Videos aufzurufen, die in einem S3-Quell-Bucket gespeichert sind. Die Lambda-Funktion ruft AWS Elemental MediaConvert auf, um die Videos zu transkodieren.