Tutorial: Uso de un desencadenador de Amazon S3 para crear imágenes en miniatura

Para crear buckets de Amazon S3 (consola)

1. Abra la consola de Amazon S3 y seleccione la página Buckets de uso general.

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

   

3. Elija Crear bucket.

4. En Configuración general, haga lo siguiente:

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

   2. Para el nombre del bucket, ingrese un nombre único a nivel mundial que cumpla las reglas de nomenclatura de bucket de Amazon S3. Los nombres de bucket pueden contener únicamente letras minúsculas, números, puntos (.) y guiones (-).

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

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

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

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

Para cargar una imagen de prueba al bucket de origen (consola)

1. En la consola de Amazon S3, abra la página Buckets.

2. Seleccione el bucket de origen que creó en el paso anterior.

3. Seleccione Cargar.

4. Elija Agregar archivos y utilice el selector de archivos para elegir el objeto que desea cargar.

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

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

Para crear la política (consola)

1. Abra la página de Policies (Políticas) de la consola AWS Identity and Access Management (IAM).

2. Seleccione Crear política.

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

   {
       "Version": "2012-10-17",
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "logs:PutLogEvents",
                   "logs:CreateLogGroup",
                   "logs:CreateLogStream"
               ],
               "Resource": "arn:aws:logs:*:*:*"
           },
           {
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject"
               ],
               "Resource": "arn:aws:s3:::*/*"
           },
           {
               "Effect": "Allow",
               "Action": [
                   "s3:PutObject"
               ],
               "Resource": "arn:aws:s3:::*/*"
           }
       ]
   }

4. Elija Siguiente.

5. En Detalles de política, para el Nombre de la política, ingrese LambdaS3Policy.

6. Seleccione Crear política.

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

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

Para crear un rol de ejecución y adjuntar la política de permisos (consola)

1. Abra la página Roles en la consola (IAM).

2. Elija Creación de rol.

3. En Tipo de entidad de confianza, seleccione el Servicio de AWS; en Caso de uso, seleccione Lambda.

4. Elija Siguiente.

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

   2. En los resultados de búsqueda, seleccione la casilla de verificación para LambdaS3Policy.

   3. Elija Siguiente.

6. En Detalles del rol, para el Nombre del rol, ingrese LambdaS3Role.

7. Elija Creación de rol.

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"
       }
     ]
   }

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

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

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

2. Cree un nuevo proyecto de Node.js con npm. Para aceptar las opciones predeterminadas proporcionadas en la experiencia interactiva, oprima Enter.

   npm init

3. 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);
     };

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

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

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))

2. 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) y AWS SDK for 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.

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

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

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 en la consola de Lambda.

2. Asegúrese de trabajar en la misma Región de AWS en la que creó el bucket de Amazon S3. Puede cambiar la región por medio de la lista desplegable de la parte superior de la pantalla.

   

3. Elija Crear función.

4. Elija Author from scratch (Crear desde cero).

5. Bajo Basic information (Información básica), haga lo siguiente:

   1. En Function name (Nombre de la función), introduzca CreateThumbnail.

   2. En Tiempo de ejecución, elija Node.js 22.x o Python 3.12, según el lenguaje que elija para la función.

   3. En Arquitectura, elija x86_64.

6. En la pestaña Cambiar rol de ejecución predeterminado, haga lo siguiente:

   1. Amplíe la pestaña y, a continuación, elija Utilizar un rol existente.

   2. Seleccione el LambdaS3Role que creó anteriormente.

7. Seleccione Creación de función.

Para cargar el código de la función (consola)

1. En el panel Código fuente, elija Cargar desde.

2. Elija un archivo .zip.

3. Seleccione Cargar.

4. En el selector de archivos, seleccione un archivo .zip y luego elija Abrir.

5. Seleccione Guardar.

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 nodejs22.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.13 --timeout 10 --memory-size 1024 \
    --role arn:aws:iam::123456789012:role/LambdaS3Role --region us-east-1

Para configurar el desencadenador de Amazon S3 (consola)

1. Abra la página Funciones de la consola de Lambda y elija la función (CreateThumbnail).

2. Elija Add trigger (Añadir disparador).

3. Seleccione S3.

4. En Bucket, seleccione el bucket de origen.

5. En Tipos de eventos, seleccione Todos los eventos de creación de objetos.

6. En Invocación recursiva, marque la casilla de verificación para confirmar que no se recomienda utilizar el mismo bucket de Amazon S3 para la entrada y la salida. Puede obtener más información sobre los patrones de invocación recursiva en Lambda en Patrones recursivos que provocan funciones de Lambda descontroladas en Serverless Land.

7. Elija Agregar.

   Al crear un desencadenador mediante la consola de Lambda, Lambda crea automáticamente una política basada en recursos para conceder permiso al servicio que seleccione para invocar la función.

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

2. 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" ]
       }
     ]
   }

3. 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 en la Referencia de comandos de la CLI AWS.

Para probar la función de Lambda con un evento ficticio (consola)

1. Abra la página Funciones de la consola de Lambda y elija la función (CreateThumbnail).

2. Elija la pestaña Prueba.

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

   2. En Nombre del evento, escriba myTestEvent.

   3. En Plantilla, seleccione S3 Put.

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

      {
        "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"
              }
            }
          }
        ]
      }

   5. Seleccione Guardar.

4. En el panel Evento de prueba, seleccione Prueba.

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

   2. Elija el bucket de destino y confirme que el archivo redimensionado aparezca en el panel Objetos.

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.

   {
     "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"
           }
         }
       }
     ]
   }

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

   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.

3. 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"
           }
       ]
   }

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 de la consola de Amazon S3 y elija el bucket de origen.

   2. Seleccione Cargar.

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

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

2. 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 de la consola de Amazon S3 y elija el bucket de destino.

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

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

2. 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"
           }
       ]
   }