# Tutorial: Uso de un desencadenador de Amazon S3 para invocar una función de Lambda
<a name="with-s3-example"></a>

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.

![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-s3-example/s3_tut_config.png)


En este tutorial se muestra cómo:

1. Cree un bucket de Amazon S3.

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

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

1. 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 Consola de administración de AWS.

## Crear un bucket de Amazon S3
<a name="with-s3-example-create-bucket"></a>

![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps1.png)


**Creación de un bucket de Amazon S3**

1. Abra la [consola de Amazon S3](https://console.aws.amazon.com/s3) y seleccione la página **Buckets de uso general**.

1. Seleccione la Región de AWS más cercana a su ubicación geográfica. Puede cambiar la región por medio de la lista desplegable de la parte superior de la pantalla. Más adelante en el tutorial, debe crear la función de Lambda en la misma región.  
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/console_region_select.png)

1. Elija **Crear bucket**.

1. En **Configuración general**, haga lo siguiente:

   1. En **Tipo de bucket**, asegúrese de que **Uso general** está seleccionado.

   1. Para el **nombre del bucket**, ingrese un nombre único a nivel mundial que cumpla las [reglas de nomenclatura de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html) de Amazon S3. Los nombres de bucket pueden contener únicamente letras minúsculas, números, puntos (.) y guiones (-).

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

## Cargar un objeto de prueba en un bucket
<a name="with-s3-example-upload-test-object"></a>

![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps2.png)


**Para cargar un objeto de prueba**

1. Abra la página [Buckets](https://console.aws.amazon.com/s3/buckets) de la consola de Amazon S3 y elija el bucket que creó durante el paso anterior.

1. Seleccione **Cargar**.

1. Elija **Agregar archivos** y seleccione el objeto que desea cargar. Puede seleccionar cualquier archivo (por ejemplo, `HappyFace.jpg`).

1. Elija **Abrir** y, a continuación, **Cargar**.

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

## Creación de una política de permisos
<a name="with-s3-example-create-policy"></a>

![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps3.png)


Cree una política de permisos que le 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)](https://console.aws.amazon.com/iam/home#/policies) de la consola de IAM.

1. Seleccione **Crear política**.

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

------
#### [ 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:::*/*"
           }
       ]
   }
   ```

------

1. Elija **Siguiente: Etiquetas**.

1. Elija **Siguiente: Revisar**.

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

1. Elija **Crear política**.

## Creación de un rol de ejecución
<a name="with-s3-example-create-role"></a>

![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps4.png)


Un [rol de ejecución](lambda-intro-execution-role.md) es un rol de AWS Identity and Access Management (IAM) que concede a la función de Lambda permiso para acceder a recursos y Servicios 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](https://console.aws.amazon.com/iam/home#/roles) en la consola de IAM.

1. Elija **Create role** (Crear rol).

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

1. Elija **Siguiente**.

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

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

1. 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
<a name="with-s3-example-create-function"></a>

![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps5.png)


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

**Para crear la función de Lambda**

1. Abra la [página de Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.

1. 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.  
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/console_region_select.png)

1. Seleccione **Creación de función**.

1. Elija **Crear desde cero**.

1. Bajo **Información básica**, haga lo siguiente:

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

   1. En **Tiempo de ejecución**, seleccione **Python 3.14**.

   1. En **Arquitectura**, elija **x86\$164**.

1. 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**.

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

1. Seleccione **Creación de función**.

## Implementar el código de la función
<a name="with-s3-example-deploy-code"></a>

![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps6.png)


En este tutorial, se utiliza el tiempo de ejecución de Python 3.14, 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\$1object](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/s3/client/get_object.html) de AWS SDK para 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 ]

**SDK para .NET**  
 Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda). 
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**  
 Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda). 
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**  
 Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda). 
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)**  
 Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda). 
Uso de un evento de S3 con Lambda mediante JavaScript.  

   ```
   import { S3Client, HeadObjectCommand } from "@aws-sdk/client-s3";
   
   const client = new S3Client();
   
   export const 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**  
 Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos de tecnología sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda). 
Consumo de un evento de S3 con Lambda mediante PHP.  

   ```
   <?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)**  
 Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda). 
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**  
 Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos de tecnología sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda). 
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**  
 Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda). 
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(())
   }
   ```

------

1. En el panel **Código fuente** de la consola de Lambda, pegue el siguiente código en el editor de código y sustituya el código creado por Lambda.

1. En la sección **IMPLEMENTAR** elija **Implementar** para actualizar el código de la función:  
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)

## Cree un desencadenador de Amazon S3
<a name="with-s3-example-create-trigger"></a>

![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps7.png)


**Para crear el desencadenador de Amazon S3**

1. En el panel **Información general de la función**, elija **Agregar desencadenador**.  
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/overview-trigger.png)

1. Seleccione **S3**.

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

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

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

1. Elija **Agregar**.

**nota**  
Cuando crea un desencadenador de Amazon S3 para una función de Lambda mediante la consola de Lambda, Amazon S3 configura una [notificación de eventos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html) en el bucket que especifique. Antes de configurar esta notificación de evento, Amazon S3 realiza una serie de comprobaciones para confirmar que el destino del evento existe y tiene las políticas de IAM requeridas. Amazon S3 también realiza estas pruebas en cualquier otra notificación de eventos configurada para ese bucket.  
Gracias a esta comprobación, si el bucket ha configurado previamente destinos de eventos para recursos que ya no existen o para recursos que no tienen las políticas de permisos requeridas, Amazon S3 no podrá crear la nueva notificación de evento. Verá el siguiente mensaje de error que indica que no se ha podido crear el desencadenador:  

```
An error occurred when creating the trigger: Unable to validate the following destination configurations.
```
Puede ver este error si anteriormente configuró un desencadenador para otra función de Lambda con el mismo bucket y, desde entonces, ha eliminado la función o modificado sus políticas de permisos.

## Probar la función de Lambda con un evento de prueba
<a name="with-s3-example-test-dummy-event"></a>

![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps8.png)


**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**.  
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/test-tab.png)

1. En **Nombre del evento**, escriba `MyTestEvent`.

1. 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 `amzn-s3-demo-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": "amzn-s3-demo-bucket",
             "ownerIdentity": {
               "principalId": "EXAMPLE"
             },
             "arn": "arn:aws:s3:::amzn-s3-demo-bucket"
           },
           "object": {
             "key": "test%2Fkey",
             "size": 1024,
             "eTag": "0123456789abcdef0123456789abcdef",
             "sequencer": "0A1B2C3D4E5F678901"
           }
         }
       }
     ]
   }
   ```

1. Seleccione **Save**.

1. Seleccione **Probar**

1. 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: 'amzn-s3-demo-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
<a name="with-s3-example-test-s3-trigger"></a>

![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps9.png)


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](https://console.aws.amazon.com/s3/buckets) de la consola de Amazon S3 y elija el nombre del bucket que creó anteriormente.

1. Seleccione **Cargar**.

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

1. Elija **Abrir** y, a continuación, **Cargar**.

**Comprobación de la invocación de la función mediante Registros de CloudWatch**

1. [Abra la consola de CloudWatch](https://console.aws.amazon.com/cloudwatch/home).

1. 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.  
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/console_region_select.png)

1. Elija **Registros** y, a continuación, **Grupos de registro**.

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

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

1. 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 name="cleanup"></a>

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](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.

1. Seleccione la función que ha creado.

1. Elija **Acciones**, **Eliminar**.

1. Escriba **confirm** 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](https://console.aws.amazon.com/iam/home#/roles) en la consola de IAM.

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

1. Elija **Eliminar**.

1. 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](https://console.aws.amazon.com//s3/home#).

1. Seleccione el bucket que ha creado.

1. Elija **Eliminar**.

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

1. Elija **Delete bucket (Eliminar bucket)**.

## Siguientes pasos
<a name="next-steps"></a>

En [Tutorial: Uso de un desencadenador de Amazon S3 para crear imágenes en miniatura](with-s3-tutorial.md), 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.