Funzione Invoke AWS Lambda

Puoi utilizzare Amazon S3 Batch Operations per eseguire operazioni batch su larga scala su oggetti Amazon S3. L'operazione Batch Operations della AWS Lambda funzione Invoke avvia AWS Lambda le funzioni per eseguire azioni personalizzate sugli oggetti elencati in un manifesto. Questa sezione descrive come creare una funzione Lambda da utilizzare con le operazioni in batch Amazon S3 e come creare un processo per richiamare la funzione. Il processo di S3 Batch Operations utilizza l'operazione LambdaInvoke per eseguire una funzione Lambda su ogni oggetto elencato in un manifest.

Puoi lavorare con S3 Batch Operations utilizzando la console Amazon S3 AWS Command Line Interface ,AWS CLI() AWS SDKs o Amazon S3. REST API Per ulteriori informazioni sull'utilizzo di Lambda, consulta Nozioni di base su AWS Lambda nella Guida per Developer di AWS Lambda .

Le sezioni seguenti spiegano come iniziare a utilizzare le operazioni in batch S3 con Lambda.

Utilizzo di Lambda con operazioni Batch

Quando si utilizza S3 Batch Operations con AWS Lambda, è necessario creare nuove funzioni Lambda specifiche per l'uso con S3 Batch Operations. Non puoi riutilizzare funzioni basate su eventi Amazon S3 esistenti con le operazioni in batch S3. Le funzioni evento possono solo ricevere messaggi, non possono restituirli. Le funzioni Lambda utilizzate con le operazioni in batch S3 devono accettare e restituire messaggi. Per ulteriori informazioni sull'uso di Lambda con gli eventi Amazon S3, consulta Using with AWS Lambda Amazon S3 nella Developer Guide.AWS Lambda

Devi creare un processo di operazioni in batch Amazon S3 che richiama la funzione Lambda. Il processo esegue la stessa funzione Lambda su tutti gli oggetti elencati nel manifest. Puoi controllare quali versioni della funzione Lambda utilizzare durante l'elaborazione degli oggetti nel manifest. S3 Batch Operations supporta Amazon Resource Names (ARNs) non qualificati, alias e versioni specifiche. Per ulteriori informazioni, consulta Introduzione al controllo delle AWS Lambda versioni nella Guida per gli sviluppatori.AWS Lambda

Se fornisci al job S3 Batch Operations una funzione ARN che utilizza un alias o il $LATEST qualificatore e aggiorni la versione a cui fa riferimento uno di questi, S3 Batch Operations inizia a chiamare la nuova versione della funzione Lambda. Ciò può essere utile quando desideri aggiornare la parte di funzionalità durante un processo di grandi dimensioni. Se non desideri che S3 Batch Operations modifichi la versione utilizzata, fornisci la versione specifica nel FunctionARN parametro quando crei il job.

Utilizzo delle operazioni Lambda e Batch con i bucket di directory

I bucket di directory sono un tipo di bucket Amazon S3 progettato per carichi di lavoro o applicazioni critiche per le prestazioni che richiedono una latenza costante di un millisecondo. Per ulteriori informazioni, consulta Directory buckets.

Esistono requisiti speciali per l'utilizzo di Operazioni in batch per richiamare funzioni Lambda che agiscono su bucket di directory. Ad esempio, è necessario strutturare la richiesta Lambda utilizzando uno JSON schema aggiornato e specificare InvocationSchemaVersion2.0 (non 1.0) quando si crea il lavoro. Questo schema aggiornato consente di specificare coppie chiave-valore opzionali per UserArguments, che è possibile utilizzare per modificare determinati parametri delle funzioni Lambda esistenti. Per ulteriori informazioni, consulta Automatizzare l'elaborazione degli oggetti nei bucket di directory Amazon S3 con S3 Batch Operations AWS Lambda e nel blog sullo storage. AWS

Codici di risposta e dei risultati

S3 Batch Operations richiama la funzione Lambda con uno o più tasti, a ognuno dei quali è associato un tasto. TaskID S3 Batch Operations prevede un codice risultato per chiave dalle funzioni Lambda. A qualsiasi attività IDs inviata nella richiesta che non viene restituita con un codice risultato per chiave verrà assegnato il codice risultante dal campo. treatMissingKeysAs treatMissingKeysAsè un campo di richiesta opzionale e il valore predefinito è. TemporaryFailure La tabella seguente contiene gli altri codici e valori di risultato possibili per il treatMissingKeysAs campo.

Creazione di una funzione Lambda da utilizzare con le operazioni in batch S3

Questa sezione fornisce esempi di autorizzazioni AWS Identity and Access Management (IAM) che è necessario utilizzare con la funzione Lambda. Contiene anche una funzione Lambda di esempio da utilizzare con le operazioni in batch S3. Se non hai mai creato una funzione Lambda prima, consulta Tutorial: Using AWS Lambda with Amazon S3 nella AWS Lambda Developer Guide.

Devi creare funzioni Lambda specifiche da utilizzare con le operazioni in batch S3. Non puoi riutilizzare le funzioni Lambda esistenti di Amazon S3 basate su eventi perché le funzioni Lambda utilizzate per S3 Batch Operations devono accettare e restituire campi dati speciali.

Autorizzazioni IAM di esempio

Di seguito sono riportati alcuni esempi delle IAM autorizzazioni necessarie per utilizzare una funzione Lambda con S3 Batch Operations.

{
    "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": "*"
        }
    ]
}

Richiesta e risposta di esempio

Questa sezione fornisce esempi di richiesta e risposta per la funzione Lambda.

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

Funzione Lambda di esempio per le operazioni in batch S3

Nell’esempio seguente Python Lambda rimuove un contrassegno di eliminazione da un oggetto con versione.

Come mostra l'esempio, le chiavi di S3 Batch Operations sono URL codificate. Per utilizzare Amazon S3 con altri AWS servizi, è importante URL decodificare la chiave che viene passata da S3 Batch Operations.

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



                

Creazione di un processo di operazioni in batch Amazon S3 che richiama una funzione Lambda

Quando crei un processo di operazioni in batch Amazon S3 per richiamare una funzione Lambda, devi fornire gli elementi seguenti:

Per ulteriori informazioni sulla creazione di un processo di operazioni in batch Amazon S3, consulta Creazione di un processo di operazioni in batch S3 e Operazioni supportate dalle operazioni in batch S3.

L'esempio seguente crea un job S3 Batch Operations che richiama una funzione Lambda utilizzando il. AWS CLI Per utilizzare questo esempio, sostituisci segnaposti di input dall'utente con le tue informazioni.

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"

Aggiunta di informazioni a livello di attività nei manifest Lambda

Quando utilizzi AWS Lambda le funzioni con S3 Batch Operations, potresti aver bisogno di dati aggiuntivi per ogni attività o tasto su cui viene utilizzato. Ad esempio, potresti voler fornire sia una chiave dell'oggetto di origine che una nuova chiave dell'oggetto. La funzione Lambda può quindi copiare la chiave di origine in un nuovo bucket S3 con un nuovo nome. Per impostazione predefinita, Batch Operations consente di specificare solo il bucket di destinazione e un elenco di chiavi di origine nel manifesto di input del job. Gli esempi seguenti descrivono come includere dati aggiuntivi nel manifesto in modo da poter eseguire funzioni Lambda più complesse.

Per specificare i parametri per chiave nel manifesto di S3 Batch Operations da utilizzare nel codice della funzione Lambda, usa il seguente formato con codifica. URL JSON Il campo key viene passato alla funzione Lambda come se fosse una chiave oggetto Amazon S3. Tuttavia, può essere interpretata dalla funzione Lambda in modo che contenga altri valori o più chiavi, come illustrato negli esempi seguenti.

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 sulle operazioni in batch S3

Il seguente tutorial presenta end-to-end le procedure complete per alcune attività di Batch Operations con Lambda. In questo tutorial, imparerai come configurare le operazioni Batch per richiamare una funzione Lambda per la transcodifica in batch dei video archiviati in un bucket sorgente S3. La funzione Lambda chiama AWS Elemental MediaConvert per transcodificare i video.