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

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

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 añada un objeto a su bucket de Amazon S3, su función se ejecuta y envía el tipo de objeto a Amazon CloudWatch Logs.


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

Puede utilizar una función de Lambda con un desencadenador de Amazon S3 para realizar varios tipos de tareas de procesamiento de archivos. Por ejemplo, puede utilizar una función de Lambda para crear una miniatura cada vez que se cargue un archivo de imagen en su bucket de Amazon S3 o para convertir los documentos cargados a diferentes formatos. Tras completar este tutorial, puede probar el tutorial Uso de un desencadenador de Amazon S3 para crear imágenes en miniatura a fin de realizar una tarea de procesamiento de imágenes.

Para completar este tutorial, lleve a cabo los siguientes pasos:

  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.

Cómo registrarse para 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 registrarse en 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 realizar tareas que requieran acceso de usuario raíz.

AWS le enviará un correo electrónico de confirmación después de completar 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 su Usuario raíz de la cuenta de AWS
  1. Inicie sesión en AWS Management Console como propietario de 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 obtener instrucciones, consulte Habilitar un dispositivo MFA virtual para el usuario raíz Cuenta de AWS (consola) en la Guía del usuario de IAM.

Creación de un usuario administrativo
  1. Activar IAM Identity Center

    Para conocer las instrucciones, consulte Habilitar AWS IAM Identity Center en la Guía del usuario de AWS IAM Identity Center.

  2. En IAM Identity Center, otorga acceso administrativo a un usuario administrativo.

    Para ver un tutorial sobre el uso de Directorio de IAM Identity Center como origen de identidad, consulte Configurar el acceso de los usuarios con la configuración predeterminada de Directorio de IAM Identity Center en la Guía del usuario de AWS IAM Identity Center.

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

    Para obtener ayuda para iniciar sesión con un usuario del IAM Identity Center, 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

Primero, cree un bucket de Amazon S3 mediante la AWS Management Console.

Para crear 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

Más adelante en el tutorial, probará la función de Lambda en la consola de Lambda. Para confirmar que el código de la función funciona correctamente, el bucket de Amazon S3 debe contener un objeto de prueba. Este objeto puede ser cualquier archivo que elija (por ejemplo, HappyFace.jpg).

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 archivos y utilice el selector de archivos para elegir el objeto que desea cargar.

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

Cuando pruebe el código de la función más adelante en el tutorial, le pasará los datos que contienen el nombre de archivo del objeto que ha cargado, así que anótelo ahora.

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

Antes de poder crear un rol de ejecución para la función de Lambda, primero debe crear una política de permisos que permita a la función acceder a los recursos de AWS necesarios. En este tutorial, la política permite a Lambda obtener objetos de un bucket de Amazon S3 y escribirlos en Amazon CloudWatch Logs.

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. Para permitir que la función obtenga objetos de un bucket de Amazon S3, debe adjuntar 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. Elija Crear rol.

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

  4. Seleccione 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

En este ejemplo, creará una función de Lambda en la consola con el tiempo de ejecución de Node.js 16.x. La función que crea en la consola contiene el código básico “Hola, mundo”. En el siguiente paso, lo reemplazará con el código de la función para obtener un objeto de su bucket de Amazon S3.

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, elija Node.js 16.x.

    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

La función de Lambda recuperará el nombre de la 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 la llamada a la API HeadObject en AWS SDK for JavaScript para obtener el tipo de objeto del objeto cargado.

En este tutorial, se utiliza el tiempo de ejecución de Node.js 16.x, pero también hemos proporcionado 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. El JavaScript código que implementará es el primer ejemplo que se muestra en la pestaña denominada JavaScript.

.NET
AWS SDK for .NET
nota

Hay más información 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 .NET.

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 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 Go.

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 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 Java.

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 (v2)
nota

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

Consumir un evento de S3 con Lambda mediante. JavaScript

const aws = require('aws-sdk'); const s3 = new aws.S3({ apiVersion: '2006-03-01' }); 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, ' ')); const params = { Bucket: bucket, Key: key, }; try { const { ContentType } = await s3.headObject(params).promise(); 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); } };

Consumir un evento de S3 con Lambda mediante. TypeScript

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); } };
Python
SDK para Python (Boto3)
nota

Hay más información al respecto. 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 Python.

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
Rust
SDK para Rust
nota

Hay más información 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.

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(()) }
Para implementar el código de la función
  1. Abra la página de Funciones en la consola de Lambda.

  2. Seleccione la función que creó en el paso anterior (s3-trigger-tutorial).

  3. Elija la pestaña Código.

  4. Copia y pega el JavaScript código proporcionado en la pestaña index.js del panel Código fuente.

  5. Elija 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

Ahora que ha implementado el código de la función, debe crear el desencadenador de Amazon S3 que invocará la función.

Para crear el desencadenador de Amazon S3
  1. En el panel Descripción general de la función de la página de la consola de la función, seleccione Agregar desencadenador.

  2. Seleccione S3.

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

  4. En Tipos de eventos, seleccione Todos los eventos de creación de objetos. También puede configurar un desencadenador para invocar a Lambda cuando se elimina un objeto, pero no utilizaremos esa opción en este tutorial.

  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. Puede obtener más información sobre los patrones de invocación recursiva en Lambda en Patrones recursivos que provocan funciones de Lambda descontroladas en Serverless Land.

  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

Ahora que ha creado y configurado la función de Lambda, está todo listo para probarla. Primero debe probar la función enviándole un evento de prueba de Amazon S3 para confirmar que funciona correctamente.

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 Código.

  2. En el panel Código fuente, elija Probar.

  3. En el cuadro Configurar evento de prueba, haga lo siguiente:

    1. En Nombre del evento, escriba MyTestEvent.

    2. En Plantilla, elija S3 Put.

    3. En el JSON del evento, sustituya los valores siguientes:

      • 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. Seleccione Guardar.

  4. En el panel Código fuente, elija Probar.

  5. 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 Lambda se ha invocado correctamente, utilice CloudWatch Logs para ver el resultado 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 fuente 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 verificar el correcto funcionamiento mediante Logs 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

Pruebe con el tutorial más avanzado. En este tutorial, el desencadenador de Amazon S3 invoca una función a fin de crear 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. Utilice AWS Command Line Interface (AWS CLI) para crear recursos y cree un paquete de despliegue de archivo de archivos .zip para la función y sus dependencias.