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.

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

Registro en una Cuenta de AWS

Si no dispone de una Cuenta de AWS, siga los pasos que figuran a continuación para crear una.

Para registrarse en Cuenta de AWS

1. Abra https://portal.aws.amazon.com/billing/signup.

2. Siga las instrucciones en línea.

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

   Al registrase en una Cuenta de AWS, se crea un Usuario raíz de la cuenta de AWS. El usuario raíz tiene acceso a todos los recursos y Servicios de AWS 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 la ejecución tareas que requieren acceso de usuario raíz.

AWS le enviará un email de confirmación luego 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 My Account (Mi cuenta).

Crear un usuario administrativo

Después de registrarse para obtener una Cuenta de AWS, cree un usuario administrativo para que no utilice el usuario raíz en las tareas cotidianas.

Proteger 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 ingrese el email 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 Signing in as the root user (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.

Crear un usuario administrativo

• Para las tareas administrativas diarias, conceda acceso administrativo a un usuario administrativo en AWS IAM Identity Center (successor to AWS Single Sign-On).

  Para obtener instrucciones, consulte Introducción en la Guía del usuario de AWS IAM Identity Center (successor to AWS Single Sign-On).

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 Centro de identidades de IAM.

  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

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

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 Upload (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

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. Para este tutorial, la política le permite a Lambda obtener objetos de un bucket de Amazon S3 y escribir en 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. Elija Create Policy (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 Next: Tags (Siguiente: etiquetas).

5. Elija Next: Review (Siguiente: revisar).

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

7. Elija Create Policy (Crear política).

Creación de un rol de ejecución

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 Create role (Crear rol).

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

4. Elija Next (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

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 Functions (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.

   

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 Architecture (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

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 código JavaScript que implementará es el primer ejemplo que se muestra en la pestaña denominada JavaScript.

.NET

AWS SDK for .NET

nota

Hay más en GitHub. Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el repositorio de fragmentos 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 en GitHub. Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el repositorio de fragmentos sin servidor.

Uso 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 en GitHub. Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el repositorio de fragmentos sin servidor.

Uso 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 en GitHub. Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el repositorio de fragmentos sin servidor.

Uso de 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);
    }
};

Uso de 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 en GitHub. Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el repositorio de fragmentos sin servidor.

Uso 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

Esta documentación es para un SDK en versión preliminar. El SDK está sujeto a cambios y no se debe utilizar en producción.

nota

Hay más en GitHub. Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el repositorio de fragmentos 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 Functions (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. Copie y pegue el código JavaScript proporcionado en la pestaña index.js del panel Código fuente.

5. Elija Deploy (Implementar).

Cree un desencadenador de Amazon 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 Recursive patterns that cause run-away Lambda functions en Serverless Land.

6. Elija Add (Agregar).

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

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 Event name (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 example-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": "example-bucket",
                "ownerIdentity": {
                  "principalId": "EXAMPLE"
                },
                "arn": "arn:aws:s3:::example-bucket"
              },
              "object": {
                "key": "test%2Fkey",
                "size": 1024,
                "eTag": "0123456789abcdef0123456789abcdef",
                "sequencer": "0A1B2C3D4E5F678901"
              }
            }
          }
        ]
      }

   4. Elija 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-s3-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

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 invocado 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 fuente que creó anteriormente.

2. Seleccione Upload (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 funcionamiento correcto mediante 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.

   

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
   

Limpiar los recursos de

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.

Para eliminar la función de Lambda

1. Abra la página Funciones de la consola de Lambda.

2. Seleccione la función que ha creado.

3. Elija Actions (Acciones), Delete (Eliminar).

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

Para 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 (Delete).

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 (Delete).

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

5. Elija Delete bucket (Eliminar bucket).

Pasos siguientes

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.