Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Elaborare le notifiche di eventi Amazon S3 con Lambda
È possibile utilizzare Lambda per elaborare le [notifiche degli eventi](https://docs.aws.amazon.com/AmazonS3/latest/userguide/NotificationHowTo.html) da Amazon Simple Storage Service. Amazon S3 può inviare un evento a una funzione Lambda quando un oggetto viene creato o eliminato. È possibile configurare le impostazioni di notifica su un bucket e concedere ad Amazon S3 l'autorizzazione a invocare una funzione sulla policy di autorizzazione basata sulle risorse della funzione.
**avvertimento**
Se la funzione Lambda utilizza lo stesso bucket che la attiva, potrebbe causare l'esecuzione della funzione in loop. Ad esempio, se il bucket attiva una funzione ogni volta che un oggetto viene caricato e la funzione carica un oggetto nel bucket, allora la funzione indirettamente lo attiva. Per evitare questo, utilizzare due bucket, oppure configurare il trigger in modo che venga applicato solo a un prefisso utilizzato per gli oggetti in entrata.
Amazon S3 richiama la funzione [in modo asincrono](invocation-async.md) con un evento che contiene dettagli sull'oggetto. L'esempio seguente mostra un evento che Amazon S3 ha inviato quando un pacchetto di distribuzione è stato caricato su Amazon S3.
**Example Evento di notifica Amazon S3**
```
{
"Records": [
{
"eventVersion": "2.1",
"eventSource": "aws:s3",
"awsRegion": "us-east-2",
"eventTime": "2019-09-03T19:37:27.192Z",
"eventName": "ObjectCreated:Put",
"userIdentity": {
"principalId": "AWS:AIDAINPONIXQXHT3IKHL2"
},
"requestParameters": {
"sourceIPAddress": "205.255.255.255"
},
"responseElements": {
"x-amz-request-id": "D82B88E5F771F645",
"x-amz-id-2": "vlR7PnpV2Ce81l0PRw6jlUpck7Jo5ZsQjryTjKlc5aLWGVHPZLj5NeC6qMa0emYBDXOo6QBU0Wo="
},
"s3": {
"s3SchemaVersion": "1.0",
"configurationId": "828aa6fc-f7b5-4305-8584-487c791949c1",
"bucket": {
"name": "amzn-s3-demo-bucket",
"ownerIdentity": {
"principalId": "A3I5XTEXAMAI3E"
},
"arn": "arn:aws:s3:::lambda-artifacts-deafc19498e3f2df"
},
"object": {
"key": "b21b84d653bb07b05b1e6b33684dc11b",
"size": 1305107,
"eTag": "b21b84d653bb07b05b1e6b33684dc11b",
"sequencer": "0C0F6F405D6ED209E1"
}
}
}
]
}
```
Per richiamare la funzione, Amazon S3 necessita dell'autorizzazione dalla [policy basata su risorse](access-control-resource-based.md) della funzione. Quando si configura un trigger Amazon S3 nella console Lambda, la console modifica la policy basata su risorse per consentire ad Amazon S3 di richiamare la funzione se il nome del bucket e l'ID account corrispondono. Se si configura la notifica in Amazon S3, si utilizza l'API Lambda per aggiornare la policy. È inoltre possibile utilizzare l'API Lambda per concedere l'autorizzazione a un altro account o limitare l'autorizzazione a un alias designato.
[Se la tua funzione utilizza l' AWS SDK per gestire le risorse Amazon S3, necessita anche delle autorizzazioni Amazon S3 nel suo ruolo di esecuzione.](lambda-intro-execution-role.md)
**Topics**
+ [Tutorial: uso di un trigger Amazon S3 per richiamare una funzione Lambda](with-s3-example.md)
+ [Tutorial: uso di un trigger Amazon S3 per creare immagini in miniatura](with-s3-tutorial.md)
# Tutorial: uso di un trigger Amazon S3 per richiamare una funzione Lambda
In questo tutorial si utilizzerà la console per creare una funzione Lambda e configurare un trigger per un bucket Amazon Simple Storage Service (Amazon S3). Ogni volta che aggiungi un oggetto al tuo bucket Amazon S3, la funzione viene eseguita e invia il tipo di oggetto in Amazon Logs. CloudWatch
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-s3-example/s3_tut_config.png)
Questo tutorial dimostra come:
1. Crea un bucket Amazon S3.
1. Crea una funzione Lambda che restituisce il tipo di oggetto in un bucket Amazon S3.
1. Configura un trigger Lambda che richiami la tua funzione quando gli oggetti vengono caricati nel bucket.
1. Prova la tua funzione, prima con un evento fittizio e poi usando il trigger.
Completando questi passaggi, imparerai come configurare una funzione Lambda da eseguire ogni volta che vengono aggiunti o eliminati oggetti da un bucket Amazon S3. Puoi completare questo tutorial soltanto dalla Console di gestione AWS.
## Crea un bucket Amazon S3
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps1.png)
**Come creare un bucket Amazon S3.**
1. Apri la [console Amazon S3](https://console.aws.amazon.com/s3) e seleziona la pagina **Bucket per uso generico**.
1. Seleziona quello più Regione AWS vicino alla tua posizione geografica. Puoi modificare la regione utilizzando l'elenco a discesa nella parte superiore dello schermo. Più avanti nel tutorial, è necessario creare la funzione Lambda nella stessa regione.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/console_region_select.png)
1. Scegliere **Create bucket (Crea bucket)**.
1. In **General configuration (Configurazione generale)**, eseguire le operazioni seguenti:
1. Per **Tipo di secchio**, assicurati che sia selezionata l'**opzione Uso generale**.
1. Per **Nome del bucket**, inserisci un nome univoco globale che soddisfi le [regole di denominazione dei bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html) di Amazon S3. I nomi dei bucket possono contenere solo lettere minuscole, numeri, punti (.) e trattini (-).
1. Lascia tutte le altre opzioni impostate sui valori predefiniti e scegli **Crea bucket**.
## Caricamento di un oggetto di test in un bucket
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps2.png)
**Caricamento di un oggetto di test**
1. Apri la pagina [Bucket](https://console.aws.amazon.com/s3/buckets) della console Amazon S3 e scegli il bucket che hai creato durante il passaggio precedente.
1. Scegli **Carica**.
1. Scegli **Aggiungi file** e seleziona l'oggetto da caricare. È possibile selezionare qualsiasi file (ad esempio, `HappyFace.jpg`).
1. Seleziona **Apri**, quindi **Carica**.
Più avanti nel tutorial, testerai la funzione Lambda utilizzando questo oggetto.
## Creazione di una policy di autorizzazione
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps3.png)
Crea una politica di autorizzazioni che consenta a Lambda di ottenere oggetti da un bucket Amazon S3 e di scriverli su Amazon Logs. CloudWatch
**Come creare la policy**
1. Apri la pagina [Policies (Policy)](https://console.aws.amazon.com/iam/home#/policies) nella console IAM.
1. Scegli **Crea policy**.
1. Scegliere la scheda **JSON** e quindi incollare la seguente policy personalizzata nell'editor JSON.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:PutLogEvents",
"logs:CreateLogGroup",
"logs:CreateLogStream"
],
"Resource": "arn:aws:logs:*:*:*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::*/*"
}
]
}
```
------
1. Scegliere **Next: Tags (Successivo: Tag)**.
1. Scegliere **Next:Review (Successivo: Rivedi)**.
1. In **Rivedi policy**, per **Nome** della policy inserisci **s3-trigger-tutorial**.
1. Scegli **Crea policy**.
## Creazione di un ruolo di esecuzione
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps4.png)
Un [ruolo di esecuzione](lambda-intro-execution-role.md) è un ruolo AWS Identity and Access Management (IAM) che concede a una funzione Lambda l'autorizzazione all' Servizi AWS accesso e alle risorse. In questa fase, creare un ruolo di esecuzione utilizzando la policy di autorizzazioni creata nel passaggio precedente.
**Creazione di un ruolo di esecuzione e collegamento di una policy di autorizzazione personalizzata**
1. Aprire la [pagina Roles (Ruoli)](https://console.aws.amazon.com/iam/home#/roles) della console IAM.
1. Scegli **Crea ruolo**.
1. Per il tipo di entità attendibile, scegli **Servizio AWS **, quindi per il caso d'uso seleziona **Lambda**.
1. Scegli **Next (Successivo)**.
1. Nella casella di ricerca delle policy, immettere **s3-trigger-tutorial**.
1. Nei risultati della ricerca, seleziona la policy creata (`s3-trigger-tutorial`), quindi scegli **Next** (Successivo).
1. In **Role details** (Dettagli del ruolo), per **Role name** (Nome del ruolo), specifica **lambda-s3-trigger-role**, quindi scegli **Create role** (Crea ruolo).
## Creazione della funzione Lambda
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps5.png)
Crea una funzione Lambda nella console usando il runtime Python 3.14.
**Creazione della funzione Lambda**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. 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.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/console_region_select.png)
1. Scegli **Crea funzione**.
1. Scegli **Crea da zero**.
1. In **Basic information (Informazioni di base)** eseguire queste operazioni:
1. Nel campo **Nome funzione**, inserisci `s3-trigger-tutorial`.
1. Per **Runtime**, scegli **Python 3.14**.
1. In **Architecture** (Architettura), scegli **x86\$164**.
1. Nella scheda **Modifica ruolo di esecuzione predefinito**, effettua le seguenti operazioni:
1. Espandi la scheda, quindi scegli **Utilizza un ruolo esistente**.
1. Seleziona il `lambda-s3-trigger-role` che hai creato in precedenza.
1. Scegli **Crea funzione**.
## Implementazione del codice della funzione
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps6.png)
Questo tutorial utilizza il runtime di Python 3.14, ma abbiamo anche fornito file di codice di esempio per altri runtime. Per visualizzare il codice per il runtime che ti interessa, seleziona la scheda corrispondente nella casella seguente.
La funzione Lambda recupera il nome della chiave dell'oggetto caricato e il nome del bucket dal parametro `event` che riceve da Amazon S3. La funzione utilizza quindi il metodo [get\$1object](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/s3/client/get_object.html) di AWS SDK per Python (Boto3) per recuperare i metadati dell'oggetto, incluso il tipo di contenuto (tipo MIME) dell'oggetto caricato.
**Implementazione del codice della funzione**
1. Scegli la scheda **Python** nella casella seguente e copia il codice.
------
#### [ .NET ]
**SDK per .NET**
C'è altro su. GitHub Trova l'esempio completo e scopri come eseguire la configurazione e l'esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Utilizzo di un evento S3 con Lambda tramite .NET.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
using System.Threading.Tasks;
using Amazon.Lambda.Core;
using Amazon.S3;
using System;
using Amazon.Lambda.S3Events;
using System.Web;
// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
namespace S3Integration
{
public class Function
{
private static AmazonS3Client _s3Client;
public Function() : this(null)
{
}
internal Function(AmazonS3Client s3Client)
{
_s3Client = s3Client ?? new AmazonS3Client();
}
public async Task Handler(S3Event evt, ILambdaContext context)
{
try
{
if (evt.Records.Count <= 0)
{
context.Logger.LogLine("Empty S3 Event received");
return string.Empty;
}
var bucket = evt.Records[0].S3.Bucket.Name;
var key = HttpUtility.UrlDecode(evt.Records[0].S3.Object.Key);
context.Logger.LogLine($"Request is for {bucket} and {key}");
var objectResult = await _s3Client.GetObjectAsync(bucket, key);
context.Logger.LogLine($"Returning {objectResult.Key}");
return objectResult.Key;
}
catch (Exception e)
{
context.Logger.LogLine($"Error processing request - {e.Message}");
return string.Empty;
}
}
}
}
```
------
#### [ Go ]
**SDK per Go V2**
C'è dell'altro GitHub. Trova l'esempio completo e scopri come eseguire la configurazione e l'esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Utilizzo di un evento S3 con Lambda tramite Go.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package main
import (
"context"
"log"
"github.com/aws/aws-lambda-go/events"
"github.com/aws/aws-lambda-go/lambda"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/s3"
)
func handler(ctx context.Context, s3Event events.S3Event) error {
sdkConfig, err := config.LoadDefaultConfig(ctx)
if err != nil {
log.Printf("failed to load default config: %s", err)
return err
}
s3Client := s3.NewFromConfig(sdkConfig)
for _, record := range s3Event.Records {
bucket := record.S3.Bucket.Name
key := record.S3.Object.URLDecodedKey
headOutput, err := s3Client.HeadObject(ctx, &s3.HeadObjectInput{
Bucket: &bucket,
Key: &key,
})
if err != nil {
log.Printf("error getting head of object %s/%s: %s", bucket, key, err)
return err
}
log.Printf("successfully retrieved %s/%s of type %s", bucket, key, *headOutput.ContentType)
}
return nil
}
func main() {
lambda.Start(handler)
}
```
------
#### [ Java ]
**SDK per Java 2.x**
C'è dell'altro GitHub. Trova l'esempio completo e scopri come eseguire la configurazione e l'esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Utilizzo di un evento S3 con Lambda tramite Java.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package example;
import software.amazon.awssdk.services.s3.model.HeadObjectRequest;
import software.amazon.awssdk.services.s3.model.HeadObjectResponse;
import software.amazon.awssdk.services.s3.S3Client;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.S3Event;
import com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification.S3EventNotificationRecord;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class Handler implements RequestHandler {
private static final Logger logger = LoggerFactory.getLogger(Handler.class);
@Override
public String handleRequest(S3Event s3event, Context context) {
try {
S3EventNotificationRecord record = s3event.getRecords().get(0);
String srcBucket = record.getS3().getBucket().getName();
String srcKey = record.getS3().getObject().getUrlDecodedKey();
S3Client s3Client = S3Client.builder().build();
HeadObjectResponse headObject = getHeadObject(s3Client, srcBucket, srcKey);
logger.info("Successfully retrieved " + srcBucket + "/" + srcKey + " of type " + headObject.contentType());
return "Ok";
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private HeadObjectResponse getHeadObject(S3Client s3Client, String bucket, String key) {
HeadObjectRequest headObjectRequest = HeadObjectRequest.builder()
.bucket(bucket)
.key(key)
.build();
return s3Client.headObject(headObjectRequest);
}
}
```
------
#### [ JavaScript ]
**SDK per JavaScript (v3)**
C'è altro da fare. GitHub Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Consumo di un evento S3 con JavaScript Lambda utilizzando.
```
import { S3Client, HeadObjectCommand } from "@aws-sdk/client-s3";
const client = new S3Client();
export const handler = async (event, context) => {
// Get the object from the event and show its content type
const bucket = event.Records[0].s3.bucket.name;
const key = decodeURIComponent(event.Records[0].s3.object.key.replace(/\+/g, ' '));
try {
const { ContentType } = await client.send(new HeadObjectCommand({
Bucket: bucket,
Key: key,
}));
console.log('CONTENT TYPE:', ContentType);
return ContentType;
} catch (err) {
console.log(err);
const message = `Error getting object ${key} from bucket ${bucket}. Make sure they exist and your bucket is in the same region as this function.`;
console.log(message);
throw new Error(message);
}
};
```
Consumo di un evento S3 con TypeScript Lambda utilizzando.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
import { S3Event } from 'aws-lambda';
import { S3Client, HeadObjectCommand } from '@aws-sdk/client-s3';
const s3 = new S3Client({ region: process.env.AWS_REGION });
export const handler = async (event: S3Event): Promise => {
// Get the object from the event and show its content type
const bucket = event.Records[0].s3.bucket.name;
const key = decodeURIComponent(event.Records[0].s3.object.key.replace(/\+/g, ' '));
const params = {
Bucket: bucket,
Key: key,
};
try {
const { ContentType } = await s3.send(new HeadObjectCommand(params));
console.log('CONTENT TYPE:', ContentType);
return ContentType;
} catch (err) {
console.log(err);
const message = `Error getting object ${key} from bucket ${bucket}. Make sure they exist and your bucket is in the same region as this function.`;
console.log(message);
throw new Error(message);
}
};
```
------
#### [ PHP ]
**SDK per PHP**
C'è altro da fare. GitHub Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Utilizzo di un evento S3 con Lambda tramite PHP.
```
logger = $logger;
}
public function handleS3(S3Event $event, Context $context) : void
{
$this->logger->info("Processing S3 records");
// Get the object from the event and show its content type
$records = $event->getRecords();
foreach ($records as $record)
{
$bucket = $record->getBucket()->getName();
$key = urldecode($record->getObject()->getKey());
try {
$fileSize = urldecode($record->getObject()->getSize());
echo "File Size: " . $fileSize . "\n";
// TODO: Implement your custom processing logic here
} catch (Exception $e) {
echo $e->getMessage() . "\n";
echo 'Error getting object ' . $key . ' from bucket ' . $bucket . '. Make sure they exist and your bucket is in the same region as this function.' . "\n";
throw $e;
}
}
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
------
#### [ Python ]
**SDK per Python (Boto3)**
C'è dell'altro GitHub. Trova l'esempio completo e scopri come eseguire la configurazione e l'esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Utilizzo di un evento S3 con Lambda tramite Python.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
import json
import urllib.parse
import boto3
print('Loading function')
s3 = boto3.client('s3')
def lambda_handler(event, context):
#print("Received event: " + json.dumps(event, indent=2))
# Get the object from the event and show its content type
bucket = event['Records'][0]['s3']['bucket']['name']
key = urllib.parse.unquote_plus(event['Records'][0]['s3']['object']['key'], encoding='utf-8')
try:
response = s3.get_object(Bucket=bucket, Key=key)
print("CONTENT TYPE: " + response['ContentType'])
return response['ContentType']
except Exception as e:
print(e)
print('Error getting object {} from bucket {}. Make sure they exist and your bucket is in the same region as this function.'.format(key, bucket))
raise e
```
------
#### [ Ruby ]
**SDK per Ruby**
C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Utilizzo di un evento S3 con Lambda tramite Ruby.
```
require 'json'
require 'uri'
require 'aws-sdk'
puts 'Loading function'
def lambda_handler(event:, context:)
s3 = Aws::S3::Client.new(region: 'region') # Your AWS region
# puts "Received event: #{JSON.dump(event)}"
# Get the object from the event and show its content type
bucket = event['Records'][0]['s3']['bucket']['name']
key = URI.decode_www_form_component(event['Records'][0]['s3']['object']['key'], Encoding::UTF_8)
begin
response = s3.get_object(bucket: bucket, key: key)
puts "CONTENT TYPE: #{response.content_type}"
return response.content_type
rescue StandardError => e
puts e.message
puts "Error getting object #{key} from bucket #{bucket}. Make sure they exist and your bucket is in the same region as this function."
raise e
end
end
```
------
#### [ Rust ]
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri come eseguire la configurazione e l'esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Utilizzo di un evento S3 con Lambda tramite Rust.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
use aws_lambda_events::event::s3::S3Event;
use aws_sdk_s3::{Client};
use lambda_runtime::{run, service_fn, Error, LambdaEvent};
/// Main function
#[tokio::main]
async fn main() -> Result<(), Error> {
tracing_subscriber::fmt()
.with_max_level(tracing::Level::INFO)
.with_target(false)
.without_time()
.init();
// Initialize the AWS SDK for Rust
let config = aws_config::load_from_env().await;
let s3_client = Client::new(&config);
let res = run(service_fn(|request: LambdaEvent| {
function_handler(&s3_client, request)
})).await;
res
}
async fn function_handler(
s3_client: &Client,
evt: LambdaEvent
) -> Result<(), Error> {
tracing::info!(records = ?evt.payload.records.len(), "Received request from SQS");
if evt.payload.records.len() == 0 {
tracing::info!("Empty S3 event received");
}
let bucket = evt.payload.records[0].s3.bucket.name.as_ref().expect("Bucket name to exist");
let key = evt.payload.records[0].s3.object.key.as_ref().expect("Object key to exist");
tracing::info!("Request is for {} and object {}", bucket, key);
let s3_get_object_result = s3_client
.get_object()
.bucket(bucket)
.key(key)
.send()
.await;
match s3_get_object_result {
Ok(_) => tracing::info!("S3 Get Object success, the s3GetObjectResult contains a 'body' property of type ByteStream"),
Err(_) => tracing::info!("Failure with S3 Get Object request")
}
Ok(())
}
```
------
1. Nel riquadro **Codice sorgente** della console Lambda, incolla il codice nell'editor di codice, sostituendo il codice creato da Lambda.
1. Nella sezione **DEPLOY**, scegli **Implementa** per aggiornare il codice della tua funzione:
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
## Creazione del trigger Amazon S3
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps7.png)
**Creazione del trigger Amazon S3**
1. Nel riquadro **Panoramica della funzione**, scegli **Aggiungi trigger**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/overview-trigger.png)
1. Seleziona **S3**.
1. In **Bucket**, seleziona il bucket che hai creato in precedenza nel tutorial.
1. In **Tipi di eventi**, verifica che sia selezionata l'opzione **Tutti gli eventi di creazione di oggetti**.
1. In **Invocazione ricorsiva**, seleziona la casella di controllo per confermare che non è consigliabile utilizzare lo stesso bucket Amazon S3 per input e output.
1. Scegliere **Aggiungi**.
**Nota**
Quando crei un trigger Amazon S3 per una funzione Lambda utilizzando la console Lambda, Amazon S3 configura una [notifica degli eventi](https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html) sul bucket specificato. Prima di configurare questa notifica di evento, Amazon S3 esegue una serie di controlli per confermare che la destinazione dell'evento esista e disponga delle policy IAM richieste. Amazon S3 esegue questi test anche su qualsiasi altra notifica di eventi configurata per quel bucket.
A causa di questo controllo, se il bucket ha precedentemente configurato destinazioni di eventi per risorse che non esistono più o per risorse che non dispongono delle policy di autorizzazione richieste, Amazon S3 non sarà in grado di creare la nuova notifica di evento. Verrà visualizzato il seguente messaggio di errore che indica che non è stato possibile creare il trigger:
```
An error occurred when creating the trigger: Unable to validate the following destination configurations.
```
Puoi visualizzare questo errore se in precedenza hai configurato un trigger per un'altra funzione Lambda utilizzando lo stesso bucket e da allora hai eliminato la funzione o modificato le sue policy di autorizzazioni.
## Test di una funzione Lambda con un evento fittizio
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps8.png)
**Test della funzione Lambda con un evento fittizio**
1. Nella pagina della console Lambda della funzione, seleziona la scheda **Test**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/test-tab.png)
1. Per **Event name (Nome evento)** immettere `MyTestEvent`.
1. Nella sezione **JSON dell'evento**, incolla il seguente evento di test. Assicurati di sostituire i seguenti valori:
+ Sostituisci `us-east-1` con la regione in cui è stato creato il bucket Amazon S3.
+ Sostituisci entrambe le istanze di `amzn-s3-demo-bucket` con il nome del bucket Amazon S3.
+ Sostituisci `test%2FKey` con il nome dell'oggetto di test che hai caricato in precedenza nel tuo bucket (ad esempio, `HappyFace.jpg`).
```
{
"Records": [
{
"eventVersion": "2.0",
"eventSource": "aws:s3",
"awsRegion": "us-east-1",
"eventTime": "1970-01-01T00:00:00.000Z",
"eventName": "ObjectCreated:Put",
"userIdentity": {
"principalId": "EXAMPLE"
},
"requestParameters": {
"sourceIPAddress": "127.0.0.1"
},
"responseElements": {
"x-amz-request-id": "EXAMPLE123456789",
"x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH"
},
"s3": {
"s3SchemaVersion": "1.0",
"configurationId": "testConfigRule",
"bucket": {
"name": "amzn-s3-demo-bucket",
"ownerIdentity": {
"principalId": "EXAMPLE"
},
"arn": "arn:aws:s3:::amzn-s3-demo-bucket"
},
"object": {
"key": "test%2Fkey",
"size": 1024,
"eTag": "0123456789abcdef0123456789abcdef",
"sequencer": "0A1B2C3D4E5F678901"
}
}
}
]
}
```
1. Scegli **Save** (Salva).
1. Scegli **Test (Esegui test)**.
1. Se la tua funzione viene eseguita correttamente, vedrai un output simile al seguente nella scheda **Risultati dell'esecuzione**.
```
Response
"image/jpeg"
Function Logs
START RequestId: 12b3cae7-5f4e-415e-93e6-416b8f8b66e6 Version: $LATEST
2021-02-18T21:40:59.280Z 12b3cae7-5f4e-415e-93e6-416b8f8b66e6 INFO INPUT BUCKET AND KEY: { Bucket: 'amzn-s3-demo-bucket', Key: 'HappyFace.jpg' }
2021-02-18T21:41:00.215Z 12b3cae7-5f4e-415e-93e6-416b8f8b66e6 INFO CONTENT TYPE: image/jpeg
END RequestId: 12b3cae7-5f4e-415e-93e6-416b8f8b66e6
REPORT RequestId: 12b3cae7-5f4e-415e-93e6-416b8f8b66e6 Duration: 976.25 ms Billed Duration: 977 ms Memory Size: 128 MB Max Memory Used: 90 MB Init Duration: 430.47 ms
Request ID
12b3cae7-5f4e-415e-93e6-416b8f8b66e6
```
### Test della funzione Lambda mediante il trigger Amazon S3
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps9.png)
Per verificare la funzione con il trigger configurato, carica un oggetto sul bucket Amazon S3 utilizzando la console. Per verificare che la funzione Lambda sia stata eseguita come previsto, usa CloudWatch Logs per visualizzare l'output della funzione.
**Caricamento di un oggetto nel bucket Amazon S3**
1. Apri la pagina [Bucket](https://console.aws.amazon.com/s3/buckets) della console Amazon S3 e scegli il bucket che hai creato in precedenza.
1. Scegli **Carica**.
1. Scegli **Aggiungi file** e usa il selettore di file per scegliere un oggetto da caricare. Tale oggetto può essere qualsiasi file desideri.
1. Seleziona **Apri**, quindi **Carica**.
**Per verificare l'invocazione della funzione utilizzando Logs CloudWatch**
1. Aprire la console [CloudWatch](https://console.aws.amazon.com/cloudwatch/home).
1. Assicurati di lavorare nella stessa modalità in Regione AWS cui hai creato la funzione Lambda. Puoi modificare la regione utilizzando l'elenco a discesa nella parte superiore dello schermo.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/console_region_select.png)
1. Scegli **Log** e quindi **Gruppi di log**.
1. Scegli il nome del gruppo di log per la funzione (`/aws/lambda/s3-trigger-tutorial`).
1. In **Flussi di log**, scegli il flusso di log più recente.
1. Se la tua funzione è stata richiamata correttamente in risposta al trigger Amazon S3, vedrai un output simile al seguente. Il `CONTENT TYPE` visualizzato dipende dal tipo di file che hai caricato nel bucket.
```
2022-05-09T23:17:28.702Z 0cae7f5a-b0af-4c73-8563-a3430333cc10 INFO CONTENT TYPE: image/jpeg
```
## 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 carico. Account AWS
**Per eliminare la funzione Lambda**
1. Aprire la pagina [Functions (Funzioni)](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Selezionare la funzione creata.
1. Scegliere **Operazioni**, **Elimina**.
1. Inserisci **confirm** nel campo di immissione del testo, quindi scegli **Elimina**.
**Come eliminare il ruolo di esecuzione**
1. Aprire la pagina [Ruoli](https://console.aws.amazon.com/iam/home#/roles) della console IAM.
1. Selezionare il ruolo di esecuzione creato.
1. Scegliere **Elimina**.
1. 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](https://console.aws.amazon.com//s3/home#).
1. Selezionare il bucket creato in precedenza.
1. Scegli **Elimina**.
1. Inserisci il nome del bucket nel campo di immissione testo.
1. Scegli **Delete Bucket** (Elimina bucket).
## Fasi successive
In [Tutorial: uso di un trigger Amazon S3 per creare immagini in miniatura](with-s3-tutorial.md), il trigger Amazon S3 richiama una funzione per creare un'immagine in miniatura per ogni file immagine caricato nel bucket. Questo tutorial richiede un livello moderato di conoscenza del AWS dominio Lambda. Dimostra come creare risorse utilizzando AWS Command Line Interface (AWS CLI) e come creare un pacchetto di distribuzione di archivi di file.zip per la funzione e le sue dipendenze.
# 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.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_resources.png)
Per completare questo tutorial, completa le seguenti attività:
1. Crea i bucket Amazon S3 di origine e destinazione e carica un'immagine di esempio.
1. Crea una funzione Lambda che ridimensiona un'immagine e restituisce una miniatura in un bucket Amazon S3.
1. Configura un trigger Lambda che richiama la tua funzione quando gli oggetti vengono caricati nel bucket di origine.
1. 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 Console di gestione AWS.
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](https://docs.aws.amazon.com/lambda/latest/dg/with-s3-example.html).
**Topics**
+ [Prerequisiti](#with-s3-example-prereqs)
+ [Creazione di due bucket Amazon S3](#with-s3-tutorial-prepare-create-buckets)
+ [Caricamento di un'immagine di test nel bucket di origine](#with-s3-tutorial-test-image)
+ [Creazione di una policy di autorizzazione](#with-s3-tutorial-create-policy)
+ [Creazione di un ruolo di esecuzione](#with-s3-tutorial-create-execution-role)
+ [Creazione del pacchetto di implementazione della funzione](#with-s3-tutorial-create-function-package)
+ [Creazione della funzione Lambda](#with-s3-tutorial-create-function-createfunction)
+ [Configurazione di Amazon S3 per richiamare la funzione](#with-s3-tutorial-configure-s3-trigger)
+ [Test di una funzione Lambda con un evento fittizio](#with-s3-tutorial-dummy-test)
+ [Test della funzione tramite il trigger Amazon S3](#with-s3-tutorial-test-s3)
+ [Pulizia delle risorse](#s3-tutorial-cleanup)
## Prerequisiti
Se vuoi usare 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.
### Installa il AWS Command Line Interface
Se non l'hai ancora installato AWS Command Line Interface, segui i passaggi indicati in [Installazione o aggiornamento della versione più recente di AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) per installarlo.
Per eseguire i comandi nel tutorial, sono necessari un terminale a riga di comando o una shell (interprete di comandi). In Linux e macOS, utilizza la shell (interprete di comandi) e il gestore pacchetti preferiti.
**Nota**
Su Windows, alcuni comandi della CLI Bash utilizzati comunemente con Lambda (ad esempio, `zip`) non sono supportati dai terminali integrati del sistema operativo. Per ottenere una versione integrata su Windows di Ubuntu e Bash, [installa il sottosistema Windows per Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10).
## Creazione di due bucket Amazon S3
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps1.png)
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.
------
#### [ Console di gestione AWS ]
**Creazione di bucket Amazon S3 (console)**
1. Apri la [console Amazon S3](https://console.aws.amazon.com/s3) e seleziona la pagina **General Purpose bucket**.
1. Seleziona quello più Regione AWS vicino alla tua posizione geografica. Puoi modificare la regione utilizzando l'elenco a discesa nella parte superiore dello schermo. Più avanti nel tutorial, è necessario creare la funzione Lambda nella stessa regione.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/console_region_select.png)
1. Scegliere **Create bucket (Crea bucket)**.
1. In **General configuration (Configurazione generale)**, eseguire le operazioni seguenti:
1. Per **Tipo di secchio**, assicurati che sia selezionata l'**opzione Uso generale**.
1. Per **Nome del bucket**, inserisci un nome univoco globale che soddisfi le [regole di denominazione dei bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html) di Amazon S3. I nomi dei bucket possono contenere solo lettere minuscole, numeri, punti (.) e trattini (-).
1. Lascia tutte le altre opzioni impostate sui valori predefiniti e scegli **Crea bucket**.
1. Ripeti i passaggi da 1 a 5 per creare il bucket di destinazione. Per **Nome del bucket**, inserisci `amzn-s3-demo-source-bucket-resized`, dove `amzn-s3-demo-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](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html) di Amazon S3. I nomi possono contenere solo lettere minuscole, numeri, punti (.) e trattini (-). Per `region` e `LocationConstraint`, scegli la [Regione AWS](https://docs.aws.amazon.com/general/latest/gr/lambda-service.html) più vicina alla tua posizione geografica.
```
aws s3api create-bucket --bucket amzn-s3-demo-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 sorgente, quindi prendi nota della regione che hai scelto.
1. Esegui il comando sotto riportato per creare il bucket di destinazione. Per il nome del bucket, devi usare `amzn-s3-demo-source-bucket-resized`, dove `amzn-s3-demo-source-bucket` è il nome del bucket di origine che hai creato nel passaggio 1. Per `region` e`LocationConstraint`, scegli lo stesso Regione AWS che hai usato per creare il bucket sorgente.
```
aws s3api create-bucket --bucket amzn-s3-demo-source-bucket-resized --region us-east-1 \
--create-bucket-configuration LocationConstraint=us-east-1
```
------
## Caricamento di un'immagine di test nel bucket di origine
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps2.png)
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.
------
#### [ Console di gestione AWS ]
**Caricamento di un'immagine di test nel bucket di origine (console)**
1. Nella console Amazon S3, apri la pagina [Bucket](https://console.aws.amazon.com/s3/buckets).
1. Seleziona il bucket di origine che hai creato nella fase precedente.
1. Scegli **Carica**.
1. Scegli **Aggiungi file** e usa il selettore di file per scegliere l'oggetto da caricare.
1. 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 amzn-s3-demo-source-bucket --key HappyFace.jpg --body ./HappyFace.jpg
```
------
## Creazione di una policy di autorizzazione
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps3.png)
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
------
#### [ Console di gestione AWS ]
**Creazione della policy (console)**
1. Apri la pagina [Policies](https://console.aws.amazon.com/iamv2/home#policies) della console (IAM). AWS Identity and Access Management
1. Scegli **Crea policy**.
1. 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:::*/*"
}
]
}
```
1. Scegli **Next (Successivo)**.
1. In **Dettagli sulla policy**, per **Nome policy**, inserisci `LambdaS3Policy`.
1. 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:::*/*"
}
]
}
```
1. 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
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps4.png)
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.
------
#### [ Console di gestione AWS ]
**Creazione di un ruolo di esecuzione e collegamento di una policy di autorizzazione (console)**
1. Apri la pagina [Ruoli](https://console.aws.amazon.com/iamv2/home#roles) della console (IAM).
1. Scegli **Crea ruolo**.
1. Per **Tipo di entità attendibile**, seleziona **Servizio AWS**, mentre per **Caso d'uso**, seleziona **Lambda**.
1. Scegli **Next (Successivo)**.
1. Aggiungi la policy di autorizzazione che hai creato nel passaggio precedente effettuando le seguenti operazioni:
1. Nella casella di ricerca delle policy, immettere `LambdaS3Policy`.
1. Nei risultati di ricerca, seleziona la casella di controllo per `LambdaS3Policy`.
1. Scegli **Next (Successivo)**.
1. In **Dettagli ruolo**, per **Nome ruolo**, inserisci `LambdaS3Role`.
1. 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.com`autorizzazione 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"
}
]
}
```
1. 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
```
1. 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
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps5.png)
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
```
1. Crea un nuovo progetto Node.js con `npm`. Per accettare le opzioni predefinite fornite nell'esperienza interattiva, premi `Enter`.
```
npm init
```
1. Salvare il codice della funzione seguente in un file denominato `index.mjs`. Assicurati di sostituire `us-east-1` con la 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);
};
```
1. 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
```
1. 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))
```
1. Nella stessa directory in cui hai creato il file `lambda_function.py`, crea una nuova directory denominata `package` e installa la libreria [Pillow (PIL)](https://pypi.org/project/Pillow/) e AWS SDK per 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](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 libreria Pillow contiene codice C/C\$1\$1. 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.
1. 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](python-package.md).
------
## Creazione della funzione Lambda
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps6.png)
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.
------
#### [ Console di gestione AWS ]
**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](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. 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.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/console_region_select.png)
1. Selezionare **Create function (Crea funzione)**.
1. Scegli **Author from scratch** (Crea da zero).
1. In **Basic information (Informazioni di base)** eseguire queste operazioni:
1. Nel campo **Function name (Nome funzione)**, immettere `CreateThumbnail`.
1. Per **Runtime**, scegli **Node.js 22.x** o **Python 3.12**, a seconda del linguaggio che hai scelto per la funzione.
1. In **Architecture** (Architettura), scegli **x86\$164**.
1. Nella scheda **Modifica ruolo di esecuzione predefinito**, effettua le seguenti operazioni:
1. Espandi la scheda, quindi scegli **Utilizza un ruolo esistente**.
1. Seleziona il `LambdaS3Role` che hai creato in precedenza.
1. Scegli **Crea funzione**.
**Caricamento del codice della funzione (console)**
1. Nel riquadro **Origine del codice**, scegli **Carica da**.
1. Scegli **File .zip**.
1. Scegli **Carica**.
1. Nel selettore di file, seleziona il tuo file .zip e scegli **Apri**.
1. Scegli **Save** (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 nodejs24.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.14 --timeout 10 --memory-size 1024 \
--role arn:aws:iam::123456789012:role/LambdaS3Role --region us-east-1
```
------
## Configurazione di Amazon S3 per richiamare la funzione
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps7.png)
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)](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/recursive-runaway). Ciò può comportare la fatturazione di addebiti imprevisti al tuo Account AWS.
------
#### [ Console di gestione AWS ]
**Configurazione del trigger Amazon S3 (console)**
1. Apri la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda e scegli la tua funzione (`CreateThumbnail`).
1. Selezionare **Add trigger** (Aggiungi trigger).
1. Seleziona **S3**.
1. In **Bucket**, seleziona il tuo bucket di origine.
1. In **Tipi di eventi**, seleziona **Tutti gli eventi di creazione di oggetti**.
1. 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](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/recursive-runaway) in Serverless Land.
1. Scegliere **Aggiungi**.
Quando crei un trigger utilizzando la console Lambda, Lambda crea automaticamente una [policy basata sulle risorse](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html) 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](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html). 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:::amzn-s3-demo-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).
1. 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" ]
}
]
}
```
1. 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 `amzn-s3-demo-source-bucket` con il nome del tuo bucket di origine.
```
aws s3api put-bucket-notification-configuration --bucket amzn-s3-demo-source-bucket \
--notification-configuration file://notification.json
```
Per ulteriori informazioni sul `put-bucket-notification-configuration` comando e sull'`notification-configuration`opzione, consulta [put-bucket-notification-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-bucket-notification-configuration.html)la *AWS CLI Command* Reference.
------
## Test di una funzione Lambda con un evento fittizio
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps8.png)
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.
------
#### [ Console di gestione AWS ]
**Test di una funzione Lambda con un evento fittizio (console)**
1. Apri la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda e scegli la tua funzione (`CreateThumbnail`).
1. Seleziona la scheda **Test**.
1. 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**.
1. Per **Event name (Nome evento)** immettere **myTestEvent**.
1. Per **Modello**, seleziona **S3 Put**.
1. Sostituisci i valori dei seguenti parametri con i tuoi valori.
+ Infatti`awsRegion`, `us-east-1` sostituiscilo con quello in Regione AWS cui hai creato i bucket Amazon S3.
+ Per `name`, sostituisci `amzn-s3-demo-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](#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. Scegli **Save** (Salva).
1. Nel riquadro **Evento di test**, scegli **Test**.
1. 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](https://console.aws.amazon.com/s3/buckets).
1. 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:
+ Infatti`awsRegion`, `us-east-1` sostituiscilo con quello in Regione AWS cui hai creato i bucket Amazon S3.
+ Per `name`, sostituisci `amzn-s3-demo-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](#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. 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](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
```
L' cli-binary-formatopzione è 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](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list).
1. 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 `amzn-s3-demo-source-bucket-resized` con il nome del tuo bucket di destinazione.
```
aws s3api list-objects-v2 --bucket amzn-s3-demo-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
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps9.png)
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.
------
#### [ Console di gestione AWS ]
**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](https://console.aws.amazon.com/s3/buckets) della console Amazon S3 e scegli il bucket di origine.
1. Scegli **Carica**.
1. 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.
1. Seleziona **Apri**, quindi **Carica**.
1. 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](https://console.aws.amazon.com/s3/buckets) della console Amazon S3 e scegli il bucket di destinazione.
1. 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 amzn-s3-demo-source-bucket --key SmileyFace.jpg --body ./SmileyFace.jpg
```
1. 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 `amzn-s3-demo-source-bucket-resized` con il nome del tuo bucket di destinazione.
```
aws s3api list-objects-v2 --bucket amzn-s3-demo-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)](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Selezionare la funzione creata.
1. Scegliere **Operazioni**, **Elimina**.
1. Digita **confirm** nel campo di immissione testo e scegli **Delete** (Elimina).
**Per eliminare la policy creata**
1. Aprire la pagina [Policies (Policy)](https://console.aws.amazon.com/iam/home#/policies) nella console IAM.
1. Seleziona la politica che hai creato (**AWSLambdaS3Policy**).
1. Scegliere **Policy actions (Operazioni policy)**, **Delete (Elimina)**.
1. Scegliere **Delete (Elimina)**.
**Per eliminare il ruolo di esecuzione**
1. Aprire la pagina [Ruoli](https://console.aws.amazon.com/iam/home#/roles) della console IAM.
1. Selezionare il ruolo di esecuzione creato.
1. Scegliere **Elimina**.
1. 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](https://console.aws.amazon.com//s3/home#).
1. Selezionare il bucket creato in precedenza.
1. Scegli **Elimina**.
1. Inserisci il nome del bucket nel campo di immissione testo.
1. Scegli **Delete Bucket** (Elimina bucket).