Tutorial: uso di un trigger Amazon S3 per creare immagini in miniatura

In questo tutorial, creerai e configurerai una funzione Lambda che ridimensiona le immagini aggiunte a un bucket Amazon Simple Storage Service (Amazon S3). Quando aggiungi un file di immagine al bucket, Amazon S3 richiama la tua funzione Lambda. La funzione crea quindi una versione in miniatura dell'immagine e la invia a un altro bucket Amazon S3.

Per completare questo tutorial, completa le seguenti attività:

1. Crea i bucket Amazon S3 di origine e destinazione e carica un'immagine di esempio.

2. Crea una funzione Lambda che ridimensiona un'immagine e restituisce una miniatura in un bucket Amazon S3.

3. Configura un trigger Lambda che richiama la tua funzione quando gli oggetti vengono caricati nel bucket di origine.

4. Testa la tua funzione, prima con un evento fittizio e poi caricando un'immagine nel tuo bucket di origine.

Completando questi passaggi, imparerai come utilizzare Lambda per eseguire un'attività di elaborazione di file su oggetti aggiunti a un bucket Amazon S3. Puoi completare questo tutorial usando il AWS Command Line Interface (AWS CLI) o il AWS Management Console.

Se stai cercando un esempio più semplice per imparare a configurare un trigger Amazon S3 per Lambda, puoi provare Tutorial: utilizzo di un trigger Amazon S3 per richiamare una funzione Lambda.

Prerequisiti

Iscriviti per un Account AWS

Se non ne hai uno Account AWS, completa i seguenti passaggi per crearne uno.

Per iscriverti a un Account AWS

1. Apri la pagina all'indirizzo https://portal.aws.amazon.com/billing/signup.

2. Segui le istruzioni online.

   Nel corso della procedura di registrazione riceverai una telefonata, durante la quale sarà necessario inserire un codice di verifica attraverso la tastiera del telefono.

   Quando ti iscrivi a un Account AWS, Utente root dell'account AWSviene creato un. L'utente root dispone dell'accesso a tutte le risorse e tutti i Servizi AWS nell'account. Come best practice di sicurezza, assegna l'accesso amministrativo a un utente e utilizza solo l'utente root per eseguire attività che richiedono l'accesso di un utente root.

AWS ti invia un'email di conferma dopo il completamento della procedura di registrazione. È possibile visualizzare l'attività corrente dell'account e gestire l'account in qualsiasi momento accedendo all'indirizzo https://aws.amazon.com/ e selezionando Il mio account.

Crea un utente con accesso amministrativo

Dopo la registrazione Account AWS, proteggi Utente root dell'account AWS AWS IAM Identity Center, abilita e crea un utente amministrativo in modo da non utilizzare l'utente root per le attività quotidiane.

Proteggi i tuoi Utente root dell'account AWS

1. Accedi AWS Management Consolecome proprietario dell'account scegliendo Utente root e inserendo il tuo indirizzo Account AWS email. Nella pagina successiva, inserisci la password.

   Per informazioni sull'accesso utilizzando un utente root, consulta la pagina Signing in as the root user della Guida per l'utente di Accedi ad AWS .

2. Abilita l'autenticazione a più fattori (MFA) per l'utente root.

   Per istruzioni, consulta Abilitare un dispositivo MFA virtuale per l'utente Account AWS root (console) nella Guida per l'utente IAM.

Crea un utente con accesso amministrativo

1. Abilita Centro identità IAM.

   Per istruzioni, consulta Abilitazione di AWS IAM Identity Center nella Guida per l'utente di AWS IAM Identity Center .

2. In IAM Identity Center, assegna l'accesso amministrativo a un utente.

   Per un tutorial sull'utilizzo di IAM Identity Center directory come fonte di identità, consulta Configurare l'accesso utente con l'impostazione predefinita IAM Identity Center directory nella Guida per l'AWS IAM Identity Center utente.

Accesso come utente amministratore

• Per accedere con l'utente IAM Identity Center, utilizza l'URL di accesso che è stato inviato al tuo indirizzo e-mail quando hai creato l'utente IAM Identity Center.

  Per informazioni sull'accesso utilizzando un utente IAM Identity Center, consulta AWS Accedere al portale di accesso nella Guida per l'Accedi ad AWS utente.

Assegna l'accesso a ulteriori utenti

1. In IAM Identity Center, crea un set di autorizzazioni conforme alla best practice dell'applicazione di autorizzazioni con il privilegio minimo.

   Segui le istruzioni riportate nella pagina Creazione di un set di autorizzazioni nella Guida per l'utente di AWS IAM Identity Center .

2. Assegna al gruppo prima gli utenti e poi l'accesso con autenticazione unica (Single Sign-On).

   Per istruzioni, consulta Aggiungere gruppi nella Guida per l'utente di AWS IAM Identity Center .

Se desideri utilizzare il per AWS CLI completare il tutorial, installa la versione più recente di AWS Command Line Interface.

Per il codice della funzione Lambda, puoi utilizzare Python o Node.js. Installa gli strumenti di supporto linguistico e un gestore di pacchetti per il linguaggio che desideri utilizzare.

Creazione di due bucket Amazon S3

Per prima cosa, crea due bucket Amazon S3. Il primo bucket è il bucket di origine in cui caricherai le tue immagini. Il secondo bucket viene utilizzato da Lambda per salvare la miniatura ridimensionata quando richiami la tua funzione.

AWS Management Console

Creazione di bucket Amazon S3 (console)

1. Nella console Amazon S3, apri la pagina Bucket.

2. Scegliere Create bucket (Crea bucket).

3. In General configuration (Configurazione generale), eseguire le operazioni seguenti:

   1. Per Nome del bucket, inserisci un nome univoco globale che soddisfi le regole di denominazione dei bucket di Amazon S3. I nomi dei bucket possono contenere solo lettere minuscole, numeri, punti (.) e trattini (-).

   2. Per Regione AWS, scegli la Regione AWS più vicina alla tua posizione geografica. Più avanti nel tutorial, devi creare la tua funzione Lambda nella stessa Regione AWS, quindi prendi nota della regione che hai scelto.

4. Lascia tutte le altre opzioni impostate sui valori predefiniti e scegli Crea bucket.

5. Ripeti i passaggi da 1 a 4 per creare il bucket di destinazione. Per Nome del bucket, inserisci DOC-EXAMPLE-SOURCE-BUCKET-resized, dove DOC-EXAMPLE-SOURCE-BUCKET è il nome del bucket di origine che hai appena creato.

AWS CLI

Creazione dei bucket Amazon S3 (AWS CLI)

1. Esegui il comando della CLI sotto riportato per creare il bucket di origine. Il nome che scegli per il bucket deve essere univoco a livello globale e seguire le regole di denominazione dei bucket di Amazon S3. I nomi possono contenere solo lettere minuscole, numeri, punti (.) e trattini (-). Per region e LocationConstraint, scegli la Regione AWS più vicina alla tua posizione geografica.

   aws s3api create-bucket --bucket DOC-EXAMPLE-SOURCE-BUCKET --region us-east-1 \
   --create-bucket-configuration LocationConstraint=us-east-1

   Più avanti nel tutorial, devi creare la tua funzione Lambda nello Regione AWS stesso bucket di origine, quindi prendi nota della regione che hai scelto.

2. Esegui il comando sotto riportato per creare il bucket di destinazione. Per il nome del bucket, devi usare DOC-EXAMPLE-SOURCE-BUCKET-resized, dove DOC-EXAMPLE-SOURCE-BUCKET è il nome del bucket di origine che hai creato nel passaggio 1. Per region eLocationConstraint, scegli lo stesso Regione AWS che hai usato per creare il bucket sorgente.

   aws s3api create-bucket --bucket DOC-EXAMPLE-SOURCE-BUCKET-resized --region us-east-1 \
   --create-bucket-configuration LocationConstraint=us-east-1

Caricamento di un'immagine di test nel bucket di origine

Più avanti nel tutorial, testerai la tua funzione Lambda invocandola utilizzando la console o AWS CLI la console Lambda. Per confermare che la funzione funzioni correttamente, il bucket di origine deve contenere un'immagine di test. Questa immagine può essere qualsiasi file JPG o PNG che scegli.

AWS Management Console

Caricamento di un'immagine di test nel bucket di origine (console)

1. Nella console Amazon S3, apri la pagina Bucket.

2. Seleziona il bucket di origine che hai creato nella fase precedente.

3. Scegli Carica.

4. Scegli Aggiungi file e usa il selettore di file per scegliere l'oggetto da caricare.

5. Seleziona Apri, quindi Carica.

AWS CLI

Caricamento di un'immagine di test nel bucket di origine (AWS CLI)

• Dalla directory contenente l'immagine che desideri caricare, esegui il comando della CLI sotto riportato. Sostituisci il parametro --bucket con il nome del bucket di origine. Per i parametri --key e --body, usa il nome del file dell'immagine di test.

  aws s3api put-object --bucket DOC-EXAMPLE-SOURCE-BUCKET --key HappyFace.jpg --body ./HappyFace.jpg

Creazione di una policy di autorizzazione

Il primo passo per creare una funzione Lambda consiste nel creare una policy di autorizzazione. Questa politica fornisce alla funzione le autorizzazioni necessarie per accedere ad altre risorse. AWS Per questo tutorial, la policy fornisce le autorizzazioni di lettura e scrittura Lambda per i bucket Amazon S3 e consente di scrivere su Amazon Logs. CloudWatch

AWS Management Console

Creazione della policy (console)

1. Apri la pagina Policies della console (IAM). AWS Identity and Access Management

2. Scegli Crea policy.

3. Scegliere la scheda JSON e quindi incollare la seguente policy personalizzata nell'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. Seleziona Successivo.

5. In Dettagli sulla policy, per Nome policy, inserisci LambdaS3Policy.

6. Scegli Crea policy.

AWS CLI

Creazione della policy (AWS CLI)

1. Salva il seguente JSON in un file denominato 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. Nella directory in cui hai salvato il documento della policy JSON, esegui il comando della CLI sotto riportato.

   aws iam create-policy --policy-name LambdaS3Policy --policy-document file://policy.json

Creazione di un ruolo di esecuzione

Un ruolo di esecuzione è un ruolo IAM che concede a una funzione Lambda l'autorizzazione all' Servizi AWS accesso e alle risorse. Per concedere alla funzione l'accesso in lettura e scrittura a un bucket Amazon S3, è necessario collegare la policy di autorizzazione che hai creato nel passaggio precedente.

AWS Management Console

Creazione di un ruolo di esecuzione e collegamento di una policy di autorizzazione (console)

1. Apri la pagina Ruoli della console (IAM).

2. Scegli Crea ruolo.

3. Per Tipo di entità attendibile, seleziona Servizio AWS, mentre per Caso d'uso, seleziona Lambda.

4. Seleziona Successivo.

5. Aggiungi la policy di autorizzazione che hai creato nel passaggio precedente effettuando le seguenti operazioni:

   1. Nella casella di ricerca delle policy, immettere LambdaS3Policy.

   2. Nei risultati di ricerca, seleziona la casella di controllo per LambdaS3Policy.

   3. Seleziona Successivo.

6. In Dettagli ruolo, per Nome ruolo, inserisci LambdaS3Role.

7. Scegli Crea ruolo.

AWS CLI

Creazione di un ruolo di esecuzione e collegamento di una policy di autorizzazione (AWS CLI)

1. Salva il seguente JSON in un file denominato trust-policy.json. Questa politica di fiducia consente a Lambda di utilizzare le autorizzazioni del ruolo concedendo al servizio principale l'lambda.amazonaws.comautorizzazione a chiamare l'azione AWS Security Token Service ()AWS STS. AssumeRole

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "Service": "lambda.amazonaws.com"
         },
         "Action": "sts:AssumeRole"
       }
     ]
   }

2. Nella directory in cui hai salvato il documento della policy di attendibilità JSON, esegui il comando della CLI sotto riportato per creare il ruolo di esecuzione.

   aws iam create-role --role-name LambdaS3Role --assume-role-policy-document file://trust-policy.json

3. Per collegare la policy di autorizzazione creata nel passaggio precedente, esegui il comando della CLI sotto riportato. Sostituisci il Account AWS numero nell'ARN della polizza con il tuo numero di conto.

   aws iam attach-role-policy --role-name LambdaS3Role --policy-arn arn:aws:iam::123456789012:policy/LambdaS3Policy

Creazione del pacchetto di implementazione della funzione

Per creare la funzione, occorre creare un pacchetto di implementazione contenente la funzione e le rispettive dipendenze. Per questa funzione CreateThumbnail, il codice della funzione utilizza una libreria separata per il ridimensionamento dell'immagine. Segui le istruzioni per il linguaggio scelto per creare un pacchetto di implementazione contenente la libreria richiesta.

Node.js

Creazione del pacchetto di implementazione (Node.js)

1. Crea una directory denominata lambda-s3 per il codice della funzione e le dipendenze e naviga al suo interno.

   mkdir lambda-s3
   cd lambda-s3

2. Crea un nuovo progetto Node.js con npm. Per accettare le opzioni predefinite fornite nell'esperienza interattiva, premi Enter.

   npm init

3. Salvare il codice della funzione seguente in un file denominato index.mjs. Assicurati di sostituirlo us-east-1 con quello Regione AWS in cui hai creato i tuoi bucket di origine e destinazione.

   // 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. Nella directory lambda-s3, installa la libreria sharp utilizzando npm. Tieni presente che l'ultima versione di sharp (0.33) non è compatibile con Lambda. Per completare questo tutorial, installa la versione 0.32.6.

   npm install sharp@0.32.6

   Il comando install di npm crea una directory node_modules per i tuoi moduli. Dopo questo passaggio, la struttura di directory dovrebbe avere un aspetto simile al seguente.

   lambda-s3
   |- index.mjs
   |- node_modules
   |  |- base64js
   |  |- bl
   |  |- buffer
   ...
   |- package-lock.json
   |- package.json

5. Crea un pacchetto di implementazione .zip contenente il codice della funzione e le rispettive dipendenze. Su MacOS o Linux, esegui il comando sotto riportato.

   zip -r function.zip .

   Su Windows, utilizza il tuo strumento di compressione preferito per creare il file .zip. Assicurati che i tuoi file index.mjs, package.json e package-lock.json e la tua directory node_modules si trovino tutti nella directory principale del tuo file .zip.

Python

Creazione del pacchetto di implementazione (Python)

1. Salva il codice di esempio come un file denominato 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. Nella stessa directory in cui hai creato il file lambda_function.py, crea una nuova directory denominata package e installa la libreria Pillow (PIL) e AWS SDK for Python (Boto3). Sebbene il runtime Lambda di Python includa una versione dell'SDK Boto3, ti consigliamo di aggiungere tutte le dipendenze della funzione al pacchetto di implementazione, anche se sono incluse nel runtime. Per ulteriori informazioni, consulta Dipendenze del runtime in Python.

   mkdir package
   pip install \
   --platform manylinux2014_x86_64 \
   --target=package \
   --implementation cp \
   --python-version 3.12 \
   --only-binary=:all: --upgrade \
   pillow boto3

   La libreria Pillow contiene codice C/C++. Utilizzando le opzioni --platform manylinux_2014_x86_64 e --only-binary=:all:, pip scaricherà e installerà una versione di Pillow che contiene file binari precompilati compatibili con il sistema operativo Amazon Linux 2. Ciò garantisce che il pacchetto di implementazione funzioni nell'ambiente di esecuzione Lambda, indipendentemente dal sistema operativo e dall'architettura del computer di compilazione locale.

3. Crea un file .zip contenente il codice dell'applicazione e le librerie Pillow e Boto3. Su Linux o MacOS, esegui i comandi riportati di seguito dall'interfaccia della linea di comando.

   cd package
   zip -r ../lambda_function.zip .
   cd ..
   zip lambda_function.zip lambda_function.py

   Su Windows, usa il tuo strumento di compressione preferito per creare il file lambda_function.zip. Assicurati che il tuo file lambda_function.py e le cartelle contenenti le tue dipendenze si trovino tutti nella directory principale del file .zip.

Puoi creare il tuo pacchetto di implementazione anche utilizzando un ambiente virtuale Python. Per informazioni, consultare Utilizzo di archivi di file .zip per le funzioni Lambda in Python.

Creazione della funzione Lambda

Puoi creare la tua funzione Lambda utilizzando la console AWS CLI o la console Lambda. Segui le istruzioni per il linguaggio scelto per creare la funzione.

AWS Management Console

Creazione della funzione (console)

Per creare la tua funzione Lambda utilizzando la console, devi prima creare una funzione di base contenente del codice "Hello world". Quindi, sostituisci questo codice con il codice della tua funzione caricando il file .zip o JAR creato nel passaggio precedente.

1. Aprire la pagina Funzioni della console Lambda.

2. Assicurati di lavorare nello stesso bucket in Regione AWS cui hai creato il tuo bucket Amazon S3. Puoi modificare la regione utilizzando l'elenco a discesa nella parte superiore dello schermo.

   

3. Selezionare Create function (Crea funzione).

4. Scegli Author from scratch (Crea da zero).

5. In Basic information (Informazioni di base) eseguire queste operazioni:

   1. Nel campo Function name (Nome funzione), immettere CreateThumbnail.

   2. Per Runtime scegli Node.js 20.x o Python 3.12 in base al linguaggio che hai scelto per la tua funzione.

   3. In Architecture (Architettura), scegli x86_64.

6. Nella scheda Modifica ruolo di esecuzione predefinito, effettua le seguenti operazioni:

   1. Espandi la scheda, quindi scegli Utilizza un ruolo esistente.

   2. Seleziona il LambdaS3Role che hai creato in precedenza.

7. Scegli Crea funzione.

Caricamento del codice della funzione (console)

1. Nel riquadro Origine del codice, scegli Carica da.

2. Scegli File .zip.

3. Scegli Carica.

4. Nel selettore di file, seleziona il tuo file .zip e scegli Apri.

5. Selezionare Salva.

AWS CLI

Creazione della funzione (AWS CLI)

• Esegui il comando della CLI per il linguaggio che hai scelto. Per il role parametro, assicurati di sostituirlo 123456789012 con il tuo ID. Account AWS Per il parametro region, sostituisci us-east-1 con la regione in cui hai creato i bucket Amazon S3.

  • Per Node.js, esegui il comando sotto riportato dalla directory contenente il file function.zip.

    aws lambda create-function --function-name CreateThumbnail \
    --zip-file fileb://function.zip --handler index.handler --runtime nodejs20.x \
    --timeout 10 --memory-size 1024 \
    --role arn:aws:iam::123456789012:role/LambdaS3Role --region us-east-1

  • Per Python, esegui il comando sotto riportato dalla directory contenente il file lambda_function.zip.

    aws lambda create-function --function-name CreateThumbnail \
    --zip-file fileb://lambda_function.zip --handler lambda_function.lambda_handler \
    --runtime python3.12 --timeout 10 --memory-size 1024 \
    --role arn:aws:iam::123456789012:role/LambdaS3Role --region us-east-1

Configurazione di Amazon S3 per richiamare la funzione

Affinché la funzione Lambda venga eseguita quando carichi un'immagine nel bucket di origine, devi configurare un trigger per la funzione. È possibile configurare il trigger Amazon S3 utilizzando la console Lambda o la AWS CLI.

Importante

Questa procedura configura il bucket Amazon S3 per richiamare la funzione ogni volta che un oggetto viene creato nel bucket. Assicurati di configurare questa opzione solo sul bucket di origine. Se la tua funzione Lambda crea oggetti nello stesso bucket che la richiama, la tua funzione può essere richiamata continuamente in un ciclo ricorsivo (loop). Ciò può comportare la fatturazione di addebiti imprevisti al tuo Account AWS.

AWS Management Console

Configurazione del trigger Amazon S3 (console)

1. Apri la pagina Funzioni della console Lambda e scegli la tua funzione (CreateThumbnail).

2. Selezionare Add trigger (Aggiungi trigger).

3. Seleziona S3.

4. In Bucket, seleziona il tuo bucket di origine.

5. In Tipi di eventi, seleziona Tutti gli eventi di creazione di oggetti.

6. In Invocazione ricorsiva, seleziona la casella di controllo per confermare che non è consigliabile utilizzare lo stesso bucket Amazon S3 per input e output. Per maggiori informazioni sui modelli di invocazione ricorsivi in Lambda, consulta Schemi ricorsivi che causano loop indeterminati delle funzioni Lambda in Serverless Land.

7. Scegli Aggiungi.

   Quando crei un trigger utilizzando la console Lambda, Lambda crea automaticamente una policy basata sulle risorse per concedere al servizio selezionato l'autorizzazione a richiamare la funzione.

AWS CLI

Configurazione del trigger Amazon S3 (AWS CLI)

1. Affinché il bucket di origine Amazon S3 richiami la funzione quando aggiungi un file di immagine, devi prima configurare le autorizzazioni per la funzione utilizzando una policy basata sulle risorse. Una dichiarazione politica basata sulle risorse fornisce altre Servizi AWS autorizzazioni per richiamare la funzione. Per autorizzare Amazon S3 a richiamare la tua funzione, esegui il comando della CLI comando sotto riportato. Assicurati di sostituire il source-account parametro con il tuo Account AWS ID e di utilizzare il tuo nome del bucket di origine.

   aws lambda add-permission --function-name CreateThumbnail \
   --principal s3.amazonaws.com --statement-id s3invoke --action "lambda:InvokeFunction" \
   --source-arn arn:aws:s3:::DOC-EXAMPLE-SOURCE-BUCKET \
   --source-account 123456789012

   La policy che definisci con questo comando consente ad Amazon S3 di richiamare la tua funzione solo quando viene eseguita un'operazione sul tuo bucket di origine.

   Nota

   Sebbene i nomi dei bucket Amazon S3 siano univoci a livello globale, quando utilizzi policy basate sulle risorse è consigliabile specificare che il bucket deve appartenere al tuo account. Questo perché se elimini un bucket, è possibile che un altro lo Account AWS crei con lo stesso Amazon Resource Name (ARN).

2. Salva il seguente JSON in un file denominato notification.json. Quando viene applicato al tuo bucket di origine, questo JSON configura il bucket in modo che invii una notifica alla funzione Lambda ogni volta che viene aggiunto un nuovo oggetto. Sostituisci il Account AWS numero e Regione AWS nella funzione Lambda ARN con il tuo numero di account e la tua regione.

   {
   "LambdaFunctionConfigurations": [
       {
         "Id": "CreateThumbnailEventConfiguration",
         "LambdaFunctionArn": "arn:aws:lambda:us-east-1:123456789012:function:CreateThumbnail",
         "Events": [ "s3:ObjectCreated:Put" ]
       }
     ]
   }

3. Esegui il comando della CLI comando sotto riportato per applicare le impostazioni di notifica nel file JSON che hai creato al tuo bucket di origine. Sostituisci DOC-EXAMPLE-SOURCE-BUCKET con il nome del tuo bucket di origine.

   aws s3api put-bucket-notification-configuration --bucket DOC-EXAMPLE-SOURCE-BUCKET \
   --notification-configuration file://notification.json

   Per ulteriori informazioni sul put-bucket-notification-configuration comando e sull'notification-configurationopzione, consulta put-bucket-notification-configurationla AWS CLI Command Reference.

Test di una funzione Lambda con un evento fittizio

Prima di testare l'intera configurazione aggiungendo un file di immagine al tuo bucket di origine Amazon S3, verifica che la tua funzione Lambda funzioni correttamente richiamandola con un evento fittizio. Un evento in Lambda è un documento in formato JSON che contiene i dati che una funzione deve elaborare. Quando la funzione viene richiamata da Amazon S3, l'evento inviato alla funzione contiene informazioni come il nome del bucket, l'ARN del bucket e la chiave dell'oggetto.

AWS Management Console

Test di una funzione Lambda con un evento fittizio (console)

1. Apri la pagina Funzioni della console Lambda e scegli la tua funzione (CreateThumbnail).

2. Seleziona la scheda Test.

3. Per creare il tuo evento di test, nel riquadro Evento di test, procedi come segue:

   1. In Operazione evento di test, seleziona Crea nuovo evento.

   2. Per Event name (Nome evento) immettere myTestEvent.

   3. Per Modello, seleziona S3 Put.

   4. Sostituisci i valori dei seguenti parametri con i tuoi valori.

      • InfattiawsRegion, us-east-1 sostituiscilo con quello in Regione AWS cui hai creato i bucket Amazon S3.

      • Per name, sostituisci DOC-EXAMPLE-BUCKET con il nome del bucket di origine Amazon S3.

      • Per key, sostituisci test%2Fkey con il nome del file dell'oggetto di test che hai caricato nel bucket di origine durante il passaggio Caricamento di un'immagine di test nel bucket di origine.

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

   5. Selezionare Salva.

4. Nel riquadro Evento di test, scegli Test.

5. Per verificare che la funzione abbia creato una versione ridimensionata dell'immagine e l'abbia archiviata nel bucket Amazon S3 di destinazione, procedi come segue:

   1. Nella console Amazon S3, apri la pagina Bucket.

   2. Scegli il bucket di destinazione e conferma che il file ridimensionato sia elencato nel riquadro Oggetti.

AWS CLI

Test di una funzione Lambda con un evento fittizio (AWS CLI)

1. Salva il seguente JSON in un file denominato dummyS3Event.json. Sostituisci i valori dei seguenti parametri con i tuoi valori:

   • InfattiawsRegion, us-east-1 sostituiscilo con quello in Regione AWS cui hai creato i bucket Amazon S3.

   • Per name, sostituisci DOC-EXAMPLE-BUCKET con il nome del bucket di origine Amazon S3.

   • Per key, sostituisci test%2Fkey con il nome del file dell'oggetto di test che hai caricato nel bucket di origine durante il passaggio Caricamento di un'immagine di test nel bucket di origine.

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

2. Nella directory in cui hai salvato il file dummyS3Event.json, richiama la funzione eseguendo il seguente comando della CLI. Questo comando richiama la funzione Lambda in modo sincrono specificando RequestResponse come valore del parametro invocation-type. Per ulteriori informazioni sulla chiamata sincrona e asincrona, consulta la pagina Invocazione delle funzioni Lambda.

   aws lambda invoke --function-name CreateThumbnail \
   --invocation-type RequestResponse --cli-binary-format raw-in-base64-out \
   --payload file://dummyS3Event.json outputfile.txt

   L' cli-binary-format opzione è obbligatoria se si utilizza la versione 2 di. AWS CLI Per rendere questa impostazione come predefinita, esegui aws configure set cli-binary-format raw-in-base64-out. Per ulteriori informazioni, consulta Opzioni della riga di comando globali supportate da AWS CLI.

3. Verifica che la funzione abbia creato una versione in miniatura dell'immagine e l'abbia salvata nel bucket Amazon S3 di destinazione. Esegui il comando della CLI sotto riportato sostituendo DOC-EXAMPLE-SOURCE-BUCKET-resized con il nome del tuo bucket di destinazione.

   aws s3api list-objects-v2 --bucket DOC-EXAMPLE-SOURCE-BUCKET-resized

   Verrà visualizzato un output simile al seguente. Il parametro Key mostra il nome del file di immagine ridimensionato.

   {
       "Contents": [
           {
               "Key": "resized-HappyFace.jpg",
               "LastModified": "2023-06-06T21:40:07+00:00",
               "ETag": "\"d8ca652ffe83ba6b721ffc20d9d7174a\"",
               "Size": 2633,
               "StorageClass": "STANDARD"
           }
       ]
   }

Test della funzione tramite il trigger Amazon S3

Ora che hai verificato che la funzione Lambda funziona correttamente, puoi testare la configurazione completa aggiungendo un file di immagine al tuo bucket di origine Amazon S3. Quando aggiungi l'immagine al bucket di origine, la tua funzione Lambda dovrebbe essere richiamata automaticamente. La tua funzione crea una versione ridimensionata del file e la archivia nel bucket di destinazione.

AWS Management Console

Test della funzione Lambda tramite il trigger Amazon S3 (console)

1. Per caricare un'immagine nel bucket Amazon S3, procedi come segue:

   1. Apri la pagina Bucket della console Amazon S3 e scegli il bucket di origine.

   2. Scegli Carica.

   3. Scegli Aggiungi file e utilizza il selettore di file per scegliere il file di immagine da caricare. L'oggetto dell'immagine può essere qualsiasi file .jpg o .png.

   4. Seleziona Apri, quindi Carica.

2. Verifica che Lambda abbia salvato una versione ridimensionata del tuo file di immagine nel bucket di destinazione effettuando le seguenti operazioni:

   1. Torna alla pagina Bucket della console Amazon S3 e scegli il bucket di destinazione.

   2. Nel riquadro Oggetti, ora dovresti vedere due file di immagine ridimensionati, uno per ogni test della tua funzione Lambda. Per scaricare l'immagine ridimensionata, seleziona il file, quindi scegli Scarica.

AWS CLI

Test della funzione Lambda tramite il trigger Amazon S3 (AWS CLI)

1. Dalla directory contenente l'immagine che desideri caricare, esegui il comando della CLI sotto riportato. Sostituisci il parametro --bucket con il nome del bucket di origine. Per i parametri --key e --body, usa il nome del file dell'immagine di test. L'immagine di test può essere qualsiasi file .jpg o .png.

   aws s3api put-object --bucket DOC-EXAMPLE-SOURCE-BUCKET --key SmileyFace.jpg --body ./SmileyFace.jpg

2. Verifica che la funzione abbia creato una versione in miniatura dell'immagine e l'abbia salvata nel bucket Amazon S3 di destinazione. Esegui il comando della CLI sotto riportato sostituendo DOC-EXAMPLE-SOURCE-BUCKET-resized con il nome del tuo bucket di destinazione.

   aws s3api list-objects-v2 --bucket DOC-EXAMPLE-SOURCE-BUCKET-resized

   Se la tua funzione viene eseguita correttamente, vedrai un output simile al seguente. Il bucket di destinazione dovrebbe ora contenere due file ridimensionati.

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

Pulizia delle risorse

Ora è possibile eliminare le risorse create per questo tutorial, a meno che non si voglia conservarle. Eliminando AWS le risorse che non utilizzi più, eviti addebiti inutili a tuo Account AWS carico.

Per eliminare la funzione Lambda

1. Aprire la pagina Functions (Funzioni) della console Lambda.

2. Selezionare la funzione creata.

3. Scegliere Operazioni, Elimina.

4. Digita delete nel campo di immissione testo e scegli Delete (Elimina).

Per eliminare la policy creata

1. Aprire la pagina Policies (Policy) nella console IAM.

2. Seleziona la politica che hai creato (AWSLambdaS3Policy).

3. Scegliere Policy actions (Operazioni policy), Delete (Elimina).

4. Scegliere Delete (Elimina).

Per eliminare il ruolo di esecuzione

1. Aprire la pagina Ruoli della console IAM.

2. Selezionare il ruolo di esecuzione creato.

3. Scegliere Elimina.

4. Inserisci il nome del ruolo nel campo di immissione testo e seleziona Delete (Elimina).

Per eliminare il bucket S3

1. Aprire la console Amazon S3.

2. Selezionare il bucket creato in precedenza.

3. Scegliere Delete (Elimina).

4. Inserisci il nome del bucket nel campo di immissione testo.

5. Scegli Delete Bucket (Elimina bucket).