Prérequis Création de la rubrique SNS Créer la fonction Lambda Configurer la fonction Lambda Configuration du rôle IAM Lambda Création du projet Lambda AWS Toolkit for Eclipse Test de la fonction Lambda

Création d’une fonction Lambda Amazon Rekognition

Ce didacticiel montre comment obtenir les résultats d’une opération d’analyse vidéo destinée à détecter des étiquettes à l’aide d’une fonction Lambda.

Note

Ce didacticiel utilise le AWS SDK pour Java 1.x. Pour un didacticiel utilisant Rekognition et le SDK pour AWS Java version 2, consultez le référentiel d'exemples du SDK de documentation.AWS GitHub

Vous pouvez utiliser les fonctions Lambda avec les opérations Vidéo Amazon Rekognition. Par exemple, le schéma suivant illustre un site web qui utilise une fonction Lambda pour lancer automatiquement l’analyse d’une vidéo au moment où celle-ci est chargée dans un compartiment Amazon S3. Lorsque la fonction Lambda est déclenchée, elle appelle StartLabelDetectionpour commencer à détecter les étiquettes dans la vidéo téléchargée. Pour plus d’informations sur l’utilisation de la fonction Lambda pour traiter les notifications d’événements à partir d’un compartiment Amazon S3, consultez Utilisation d’AWS Lambda avec Amazon S3 Events.

Une deuxième fonction Lambda est déclenchée lorsque le statut d’achèvement de l’analyse est envoyé à la rubrique Amazon SNS enregistrée. La deuxième fonction Lambda appelle GetLabelDetectionpour obtenir les résultats de l'analyse. Les résultats sont ensuite stockés dans une base de données en vue d’être affichés sur une page web. Cette deuxième fonction lambda est l’objet de ce didacticiel.

Schéma illustrant un processus de traitement vidéo pour Amazon Rekognition Video, depuis le téléchargement d'une vidéo jusqu'au stockage des résultats dans Amazon DynamoDB en vue de leur affichage sur un site Web.

Dans ce didacticiel, la fonction Lambda est déclenchée lorsque Vidéo Amazon Rekognition envoie le statut d’achèvement de l’analyse vidéo à la rubrique Amazon SNS enregistrée. Elle recueille ensuite les résultats de l'analyse vidéo en appelant GetLabelDetection. À des fins de démonstration, ce didacticiel enregistre les résultats de détection d'étiquettes dans un CloudWatch journal. Dans la fonction Lambda de votre application, vous avez tout intérêt à stocker les résultats d’analyse en vue d’une utilisation ultérieure. Par exemple, vous pouvez utiliser Amazon DynamoDB pour enregistrer les résultats d’analyse. Pour plus d’informations, consultez Utilisation de DynamoDB.

Les procédures suivantes vous montrent comment :

Créer la rubrique Amazon SNS et configurer des autorisations.
Créez la fonction Lambda à l'aide du AWS Management Console et abonnez-la à la rubrique Amazon SNS.
Configurer la fonction Lambda à l’aide d’ AWS Management Console.
Ajoutez un exemple de code à un AWS Toolkit for Eclipse projet et chargez-le dans la fonction Lambda.
Tester la fonction Lambda à l’aide de l’ AWS CLI.

Note

Utilisez la même AWS région tout au long du didacticiel.

Prérequis

Ce didacticiel part du principe que vous maîtrisez AWS Toolkit for Eclipse. Pour plus d’informations, consultez AWS Toolkit pour Eclipse.

Le statut d’achèvement d’une opération d’analyse vidéo Vidéo Amazon Rekognition est envoyé à une rubrique Amazon SNS. Cette procédure crée la rubrique Amazon SNS, ainsi que la fonction de service IAM qui donne à Vidéo Amazon Rekognition l’accès à vos rubriques Amazon SNS. Pour de plus amples informations, veuillez consulter Appeler les opérations de Vidéo Amazon Rekognition.

Pour créer une rubrique Amazon SNS

Si vous ne l’avez pas encore fait, créez une fonction de service IAM pour donner à Vidéo Amazon Rekognition l’accès à vos rubriques Amazon SNS. Notez l’Amazon Resource Name (ARN). Pour de plus amples informations, veuillez consulter Accorder l’accès à plusieurs rubriques Amazon SNS.
Créez une rubrique Amazon SNS à l’aide de la console Amazon SNS. Vous devez uniquement spécifier le nom de la rubrique. Ajoutez le nom du sujet avec AmazonRekognition. Notez l’ARN de la rubrique.

Créer la fonction Lambda

Vous devez créer la fonction Lambda à l’aide d’ AWS Management Console. Vous devez ensuite utiliser un projet AWS Toolkit for Eclipse pour charger le package de fonctions Lambda dans AWS Lambda. Il est également possible de créer la fonction Lambda avec AWS Toolkit for Eclipse. Pour plus d’informations, consultez Didacticiel : comment créer, charger et appeler une fonction AWS Lambda.

Pour créer la fonction Lambda

Connectez-vous à AWS Management Console et ouvrez la console AWS Lambda à l'adresse https://console.aws.amazon.com/lambda/.
Choisissez Créer une fonction.
Choisissez Créer à partir de zéro.
Dans Function name (Nom de la fonction), saisissez un nom pour votre fonction.
Dans Runtime (Exécution), choisissez Java 8.
Choisissez Choose or create an execution role (Choisir ou créer un rôle d’exécution).
Pour Execution role (Rôle d’exécution), choisissez Create a new role with basic Lambda permissions (Créer un nouveau rôle avec les autorisations Lambda de base).
Notez le nom du nouveau rôle affiché en bas de la rubrique Basic information (Informations de base).
Choisissez Créer une fonction.

Configurer la fonction Lambda

Une fois la fonction Lambda créée, vous devez la configurer de sorte qu’elle soit déclenchée par la rubrique Amazon SNS que vous créez dans Création de la rubrique SNS. Vous devez également ajuster les besoins en mémoire et le délai d’expiration de la fonction Lambda.

Pour configurer la fonction Lambda

Dans Function Code (Code de fonction), tapez com.amazonaws.lambda.demo.JobCompletionHandler pour Handler (Gestionnaire).
Dans Basic settings (Paramètres de base), choisissez Edit (Modifier). La boîte de dialogue Edit basic settings (Modifier les paramètres de base) s’affiche.
1. Choisissez 1024 pour Memory (Mémoire).
2. Choisissez 10 secondes pour Timeout (Expiration).
3. Choisissez Enregistrer.
Sous Designer (Concepteur), choisissez + Add trigger (+ Ajouter un déclencheur). La boîte de dialogue Ajouter un déclencheur s’affiche.
Dans Trigger configuration (Configuration du déclencheur), choisissez SNS.

Dans Rubrique SNS, choisissez la rubrique Amazon SNS que vous avez créée dans Création de la rubrique SNS.
Choisissez Activer le déclencheur.
Pour ajouter le déclencheur, choisissez Ajouter.
Choisissez Enregistrer pour enregistrer la fonction Lambda.

Configuration du rôle IAM Lambda

Pour appeler les opérations Amazon Rekognition Video, vous ajoutez la politique gérée par AmazonRekognitionFullAccessAWS au rôle IAM Lambda. Les opérations de démarrage, telles que StartLabelDetection, nécessitent également des autorisations de transfert pour le rôle de service IAM utilisé par Amazon Rekognition Video pour accéder à la rubrique Amazon SNS.

Pour configurer le rôle

Connectez-vous à la console IAM AWS Management Console et ouvrez-la à https://console.aws.amazon.com/iam/l'adresse.
Dans le panneau de navigation, choisissez Roles (Rôles).
Dans la liste, choisissez le nom du rôle d’exécution que vous avez créé à l’étape Créer la fonction Lambda.
Choisissez l’onglet Permissions (Autorisations).
Choisissez Attach Policies (Attacher des politiques).
AmazonRekognitionFullAccessChoisissez dans la liste des politiques.
Choisissez Attach policy (Attacher la politique).
Choisissez encore une fois le rôle d’exécution.
Sélectionnez Ajouter une politique en ligne.
Sélectionnez l’onglet JSON.
Remplacez la stratégie existante par la stratégie suivante. Remplacez servicerole par la fonction de service IAM que vous avez créée à l’étape Création de la rubrique SNS.
Choisissez Examiner une politique.
Dans Name* (Nom), attribuez un nom à la stratégie.
Choisissez Create Policy (Créer une politique).

Création du projet Lambda AWS Toolkit for Eclipse

Lorsque la fonction Lambda est déclenchée, le code suivant obtient l'état d'achèvement dans la rubrique Amazon SNS et GetLabelDetectionappelle pour obtenir les résultats de l'analyse. Le nombre d'étiquettes détectées et la liste des étiquettes détectées sont consignés dans un CloudWatch journal. Votre fonction Lambda doit stocker les résultats d’analyse vidéo en vue d’une utilisation ultérieure.

Pour créer le projet AWS Toolkit for Eclipse Lambda

Créez un projet AWS Toolkit for EclipseAWS Lambda.
- Pour Project name: (Nom du projet), tapez le nom de projet de votre choix.
- Pour Nom de classe :, entrez JobCompletionHandler.
- Pour Input type: (Type d’entrée), choisissez SNS Event (Événement SNS).
- Laissez les autres champs en l’état.

Dans l'explorateur de projet Eclipse, ouvrez la méthode de gestion Lambda générée (JobCompletionHandler.java) et remplacez le contenu par le suivant :


//Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
//PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)

package com.amazonaws.lambda.demo;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.SNSEvent;
import java.util.List;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.rekognition.AmazonRekognition;
import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
import com.amazonaws.services.rekognition.model.GetLabelDetectionRequest;
import com.amazonaws.services.rekognition.model.GetLabelDetectionResult;
import com.amazonaws.services.rekognition.model.LabelDetection;
import com.amazonaws.services.rekognition.model.LabelDetectionSortBy;
import com.amazonaws.services.rekognition.model.VideoMetadata;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;



public class JobCompletionHandler implements RequestHandler<SNSEvent, String> {

   @Override
   public String handleRequest(SNSEvent event, Context context) {

      String message = event.getRecords().get(0).getSNS().getMessage();
      LambdaLogger logger = context.getLogger(); 

      // Parse SNS event for analysis results. Log results
      try {
         ObjectMapper operationResultMapper = new ObjectMapper();
         JsonNode jsonResultTree = operationResultMapper.readTree(message);
         logger.log("Rekognition Video Operation:=========================");
         logger.log("Job id: " + jsonResultTree.get("JobId"));
         logger.log("Status : " + jsonResultTree.get("Status"));
         logger.log("Job tag : " + jsonResultTree.get("JobTag"));
         logger.log("Operation : " + jsonResultTree.get("API"));

         if (jsonResultTree.get("API").asText().equals("StartLabelDetection")) {

            if (jsonResultTree.get("Status").asText().equals("SUCCEEDED")){
               GetResultsLabels(jsonResultTree.get("JobId").asText(), context);
            }
            else{
               String errorMessage = "Video analysis failed for job " 
                     + jsonResultTree.get("JobId") 
                     + "State " + jsonResultTree.get("Status");
               throw new Exception(errorMessage); 
            }

         } else
            logger.log("Operation not StartLabelDetection");

      } catch (Exception e) {
         logger.log("Error: " + e.getMessage());
         throw new RuntimeException (e);


      }

      return message;
   }

   void GetResultsLabels(String startJobId, Context context) throws Exception {

      LambdaLogger logger = context.getLogger();

      AmazonRekognition rek = AmazonRekognitionClientBuilder.standard().withRegion(Regions.US_EAST_1).build();

      int maxResults = 1000;
      String paginationToken = null;
      GetLabelDetectionResult labelDetectionResult = null;
      String labels = "";
      Integer labelsCount = 0;
      String label = "";
      String currentLabel = "";
     
      //Get label detection results and log them. 
      do {

         GetLabelDetectionRequest labelDetectionRequest = new GetLabelDetectionRequest().withJobId(startJobId)
               .withSortBy(LabelDetectionSortBy.NAME).withMaxResults(maxResults).withNextToken(paginationToken);

         labelDetectionResult = rek.getLabelDetection(labelDetectionRequest);
         
         paginationToken = labelDetectionResult.getNextToken();
         VideoMetadata videoMetaData = labelDetectionResult.getVideoMetadata();

         // Add labels to log
         List<LabelDetection> detectedLabels = labelDetectionResult.getLabels();
         
         for (LabelDetection detectedLabel : detectedLabels) {
            label = detectedLabel.getLabel().getName();
            if (label.equals(currentLabel)) {
               continue;
            }
            labels = labels + label + " / ";
            currentLabel = label;
            labelsCount++;

         }
      } while (labelDetectionResult != null && labelDetectionResult.getNextToken() != null);

      logger.log("Total number of labels : " + labelsCount);
      logger.log("labels : " + labels);

   }


}

Les espaces de noms Rekognition ne sont pas résolus. Pour corriger cela :
- Placez le curseur de votre souris sur la partie sous-lignée de la ligne import com.amazonaws.services.rekognition.AmazonRekognition;.
- Choisissez Fix project set up... (Corriger la configuration du projet).
- Choisissez la version la plus récente de l’archive Amazon Rekognition.
- Choisissez OK pour ajouter l’archive au projet.
Enregistrez le fichier.
Cliquez avec le bouton droit dans la fenêtre de votre code Eclipse et sélectionnez AWS Lambda, puis choisissez Upload function to AWS Lambda.
Sur la page Select Target Lambda Function, choisissez la région AWS à utiliser.
Choisissez Choose an existing lambda function (Choisir une fonction Lambda existante), puis sélectionnez la fonction Lambda que vous avez créée à l’étape Créer la fonction Lambda.
Choisissez Suivant. La boîte de dialogue Function Configuration (Configuration de la fonction) s’affiche.
Dans IAM Role (Rôle IAM), choisissez le rôle IAM que vous avez créé à l’étape Créer la fonction Lambda.
Choisissez Terminer ; la fonction Lambda est alors chargée dans AWS.

Test de la fonction Lambda

Utilisez la AWS CLI commande suivante pour tester la fonction Lambda en démarrant l'analyse de détection des étiquettes d'une vidéo. Une fois l’analyse terminée, la fonction Lambda est déclenchée. Vérifiez que l'analyse a réussi en consultant CloudWatch les journaux.

Pour tester la fonction Lambda

Chargez un fichier vidéo au format MOV ou MPEG-4 dans votre compartiment S3. À des fins de test, téléchargez une vidéo de 30 secondes au maximum.

Pour en savoir plus, consultez Chargement d’objets dans Amazon S3 dans le Guide de l’utilisateur Amazon Simple Storage Service.
Exécutez la AWS CLI commande suivante pour commencer à détecter les étiquettes dans une vidéo.
```
aws rekognition start-label-detection --video "S3Object={Bucket="bucketname",Name="videofile"}" \
--notification-channel "SNSTopicArn=TopicARN,RoleArn=RoleARN" \
--region Region 
    
```
Mettez à jour les valeurs suivantes :
- Remplacez bucketname et videofile par le nom du compartiment Amazon S3 et le nom de fichier de la vidéo dans laquelle vous souhaitez détecter les étiquettes.
- Remplacez TopicARN par l’ARN de la rubrique Amazon SNS que vous avez créée à l’étape Création de la rubrique SNS.
- Remplacez RoleARN par l’ARN du rôle IAM que vous avez créé à l’étape Création de la rubrique SNS.
- Passez Region à la AWS région que vous utilisez.
Notez la valeur de JobId dans la réponse. La réponse est semblable à l’exemple JSON suivant.
```
{
    "JobId": "547089ce5b9a8a0e7831afa655f42e5d7b5c838553f1a584bf350ennnnnnnnnn"
}
```
Ouvrez la console https://console.aws.amazon.com/cloudwatch/.
Une fois l’analyse terminée, une entrée de journal pour la fonction Lambda s’affiche dans le Groupe de journaux.
Choisissez la fonction Lambda pour afficher les flux de journaux.
Choisissez le flux de journal le plus récent pour voir les entrées de journal créées par la fonction Lambda. Si l'opération a réussi, cela ressemble à la sortie suivante, qui montre les détails de l'opération de reconnaissance vidéo, y compris l'identifiant de la tâche, le type d'opération StartLabelDetection « » et une liste des catégories d'étiquettes détectées telles que Bottle, Clothing, Crowd et Food :

La valeur de Jod id (ID de tâche) doit correspondre à la valeur de JobId que vous avez notée à l’étape 3.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Création d' AWS applications d'analyse vidéo

Utilisation d’Amazon Rekognition pour la vérification d’identité