Tutorial: Uso de un desencadenador de Amazon S3 para invocar una función de Lambda - AWS Lambda

Tutorial: Uso de un desencadenador de Amazon S3 para invocar una función de Lambda

En este tutorial, se utiliza la consola a fin de crear una función de Lambda y configurar un desencadenador para un bucket de Amazon Simple Storage Service (Amazon S3). Cada vez que agrega un objeto al bucket de Amazon S3, la función se ejecuta y muestra el tipo de objeto en Registros de Amazon CloudWatch.

Diagrama que muestra el flujo de datos entre un bucket de Amazon S3, una función de Lambda y Registros de Amazon CloudWatch

En este tutorial se muestra cómo:

  1. Cree un bucket de Amazon S3.

  2. Cree una función de Lambda que devuelva el tipo de objeto de los objetos en un bucket de Amazon S3.

  3. Configure un desencadenador de Lambda que invoque su función cuando se carguen objetos en su bucket.

  4. Pruebe su función, primero con un evento de prueba y, a continuación, con el desencadenador.

Al completar estos pasos, aprenderá a configurar una función de Lambda para que se ejecute siempre que se agreguen objetos a un bucket de Amazon S3 o se eliminen de él. Solo puede completar este tutorial mediante la AWS Management Console.

Requisitos previos

Si no dispone de una Cuenta de AWS, siga estos pasos para crear una.

Para registrarse y obtener una Cuenta de AWS
  1. Abra https://portal.aws.amazon.com/billing/signup.

  2. Siga las instrucciones que se le indiquen.

    Parte del procedimiento de registro consiste en recibir una llamada telefónica e indicar un código de verificación en el teclado del teléfono.

    Al registrase para obtener una Cuenta de AWS, se crea un Usuario raíz de la cuenta de AWS. El usuario raíz tendrá acceso a todos los Servicios de AWS y recursos de esa cuenta. Como práctica recomendada de seguridad, asigne acceso administrativo a un usuario administrativo y utilice únicamente el usuario raíz para ejecutar tareas que requieren acceso de usuario raíz.

AWS le enviará un email de confirmación cuando complete el proceso de registro. Puede ver la actividad de la cuenta y administrar la cuenta en cualquier momento entrando en https://aws.amazon.com/ y seleccionando Mi cuenta.

Después de registrarse para obtener una Cuenta de AWS, proteja su Usuario raíz de la cuenta de AWS, habilite AWS IAM Identity Center y cree un usuario administrativo para no utilizar el usuario raíz en las tareas cotidianas.

Protección de Usuario raíz de la cuenta de AWS
  1. Inicie sesión en AWS Management Console como propietario de la cuenta eligiendo Usuario raíz e introduzca el correo electrónico de su Cuenta de AWS. En la siguiente página, escriba su contraseña.

    Para obtener ayuda para iniciar sesión con el usuario raíz, consulte Iniciar sesión como usuario raíz en la Guía del usuario de AWS Sign-In.

  2. Active la autenticación multifactor (MFA) para el usuario raíz.

    Para ver las instrucciones, consulte Habilitar un dispositivo MFA virtual para el usuario raíz Cuenta de AWS (consola) en la Guía del usuario de IAM.

Crear un usuario administrativo
  1. Activar IAM Identity Center

    Consulte las instrucciones en Enabling AWS IAM Identity Center en la Guía del usuario de AWS IAM Identity Center.

  2. En el Centro de identidades de IAM, conceda acceso administrativo a un usuario administrativo.

    Para ver un tutorial sobre cómo utilizar Directorio de IAM Identity Center como origen de identidad, consulte Configuración del acceso de los usuarios con el Directorio de IAM Identity Center predeterminado en la Guía del usuario de AWS IAM Identity Center.

Inicio de sesión como usuario administrativo
  • Para iniciar sesión con el usuario de IAM Identity Center, utilice la URL de inicio de sesión que se envió a la dirección de correo electrónico cuando creó el usuario de IAM Identity Center.

    Para obtener ayuda para iniciar sesión con un usuario del Centro de Identidades de IAM, consulte Iniciar sesión en el portal de acceso de AWS en la Guía del usuario de AWS Sign-In.

Crear un bucket de Amazon S3

Diagrama de flujo de trabajo del tutorial que muestra que se encuentra creando el bucket en el paso del bucket de Amazon S3
Creación de un bucket de Amazon S3
  1. Abra la consola de Amazon S3 y seleccione la página Buckets.

  2. Elija Crear bucket.

  3. En Configuración general, haga lo siguiente:

    1. Para el nombre del bucket, ingrese un nombre único a nivel mundial que cumpla las reglas de nomenclatura de bucket de Amazon S3. Los nombres de bucket pueden contener únicamente de letras minúsculas, números, puntos (.) y guiones (-).

    2. En AWS Región, seleccione una región. Más adelante en el tutorial, debe crear la función de Lambda en la misma región.

  4. Deje el resto de las opciones con sus valores predeterminados y seleccione Crear bucket.

Cargar un objeto de prueba en un bucket

Diagrama de flujo de trabajo del tutorial que muestra que se encuentra cargando un objeto de prueba en el paso del bucket de Amazon S3
Para cargar un objeto de prueba
  1. Abra la página Buckets de la consola de Amazon S3 y elija el bucket que creó durante el paso anterior.

  2. Seleccione Cargar.

  3. Elija Agregar archivo y seleccione los objetos que desea cargar. Puede seleccionar cualquier archivo (por ejemplo, HappyFace.jpg).

  4. Elija Abrir y, a continuación, Cargar.

Más adelante en el tutorial, probará la función de Lambda con este objeto.

Crear una política de permisos

Diagrama de flujo de trabajo del tutorial que muestra que se encuentra creando la política de permisos en el paso de la función de Lambda

Cree una política de permisos que permita a Lambda obtener objetos de un bucket de Amazon S3 y escribir en los registros de Amazon CloudWatch.

Para crear la política de
  1. Abra la página de Policies (Políticas) de la consola de IAM.

  2. Seleccione Crear política.

  3. Elija la pestaña JSON y pegue la siguiente política personalizada en el editor JSON.

    { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "logs:PutLogEvents", "logs:CreateLogGroup", "logs:CreateLogStream" ], "Resource": "arn:aws:logs:*:*:*" }, { "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": "arn:aws:s3:::*/*" } ] }
  4. Elija Siguiente: Etiquetas.

  5. Elija Siguiente: Revisar.

  6. En Review policy (Revisar política), para el Name (Nombre) de la política, ingrese s3-trigger-tutorial.

  7. Elija Crear política.

Creación de un rol de ejecución

Diagrama de flujo de trabajo del tutorial que muestra que se encuentra creando el rol de ejecución en el paso de la función de Lambda

Un rol de ejecución es un rol de AWS Identity and Access Management (IAM) que concede a la función de Lambda permiso para acceder a servicios y recursos de AWS. En este paso, creará un rol de ejecución mediante la política de permisos que creó en el paso anterior.

Para crear una función de ejecución y adjuntar su política de permisos personalizada
  1. Abra la página Roles en la consola de IAM.

  2. Seleccione Crear rol.

  3. Para el tipo de entidad de confianza, seleccione Servicio de AWS y, para el caso de uso, elija Lambda.

  4. Elija Siguiente.

  5. En el cuadro de búsqueda de políticas, escriba s3-trigger-tutorial.

  6. En los resultados de búsqueda, seleccione la política que ha creado (s3-trigger-tutorial), y luego Next (Siguiente).

  7. En Role details (Detalles del rol), introduzca lambda-s3-trigger-role en Role name (Nombre del rol) y, luego, elija Create role (Crear rol).

Crear la función de Lambda

Diagrama de flujo de trabajo del tutorial que muestra que se encuentra creando la función en el paso de la función de Lambda

Cree una función de Lambda en la consola con el tiempo de ejecución de Python 3.12.

Para crear la función de Lambda
  1. Abra la página de Funciones en la consola de Lambda.

  2. Asegúrese de trabajar en la misma Región de AWS en la que creó el bucket de Amazon S3. Puede cambiar la región mediante la lista desplegable de la parte superior de la pantalla.

    Imagen que muestra el menú desplegable de regiones en la consola de Lambda
  3. Elija Crear función.

  4. Elija Crear desde cero.

  5. En Información básica, haga lo siguiente:

    1. En Nombre de la función, ingrese s3-trigger-tutorial.

    2. En Tiempo de ejecución, seleccione Python 3.12.

    3. En Arquitectura, elija x86_64.

  6. En la pestaña Cambiar rol de ejecución predeterminado, haga lo siguiente:

    1. Amplíe la pestaña y, a continuación, elija Utilizar un rol existente.

    2. Seleccione el lambda-s3-trigger-role que creó anteriormente.

  7. Elija Crear función.

Implementar el código de la función

Diagrama de flujo de trabajo del tutorial que muestra que se encuentra implementando el código en el paso de la función de Lambda

Este tutorial utiliza el tiempo de ejecución de Python 3.12, pero también proporcionamos archivos de código de ejemplo para otros tiempos de ejecución. Puede seleccionar la pestaña del siguiente cuadro para ver el código del tiempo de ejecución que le interesa.

La función de Lambda recuperará el nombre de clave del objeto cargado y el nombre del bucket desde el parámetro event que recibe de Amazon S3. A continuación, la función utiliza el método get_object de AWS SDK for Python (Boto3) para recuperar los metadatos del objeto, incluido el tipo de contenido (tipo MIME) del objeto cargado.

Para implementar el código de la función
  1. Seleccione la pestaña Python en el siguiente cuadro y copie el código.

    .NET
    AWS SDK for .NET
    nota

    Hay más información en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de ejemplos sin servidor.

    Uso de un evento de S3 con Lambda mediante .NET.

    // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. // SPDX-License-Identifier: Apache-2.0 using System.Threading.Tasks; using Amazon.Lambda.Core; using Amazon.S3; using System; using Amazon.Lambda.S3Events; using System.Web; // Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class. [assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))] namespace S3Integration { public class Function { private static AmazonS3Client _s3Client; public Function() : this(null) { } internal Function(AmazonS3Client s3Client) { _s3Client = s3Client ?? new AmazonS3Client(); } public async Task<string> Handler(S3Event evt, ILambdaContext context) { try { if (evt.Records.Count <= 0) { context.Logger.LogLine("Empty S3 Event received"); return string.Empty; } var bucket = evt.Records[0].S3.Bucket.Name; var key = HttpUtility.UrlDecode(evt.Records[0].S3.Object.Key); context.Logger.LogLine($"Request is for {bucket} and {key}"); var objectResult = await _s3Client.GetObjectAsync(bucket, key); context.Logger.LogLine($"Returning {objectResult.Key}"); return objectResult.Key; } catch (Exception e) { context.Logger.LogLine($"Error processing request - {e.Message}"); return string.Empty; } } } }
    Go
    SDK para Go V2
    nota

    Hay más información en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de ejemplos sin servidor.

    Uso de un evento de S3 con Lambda mediante Go.

    // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. // SPDX-License-Identifier: Apache-2.0 package main import ( "context" "log" "github.com/aws/aws-lambda-go/events" "github.com/aws/aws-lambda-go/lambda" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/service/s3" ) func handler(ctx context.Context, s3Event events.S3Event) error { sdkConfig, err := config.LoadDefaultConfig(ctx) if err != nil { log.Printf("failed to load default config: %s", err) return err } s3Client := s3.NewFromConfig(sdkConfig) for _, record := range s3Event.Records { bucket := record.S3.Bucket.Name key := record.S3.Object.URLDecodedKey headOutput, err := s3Client.HeadObject(ctx, &s3.HeadObjectInput{ Bucket: &bucket, Key: &key, }) if err != nil { log.Printf("error getting head of object %s/%s: %s", bucket, key, err) return err } log.Printf("successfully retrieved %s/%s of type %s", bucket, key, *headOutput.ContentType) } return nil } func main() { lambda.Start(handler) }
    Java
    SDK para Java 2.x
    nota

    Hay más información en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de ejemplos sin servidor.

    Uso de un evento de S3 con Lambda mediante Java.

    // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. // SPDX-License-Identifier: Apache-2.0 package example; import software.amazon.awssdk.services.s3.model.HeadObjectRequest; import software.amazon.awssdk.services.s3.model.HeadObjectResponse; import software.amazon.awssdk.services.s3.S3Client; import com.amazonaws.services.lambda.runtime.Context; import com.amazonaws.services.lambda.runtime.RequestHandler; import com.amazonaws.services.lambda.runtime.events.S3Event; import com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification.S3EventNotificationRecord; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class Handler implements RequestHandler<S3Event, String> { private static final Logger logger = LoggerFactory.getLogger(Handler.class); @Override public String handleRequest(S3Event s3event, Context context) { try { S3EventNotificationRecord record = s3event.getRecords().get(0); String srcBucket = record.getS3().getBucket().getName(); String srcKey = record.getS3().getObject().getUrlDecodedKey(); S3Client s3Client = S3Client.builder().build(); HeadObjectResponse headObject = getHeadObject(s3Client, srcBucket, srcKey); logger.info("Successfully retrieved " + srcBucket + "/" + srcKey + " of type " + headObject.contentType()); return "Ok"; } catch (Exception e) { throw new RuntimeException(e); } } private HeadObjectResponse getHeadObject(S3Client s3Client, String bucket, String key) { HeadObjectRequest headObjectRequest = HeadObjectRequest.builder() .bucket(bucket) .key(key) .build(); return s3Client.headObject(headObjectRequest); } }
    JavaScript
    SDK para JavaScript (v3)
    nota

    Hay más información en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de ejemplos sin servidor.

    Uso de un evento de S3 con Lambda mediante JavaScript.

    // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. // SPDX-License-Identifier: Apache-2.0 import { S3Client, HeadObjectCommand } from "@aws-sdk/client-s3"; const client = new S3Client(); exports.handler = async (event, context) => { // Get the object from the event and show its content type const bucket = event.Records[0].s3.bucket.name; const key = decodeURIComponent(event.Records[0].s3.object.key.replace(/\+/g, ' ')); try { const { ContentType } = await client.send(new HeadObjectCommand({ Bucket: bucket, Key: key, })); console.log('CONTENT TYPE:', ContentType); return ContentType; } catch (err) { console.log(err); const message = `Error getting object ${key} from bucket ${bucket}. Make sure they exist and your bucket is in the same region as this function.`; console.log(message); throw new Error(message); } };

    Uso de un evento de S3 con Lambda mediante TypeScript.

    // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. // SPDX-License-Identifier: Apache-2.0 import { S3Event } from 'aws-lambda'; import { S3Client, HeadObjectCommand } from '@aws-sdk/client-s3'; const s3 = new S3Client({ region: process.env.AWS_REGION }); export const handler = async (event: S3Event): Promise<string | undefined> => { // Get the object from the event and show its content type const bucket = event.Records[0].s3.bucket.name; const key = decodeURIComponent(event.Records[0].s3.object.key.replace(/\+/g, ' ')); const params = { Bucket: bucket, Key: key, }; try { const { ContentType } = await s3.send(new HeadObjectCommand(params)); console.log('CONTENT TYPE:', ContentType); return ContentType; } catch (err) { console.log(err); const message = `Error getting object ${key} from bucket ${bucket}. Make sure they exist and your bucket is in the same region as this function.`; console.log(message); throw new Error(message); } };
    PHP
    SDK para PHP
    nota

    Hay más información en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de ejemplos sin servidor.

    Consumo de un evento de S3 con Lambda mediante PHP.

    // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. // SPDX-License-Identifier: Apache-2.0 <?php use Bref\Context\Context; use Bref\Event\S3\S3Event; use Bref\Event\S3\S3Handler; use Bref\Logger\StderrLogger; require __DIR__ . '/vendor/autoload.php'; class Handler extends S3Handler { private StderrLogger $logger; public function __construct(StderrLogger $logger) { $this->logger = $logger; } public function handleS3(S3Event $event, Context $context) : void { $this->logger->info("Processing S3 records"); // Get the object from the event and show its content type $records = $event->getRecords(); foreach ($records as $record) { $bucket = $record->getBucket()->getName(); $key = urldecode($record->getObject()->getKey()); try { $fileSize = urldecode($record->getObject()->getSize()); echo "File Size: " . $fileSize . "\n"; // TODO: Implement your custom processing logic here } catch (Exception $e) { echo $e->getMessage() . "\n"; echo 'Error getting object ' . $key . ' from bucket ' . $bucket . '. Make sure they exist and your bucket is in the same region as this function.' . "\n"; throw $e; } } } } $logger = new StderrLogger(); return new Handler($logger);
    Python
    SDK para Python (Boto3)
    nota

    Hay más información en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de ejemplos sin servidor.

    Uso de un evento de S3 con Lambda mediante Python.

    # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 import json import urllib.parse import boto3 print('Loading function') s3 = boto3.client('s3') def lambda_handler(event, context): #print("Received event: " + json.dumps(event, indent=2)) # Get the object from the event and show its content type bucket = event['Records'][0]['s3']['bucket']['name'] key = urllib.parse.unquote_plus(event['Records'][0]['s3']['object']['key'], encoding='utf-8') try: response = s3.get_object(Bucket=bucket, Key=key) print("CONTENT TYPE: " + response['ContentType']) return response['ContentType'] except Exception as e: print(e) print('Error getting object {} from bucket {}. Make sure they exist and your bucket is in the same region as this function.'.format(key, bucket)) raise e
    Ruby
    SDK para Ruby
    nota

    Hay más información en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de ejemplos sin servidor.

    Consumo de un evento de S3 con Lambda mediante Ruby.

    require 'json' require 'uri' require 'aws-sdk' puts 'Loading function' def lambda_handler(event:, context:) s3 = Aws::S3::Client.new(region: 'region') # Your AWS region # puts "Received event: #{JSON.dump(event)}" # Get the object from the event and show its content type bucket = event['Records'][0]['s3']['bucket']['name'] key = URI.decode_www_form_component(event['Records'][0]['s3']['object']['key'], Encoding::UTF_8) begin response = s3.get_object(bucket: bucket, key: key) puts "CONTENT TYPE: #{response.content_type}" return response.content_type rescue StandardError => e puts e.message puts "Error getting object #{key} from bucket #{bucket}. Make sure they exist and your bucket is in the same region as this function." raise e end end
    Rust
    SDK para Rust
    nota

    Hay más información en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de ejemplos sin servidor.

    Uso de un evento de S3 con Lambda mediante Rust.

    // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. // SPDX-License-Identifier: Apache-2.0 use aws_lambda_events::event::s3::S3Event; use aws_sdk_s3::{Client}; use lambda_runtime::{run, service_fn, Error, LambdaEvent}; /// Main function #[tokio::main] async fn main() -> Result<(), Error> { tracing_subscriber::fmt() .with_max_level(tracing::Level::INFO) .with_target(false) .without_time() .init(); // Initialize the AWS SDK for Rust let config = aws_config::load_from_env().await; let s3_client = Client::new(&config); let res = run(service_fn(|request: LambdaEvent<S3Event>| { function_handler(&s3_client, request) })).await; res } async fn function_handler( s3_client: &Client, evt: LambdaEvent<S3Event> ) -> Result<(), Error> { tracing::info!(records = ?evt.payload.records.len(), "Received request from SQS"); if evt.payload.records.len() == 0 { tracing::info!("Empty S3 event received"); } let bucket = evt.payload.records[0].s3.bucket.name.as_ref().expect("Bucket name to exist"); let key = evt.payload.records[0].s3.object.key.as_ref().expect("Object key to exist"); tracing::info!("Request is for {} and object {}", bucket, key); let s3_get_object_result = s3_client .get_object() .bucket(bucket) .key(key) .send() .await; match s3_get_object_result { Ok(_) => tracing::info!("S3 Get Object success, the s3GetObjectResult contains a 'body' property of type ByteStream"), Err(_) => tracing::info!("Failure with S3 Get Object request") } Ok(()) }
  2. En el panel Código fuente de la consola de Lambda, pegue el siguiente código en el archivo lambda_function.py.

    Editor de código de la consola de Lambda.
  3. Seleccione Implementar.

Cree un desencadenador de Amazon S3

Diagrama de flujo de trabajo del tutorial que muestra que se encuentra creando el desencadenador en el paso del desencadenador de S3
Para crear el desencadenador de Amazon S3
  1. En el panel Información general de la función, elija Agregar desencadenador.

    Sección de descripción general de Función de la consola de Lambda.
  2. Seleccione S3.

  3. En Bucket, seleccione el bucket que creó anteriormente en el tutorial.

  4. En Tipos de eventos, asegúrese de seleccionar Todos los eventos de creación de objetos.

  5. En Invocación recursiva, marque la casilla de verificación para confirmar que no se recomienda utilizar el mismo bucket de Amazon S3 para la entrada y la salida.

  6. Elija Añadir.

Probar la función de Lambda con un evento de prueba

Diagrama de flujo de trabajo del tutorial que muestra que se encuentra realizando pruebas con un evento de prueba en el paso de pruebas
Para probar la función de Lambda con un evento de prueba
  1. En la página de la consola de Lambda para la función, seleccione la pestaña Prueba.

    Pestaña Prueba de la consola de Lambda.
  2. En Nombre del evento, escriba MyTestEvent.

  3. En el Evento JSON, pegue el siguiente evento de prueba. Asegúrese de reemplazar los siguientes valores:

    • Reemplace us-east-1 por la región en la que creó el bucket de Amazon S3.

    • Reemplace ambas instancias de my-bucket por el nombre de su bucket de Amazon S3.

    • Reemplace test%2FKey por el nombre del objeto de prueba que cargó anteriormente al bucket (por ejemplo, HappyFace.jpg).

    { "Records": [ { "eventVersion": "2.0", "eventSource": "aws:s3", "awsRegion": "us-east-1", "eventTime": "1970-01-01T00:00:00.000Z", "eventName": "ObjectCreated:Put", "userIdentity": { "principalId": "EXAMPLE" }, "requestParameters": { "sourceIPAddress": "127.0.0.1" }, "responseElements": { "x-amz-request-id": "EXAMPLE123456789", "x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH" }, "s3": { "s3SchemaVersion": "1.0", "configurationId": "testConfigRule", "bucket": { "name": "my-bucket", "ownerIdentity": { "principalId": "EXAMPLE" }, "arn": "arn:aws:s3:::my-bucket" }, "object": { "key": "test%2Fkey", "size": 1024, "eTag": "0123456789abcdef0123456789abcdef", "sequencer": "0A1B2C3D4E5F678901" } } } ] }
  4. Elija Guardar.

  5. Seleccione Test (Probar).

  6. Si la función se ejecuta correctamente, verá un resultado similar al siguiente en la pestaña Resultados de ejecución.

    Response "image/jpeg" Function Logs START RequestId: 12b3cae7-5f4e-415e-93e6-416b8f8b66e6 Version: $LATEST 2021-02-18T21:40:59.280Z 12b3cae7-5f4e-415e-93e6-416b8f8b66e6 INFO INPUT BUCKET AND KEY: { Bucket: 'my-bucket', Key: 'HappyFace.jpg' } 2021-02-18T21:41:00.215Z 12b3cae7-5f4e-415e-93e6-416b8f8b66e6 INFO CONTENT TYPE: image/jpeg END RequestId: 12b3cae7-5f4e-415e-93e6-416b8f8b66e6 REPORT RequestId: 12b3cae7-5f4e-415e-93e6-416b8f8b66e6 Duration: 976.25 ms Billed Duration: 977 ms Memory Size: 128 MB Max Memory Used: 90 MB Init Duration: 430.47 ms Request ID 12b3cae7-5f4e-415e-93e6-416b8f8b66e6

Probar la función de Lambda con el desencadenador de Amazon S3

Diagrama de flujo de trabajo del tutorial que muestra que se encuentra utilizando el desencadenador de S3 en el paso de pruebas

Para probar la función con el desencadenador configurado, se carga un objeto al bucket de Amazon S3 mediante la consola. Para comprobar que la función de Lambda se ha ejecutado correctamente, utilice Registros de CloudWatch para ver la salida de la función.

Para cargar un objeto en un bucket de Amazon S3
  1. Abra la página Buckets de la consola de Amazon S3 y elija el nombre del bucket que creó anteriormente.

  2. Seleccione Cargar.

  3. Elija Agregar archivos y utilice el selector de archivos para elegir el objeto que desee cargar. Este objeto puede ser cualquier archivo que elija.

  4. Elija Abrir y, a continuación, Cargar.

Para comprobar la invocación de la función mediante los registros de CloudWatch
  1. Abra la consola de CloudWatch.

  2. Asegúrese de trabajar en la misma Región de AWS en la que creó la función de Lambda. Puede cambiar la región mediante la lista desplegable de la parte superior de la pantalla.

    Imagen que muestra el menú desplegable de regiones en la consola de Lambda
  3. Elija Registros y, a continuación, Grupos de registro.

  4. Elija el grupo de registro para la función (/aws/lambda/s3-trigger-tutorial).

  5. En Flujos de registro, elija el flujo de registro más reciente.

  6. Si su función se ha invocado correctamente en respuesta a su desencadenador de Amazon S3, verá un resultado similar al siguiente. El CONTENT TYPE que vea depende del tipo de archivo que haya subido a su bucket.

    2022-05-09T23:17:28.702Z 0cae7f5a-b0af-4c73-8563-a3430333cc10 INFO CONTENT TYPE: image/jpeg

Eliminación de sus recursos

A menos que desee conservar los recursos que creó para este tutorial, puede eliminarlos ahora. Si elimina los recursos de AWS que ya no utiliza, evitará gastos innecesarios en su Cuenta de AWS.

Cómo eliminar la función de Lambda
  1. Abra la página de Funciones en la consola de Lambda.

  2. Seleccione la función que ha creado.

  3. Elija Acciones, Eliminar.

  4. Escriba delete en el campo de entrada de texto y elija Delete(Eliminar).

Cómo eliminar el rol de ejecución
  1. Abra la página Roles en la consola de IAM.

  2. Seleccione el rol de ejecución que creó.

  3. Elija Eliminar.

  4. Si desea continuar, escriba el nombre del rol en el campo de entrada de texto y elija Delete (Eliminar).

Para eliminar el bucket de S3
  1. Abra la consola de Amazon S3.

  2. Seleccione el bucket que ha creado.

  3. Elija Eliminar.

  4. Introduzca el nombre del bucket en el campo de entrada de texto.

  5. Elija Delete bucket (Eliminar bucket).

Siguientes pasos

En Tutorial: Uso de un desencadenador de Amazon S3 para crear imágenes en miniatura, el desencadenador de Amazon S3 invoca una función que crea una imagen en miniatura para cada archivo de imagen que se carga en el bucket. Este tutorial requiere un nivel moderado de conocimiento del dominio de AWS y Lambda. Demuestra cómo crear recursos usando la AWS Command Line Interface (AWS CLI) y cómo crear un paquete de implementación de archivo .zip para la función y sus dependencias.