# Procese las notificaciones de eventos de Amazon S3 con Lambda.
Puede usar Lambda para procesar [notificaciones de eventos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/NotificationHowTo.html) de Amazon Simple Storage Service. Amazon S3 puede enviar un evento a una función de Lambda cuando se crea o elimina un objeto. Puede configurar las opciones de notificación en un bucket y conceder a Amazon S3 permiso para invocar una función en la política de permisos basada en recursos de la función.
**aviso**
Si la función de Lambda utiliza el mismo bucket que el que la desencadena, podría ocurrir que la ejecución de la función entrara en un bucle. Por ejemplo, si el bucket activa una función cada vez que se carga un objeto y la función carga un objeto en el bucket, la función se activa indirectamente a sí misma. Para evitarlo, utilice dos buckets o configure el desencadenador para que solo se aplique a un prefijo que se utiliza para los objetos entrantes.
Amazon S3 invoca la función de [forma asíncrona](invocation-async.md) con un evento que contiene detalles sobre el objeto. En el siguiente ejemplo se muestra un evento que envió Amazon S3 cuando se cargó un paquete de implementación en Amazon S3.
**Example Evento de notificaciones de Amazon S3**
```
{
"Records": [
{
"eventVersion": "2.1",
"eventSource": "aws:s3",
"awsRegion": "us-east-2",
"eventTime": "2019-09-03T19:37:27.192Z",
"eventName": "ObjectCreated:Put",
"userIdentity": {
"principalId": "AWS:AIDAINPONIXQXHT3IKHL2"
},
"requestParameters": {
"sourceIPAddress": "205.255.255.255"
},
"responseElements": {
"x-amz-request-id": "D82B88E5F771F645",
"x-amz-id-2": "vlR7PnpV2Ce81l0PRw6jlUpck7Jo5ZsQjryTjKlc5aLWGVHPZLj5NeC6qMa0emYBDXOo6QBU0Wo="
},
"s3": {
"s3SchemaVersion": "1.0",
"configurationId": "828aa6fc-f7b5-4305-8584-487c791949c1",
"bucket": {
"name": "amzn-s3-demo-bucket",
"ownerIdentity": {
"principalId": "A3I5XTEXAMAI3E"
},
"arn": "arn:aws:s3:::lambda-artifacts-deafc19498e3f2df"
},
"object": {
"key": "b21b84d653bb07b05b1e6b33684dc11b",
"size": 1305107,
"eTag": "b21b84d653bb07b05b1e6b33684dc11b",
"sequencer": "0C0F6F405D6ED209E1"
}
}
}
]
}
```
Para invocar la función, Amazon S3 necesita permiso de la [política basada en recursos](access-control-resource-based.md) de la función. Al configurar un desencadenador de Amazon S3 en la consola de Lambda, esta modifica la política basada en recursos para permitir a Amazon S3 invocar la función si el nombre del bucket y el ID de cuenta coinciden. Si configura la notificación en Amazon S3, utilice la API de Lambda para actualizar la política. También puede utilizar la API de Lambda para conceder permisos a otra cuenta o restringir el permiso a un alias designado.
Si la función utiliza el SDK de AWS para administrar los recursos de Amazon S3, también necesita permisos de Amazon S3 en su [rol de ejecución](lambda-intro-execution-role.md).
**Topics**
+ [
# Tutorial: Uso de un desencadenador de Amazon S3 para invocar una función de Lambda
](with-s3-example.md)
+ [
# Tutorial: Uso de un desencadenador de Amazon S3 para crear imágenes en miniatura
](with-s3-tutorial.md)
# 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.
![\[\]](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
![\[\]](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
![\[\]](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
![\[\]](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
![\[\]](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
![\[\]](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
![\[\]](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 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 {
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 => {
// 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.
```
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| {
function_handler(&s3_client, request)
})).await;
res
}
async fn function_handler(
s3_client: &Client,
evt: LambdaEvent
) -> 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
![\[\]](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
![\[\]](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
![\[\]](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 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
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.
# Tutorial: Uso de un desencadenador de Amazon S3 para crear imágenes en miniatura
En este tutorial, se crea y configura una función de Lambda para cambiar el tamaño de las imágenes agregadas a un bucket de Amazon Simple Storage Service (Amazon S3). Al agregar un archivo de imagen al bucket, Amazon S3 invoca la función de Lambda. A continuación, la función crea una versión en miniatura de la imagen y la envía a otro bucket de Amazon S3.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_resources.png)
Para completar este tutorial, lleve a cabo los siguientes pasos:
1. Cree buckets de origen y destino de Amazon S3 y cargue una imagen de muestra.
1. Cree una función de Lambda que cambie el tamaño de una imagen y genere una miniatura en un bucket de Amazon S3.
1. Configure un desencadenador de Lambda que invoque la función cuando se carguen objetos en el bucket de origen.
1. Pruebe la función, primero con un evento ficticio y, a continuación, cargando una imagen al bucket de origen.
Al completar estos pasos, aprenderá a utilizar Lambda para llevar a cabo una tarea de procesamiento de archivos en objetos agregados a un bucket de Amazon S3. Puede completar esta tarea mediante la AWS Command Line Interface (AWS CLI) o la Consola de administración de AWS.
Si busca un ejemplo más sencillo para aprender a configurar un desencadenador de Amazon S3 para Lambda, puede probar el [Tutorial: Uso de un desencadenador de Amazon S3 para invocar una función de Lambda](https://docs.aws.amazon.com/lambda/latest/dg/with-s3-example.html).
**Topics**
+ [
## Requisitos previos
](#with-s3-example-prereqs)
+ [
## Crear dos buckets de Amazon S3
](#with-s3-tutorial-prepare-create-buckets)
+ [
## Cargar una imagen de prueba al bucket de origen
](#with-s3-tutorial-test-image)
+ [
## Creación de una política de permisos
](#with-s3-tutorial-create-policy)
+ [
## Creación de un rol de ejecución
](#with-s3-tutorial-create-execution-role)
+ [
## Crear el paquete de despliegue de la función
](#with-s3-tutorial-create-function-package)
+ [
## Crear la función de Lambda
](#with-s3-tutorial-create-function-createfunction)
+ [
## Configurar Amazon S3 para invocar una función
](#with-s3-tutorial-configure-s3-trigger)
+ [
## Probar la función de Lambda con un evento de prueba
](#with-s3-tutorial-dummy-test)
+ [
## Probar la función con el desencadenador de Amazon S3
](#with-s3-tutorial-test-s3)
+ [
## Eliminación de sus recursos
](#s3-tutorial-cleanup)
## Requisitos previos
Si desea utilizar la AWS CLI para completar el tutorial, instale la [versión más reciente de la AWS Command Line Interface]().
Para el código de la función de Lambda, puede utilizar Python o Node.js. Instale las herramientas de soporte de lenguajes y un administrador de paquetes para el lenguaje que desee utilizar.
### Instala la AWS Command Line Interface
Si aún no ha instalado AWS Command Line Interface, siga los pasos que se indican en [Instalación o actualización de la versión más reciente de AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) para instalarlo.
El tutorial requiere un intérprete de comandos o un terminal de línea de comando para ejecutar los comandos. En Linux y macOS, use su administrador de intérprete de comandos y paquetes preferido.
**nota**
En Windows, algunos comandos de la CLI de Bash que se utilizan habitualmente con Lambda (por ejemplo, `zip`) no son compatibles con los terminales integrados del sistema operativo. Para obtener una versión de Ubuntu y Bash integrada con Windows, [instale el subsistema de Windows para Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10).
## Crear dos buckets de Amazon S3
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps1.png)
Primero, cree dos buckets de Amazon S3. El primer bucket es el bucket de origen al que subirá las imágenes. Lambda utiliza el segundo bucket para guardar las miniaturas redimensionadas cuando se invoca la función.
------
#### [ Consola de administración de AWS ]
**Para crear buckets de Amazon S3 (consola)**
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**.
1. Repita los pasos 1 a 5 para crear el bucket de destino. En **Nombre del bucket**, introduzca `amzn-s3-demo-source-bucket-resized`, donde `amzn-s3-demo-source-bucket` es el nombre del bucket de origen que acaba de crear.
------
#### [ AWS CLI ]
**Para crear buckets de Amazon S3 (AWS CLI)**
1. Ejecute el siguiente comando de la CLI para crear el bucket de origen. El nombre que elija para el bucket debe ser globalmente único y seguir las [reglas de nomenclatura de buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html) de Amazon S3. Los nombres pueden contener únicamente letras minúsculas, números, puntos (.) y guiones (-). Para `region` y `LocationConstraint`, elija la [Región de AWS](https://docs.aws.amazon.com/general/latest/gr/lambda-service.html) más cercana a su ubicación geográfica.
```
aws s3api create-bucket --bucket amzn-s3-demo-source-bucket --region us-east-1 \
--create-bucket-configuration LocationConstraint=us-east-1
```
Más adelante en el tutorial, debe crear la función de Lambda en la misma Región de AWS que la del bucket de origen, por lo que debe anotar la región que eligió.
1. Ejecute el siguiente comando para crear el bucket de destino. Para el nombre del bucket, debe utilizar `amzn-s3-demo-source-bucket-resized`, donde `amzn-s3-demo-source-bucket` es el nombre del bucket de origen que creó en el paso 1. Para `region` y `LocationConstraint`, elija la misma Región de AWS que usó para crear el bucket de origen.
```
aws s3api create-bucket --bucket amzn-s3-demo-source-bucket-resized --region us-east-1 \
--create-bucket-configuration LocationConstraint=us-east-1
```
------
## Cargar una imagen de prueba al bucket de origen
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps2.png)
Más adelante en el tutorial, probará la función de Lambda al invocarla mediante la AWS CLI o la consola de Lambda. Para confirmar que la función se ejecuta correctamente, el bucket de origen debe contener una imagen de prueba. Esta imagen puede ser cualquier archivo JPG o PNG que elija.
------
#### [ Consola de administración de AWS ]
**Para cargar una imagen de prueba al bucket de origen (consola)**
1. En la consola de Amazon S3, abra la página [Buckets](https://console.aws.amazon.com/s3/buckets).
1. Seleccione el bucket de origen que creó en el paso anterior.
1. Seleccione **Cargar**.
1. Elija **Agregar archivos** y utilice el selector de archivos para elegir el objeto que desea cargar.
1. Elija **Abrir** y, a continuación, **Cargar**.
------
#### [ AWS CLI ]
**Para cargar una imagen de prueba al bucket de origen (AWS CLI)**
+ Desde el directorio que contiene la imagen que desea cargar, ejecute el siguiente comando de la CLI. Reemplace el parámetro `--bucket` con el nombre del bucket de origen. Para los parámetros `--key` y `--body`, utilice el nombre de archivo de la imagen de prueba.
```
aws s3api put-object --bucket amzn-s3-demo-source-bucket --key HappyFace.jpg --body ./HappyFace.jpg
```
------
## Creación de una política de permisos
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps3.png)
El primer paso para crear la función de Lambda es crear una política de permisos. Esta política concede a la función los permisos que necesita para acceder a otros recursos de AWS. En este tutorial, la política concede permisos de lectura y escritura a Lambda para los buckets de Amazon S3 y permite que escriba en los Registros de Amazon CloudWatch.
------
#### [ Consola de administración de AWS ]
**Para crear la política (consola)**
1. Abra la página de [Policies (Políticas)](https://console.aws.amazon.com/iamv2/home#policies) de la consola AWS Identity and Access Management (IAM).
1. Elija **Crear política**.
1. 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:::*/*"
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": "arn:aws:s3:::*/*"
}
]
}
```
1. Elija **Siguiente**.
1. En **Detalles de política**, para el **Nombre de la política**, ingrese `LambdaS3Policy`.
1. Elija **Crear política**.
------
#### [ AWS CLI ]
**Para crear la política (AWS CLI)**
1. Guarde el siguiente JSON en un archivo llamado `policy.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:::*/*"
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": "arn:aws:s3:::*/*"
}
]
}
```
1. Desde el directorio en el que guardó el documento de política JSON, ejecute el siguiente comando de la CLI.
```
aws iam create-policy --policy-name LambdaS3Policy --policy-document file://policy.json
```
------
## Creación de un rol de ejecución
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps4.png)
Un rol de ejecución es un rol de IAM que concede a la función de Lambda permiso para acceder a servicios y recursos de Servicios de AWS. Para conceder a la función acceso de lectura y escritura a un bucket de Amazon S3, debe adjuntar la política de permisos que creó en el paso anterior.
------
#### [ Consola de administración de AWS ]
**Para crear un rol de ejecución y adjuntar la política de permisos (consola)**
1. Abra la página [Roles](https://console.aws.amazon.com/iamv2/home#roles) en la consola (IAM).
1. Elija **Creación de rol**.
1. En **Tipo de entidad de confianza**, seleccione el **Servicio de AWS**; en **Caso de uso**, seleccione **Lambda**.
1. Elija **Siguiente**.
1. Agregue la política de permisos que creó en el paso anterior de la siguiente manera:
1. En el cuadro de búsqueda de políticas, escriba `LambdaS3Policy`.
1. En los resultados de búsqueda, seleccione la casilla de verificación para `LambdaS3Policy`.
1. Elija **Siguiente**.
1. En **Detalles del rol**, para el **Nombre del rol**, ingrese `LambdaS3Role`.
1. Elija **Creación de rol**.
------
#### [ AWS CLI ]
**Para crear un rol de ejecución y adjuntar la política de permisos (AWS CLI)**
1. Guarde el siguiente JSON en un archivo llamado `trust-policy.json`. Esta política de confianza permite a Lambda utilizar los permisos del rol al dar permiso al servicio principal `lambda.amazonaws.com` para llamar a la acción de AWS Security Token Service (AWS STS) `AssumeRole`.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. Desde el directorio en el que guardó el documento de política de confianza JSON, ejecute el siguiente comando de la CLI para crear el rol de ejecución.
```
aws iam create-role --role-name LambdaS3Role --assume-role-policy-document file://trust-policy.json
```
1. Para adjuntar la política de permisos que creó en el paso anterior, ejecute el siguiente comando de la CLI. Reemplace el número de Cuenta de AWS en el ARN de la política por su propio número de cuenta.
```
aws iam attach-role-policy --role-name LambdaS3Role --policy-arn arn:aws:iam::123456789012:policy/LambdaS3Policy
```
------
## Crear el paquete de despliegue de la función
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps5.png)
Para crear una función, debe crear un *paquete de despliegue* que contenga el código y las dependencias de la función. Para esta función `CreateThumbnail`, el código de la función utiliza una biblioteca independiente para cambiar el tamaño de la imagen. Siga las instrucciones del lenguaje elegido para crear un paquete de despliegue que contenga la biblioteca requerida.
------
#### [ Node.js ]
**Para crear el paquete de despliegue (Node.js)**
1. Cree un directorio llamado `lambda-s3` para el código y las dependencias de la función y desplácese hasta él.
```
mkdir lambda-s3
cd lambda-s3
```
1. Cree un nuevo proyecto de Node.js con `npm`. Para aceptar las opciones predeterminadas proporcionadas en la experiencia interactiva, oprima `Enter`.
```
npm init
```
1. Guarde el siguiente código de función en un archivo llamado `index.mjs`. Asegúrese de reemplazar `us-east-1` por la Región de AWS en la que creó sus propios buckets de origen y destino.
```
// dependencies
import { S3Client, GetObjectCommand, PutObjectCommand } from '@aws-sdk/client-s3';
import { Readable } from 'stream';
import sharp from 'sharp';
import util from 'util';
// create S3 client
const s3 = new S3Client({region: 'us-east-1'});
// define the handler function
export const handler = async (event, context) => {
// Read options from the event parameter and get the source bucket
console.log("Reading options from event:\n", util.inspect(event, {depth: 5}));
const srcBucket = event.Records[0].s3.bucket.name;
// Object key may have spaces or unicode non-ASCII characters
const srcKey = decodeURIComponent(event.Records[0].s3.object.key.replace(/\+/g, " "));
const dstBucket = srcBucket + "-resized";
const dstKey = "resized-" + srcKey;
// Infer the image type from the file suffix
const typeMatch = srcKey.match(/\.([^.]*)$/);
if (!typeMatch) {
console.log("Could not determine the image type.");
return;
}
// Check that the image type is supported
const imageType = typeMatch[1].toLowerCase();
if (imageType != "jpg" && imageType != "png") {
console.log(`Unsupported image type: ${imageType}`);
return;
}
// Get the image from the source bucket. GetObjectCommand returns a stream.
try {
const params = {
Bucket: srcBucket,
Key: srcKey
};
var response = await s3.send(new GetObjectCommand(params));
var stream = response.Body;
// Convert stream to buffer to pass to sharp resize function.
if (stream instanceof Readable) {
var content_buffer = Buffer.concat(await stream.toArray());
} else {
throw new Error('Unknown object stream type');
}
} catch (error) {
console.log(error);
return;
}
// set thumbnail width. Resize will set the height automatically to maintain aspect ratio.
const width = 200;
// Use the sharp module to resize the image and save in a buffer.
try {
var output_buffer = await sharp(content_buffer).resize(width).toBuffer();
} catch (error) {
console.log(error);
return;
}
// Upload the thumbnail image to the destination bucket
try {
const destparams = {
Bucket: dstBucket,
Key: dstKey,
Body: output_buffer,
ContentType: "image"
};
const putResult = await s3.send(new PutObjectCommand(destparams));
} catch (error) {
console.log(error);
return;
}
console.log('Successfully resized ' + srcBucket + '/' + srcKey +
' and uploaded to ' + dstBucket + '/' + dstKey);
};
```
1. En el directorio `lambda-s3`, instale la biblioteca sharp con npm. Tenga en cuenta que la última versión de sharp (0.33) no es compatible con Lambda. Instale la versión 0.32.6 para completar este tutorial.
```
npm install sharp@0.32.6
```
El comando npm `install` crea un directorio `node_modules` para los módulos. Después de este paso, la estructura de directorios debería tener el siguiente aspecto.
```
lambda-s3
|- index.mjs
|- node_modules
| |- base64js
| |- bl
| |- buffer
...
|- package-lock.json
|- package.json
```
1. Cree un paquete de despliegue .zip que contenga el código y las dependencias de la función. En Linux o macOS, ejecute el siguiente comando.
```
zip -r function.zip .
```
En Windows, utilice la utilidad de compresión que prefiera para crear un archivo .zip. Asegúrese de que los archivos `index.mjs`, `package.json`, `package-lock.json` y el directorio `node_modules` estén todos en la raíz del archivo .zip.
------
#### [ Python ]
**Para crear el paquete de despliegue (Python)**
1. Guarde el código de ejemplo como un archivo denominado `lambda_function.py`.
```
import boto3
import os
import sys
import uuid
from urllib.parse import unquote_plus
from PIL import Image
import PIL.Image
s3_client = boto3.client('s3')
def resize_image(image_path, resized_path):
with Image.open(image_path) as image:
image.thumbnail(tuple(x / 2 for x in image.size))
image.save(resized_path)
def lambda_handler(event, context):
for record in event['Records']:
bucket = record['s3']['bucket']['name']
key = unquote_plus(record['s3']['object']['key'])
tmpkey = key.replace('/', '')
download_path = '/tmp/{}{}'.format(uuid.uuid4(), tmpkey)
upload_path = '/tmp/resized-{}'.format(tmpkey)
s3_client.download_file(bucket, key, download_path)
resize_image(download_path, upload_path)
s3_client.upload_file(upload_path, '{}-resized'.format(bucket), 'resized-{}'.format(key))
```
1. En el mismo directorio en el que creó el archivo `lambda_function.py`, cree un nuevo directorio llamado `package` e instale la biblioteca [Pillow (PIL)](https://pypi.org/project/Pillow/) y AWS SDK para Python (Boto3). Si bien el tiempo de ejecución de Lambda Python incluye una versión del SDK Boto3, recomendamos agregar todas las dependencias de la función al paquete de despliegue, incluso si están incluidas en el tiempo de ejecución. Para obtener más información, consulte [Dependencias del tiempo de ejecución en Python](https://docs.aws.amazon.com/lambda/latest/dg/python-package.html#python-package-dependencies).
```
mkdir package
pip install \
--platform manylinux2014_x86_64 \
--target=package \
--implementation cp \
--python-version 3.12 \
--only-binary=:all: --upgrade \
pillow boto3
```
La biblioteca Pillow contiene código C y C\$1\$1. Al utilizar las opciones `--platform manylinux_2014_x86_64` y `--only-binary=:all:`, pip descargará e instalará una versión de Pillow que contiene archivos binarios precompilados compatibles con el sistema operativo Amazon Linux 2. Esto garantiza que el paquete de implementación funcione en el entorno de ejecución de Lambda, independientemente del sistema operativo y la arquitectura del equipo de compilación local.
1. Cree un archivo .zip que contenga el código de la aplicación y las bibliotecas Pillow y Boto3. En Linux o macOS, ejecute los siguientes comandos desde la interfaz de la línea de comandos.
```
cd package
zip -r ../lambda_function.zip .
cd ..
zip lambda_function.zip lambda_function.py
```
En Windows, utilice la herramienta de compresión que prefiera para crear el archivo `lambda_function.zip`. Asegúrese de que el archivo `lambda_function.py` y las carpetas que contienen las dependencias estén en la raíz del archivo .zip.
También puede crear su paquete de implementación mediante un entorno virtual de Python. Consulte [Uso de archivos .zip para funciones de Lambda en Python](python-package.md)
------
## Crear la función de Lambda
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps6.png)
También puede crear la función de Lambda con la AWS CLI o la consola de Lambda. Siga las instrucciones del lenguaje elegido para crear la función.
------
#### [ Consola de administración de AWS ]
**Para crear la función (consola)**
Para crear una función de Lambda con la consola, primero debe crear una función básica que contenga el código “Hola, mundo”. A continuación, reemplace este código por su propio código de función mediante la carga del archivo .zip o JAR que creó en el paso anterior.
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 por medio de 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 **Crear función**.
1. Elija **Crear desde cero**.
1. Bajo **Información básica**, haga lo siguiente:
1. En **Nombre de la función**, introduzca `CreateThumbnail`.
1. En **Tiempo de ejecución**, elija **Node.js 22.x** o **Python 3.12**, según el lenguaje que elija para la función.
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 `LambdaS3Role` que creó anteriormente.
1. Elija **Crear función**.
**Para cargar el código de la función (consola)**
1. En el panel **Código fuente**, elija **Cargar desde**.
1. Elija un **archivo .zip**.
1. Seleccione **Cargar**.
1. En el selector de archivos, seleccione un archivo .zip y luego elija **Abrir**.
1. Seleccione **Save**.
------
#### [ AWS CLI ]
**Para crear la función (AWS CLI)**
+ Ejecute el comando de CLI para el lenguaje elegido. En el parámetro `role`, asegúrese de reemplazar `123456789012` por el ID de la Cuenta de AWS. En el parámetro `region`, reemplace `us-east-1` por la región en la que creó los buckets de Amazon S3.
+ Para **Node.js**, ejecute el siguiente comando desde el directorio que contiene el archivo `function.zip`.
```
aws lambda create-function --function-name CreateThumbnail \
--zip-file fileb://function.zip --handler index.handler --runtime nodejs24.x \
--timeout 10 --memory-size 1024 \
--role arn:aws:iam::123456789012:role/LambdaS3Role --region us-east-1
```
+ Para **Python**, ejecute el siguiente comando desde el directorio que contiene el archivo `lambda_function.zip`.
```
aws lambda create-function --function-name CreateThumbnail \
--zip-file fileb://lambda_function.zip --handler lambda_function.lambda_handler \
--runtime python3.14 --timeout 10 --memory-size 1024 \
--role arn:aws:iam::123456789012:role/LambdaS3Role --region us-east-1
```
------
## Configurar Amazon S3 para invocar una función
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps7.png)
Para que la función de Lambda se ejecute cuando carga una imagen al bucket de origen, debe configurar un desencadenador para la función. Puede configurar el desencadenador de Amazon S3 mediante la consola o la AWS CLI.
**importante**
Este procedimiento configura el bucket de Amazon S3 para invocar la función cada vez que se crea un objeto en el bucket. Asegúrese de configurar esto solo en el bucket de origen. Si la función de Lambda crea objetos en el mismo bucket que la invoca, la función se puede [invocar de forma continua en un bucle](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/recursive-runaway). Esto puede provocar que se facturen cargos imprevistos en su Cuenta de AWS.
------
#### [ Consola de administración de AWS ]
**Para configurar el desencadenador de Amazon S3 (consola)**
1. Abra la [página Funciones](https://console.aws.amazon.com/lambda/home#/functions) de la consola de Lambda y elija la función (`CreateThumbnail`).
1. Elija **Add trigger (Añadir disparador)**.
1. Seleccione **S3**.
1. En **Bucket**, seleccione el bucket de origen.
1. En **Tipos de eventos**, seleccione **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. Puede obtener más información sobre los patrones de invocación recursiva en Lambda en [Patrones recursivos que provocan funciones de Lambda descontroladas](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/recursive-runaway) en Serverless Land.
1. Elija **Agregar**.
Al crear un desencadenador mediante la consola de Lambda, Lambda crea automáticamente una [política basada en recursos](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html) para conceder permiso al servicio que seleccione para invocar la función.
------
#### [ AWS CLI ]
**Para configurar el desencadenador de Amazon S3 (AWS CLI)**
1. Para que el bucket de origen de Amazon S3 invoque la función al agregar un archivo de imagen, primero debe configurar los permisos de la función mediante una [política basada en recursos](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html). Una instrucción de política basada en recursos concede permisos a otros Servicios de AWS para invocar la función. Para conceder permisos a Amazon S3 para invocar la función, ejecute el siguiente comando de la CLI. Asegúrese de reemplazar el parámetro `source-account` por su propio ID de Cuenta de AWS y de utilizar su propio nombre de bucket de origen.
```
aws lambda add-permission --function-name CreateThumbnail \
--principal s3.amazonaws.com --statement-id s3invoke --action "lambda:InvokeFunction" \
--source-arn arn:aws:s3:::amzn-s3-demo-source-bucket \
--source-account 123456789012
```
La política que defina con este comando permite a Amazon S3 invocar la función solo cuando se lleva a cabo una acción en el bucket de origen.
**nota**
Si bien los nombres de los buckets de Amazon S3 son globalmente únicos, cuando se utilizan políticas basadas en recursos, se recomienda aclarar que el bucket debe pertenecer a la cuenta. Esto sucede porque si elimina un bucket, es posible que otra Cuenta de AWS cree un bucket con el mismo Nombre de recurso de Amazon (ARN).
1. Guarde el siguiente JSON en un archivo llamado `notification.json`. Cuando se aplica al bucket de origen, este JSON configura el bucket para enviar una notificación a la función de Lambda cada vez que se agrega un objeto nuevo. Reemplace el número de Cuenta de AWS y la Región de AWS en el ARN de la función de Lambda por su número de cuenta y su región.
```
{
"LambdaFunctionConfigurations": [
{
"Id": "CreateThumbnailEventConfiguration",
"LambdaFunctionArn": "arn:aws:lambda:us-east-1:123456789012:function:CreateThumbnail",
"Events": [ "s3:ObjectCreated:Put" ]
}
]
}
```
1. Ejecute el siguiente comando de la CLI para aplicar la configuración de notificación del archivo JSON que creó al bucket de origen. Reemplace `amzn-s3-demo-source-bucket` por el nombre del bucket de origen.
```
aws s3api put-bucket-notification-configuration --bucket amzn-s3-demo-source-bucket \
--notification-configuration file://notification.json
```
Para obtener más información sobre el comando `put-bucket-notification-configuration` y la opción `notification-configuration`, consulte [put-bucket-notification-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-bucket-notification-configuration.html) en la *Referencia de comandos de la CLI AWS*.
------
## Probar la función de Lambda con un evento de prueba
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps8.png)
Antes de probar toda la configuración al agregar un archivo de imagen al bucket de origen de Amazon S3, debe comprobar que la función de Lambda funciona correctamente al invocarla con un evento ficticio. Un evento en Lambda es un documento con formato JSON que contiene datos para que una función los procese. Cuando Amazon S3 invoca la función, el evento enviado a la función contiene información como el nombre del bucket, el ARN del bucket y la clave del objeto.
------
#### [ Consola de administración de AWS ]
**Para probar la función de Lambda con un evento ficticio (consola)**
1. Abra la [página Funciones](https://console.aws.amazon.com/lambda/home#/functions) de la consola de Lambda y elija la función (`CreateThumbnail`).
1. Elija la pestaña **Prueba**.
1. Para crear el evento de prueba, en el panel **Evento de prueba**, haga lo siguiente:
1. En **Acción del evento de prueba**, seleccione **Crear nuevo evento**.
1. En **Nombre del evento**, escriba **myTestEvent**.
1. En **Plantilla**, seleccione **S3 Put**.
1. Reemplace los valores de los siguientes parámetros por sus propios valores.
+ En `awsRegion`, reemplace `us-east-1` por la Región de AWS en la que creó el bucket de Amazon S3.
+ En `name`, reemplace `amzn-s3-demo-bucket` por el nombre del bucket de origen de Amazon S3.
+ En `key`, reemplace `test%2Fkey` por el nombre del objeto de prueba que cargó al bucket de origen en el paso [Cargar una imagen de prueba al bucket de origen](#with-s3-tutorial-test-image).
```
{
"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. En el panel **Evento de prueba**, seleccione **Prueba**.
1. Para comprobar que la función creó una versión redimensionada de la imagen y la almacenó en el bucket de Amazon S3 de destino, haga lo siguiente:
1. En la consola de Amazon S3, abra la página [Buckets](https://console.aws.amazon.com/s3/buckets).
1. Elija el bucket de destino y confirme que el archivo redimensionado aparezca en el panel **Objetos**.
------
#### [ AWS CLI ]
**Para probar la función de Lambda con un evento ficticio (AWS CLI)**
1. Guarde el siguiente JSON en un archivo llamado `dummyS3Event.json`. Reemplace los valores de los siguientes parámetros por sus propios valores:
+ En `awsRegion`, reemplace `us-east-1` por la Región de AWS en la que creó el bucket de Amazon S3.
+ En `name`, reemplace `amzn-s3-demo-bucket` por el nombre del bucket de origen de Amazon S3.
+ En `key`, reemplace `test%2Fkey` por el nombre del objeto de prueba que cargó al bucket de origen en el paso [Cargar una imagen de prueba al bucket de origen](#with-s3-tutorial-test-image).
```
{
"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. Desde el directorio en el que guardó el archivo `dummyS3Event.json`, invoque la función mediante la ejecución del siguiente comando de la CLI. Este comando invoca la función de Lambda de forma sincrónica al definir `RequestResponse` como valor del parámetro de tipo de invocación. Para obtener más información sobre la invocación sincrónica y asíncrona, consulte [Invocación de funciones de Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-invocation.html).
```
aws lambda invoke --function-name CreateThumbnail \
--invocation-type RequestResponse --cli-binary-format raw-in-base64-out \
--payload file://dummyS3Event.json outputfile.txt
```
La opción cli-binary-format es obligatoria si utiliza la versión 2 de la AWS CLI. Para que esta sea la configuración predeterminada, ejecute `aws configure set cli-binary-format raw-in-base64-out`. Para obtener más información, consulte [las opciones globales de la línea de comandos admitidas de AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list).
1. Compruebe que la función haya creado una versión en miniatura de la imagen y la haya guardado en el bucket de Amazon S3 de destino. Ejecute el siguiente comando de la CLI, para ello reemplace `amzn-s3-demo-source-bucket-resized` por el nombre del bucket de destino.
```
aws s3api list-objects-v2 --bucket amzn-s3-demo-source-bucket-resized
```
Debería ver un resultado similar a este. El parámetro `Key` muestra el nombre del archivo de imagen redimensionado.
```
{
"Contents": [
{
"Key": "resized-HappyFace.jpg",
"LastModified": "2023-06-06T21:40:07+00:00",
"ETag": "\"d8ca652ffe83ba6b721ffc20d9d7174a\"",
"Size": 2633,
"StorageClass": "STANDARD"
}
]
}
```
------
## Probar la función con el desencadenador de Amazon S3
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps9.png)
Ahora que confirmó que la función de Lambda se ejecuta correctamente, puede probar toda la configuración al agregar un archivo de imagen al bucket de origen de Amazon S3. Al agregar la imagen al bucket de origen, la función de Lambda se debe invocar automáticamente. La función crea una versión redimensionada del archivo y la almacena en el bucket de destino.
------
#### [ Consola de administración de AWS ]
**Para probar la función de Lambda mediante el desencadenador de Amazon S3 (consola)**
1. Para cargar una imagen en el bucket de Amazon S3, haga lo siguiente:
1. Abra la página [Buckets](https://console.aws.amazon.com/s3/buckets) de la consola de Amazon S3 y elija el bucket de origen.
1. Seleccione **Cargar**.
1. Elija **Agregar archivos** y utilice el selector de archivos para elegir el archivo de imagen que desea cargar. El objeto de imagen puede ser cualquier archivo .jpg o .png.
1. Elija **Abrir** y, a continuación, **Cargar**.
1. Compruebe que Lambda haya guardado una versión redimensionada del archivo de imagen en el bucket de destino, de la siguiente manera:
1. Vuelva a la página [Buckets](https://console.aws.amazon.com/s3/buckets) de la consola de Amazon S3 y elija el bucket de destino.
1. En el panel **Objetos**, debería ver dos archivos de imagen redimensionados, uno de cada prueba de la función de Lambda. Para descargar la imagen redimensionada, selecciona el archivo y luego elija **Descargar**.
------
#### [ AWS CLI ]
**Para probar la función de Lambda mediante el desencadenador de Amazon S3 (AWS CLI)**
1. Desde el directorio que contiene la imagen que desea cargar, ejecute el siguiente comando de la CLI. Reemplace el parámetro `--bucket` con el nombre del bucket de origen. Para los parámetros `--key` y `--body`, utilice el nombre de archivo de la imagen de prueba. La imagen de prueba puede ser cualquier archivo .jpg o .png.
```
aws s3api put-object --bucket amzn-s3-demo-source-bucket --key SmileyFace.jpg --body ./SmileyFace.jpg
```
1. Compruebe que la función haya creado una versión en miniatura de la imagen y la haya guardado en el bucket de Amazon S3 de destino. Ejecute el siguiente comando de la CLI, para ello reemplace `amzn-s3-demo-source-bucket-resized` por el nombre del bucket de destino.
```
aws s3api list-objects-v2 --bucket amzn-s3-demo-source-bucket-resized
```
Si la función se ejecuta correctamente, verá un resultado similar al siguiente. El bucket de destino ahora debería contener dos archivos redimensionados.
```
{
"Contents": [
{
"Key": "resized-HappyFace.jpg",
"LastModified": "2023-06-07T00:15:50+00:00",
"ETag": "\"7781a43e765a8301713f533d70968a1e\"",
"Size": 2763,
"StorageClass": "STANDARD"
},
{
"Key": "resized-SmileyFace.jpg",
"LastModified": "2023-06-07T00:13:18+00:00",
"ETag": "\"ca536e5a1b9e32b22cd549e18792cdbc\"",
"Size": 1245,
"StorageClass": "STANDARD"
}
]
}
```
------
## 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](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).
**Para eliminar la política que creó**
1. Abra la página de [Policies (Políticas)](https://console.aws.amazon.com/iam/home#/policies) de la consola de IAM.
1. Seleccione la política que creó (**AWSLambdas3Policy**).
1. Elija **Policy actions (Acciones de política)**, **Delete (Eliminar)**.
1. Elija **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)**.