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

# Utilizzo di Amazon Rekognition e Lambda per etichettare gli asset in un bucket Amazon S3
<a name="images-lambda-s3-tutorial"></a>

In questo tutorial, crei una AWS Lambda funzione che tagga automaticamente le risorse digitali che si trovano in un bucket Amazon S3. La funzione Lambda legge tutti gli oggetti da un determinato bucket Amazon S3. Per ogni oggetto nel bucket, passa l'immagine al servizio Amazon Rekognition per generare una serie di etichette. Ogni etichetta viene utilizzata per creare un tag da applicare all'immagine. Dopo aver eseguito la funzione Lambda, crea automaticamente tag basati su tutte le immagini in un determinato bucket Amazon S3 e li applica alle immagini.

Ad esempio, supponiamo di eseguire la funzione Lambda e di avere questa immagine in un bucket Amazon S3.

![Vulcano in eruzione con lava fusa che scorre lungo i suoi fianchi contro un cielo nuvoloso.](http://docs.aws.amazon.com/it_it/rekognition/latest/dg/images/v2-image-tutorial-picture.png)


L'applicazione crea quindi automaticamente i tag e li applica all'immagine.

![Tabella che mostra i tag per il monitoraggio dei costi di stoccaggio, tra cui Nature, Volcano, Eruption, Lava, Mountain e Outdoors con valori numerici.](http://docs.aws.amazon.com/it_it/rekognition/latest/dg/images/v2-image-tutorial-results.png)


**Nota**  
I servizi utilizzati in questo tutorial fanno parte del piano gratuito. AWS Quando hai finito con il tutorial, ti consigliamo di eliminare tutte le risorse che hai creato durante il tutorial in modo da non ricevere alcun addebito.

Questo tutorial utilizza l'AWSSDK for Java versione 2. Consulta l'[ GitHub archivio degli esempi di AWS Documentation SDK](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javav2/usecases) per ulteriori tutorial su Java V2.

**Topics**
+ [Prerequisiti](#lambda-s3-tutorial-prerequisites)
+ [Configurazione del ruolo IAM Lambda](#lambda-s3-tutorial-lambda-role)
+ [Creazione del progetto](#lambda-s3-tutorial-pom)
+ [Scrivi il codice](#lambda-s3-tutorial-code)
+ [Package del progetto](#lambda-s3-tutorial-package)
+ [Distribuire la funzione Lambda](#lambda-s3-tutorial-deploy)
+ [Test del metodo Lambda](#lambda-s3-tutorial-test)

## Prerequisiti
<a name="lambda-s3-tutorial-prerequisites"></a>

Prima di iniziare, devi completare i passaggi descritti in [Configurazione dell'AWSSDK for Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html). Poi assicurati di disporre di:
+ Java 1.8 JDK.
+ Maven 3.6 o versione successiva.
+ Un bucket [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) con 5-7 immagini della natura. Queste immagini vengono lette dalla funzione Lambda.

## Configurazione del ruolo IAM Lambda
<a name="lambda-s3-tutorial-lambda-role"></a>

Questo tutorial utilizza i servizi Amazon Rekognition e Amazon S3. Configura il ruolo **lambda-support** per disporre di politiche che gli consentano di richiamare questi servizi da una funzione Lambda.

**Per configurare il ruolo**

1. Accedi Console di gestione AWS e apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Nel riquadro di navigazione seleziona **Ruoli**, quindi scegli **Crea ruolo**.

1. Scegliere **AWSServizio**, quindi scegliere **Lambda**.

1. Scegli la scheda **Autorizzazioni**.

1. Cercare **AWSLambdaBasicExecutionRole**.

1. Scegli **Tag successivi**.

1. Scegli **Rivedi**.

1. Assegna un nome al ruolo **lambda-support**.

1. Scegli **Crea ruolo**.

1. Scegli **lambda-support** per visualizzare la pagina di panoramica.

1. Scegli **Collega policy**.

1. Scegli *AmazonRekognitionFullAccess*dall'elenco delle politiche.

1. Scegli **Collega policy**.

1. **Cerca **AmazonS3 FullAccess**, quindi scegli Allega politica.**

## Creazione del progetto
<a name="lambda-s3-tutorial-pom"></a>

Crea un nuovo progetto Java, quindi configura Maven pom.xml con le impostazioni e le dipendenze richieste. Assicurati che il file pom.xml sia simile al seguente:

```
<?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>WorkflowTagAssets</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>java-basic-function</name>
<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>bom</artifactId>
            <version>2.10.54</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
<dependencies>
   <dependency>
        <groupId>com.amazonaws</groupId>
        <artifactId>aws-lambda-java-core</artifactId>
        <version>1.2.1</version>
    </dependency>
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.8.6</version>
    </dependency>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-api</artifactId>
        <version>2.10.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>2.13.0</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-slf4j18-impl</artifactId>
        <version>2.13.3</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.6.0</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-engine</artifactId>
        <version>5.6.0</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>com.googlecode.json-simple</groupId>
        <artifactId>json-simple</artifactId>
        <version>1.1.1</version>
    </dependency>
    <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>s3</artifactId>
    </dependency>
    <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>rekognition</artifactId>
    </dependency>
</dependencies>
<build>
    <plugins>
        <plugin>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.22.2</version>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>3.2.2</version>
            <configuration>
                <createDependencyReducedPom>false</createDependencyReducedPom>
            </configuration>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
            </configuration>
        </plugin>
    </plugins>
  </build>
 </project>
```

## Scrivi il codice
<a name="lambda-s3-tutorial-code"></a>

Utilizzate l'API Java AWS Lambda runtime per creare la classe Java che definisce la funzione Lambda. In questo esempio, esiste una classe Java per la funzione Lambda denominata **Handler** e classi aggiuntive richieste per questo caso d'uso. La figura seguente mostra le classi Java del progetto. Notate che tutte le classi Java si trovano in un pacchetto denominato **com.example.tags**.

![Struttura del progetto che mostra le classi Java per l'etichettatura di risorse nel flusso di lavoro come AnalyzePhotos BucketItem, Handler, S3Service e. WorkItem](http://docs.aws.amazon.com/it_it/rekognition/latest/dg/images/v2-image-tutorial-files.png)


Create le seguenti classi Java per il codice:
+ **Handler** utilizza l'API run-time Lambda Java ed esegue lo use case descritto in questo tutorial. AWS La logica dell'applicazione che viene eseguita si trova nel metodo handleRequest.
+ **S3Service** utilizza l'API Amazon S3 per eseguire operazioni S3.
+ **AnalyzePhotos**utilizza l'API Amazon Rekognition per analizzare le immagini.
+ **BucketItem**definisce un modello che memorizza le informazioni sui bucket Amazon S3.
+ **WorkItem**definisce un modello che archivia i dati di Amazon Rekognition.

### Classe gestore
<a name="w2aac52b9c25c11"></a>

Questo codice Java rappresenta la classe **Gestore**. La classe legge un flag passato alla funzione Lambda. **Il servizio S3. ListBucketObjects**metodo restituisce un oggetto **List** in cui ogni elemento è un valore di stringa che rappresenta la chiave dell'oggetto. Se il valore del flag è true, i tag vengono applicati scorrendo l'elenco e applicando i tag a ciascun oggetto chiamando il metodo **s3Service.tagAssets**. Se il valore del flag è false, allora **S3Service. deleteTagFromViene richiamato il metodo Object** che elimina i tag. Inoltre, tieni presente che puoi registrare i messaggi CloudWatch nei log di Amazon utilizzando un **LambdaLogger**oggetto.

**Nota**  
Assicurati di assegnare il nome del bucket alla variabile **bucketName**.

```
package com.example.tags;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class Handler implements RequestHandler<Map<String,String>, String> {

@Override
public String handleRequest(Map<String, String> event, Context context) {
    LambdaLogger logger = context.getLogger();
    String delFlag = event.get("flag");
    logger.log("FLAG IS: " + delFlag);
    S3Service s3Service = new S3Service();
    AnalyzePhotos photos = new AnalyzePhotos();

    String bucketName = "<Enter your bucket name>";
    List<String> myKeys = s3Service.listBucketObjects(bucketName);
    if (delFlag.compareTo("true") == 0) {

        // Create a List to store the data.
        List<ArrayList<WorkItem>> myList = new ArrayList<>();

        // loop through each element in the List and tag the assets.
        for (String key : myKeys) {

            byte[] keyData = s3Service.getObjectBytes(bucketName, key);

            // Analyze the photo and return a list where each element is a WorkItem.
            ArrayList<WorkItem> item = photos.detectLabels(keyData, key);
            myList.add(item);
        }

        s3Service.tagAssets(myList, bucketName);
        logger.log("All Assets in the bucket are tagged!");

    } else {

        // Delete all object tags.
        for (String key : myKeys) {
            s3Service.deleteTagFromObject(bucketName, key);
            logger.log("All Assets in the bucket are deleted!");
        }
     }
    return delFlag;
  }
 }
```

### Classe S3Service
<a name="w2aac52b9c25c13"></a>

La classe seguente utilizza l'API Amazon S3 per eseguire operazioni S3. Ad esempio, il **getObjectBytes**metodo restituisce un array di byte che rappresenta l'immagine. Allo stesso modo, il **listBucketObjects**metodo restituisce un oggetto **List** in cui ogni elemento è un valore di stringa che specifica il nome della chiave.

```
 package com.example.tags;

 import software.amazon.awssdk.core.ResponseBytes;
 import software.amazon.awssdk.regions.Region;
 import software.amazon.awssdk.services.s3.S3Client;
 import software.amazon.awssdk.services.s3.model.GetObjectRequest;
 import software.amazon.awssdk.services.s3.model.PutObjectTaggingRequest;
 import software.amazon.awssdk.services.s3.model.GetObjectResponse;
 import software.amazon.awssdk.services.s3.model.S3Exception;
 import software.amazon.awssdk.services.s3.model.ListObjectsResponse;
 import software.amazon.awssdk.services.s3.model.S3Object;
 import software.amazon.awssdk.services.s3.model.GetObjectTaggingResponse;
 import software.amazon.awssdk.services.s3.model.ListObjectsRequest;
 import java.util.ArrayList;
 import java.util.List;
 import software.amazon.awssdk.services.s3.model.Tagging;
 import software.amazon.awssdk.services.s3.model.Tag;
 import software.amazon.awssdk.services.s3.model.GetObjectTaggingRequest;
 import software.amazon.awssdk.services.s3.model.DeleteObjectTaggingRequest;

 public class S3Service {

 private S3Client getClient() {

    Region region = Region.US_WEST_2;
    return S3Client.builder()
            .region(region)
            .build();
 }

 public byte[] getObjectBytes(String bucketName, String keyName) {

    S3Client s3 = getClient();

    try {

        GetObjectRequest objectRequest = GetObjectRequest
                .builder()
                .key(keyName)
                .bucket(bucketName)
                .build();

        // Return the byte[] from this object.
        ResponseBytes<GetObjectResponse> objectBytes = s3.getObjectAsBytes(objectRequest);
        return objectBytes.asByteArray();

    } catch (S3Exception e) {
        System.err.println(e.awsErrorDetails().errorMessage());
        System.exit(1);
    }
    return null;
 }

 // Returns the names of all images in the given bucket.
 public List<String> listBucketObjects(String bucketName) {

    S3Client s3 = getClient();
    String keyName;

    List<String> keys = new ArrayList<>();

    try {
        ListObjectsRequest listObjects = ListObjectsRequest
                .builder()
                .bucket(bucketName)
                .build();

        ListObjectsResponse res = s3.listObjects(listObjects);
        List<S3Object> objects = res.contents();

        for (S3Object myValue: objects) {
            keyName = myValue.key();
            keys.add(keyName);
        }
        return keys;

    } catch (S3Exception e) {
        System.err.println(e.awsErrorDetails().errorMessage());
        System.exit(1);
    }
    return null;
 }

 // Tag assets with labels in the given list.
 public void tagAssets(List myList, String bucketName) {

    try {

        S3Client s3 = getClient();
        int len = myList.size();

        String assetName = "";
        String labelName = "";
        String labelValue = "";

        // Tag all the assets in the list.
        for (Object o : myList) {

            // Need to get the WorkItem from each list.
            List innerList = (List) o;
            for (Object value : innerList) {

                WorkItem workItem = (WorkItem) value;
                assetName = workItem.getKey();
                labelName = workItem.getName();
                labelValue = workItem.getConfidence();
                tagExistingObject(s3, bucketName, assetName, labelName, labelValue);
            }
        }

    } catch (S3Exception e) {
        System.err.println(e.awsErrorDetails().errorMessage());
        System.exit(1);
    }
 }

 // This method tags an existing object.
 private void tagExistingObject(S3Client s3, String bucketName, String key, String label, String LabelValue) {

    try {

        // First need to get existing tag set; otherwise the existing tags are overwritten.
        GetObjectTaggingRequest getObjectTaggingRequest = GetObjectTaggingRequest.builder()
                .bucket(bucketName)
                .key(key)
                .build();

        GetObjectTaggingResponse response = s3.getObjectTagging(getObjectTaggingRequest);

        // Get the existing immutable list - cannot modify this list.
        List<Tag> existingList = response.tagSet();
        ArrayList<Tag> newTagList = new ArrayList(new ArrayList<>(existingList));

        // Create a new tag.
        Tag myTag = Tag.builder()
                .key(label)
                .value(LabelValue)
                .build();

        // push new tag to list.
        newTagList.add(myTag);
        Tagging tagging = Tagging.builder()
                .tagSet(newTagList)
                .build();

        PutObjectTaggingRequest taggingRequest = PutObjectTaggingRequest.builder()
                .key(key)
                .bucket(bucketName)
                .tagging(tagging)
                .build();

        s3.putObjectTagging(taggingRequest);
        System.out.println(key + " was tagged with " + label);

    } catch (S3Exception e) {
        System.err.println(e.awsErrorDetails().errorMessage());
        System.exit(1);
    }
  }

 // Delete tags from the given object.
 public void deleteTagFromObject(String bucketName, String key) {

    try {

        DeleteObjectTaggingRequest deleteObjectTaggingRequest = DeleteObjectTaggingRequest.builder()
                .key(key)
                .bucket(bucketName)
                .build();

        S3Client s3 = getClient();
        s3.deleteObjectTagging(deleteObjectTaggingRequest);

    } catch (S3Exception e) {
        System.err.println(e.awsErrorDetails().errorMessage());
        System.exit(1);
    }
  }
}
```

### AnalyzePhotos classe
<a name="w2aac52b9c25c15"></a>

Il seguente codice Java rappresenta la **AnalyzePhotos**classe. Questa classe utilizza l'API Amazon Rekognition per analizzare le immagini.

```
package com.example.tags;

import software.amazon.awssdk.auth.credentials.EnvironmentVariableCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.Image;
import software.amazon.awssdk.services.rekognition.model.DetectLabelsRequest;
import software.amazon.awssdk.services.rekognition.model.DetectLabelsResponse;
import software.amazon.awssdk.services.rekognition.model.Label;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import java.util.ArrayList;
import java.util.List;

public class AnalyzePhotos {

 // Returns a list of WorkItem objects that contains labels.
 public ArrayList<WorkItem> detectLabels(byte[] bytes, String key) {

    Region region = Region.US_EAST_2;
    RekognitionClient rekClient = RekognitionClient.builder()
            .credentialsProvider(EnvironmentVariableCredentialsProvider.create())
            .region(region)
            .build();

    try {

        SdkBytes sourceBytes = SdkBytes.fromByteArray(bytes);

        // Create an Image object for the source image.
        Image souImage = Image.builder()
                .bytes(sourceBytes)
                .build();

        DetectLabelsRequest detectLabelsRequest = DetectLabelsRequest.builder()
                .image(souImage)
                .maxLabels(10)
                .build();

        DetectLabelsResponse labelsResponse = rekClient.detectLabels(detectLabelsRequest);

        // Write the results to a WorkItem instance.
        List<Label> labels = labelsResponse.labels();
        ArrayList<WorkItem> list = new ArrayList<>();
        WorkItem item ;
        for (Label label: labels) {
            item = new WorkItem();
            item.setKey(key); // identifies the photo.
            item.setConfidence(label.confidence().toString());
            item.setName(label.name());
            list.add(item);
        }
        return list;

    } catch (RekognitionException e) {
        System.out.println(e.getMessage());
        System.exit(1);
    }
    return null ;
  }
}
```

### BucketItem classe
<a name="w2aac52b9c25c17"></a>

Il seguente codice Java rappresenta la **BucketItem**classe che memorizza i dati degli oggetti Amazon S3.

```
package com.example.tags;

public class BucketItem {

 private String key;
 private String owner;
 private String date ;
 private String size ;


 public void setSize(String size) {
    this.size = size ;
 }

 public String getSize() {
    return this.size ;
 }

 public void setDate(String date) {
    this.date = date ;
 }

 public String getDate() {
    return this.date ;
 }

 public void setOwner(String owner) {
    this.owner = owner ;
 }

 public String getOwner() {
    return this.owner ;
 }

 public void setKey(String key) {
    this.key = key ;
 }

 public String getKey() {
    return this.key ;
 }
}
```

### WorkItem classe
<a name="w2aac52b9c25c19"></a>

Il seguente codice Java rappresenta la **WorkItem**classe.

```
 package com.example.tags;

 public class WorkItem {

 private String key;
 private String name;
 private String confidence ;

public void setKey (String key) {
    this.key = key;
}

public String getKey() {
    return this.key;
}

public void setName (String name) {
    this.name = name;
}

public String getName() {
    return this.name;
}

public void setConfidence (String confidence) {
    this.confidence = confidence;
}

public String getConfidence() {
    return this.confidence;
}

}
```

## Package del progetto
<a name="lambda-s3-tutorial-package"></a>

Package del progetto in un file.jar (JAR) utilizzando il seguente comando Maven.

```
mvn package
```

Il file JAR si trova nella cartella di **destinazione** (che è una cartella secondaria della cartella del progetto).

![Finestra di esplorazione dei file che mostra la cartella di destinazione con file JAR come WorkflowTagAssets -1.0-Snapshot.jar e altri file e cartelle di progetto.](http://docs.aws.amazon.com/it_it/rekognition/latest/dg/images/v2-image-tutorial-folder.png)


**Nota**  
Notate l'uso di nel file POM del progetto. **maven-shade-plugin** Questo plugin è responsabile della creazione di un JAR che contiene le dipendenze richieste. Se tenti di impacchettare il progetto senza questo plugin, le dipendenze richieste non sono incluse nel file JAR e incontrerai un. **ClassNotFoundException**

## Distribuire la funzione Lambda
<a name="lambda-s3-tutorial-deploy"></a>

1. Aprire la [console Lambda](https://console.aws.amazon.com/lambda/home).

1. Selezionare **Create function (Crea funzione)**.

1. Scegli **Author from scratch** (Crea da zero).

1. Nella sezione **Informazioni di base**, inserisci **cron** come nome.

1. In **Runtime**, selezionare **Java 8**.

1. Scegliere **Usa un ruolo esistente**, quindi scegliere **lambda-support** (il ruolo IAM creato).

1. Scegli **Crea funzione**.

1. In **Tipo di voce del codice**, scegli **Carica un file .zip o un file .jar**.

1. Scegli **Carica**, quindi naviga fino al file JAR che hai creato.

1. Per **Handler**, inserite il nome completo della funzione, ad esempio **com.example.tags.Handler:handleRequest** (**com.example.tags** specifica il pacchetto, **Handler** è la classe seguita da :: e il nome del metodo).

1. Scegli **Save** (Salva).

## Test del metodo Lambda
<a name="lambda-s3-tutorial-test"></a>

A questo punto del tutorial, è possibile testare la funzione Lambda.

1. Nella console Lambda, fai clic sulla scheda **Test**, quindi inserisci il seguente codice JSON.

   ```
                    {
   "flag": "true"
    }
   ```  
![Prova l'editor JSON degli eventi con una coppia chiave-valore flag, i pulsanti Elimina e Format e il pulsante Invoke.](http://docs.aws.amazon.com/it_it/rekognition/latest/dg/images/v2-image-tutorial-test.png)
**Nota**  
Se si passa a **true** tags alle risorse digitali e si passa a **false**, i tag vengono eliminati.

1. Scegliete il pulsante **Invoke**. Dopo aver richiamato la funzione Lambda, viene visualizzato un messaggio di successo.  
![Messaggio del risultato dell'esecuzione che indica che l'operazione è riuscita, con un pulsante Dettagli.](http://docs.aws.amazon.com/it_it/rekognition/latest/dg/images/v2-image-tutorial-success.png)

Congratulazioni, hai creato una AWS Lambda funzione che applica automaticamente i tag agli asset digitali che si trovano in un bucket Amazon S3. Come indicato all'inizio di questo tutorial, assicurati di terminare tutte le risorse che hai creato durante lo svolgimento di questo tutorial per assicurarti che non ti vengano addebitati costi.

[Per altri esempi AWS multiservizio, consulta l'archivio degli esempi di Documentation SDK. AWS GitHub ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javav2/usecases)