Criar uma função do Amazon Rekognition Lambda

Este tutorial mostra como obter os resultados de uma operação de análise de vídeo para detecção de rótulo usando uma função Java Lambda.

nota

Este tutorial usa o AWS SDK for Java 1.x. Para ver um tutorial usando o Rekognition e o AWS SDK for Java versão 2, consulte o repositório de exemplos do SDK de documentação.AWS GitHub

Você pode usar as funções do Lambda com as operações de vídeo do Amazon Rekognition Video. Por exemplo, o diagrama a seguir mostra um site que usa uma função do Lambda para iniciar automaticamente a análise de um vídeo durante o upload dele em um bucket do Amazon S3. Quando a função Lambda é acionada, ela chama StartLabelDetectionpara começar a detectar rótulos no vídeo enviado. Para obter informações sobre como usar o a fim de processar notificações de eventos de um bucket do Amazon S3, consulte Usar o AWS Lambda com eventos do Amazon S3.

Uma segunda função do Lambda é acionada quando o status da conclusão da análise é enviado ao tópico do Amazon SNS registrado. A segunda função Lambda é chamada GetLabelDetectionpara obter os resultados da análise. Os resultados são então armazenados em um banco de dados em preparação para exibição em uma página da web. Essa segunda função do Lambda é o foco deste tutorial.

Neste tutorial, a função do Lambda é acionada quando o Amazon Rekognition Video envia o status de conclusão da análise de vídeo para o tópico Amazon SNS registrado. Em seguida, ele coleta os resultados da análise de vídeo por meio de chamadas GetLabelDetection. Para fins de demonstração, este tutorial grava os resultados da detecção de rótulos em um CloudWatch registro. Na função do Lambda do seu aplicativo, você deve armazenar os resultados da análise para uso posterior. Por exemplo, você pode usar o Amazon DynamoDB para salvar os resultados da análise. Para obter mais informações, consulte Como trabalhar com o DynamoDB.

Os procedimentos a seguir mostram como:

• Criar o tópico do Amazon SNS e configurar as permissões.

• Crie a função Lambda usando o tópico do Amazon SNS AWS Management Console e inscreva-a no tópico do Amazon SNS.

• Configurar a função do Lambda usando o AWS Management Console.

• Adicione um código de amostra a um AWS Toolkit for Eclipse projeto e faça o upload para a função Lambda.

• Teste a função do Lambda usando a AWS CLI.

nota

Use a mesma AWS região em todo o tutorial.

Pré-requisitos

Este tutorial pressupõe que você conhece o AWS Toolkit for Eclipse. Para obter mais informações, consulte AWS Toolkit for Eclipse.

Criar o tópico do SNS

O status de conclusão de uma operação de análise do Amazon Rekognition Video Video é enviado para um tópico do Amazon SNS. Esse procedimento cria o tópico do Amazon SNS e perfil de serviço IAM que dá ao Amazon Rekognition Video acesso aos seus tópicos do Amazon SNS. Para ter mais informações, consulte Chamando as operações de vídeo do Amazon Rekognition Video.

Para criar um tópico do Amazon SNS

1. Caso ainda não o tenha feito, crie um perfil de serviço IAM para conceder ao Amazon Rekognition Video acesso aos seus tópicos do Amazon SNS. Anote o nome de recurso da Amazon (ARN). Para ter mais informações, consulte Conceder acesso a vários tópicos do Amazon SNS.

2. Criar um tópico do Amazon SNS usando o console do Amazon SNS. Você só precisa especificar o nome do tópico. Prefixe o nome do tópico com. AmazonRekognition Anote o ARN do tópico.

Criar a função do Lambda

Você cria a função do Lambda usando o AWS Management Console. Em seguida, você usa um projeto AWS Toolkit for Eclipse para carregar o pacote da função do Lambda no AWS Lambda. Também é possível criar a função do Lambda com o AWS Toolkit for Eclipse. Para obter mais informações, consulte Tutorial: Como criar, fazer upload e invocar uma função do AWS Lambda.

Para criar a função do Lambda

1. Faça login no Console de Gerenciamento da AWS e abra o console do AWS Lambda em https://console.aws.amazon.com/lambda/.

2. Escolha Create function (Criar função).

3. Escolha Author from scratch (Criar do zero).

4. Em Function name (Nome da função), digite um nome para a função.

5. Em Runtime (Runtime), selecione Java 8.

6. Selecione Choose or create an execution role (Escolher ou criar uma função de execução).

7. Em Execution role (Função de execução), escolha Create a new role with basic Lambda permissions (Criar uma função com permissões básicas do Lambda).

8. Anote o nome da nova função que é exibido na parte inferior da seção Basic information (Informações básicas).

9. Escolha a opção Criar função.

Configurar a função do Lambda

Depois de criar a função do Lambda, configure-a para ser acionada pelo tópico do Amazon SNS criado em Criar o tópico do SNS. Ajuste também os requisitos de memória e o tempo limite da função do Lambda.

Configurar a função do Lambda

1. Em Function Code (Código da função), digite com.amazonaws.lambda.demo.JobCompletionHandler para o Handler (Manipulador).

2. Em Basic settings (Configurações básicas), selecione Edit (Editar). A caixa de diálogo Edit basic settings (Editar configurações básicas) é exibida.

   1. Selecione 1024 para Memory (Memória).

   2. Selecione 10 segundos para Timeout (Tempo limite).

   3. Escolha Salvar.

3. Em Designer, selecione + Add trigger (+ Adicionar trigger). A caixa de diálogo Add trigger (Adicionar trigger) é exibida.

4. Em Trigger configuration (Configuração de trigger), selecione SNS.

   No tópico SNS, escolha o tópico do Amazon SNS que você criou em Criar o tópico do SNS.

5. Selecione Enable trigger (Habilitar trigger).

6. Para adicionar o trigger, selecione Add (Adicionar).

7. Escolha Salvar para salvar a função do Lambda.

Configurar o perfil IAM do Lambda

Para chamar as operações do Amazon Rekognition Video, você adiciona a política gerenciada da AWS à função AmazonRekognitionFullAccessdo IAM Lambda. Operações iniciais, como StartLabelDetection, também exigem permissões de função de aprovação para a função de serviço do IAM que o Amazon Rekognition Video usa para acessar o tópico do Amazon SNS.

Para configurar a função

1. Faça login AWS Management Console e abra o console do IAM em https://console.aws.amazon.com/iam/.

2. No painel de navegação, escolha Perfis.

3. Na lista, selecione o nome da função de execução criada em Criar a função do Lambda.

4. Escolha a aba Permissões.

5. Escolha Anexar políticas.

6. AmazonRekognitionFullAccessEscolha na lista de políticas.

7. Escolha Anexar política.

8. Novamente, selecione a função de execução.

9. Escolha Add inline policy (Adicionar política em linha).

10. Selecione a guia JSON.

11. Substitua a política existente pela política a seguir. Substituir servicerole com o perfil de serviço do IAM que você criou em Criar o tópico do SNS.

    {
        "Version": "2012-10-17",
        "Statement": [
            {
                "Sid": "mysid",
                "Effect": "Allow",
                "Action": "iam:PassRole",
                "Resource": "arn:servicerole"
            }
        ]
    }

12. Escolha Revisar política.

13. Em Name* (Nome*), digite um nome para a política.

14. Escolha Criar política.

Crie o projeto AWS Toolkit for Eclipse Lambda

Quando a função Lambda é acionada, o código a seguir obtém o status de conclusão do tópico do Amazon SNS e GetLabelDetectionchama para obter os resultados da análise. Uma contagem de rótulos detectados e uma lista de rótulos detectados são gravados em um CloudWatch registro. Sua função do Lambda deve armazenar os resultados da análise de vídeo para uso posterior.

Para criar o projeto AWS Toolkit for Eclipse Lambda

1. Crie um projeto AWS Toolkit for EclipseAWS Lambda.

   • Em Project name: (Nome do projeto:), digite um nome de sua escolha para o projeto.

   • Em Nome da classe:, insira JobCompletionHandler.

   • Em Input type: (Tipo de entrada:), selecione SNS Event (Evento do SNS).

   • Deixe os outros campos inalterados.

2. No Eclipse Project Explorer, abra o método do manipulador Lambda gerado JobCompletionHandler (.java) e substitua o conteúdo pelo seguinte:

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

3. Os namespaces do Rekognition não foram resolvidos. Para corrigir isso:

   • Pause o mouse sobre a parte sublinhada da linha import com.amazonaws.services.rekognition.AmazonRekognition;.

   • Selecione Fix project set up... (Corrigir a configuração do projeto...)

   • Escolha a versão mais recente do arquivo Amazon Rekognition.

   • Selecione OK para adicionar o arquivo morto ao projeto.

4. Salve o arquivo.

5. Clique com o botão direito na janela de código do Eclipse e selecione AWS Lambda e, então, Upload function to AWS Lambda.

6. Na página Select Target Lambda Function, escolha a região da AWS para usar.

7. Selecione Choose an existing lambda function (Selecionar um função existente do Lambda) e selecione a função do Lambda criada em Criar a função do Lambda.

8. Escolha Próximo. A caixa de diálogo Function Configuration (Configuração da função) é exibida.

9. Em IAM Role (Função do IAM), escolha a função do IAM criada em Criar a função do Lambda.

10. Escolha Concluir e a função do Lambda será enviada para AWS.

Testar a função do Lambda

Use o AWS CLI comando a seguir para testar a função Lambda iniciando a análise de detecção de rótulos de um vídeo. Após a conclusão da análise, a função do Lambda é acionada. Confirme se a análise foi bem-sucedida verificando os CloudWatch registros de registros.

Para testar a função do Lambda

1. Faça upload de um arquivo de vídeo no formato MOV ou MPEG-4 no bucket do S3. Para fins de teste, faça upload de um vídeo com até 30 segundos de duração.

   Para obter instruções, consulte Como fazer upload de objetos no Amazon S3 no Guia do usuário do Amazon Simple Storage Service.

2. Execute o AWS CLI comando a seguir para começar a detectar rótulos em um vídeo.

   aws rekognition start-label-detection --video "S3Object={Bucket="bucketname",Name="videofile"}" \
   --notification-channel "SNSTopicArn=TopicARN,RoleArn=RoleARN" \
   --region Region 
       
   

   Atualize os seguintes valores:

   • Mude bucketname e videofile para o nome do bucket do Amazon S3 e o nome do arquivo do vídeo no qual você deseja detectar rótulos.

   • Mude TopicARN para o ARN do tópico do Amazon SNS que você criou em Criar o tópico do SNS.

   • Mude RoleARN para o ARN do perfil do IAM que você criou em Criar o tópico do SNS.

   • RegionMude para a AWS região que você está usando.

3. Anote o valor do JobId na resposta. A resposta é semelhante ao seguinte exemplo JSON.

   {
       "JobId": "547089ce5b9a8a0e7831afa655f42e5d7b5c838553f1a584bf350ennnnnnnnnn"
   }

4. Abra o console https://console.aws.amazon.com/cloudwatch/.

5. Quando a análise é concluída, uma entrada de registro para a função do Lambda aparece no Grupo de logs.

6. Escolha a função do Lambda para ver os fluxos de log.

7. Selecione o fluxo de log mais recente para ver as entradas de log feitas pela função do Lambda. Se a operação for bem-sucedida, será semelhante à saída a seguir, que mostra os detalhes da operação de reconhecimento de vídeo, incluindo a ID do trabalho, o tipo de operação "StartLabelDetection“e uma lista das categorias de rótulos detectadas, como Garrafa, Roupa, Multidão e Comida:

   

   O valor de Job id (ID do trabalho) deve corresponder ao valor de JobId anotado na etapa 3.