# 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)**.