Verwenden von Amazon Rekognition und Lambda zum Taggen von Assets in einem Amazon-S3-Bucket

In diesem Tutorial erstellen Sie eine AWS Lambda Funktion, die digitale Assets, die sich in einem Amazon S3-Bucket befinden, automatisch kennzeichnet. Die Lambda-Funktion liest alle Objekte aus einem bestimmten Amazon-S3-Bucket. Für jedes Objekt im Bucket wird das Bild an den Amazon-Rekognition-Service übergeben, um eine Reihe von Labels zu generieren. Jedes Label wird verwendet, um ein Tag zu erstellen, das auf das Bild angewendet wird. Nachdem Sie die Lambda-Funktion ausgeführt haben, erstellt sie automatisch Tags, die auf allen Bildern in einem bestimmten Amazon-S3-Bucket basieren, und wendet sie auf die Bilder an.

Nehmen wir zum Beispiel an, Sie führen die Lambda-Funktion aus und haben dieses Bild in einem Amazon-S3-Bucket.

Die Anwendung erstellt dann automatisch Tags und wendet sie auf das Bild an.

Anmerkung

Die Dienste, die Sie in diesem Tutorial nutzen, sind Teil des AWS kostenlosen Kontingents. Wenn Sie mit dem Tutorial fertig sind, empfehlen wir, alle Ressourcen, die Sie während des Tutorials erstellt haben, zu beenden, damit Ihnen nichts berechnet wird.

Dieses Tutorial verwendet das AWS SDK for Java Version 2. Weitere Anleitungen zu Java V2 finden Sie im AWS Documentation SDK Examples GitHub Repository.

Voraussetzungen

Bevor Sie beginnen, müssen Sie die Schritte unter Einrichten des AWS SDK for Java ausführen. Dann stellen Sie sicher, dass Sie Folgendes haben:

• Java 1.8 JDK.

• Maven 3.6 oder höher.

• Ein Amazon-S3-Bucket mit 5 bis 7 Naturbildern. Diese Bilder werden von der Lambda-Funktion gelesen.

Konfigurieren der IAM-Lambda-Rolle

In diesem Tutorial werden die Dienste Amazon Rekognition und Amazon S3 verwendet. Konfigurieren Sie die lambda-support-Rolle so, dass sie über Richtlinien verfügt, die es ihr ermöglichen, diese Dienste von einer Lambda-Funktion aus aufzurufen.

Konfigurieren Sie die Rolle wie folgt:

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die IAM-Konsole unter https://console.aws.amazon.com/iam/.

2. Wählen Sie im Navigationsbereich Rollen und dann Rolle erstellen aus.

3. Wählen Sie AWS -Service und anschließend Lambda aus.

4. Wählen Sie die Registerkarte Berechtigungen.

5. Suchen Sie nach AWSLambdaBasicExecutionRole.

6. Wählen Sie Nächste Tags.

7. Wählen Sie Überprüfen.

8. Nennen Sie die Rolle lambda-support.

9. Wählen Sie Rolle erstellen aus.

10. Wählen Sie lambda-support, um die Übersichtsseite aufzurufen.

11. Wählen Sie Richtlinien anfügen.

12. Wählen Sie AmazonRekognitionFullAccessaus der Liste der Richtlinien aus.

13. Wählen Sie Richtlinie anfügen aus.

14. Suchen Sie nach AmazonS3 FullAccess und wählen Sie dann Attach policy aus.

Erstellen des Projekts

Erstellen Sie ein neues Java-Projekt und konfigurieren Sie dann die Datei Maven pom.xml mit den erforderlichen Einstellungen und Abhängigkeiten. Stellen Sie sicher, dass Ihre pom.xml-Datei wie folgt aussieht:

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

Schreiben des Codes

Verwenden Sie die AWS Lambda Runtime-Java-API, um die Java-Klasse zu erstellen, die die Lambda-Funktion definiert. In diesem Beispiel gibt es eine Java-Klasse für die Lambda-Funktion namens Handler und zusätzliche Klassen, die für diesen Anwendungsfall erforderlich sind. In der folgenden Abbildung sind die Java-Klassen im Projekt dargestellt. Beachten Sie, dass sich alle Java-Klassen in einem Paket mit dem Namen com.example.tags befinden.

Erstellen Sie die folgenden Java-Klassen für den Code:

• Handler verwendet die Lambda-Java-Laufzeit-API und führt den in diesem Tutorial beschriebenen Anwendungsfall durch. AWS Die ausgeführte Anwendungslogik befindet sich in der Methode handleRequest.

• S3Service verwendet die Amazon-S3-API, um S3-Operationen durchzuführen.

• AnalyzePhotosverwendet die Amazon Rekognition API, um die Bilder zu analysieren.

• BucketItemdefiniert ein Modell, das Amazon S3 S3-Bucket-Informationen speichert.

• WorkItemdefiniert ein Modell, das Amazon Rekognition Rekognition-Daten speichert.

Handler-Klasse

Dieser Java-Code repräsentiert die Handler-Klasse. Die Klasse liest ein Flag, das an die Lambda-Funktion übergeben wird. Der S3-Service. ListBucketObjectsDie Methode gibt ein List-Objekt zurück, wobei jedes Element ein Zeichenkettenwert ist, der den Objektschlüssel darstellt. Wenn der Flag-Wert wahr ist, werden Tags angewendet, indem durch die Liste iteriert und Tags auf jedes Objekt angewendet werden, indem die Methode s3Service.tagAssets aufgerufen wird. Wenn der Flag-Wert falsch ist, dann der S3Service. deleteTagFromEs wird eine Objektmethode aufgerufen, die die Tags löscht. Beachten Sie auch, dass Sie Nachrichten mithilfe eines LambdaLoggerObjekts in CloudWatch Amazon-Protokollen protokollieren können.

Anmerkung

Stellen Sie sicher, dass Sie Ihren Bucket-Namen der Variablen bucketName zuweisen.

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

S3Service-Klasse

Die folgende Klasse verwendet die Amazon-S3-API, um S3-Operationen durchzuführen. Die getObjectBytesMethode gibt beispielsweise ein Byte-Array zurück, das das Bild darstellt. Ebenso gibt die listBucketObjectsMethode ein List-Objekt zurück, bei dem jedes Element ein Zeichenkettenwert ist, der den Schlüsselnamen angibt.

 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 Klasse

Der folgende Java-Code repräsentiert die AnalyzePhotosKlasse. Diese Klasse verwendet die Amazon-Rekognition-API, um die Bilder zu analysieren.

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 Klasse

Der folgende Java-Code stellt die BucketItemKlasse dar, die Amazon S3 S3-Objektdaten speichert.

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 Klasse

Der folgende Java-Code repräsentiert die WorkItemKlasse.

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

}

Projekt verpacken

Package Sie das Projekt mithilfe des folgenden Maven-Befehls in eine JAR-Datei (JAR).

mvn package

Die JAR-Datei befindet sich im Zielordner (der ein untergeordneter Ordner des Projektordners ist).

Anmerkung

Beachten Sie die Verwendung von maven-shade-pluginin der POM-Datei des Projekts. Dieses Plug-In ist dafür verantwortlich, ein JAR zu erstellen, das die erforderlichen Abhängigkeiten enthält. Wenn Sie versuchen, das Projekt ohne dieses Plugin zu verpacken, sind die erforderlichen Abhängigkeiten nicht in der JAR-Datei enthalten und Sie werden auf eine stoßen. ClassNotFoundException

Stellen Sie die Lambda-Funktion bereit

1. Öffnen Sie die Lambda-Konsole.

2. Wählen Sie Funktion erstellen.

3. Wählen Sie Von Grund auf neu schreiben aus.

4. Geben Sie im Abschnitt Grundinformationen cron als Namen ein.

5. Wählen Sie in Laufzeit die Option Java 8 aus.

6. Wählen Sie Vorhandene Rolle verwenden und wählen Sie dann lambda-support (die von Ihnen erstellte IAM-Rolle).

7. Wählen Sie Funktion erstellen aus.

8. Wählen Sie für Codeeingabetyp die Option ZIP- oder JAR-Datei hochladen aus.

9. Wählen Sie Hochladen aus und suchen Sie dann die JAR-Datei, die Sie erstellt haben.

10. Geben Sie für Handler den vollqualifizierten Namen der Funktion ein, z. B. com.example.tags.handler:HandleRequest (com.example.tags gibt das Paket an, Handler ist die Klasse, gefolgt von :: und Methodenname).

11. Wählen Sie Save (Speichern) aus.

Lambda-Methode testen

An diesem Punkt des Tutorials können Sie die Lambda-Funktion testen.

1. Klicken Sie in der Lambda-Konsole auf die Registerkarte Test und geben Sie dann den folgenden JSON-Code ein.

   
                    {
   "flag": "true"
    }
               

   

   Anmerkung

   Die Übergabe von wahr kennzeichnet die digitalen Assets und die Übergabe von falsch löscht die Tags.

2. Wählen Sie die Schaltfläche Aufrufen. Nachdem die Lambda-Funktion aufgerufen wurde, wird eine Erfolgsmeldung angezeigt.

   

Herzlichen Glückwunsch, Sie haben eine AWS Lambda Funktion erstellt, die automatisch Tags auf digitale Assets anwendet, die sich in einem Amazon S3 S3-Bucket befinden. Wie zu Beginn dieses Tutorials erwähnt, sollten Sie darauf achten, alle Ressourcen zu beenden, die Sie während der Bearbeitung dieses Tutorials erstellt haben, um sicherzustellen, dass Ihnen nichts in Rechnung gestellt wird.

Weitere AWS Multiservice-Beispiele finden Sie im Documentation SDK Examples Repository.AWS GitHub