Utilisation d’Amazon Rekognition et Lambda pour étiqueter les actifs dans un compartiment Amazon S3

Dans ce didacticiel, vous allez créer une AWS Lambda fonction qui balise automatiquement les actifs numériques situés dans un compartiment Amazon S3. La fonction Lambda lit tous les objets dans un compartiment Amazon S3 donné. Pour chaque objet du compartiment, elle transmet l’image au service Amazon Rekognition afin de générer une série d’étiquettes. Chaque étiquette est utilisée pour créer une étiquette qui est appliquée à l’image. Une fois que vous avez exécuté la fonction Lambda, elle crée automatiquement des balises basées sur toutes les images d’un compartiment Amazon S3 donné et les applique aux images.

Supposons, par exemple, que vous exécutiez la fonction Lambda et que vous disposiez de cette image dans un compartiment Amazon S3.

L’application crée ensuite automatiquement des balises et les applique à l’image.

Note

Les services que vous utilisez dans ce didacticiel font partie du niveau AWS gratuit. Lorsque vous aurez terminé le didacticiel, nous vous recommandons de supprimer toutes les ressources que vous avez créées pendant le didacticiel afin qu’elles ne vous soient pas facturées.

Ce didacticiel utilise le AWS SDK pour Java version 2. Consultez le GitHub référentiel d'exemples du SDK de AWS documentation pour des didacticiels supplémentaires sur Java V2.

Prérequis

Avant de commencer, vous devez suivre les étapes décrites dans Configuration du AWS SDK for Java. Veillez à effectuer les opérations suivantes :

• Java 1.8 JDK.

• Apache Maven 3.6 ou version ultérieure.

• Un compartiment Amazon S3 contenant 5 à 7 images nature. Ces images sont lues par la fonction Lambda.

Configuration du rôle IAM Lambda

Ce didacticiel utilise les services Amazon Rekognition et Amazon S3. Configurez le rôle Lambda support pour disposer de politiques lui permettant d’appeler ces services à partir d’une fonction Lambda.

Pour configurer le rôle

1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à https://console.aws.amazon.com/iam/l'adresse.

2. Dans le panneau de navigation, choisissez Rôles, puis Créer un rôle.

3. Choisissez Service AWS , puis choisissez Lambda.

4. Choisissez l’onglet Permissions (Autorisations).

5. Recherchez AWSLambdaBasicExecutionRole.

6. Choisissez Balises suivantes.

7. Choisissez Examiner.

8. Nommez le rôle lambda-support.

9. Choisissez Créer un rôle.

10. Choisissez lambda-support pour afficher la page de présentation.

11. Choisissez Attach Policies (Attacher des politiques).

12. AmazonRekognitionFullAccessChoisissez dans la liste des politiques.

13. Choisissez Attach policy (Attacher la politique).

14. Recherchez AmazonS3 FullAccess, puis choisissez Attach policy.

Création du projet

Créez un nouveau projet Java, puis configurez le fichier Maven pom.xml avec les paramètres et dépendances requis. Assurez-vous que votre fichier pom.xml ressemble à ce qui suit :

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

Ecriture du code

Utilisez l'API Java AWS Lambda d'exécution pour créer la classe Java qui définit la fonction Lambda. Dans cet exemple, il existe une classe Java pour la fonction Lambda nommée Handler et des classes supplémentaires sont requises pour ce cas d’utilisation. L’illustration suivante représente les classes Java du projet. Notez que toutes les classes Java se trouvent dans un package nommé com.example.tags.

Créez les classes Java suivantes pour le code :

• Handler utilise l'API d'exécution Lambda Java et exécute le cas d'utilisation décrit dans ce didacticiel. AWS La logique de l’application exécutée se trouve dans la méthode handleRequest.

• S3Service utilise l’API Amazon S3 pour effectuer des opérations S3.

• AnalyzePhotosutilise l'API Amazon Rekognition pour analyser les images.

• BucketItemdéfinit un modèle qui stocke les informations du compartiment Amazon S3.

• WorkItemdéfinit un modèle qui stocke les données Amazon Rekognition.

Classe de gestionnaire :

Ce code Java représente la classe Gestionnaire. La classe lit un drapeau qui est transmis à la fonction Lambda. Le service S3. ListBucketObjectsméthode renvoie un objet List où chaque élément est une valeur de chaîne qui représente la clé de l'objet. Si la valeur de l’indicateur est vraie, les balises sont appliquées en parcourant la liste et en appliquant des balises à chaque objet en appelant la méthode s3Service.tagAssets. Si la valeur de l'indicateur est fausse, alors le S3Service. deleteTagFromLa méthode Object est invoquée pour supprimer les balises. Notez également que vous pouvez enregistrer des messages dans Amazon CloudWatch Logs à l'aide d'un LambdaLoggerobjet.

Note

Assurez-vous d’attribuer le nom de votre compartiment à la variable 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 suivante utilise l’API Amazon S3 pour effectuer des opérations S3. Par exemple, la getObjectBytesméthode renvoie un tableau d'octets qui représente l'image. De même, la listBucketObjectsméthode renvoie un objet List où chaque élément est une valeur de chaîne spécifiant le nom de la clé.

 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

Le code Java suivant représente la AnalyzePhotosclasse. Cette classe utilise l’API Amazon Rekognition pour analyser les images.

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

Le code Java suivant représente la BucketItemclasse qui stocke les données des objets 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

Le code Java suivant représente 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 du projet

Empaquetez le projet dans un fichier .jar (JAR) à l’aide de la commande Maven suivante.

mvn package

Le fichier JAR se trouve dans le dossier cible (qui est un dossier enfant du dossier du projet).

Note

Notez l'utilisation du maven-shade-plugindans le fichier POM du projet. Ce plugin est chargé de créer un fichier JAR contenant les dépendances requises. Si vous essayez d'empaqueter le projet sans ce plugin, les dépendances requises ne sont pas incluses dans le fichier JAR et vous rencontrerez un ClassNotFoundException.

Déployez la fonction Lambda.

1. Ouvrez la console Lambda.

2. Choisissez Créer une fonction.

3. Choisissez Créer à partir de zéro.

4. Dans la section Informations de base, entrez cron comme nom.

5. Dans Exécution, choisissez Java 8.

6. Choisissez Utiliser un rôle existant, puis le rôle service Lambda (le rôle IAM que vous avez créé).

7. Choisissez Créer une fonction.

8. Dans Type d’entrée de code, choisissez Charger un fichier .zip ou .jar.

9. Choisissez Charger, puis naviguez jusqu’au fichier JAR que vous avez créé.

10. Pour Gestionnaire, entrez le nom complet de la fonction, par exemple com.example.tags.handler:handleRequest (com.example.tags indique le package, Gestionnaire est la classe suivie de : : et du nom de la méthode).

11. Choisissez Enregistrer.

Test de la méthode Lambda

À ce stade du didacticiel, vous pouvez tester la fonction Lambda.

1. Dans la console Lambda, cliquez sur l’onglet Test, puis entrez le code JSON suivant.

   
                    {
   "flag": "true"
    }
               

   

   Note

   Transmission des balises true aux actifs numériques et transmission false supprime les balises.

2. Choisissez le bouton Invoquer. Une fois la fonction Lambda invoquée, vous voyez un message de réussite.

   

Félicitations, vous avez créé une AWS Lambda fonction qui applique automatiquement des balises aux actifs numériques situés dans un compartiment Amazon S3. Comme indiqué au début de ce didacticiel, veillez à supprimer toutes les ressources que vous avez créées au cours de ce didacticiel pour vous assurer que vous n’êtes pas facturé.

Pour d'autres exemples AWS multiservices, consultez le référentiel d'exemples GitHub du SDK de AWS documentation.