Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Verwenden von Amazon Rekognition und Lambda zum Taggen von Assets in einem Amazon-S3-Bucket
<a name="images-lambda-s3-tutorial"></a>

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.

![Vulkanausbruch, an dessen Seiten geschmolzene Lava vor einem wolkenverhangenen Himmel herunterströmt.](http://docs.aws.amazon.com/de_de/rekognition/latest/dg/images/v2-image-tutorial-picture.png)


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

![Tabelle mit Tags zur Erfassung der Lagerkosten, einschließlich Natur, Vulkan, Eruption, Lava, Berg und Im Freien mit numerischen Werten.](http://docs.aws.amazon.com/de_de/rekognition/latest/dg/images/v2-image-tutorial-results.png)


**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 [AWSDocumentation SDK Examples GitHub Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javav2/usecases).

**Topics**
+ [Voraussetzungen](#lambda-s3-tutorial-prerequisites)
+ [Konfigurieren der IAM-Lambda-Rolle](#lambda-s3-tutorial-lambda-role)
+ [Erstellen des Projekts](#lambda-s3-tutorial-pom)
+ [Schreiben des Codes](#lambda-s3-tutorial-code)
+ [Projekt verpacken](#lambda-s3-tutorial-package)
+ [Stellen Sie die Lambda-Funktion bereit](#lambda-s3-tutorial-deploy)
+ [Lambda-Methode testen](#lambda-s3-tutorial-test)

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

Bevor Sie beginnen, müssen Sie die Schritte unter [Einrichten des AWS SDK for Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html) ausführen. Dann stellen Sie sicher, dass Sie Folgendes haben:
+ Java 1.8 JDK.
+ Maven 3.6 oder höher.
+ Ein [Amazon-S3-Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) mit 5 bis 7 Naturbildern. Diese Bilder werden von der Lambda-Funktion gelesen.

## Konfigurieren der IAM-Lambda-Rolle
<a name="lambda-s3-tutorial-lambda-role"></a>

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-Managementkonsole und öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

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

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

1. Wählen Sie die Registerkarte **Berechtigungen**.

1. Suchen Sie nach **AWSLambdaBasicExecutionRole**.

1. Wählen Sie **Nächste Tags**.

1. Wählen Sie **Überprüfen**.

1. Nennen Sie die Rolle **lambda-support**.

1. Wählen Sie **Rolle erstellen** aus.

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

1. Wählen Sie **Richtlinien anfügen**.

1. Wählen Sie *AmazonRekognitionFullAccess*aus der Liste der Richtlinien aus.

1. Wählen Sie **Richtlinie anfügen** aus.

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

## Erstellen des Projekts
<a name="lambda-s3-tutorial-pom"></a>

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
<a name="lambda-s3-tutorial-code"></a>

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.

![Projektstruktur mit Java-Klassen für Workflow-Tagging von Assets wie AnalyzePhotos,, Handler BucketItem, S3Service und. WorkItem](http://docs.aws.amazon.com/de_de/rekognition/latest/dg/images/v2-image-tutorial-files.png)


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.
+ **AnalyzePhotos**verwendet die Amazon Rekognition API, um die Bilder zu analysieren.
+ **BucketItem**definiert ein Modell, das Amazon S3 S3-Bucket-Informationen speichert.
+ **WorkItem**definiert ein Modell, das Amazon Rekognition Rekognition-Daten speichert.

### Handler-Klasse
<a name="w2aac52b9c25c11"></a>

Dieser Java-Code repräsentiert die **Handler**-Klasse. Die Klasse liest ein Flag, das an die Lambda-Funktion übergeben wird. **Der S3-Service. ListBucketObjects**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 **LambdaLogger**Objekts 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
<a name="w2aac52b9c25c13"></a>

Die folgende Klasse verwendet die Amazon-S3-API, um S3-Operationen durchzuführen. Die **getObjectBytes**Methode gibt beispielsweise ein Byte-Array zurück, das das Bild darstellt. Ebenso gibt die **listBucketObjects**Methode 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
<a name="w2aac52b9c25c15"></a>

Der folgende Java-Code repräsentiert die **AnalyzePhotos**Klasse. 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
<a name="w2aac52b9c25c17"></a>

Der folgende Java-Code stellt die **BucketItem**Klasse 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
<a name="w2aac52b9c25c19"></a>

Der folgende Java-Code repräsentiert die **WorkItem**Klasse.

```
 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
<a name="lambda-s3-tutorial-package"></a>

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

![Datei-Explorer-Fenster mit dem Zielordner mit JAR-Dateien wie WorkflowTagAssets -1.0-Snapshot.jar und anderen Projektdateien und -ordnern.](http://docs.aws.amazon.com/de_de/rekognition/latest/dg/images/v2-image-tutorial-folder.png)


**Anmerkung**  
Beachten Sie die Verwendung von **maven-shade-plugin**in 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
<a name="lambda-s3-tutorial-deploy"></a>

1. Öffnen Sie die [Lambda-Konsole](https://console.aws.amazon.com/lambda/home).

1. Wählen Sie **Funktion erstellen**.

1. Wählen Sie **Von Grund auf neu schreiben** aus.

1. Geben Sie im Abschnitt **Grundinformationen** **cron** als Namen ein.

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

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

1. Wählen Sie **Funktion erstellen**.

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

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

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

1. Wählen Sie **Speichern**.

## Lambda-Methode testen
<a name="lambda-s3-tutorial-test"></a>

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"
    }
   ```  
![Testen Sie den JSON-Editor für Ereignisse mit einem Flaggen-Schlüssel-Wert-Paar, den Schaltflächen Löschen und Formatieren sowie der Schaltfläche Aufrufen.](http://docs.aws.amazon.com/de_de/rekognition/latest/dg/images/v2-image-tutorial-test.png)
**Anmerkung**  
Die Übergabe von **wahr** kennzeichnet die digitalen Assets und die Übergabe von **falsch** löscht die Tags.

1. Wählen Sie die Schaltfläche **Aufrufen**. Nachdem die Lambda-Funktion aufgerufen wurde, wird eine Erfolgsmeldung angezeigt.  
![Meldung des Ausführungsergebnisses, die angibt, dass der Vorgang erfolgreich war, mit einer Schaltfläche „Details“.](http://docs.aws.amazon.com/de_de/rekognition/latest/dg/images/v2-image-tutorial-success.png)

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 ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javav2/usecases)