Utilizzo di Amazon Rekognition e Lambda per etichettare gli asset in un bucket Amazon S3

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.

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

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' AWS SDK for Java versione 2. Consulta l' GitHub archivio degli esempi di AWS Documentation SDK per ulteriori tutorial su Java V2.

Prerequisiti

Prima di iniziare, devi completare i passaggi descritti in Configurazione dell' AWS SDK for Java. Poi assicurati di disporre di:

• Java 1.8 JDK.

• Maven 3.6 o versione successiva.

• Un bucket Amazon S3 con 5-7 immagini della natura. Queste immagini vengono lette dalla funzione Lambda.

Configurazione del ruolo IAM Lambda

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 AWS Management Console e apri la console IAM all'indirizzo https://console.aws.amazon.com/iam/.

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

3. Scegliere AWS Servizio, quindi scegliere Lambda.

4. Scegli la scheda Autorizzazioni.

5. Cercare AWSLambdaBasicExecutionRole.

6. Scegli Tag successivi.

7. Scegli Rivedi.

8. Assegna un nome al ruolo lambda-support.

9. Scegliere Crea ruolo.

10. Scegli lambda-support per visualizzare la pagina di panoramica.

11. Scegli Collega policy.

12. Scegli AmazonRekognitionFullAccessdall'elenco delle politiche.

13. Scegli Collega policy.

14. Cerca AmazonS3 FullAccess, quindi scegli Allega politica.

Creazione del progetto

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

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.

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.

• AnalyzePhotosutilizza l'API Amazon Rekognition per analizzare le immagini.

• BucketItemdefinisce un modello che memorizza le informazioni sui bucket Amazon S3.

• WorkItemdefinisce un modello che archivia i dati di Amazon Rekognition.

Classe gestore

Questo codice Java rappresenta la classe Gestore. La classe legge un flag passato alla funzione Lambda. Il servizio S3. ListBucketObjectsmetodo 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 LambdaLoggeroggetto.

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

La classe seguente utilizza l'API Amazon S3 per eseguire operazioni S3. Ad esempio, il getObjectBytesmetodo restituisce un array di byte che rappresenta l'immagine. Allo stesso modo, il listBucketObjectsmetodo 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

Il seguente codice Java rappresenta la AnalyzePhotosclasse. 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

Il seguente codice Java rappresenta la BucketItemclasse 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

Il seguente codice Java rappresenta la WorkItemclasse.

 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

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

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

1. Aprire la console Lambda.

2. Selezionare Create function (Crea funzione).

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

4. Nella sezione Informazioni di base, inserisci cron come nome.

5. In Runtime, selezionare Java 8.

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

7. Scegli Crea funzione.

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

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

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

11. Seleziona Salva.

Test del metodo Lambda

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

   

   Nota

   Se si passa a true tags alle risorse digitali e si passa a false, i tag vengono eliminati.

2. Scegliete il pulsante Invoke. Dopo aver richiamato la funzione Lambda, viene visualizzato un messaggio di successo.

   

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