As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Analisar uma imagem carregada de um sistema de arquivos local
<a name="images-bytes"></a>

As operações do Amazon Rekognition Image podem analisar imagens que são fornecidas como bytes de imagem ou imagens armazenadas em um bucket do Amazon S3.

Estes tópicos fornecem exemplos de fornecimento de bytes de imagens para as operações da API Amazon Rekognition Image usando um arquivo carregado de um sistema de arquivos local. Você passa bytes de imagem para uma operação da API Amazon Rekognition usando o parâmetro de entrada [Image](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Image.html). Dentro de `Image`, você especifica a propriedade `Bytes` para passar bytes de imagem codificados em base64.

Os bytes de imagem passados para uma operação da API do Amazon Rekognition usando o parâmetro de entrada `Bytes` devem ser codificados em base64. A AWS SDKs que esses exemplos usam imagens codificadas automaticamente em base64. Não é necessário codificar bytes de imagem antes de chamar uma operação da API Amazon Rekognition. Para obter mais informações, consulte [Especificações de imagem](images-information.md). 

Nesta solicitação JSON de exemplo de `DetectLabels`, os bytes da imagem de origem são passados no parâmetro de entrada `Bytes`. 

```
{
    "Image": {
        "Bytes": "/9j/4AAQSk....."
    },
    "MaxLabels": 10,
    "MinConfidence": 77
}
```

Os exemplos a seguir usam various AWS SDKs e the AWS CLI to call`DetectLabels`. Para obter informações sobre a resposta da operação `DetectLabels`, consulte [DetectLabels resposta](labels-detect-labels-image.md#detectlabels-response).

Para obter um JavaScript exemplo do lado do cliente, consulte. [Usando JavaScript](image-bytes-javascript.md)

**Para detectar rótulos em uma imagem local**

1. Se ainda não tiver feito isso:

   1. Crie ou atualize um usuário com permissões `AmazonRekognitionFullAccess` e `AmazonS3ReadOnlyAccess`. Para obter mais informações, consulte [Etapa 1: Configure uma conta da AWS e crie um usuário](setting-up.md#setting-up-iam).

   1. Instale e configure o AWS CLI e AWS SDKs o. Para obter mais informações, consulte [Etapa 2: configurar o AWS CLI e AWS SDKs](setup-awscli-sdk.md).

1. Use os exemplos a seguir para chamar a operação `DetectLabels`.

------
#### [ Java ]

   O exemplo de Java a seguir mostra como carregar uma imagem do sistema de arquivos local e detectar rótulos usando a operação [detectLabels](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/rekognition/model/DetectLabelsRequest.html) do SDK da AWS. Altere o valor de `photo` para o caminho e o nome de arquivo de um arquivo de imagem (formato .jpg ou .png).

   ```
   //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 aws.example.rekognition.image;
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.InputStream;
   import java.nio.ByteBuffer;
   import java.util.List;
   import com.amazonaws.services.rekognition.AmazonRekognition;
   import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
   import com.amazonaws.AmazonClientException;
   import com.amazonaws.services.rekognition.model.AmazonRekognitionException;
   import com.amazonaws.services.rekognition.model.DetectLabelsRequest;
   import com.amazonaws.services.rekognition.model.DetectLabelsResult;
   import com.amazonaws.services.rekognition.model.Image;
   import com.amazonaws.services.rekognition.model.Label;
   import com.amazonaws.util.IOUtils;
   
   public class DetectLabelsLocalFile {
       public static void main(String[] args) throws Exception {
       	String photo="input.jpg";
   
   
           ByteBuffer imageBytes;
           try (InputStream inputStream = new FileInputStream(new File(photo))) {
               imageBytes = ByteBuffer.wrap(IOUtils.toByteArray(inputStream));
           }
   
   
           AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient();
   
           DetectLabelsRequest request = new DetectLabelsRequest()
                   .withImage(new Image()
                           .withBytes(imageBytes))
                   .withMaxLabels(10)
                   .withMinConfidence(77F);
   
           try {
   
               DetectLabelsResult result = rekognitionClient.detectLabels(request);
               List <Label> labels = result.getLabels();
   
               System.out.println("Detected labels for " + photo);
               for (Label label: labels) {
                  System.out.println(label.getName() + ": " + label.getConfidence().toString());
               }
   
           } catch (AmazonRekognitionException e) {
               e.printStackTrace();
           }
   
       }
   }
   ```

------
#### [ Python ]

   O exemplo de [AWS SDK para Python](https://aws.amazon.com/sdk-for-python/) a seguir mostra como carregar uma imagem do sistema de arquivos local e chamar a operação [detect\$1labels](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rekognition.html#Rekognition.Client.detect_labels). Altere o valor de `photo` para o caminho e o nome de arquivo de um arquivo de imagem (formato .jpg ou .png). 

   ```
   #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.)
   
   import boto3
   
   def detect_labels_local_file(photo):
   
   
       client=boto3.client('rekognition')
      
       with open(photo, 'rb') as image:
           response = client.detect_labels(Image={'Bytes': image.read()})
           
       print('Detected labels in ' + photo)    
       for label in response['Labels']:
           print (label['Name'] + ' : ' + str(label['Confidence']))
   
       return len(response['Labels'])
   
   def main():
       photo='photo'
   
       label_count=detect_labels_local_file(photo)
       print("Labels detected: " + str(label_count))
   
   
   if __name__ == "__main__":
       main()
   ```

------
#### [ .NET ]

   O exemplo a seguir mostra como carregar uma imagem do sistema de arquivos local e detectar rótulos usando a operação `DetectLabels`. Altere o valor de `photo` para o caminho e o nome de arquivo de um arquivo de imagem (formato .jpg ou .png).

   ```
   //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.)
   
   using System;
   using System.IO;
   using Amazon.Rekognition;
   using Amazon.Rekognition.Model;
   
   public class DetectLabelsLocalfile
   {
       public static void Example()
       {
           String photo = "input.jpg";
   
           Amazon.Rekognition.Model.Image image = new Amazon.Rekognition.Model.Image();
           try
           {
               using (FileStream fs = new FileStream(photo, FileMode.Open, FileAccess.Read))
               {
                   byte[] data = null;
                   data = new byte[fs.Length];
                   fs.Read(data, 0, (int)fs.Length);
                   image.Bytes = new MemoryStream(data);
               }
           }
           catch (Exception)
           {
               Console.WriteLine("Failed to load file " + photo);
               return;
           }
   
           AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient();
   
           DetectLabelsRequest detectlabelsRequest = new DetectLabelsRequest()
           {
               Image = image,
               MaxLabels = 10,
               MinConfidence = 77F
           };
   
           try
           {
               DetectLabelsResponse detectLabelsResponse = rekognitionClient.DetectLabels(detectlabelsRequest);
               Console.WriteLine("Detected labels for " + photo);
               foreach (Label label in detectLabelsResponse.Labels)
                   Console.WriteLine("{0}: {1}", label.Name, label.Confidence);
           }
           catch (Exception e)
           {
               Console.WriteLine(e.Message);
           }
       }
   }
   ```

------
#### [ PHP ]

   O exemplo a seguir do [AWS SDK for](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/welcome.html#getting-started) PHP mostra como carregar uma imagem do sistema de arquivos local e chamar [DetectFaces](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-rekognition-2016-06-27.html#detectfaces)a operação da API. Altere o valor de `photo` para o caminho e o nome de arquivo de um arquivo de imagem (formato .jpg ou .png). 

   ```
   
   <?php
   //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.)
   
       require 'vendor/autoload.php';
   
       use Aws\Rekognition\RekognitionClient;
   
       $options = [
          'region'            => 'us-west-2',
           'version'           => 'latest'
       ];
   
       $rekognition = new RekognitionClient($options);
   	
       // Get local image
       $photo = 'input.jpg';
       $fp_image = fopen($photo, 'r');
       $image = fread($fp_image, filesize($photo));
       fclose($fp_image);
   
   
       // Call DetectFaces
       $result = $rekognition->DetectFaces(array(
          'Image' => array(
             'Bytes' => $image,
          ),
          'Attributes' => array('ALL')
          )
       );
   
       // Display info for each detected person
       print 'People: Image position and estimated age' . PHP_EOL;
       for ($n=0;$n<sizeof($result['FaceDetails']); $n++){
   
         print 'Position: ' . $result['FaceDetails'][$n]['BoundingBox']['Left'] . " "
         . $result['FaceDetails'][$n]['BoundingBox']['Top']
         . PHP_EOL
         . 'Age (low): '.$result['FaceDetails'][$n]['AgeRange']['Low']
         .  PHP_EOL
         . 'Age (high): ' . $result['FaceDetails'][$n]['AgeRange']['High']
         .  PHP_EOL . PHP_EOL;
       }
   ?>
   ```

------
#### [ Ruby ]

   Este exemplo exibe uma lista de rótulos que foram detectados na imagem de entrada. Altere o valor de `photo` para o caminho e o nome de arquivo de um arquivo de imagem (formato .jpg ou .png).

   ```
   #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.)
   
       # gem 'aws-sdk-rekognition'
       require 'aws-sdk-rekognition'
       credentials = Aws::Credentials.new(
          ENV['AWS_ACCESS_KEY_ID'],
          ENV['AWS_SECRET_ACCESS_KEY']
       )
       client   = Aws::Rekognition::Client.new credentials: credentials
       photo = 'photo.jpg'
       path = File.expand_path(photo) # expand path relative to the current directory
       file = File.read(path)
       attrs = {
         image: {
           bytes: file
         },
         max_labels: 10
       }
       response = client.detect_labels attrs
       puts "Detected labels for: #{photo}"
       response.labels.each do |label|
         puts "Label:      #{label.name}"
         puts "Confidence: #{label.confidence}"
         puts "Instances:"
         label['instances'].each do |instance|
           box = instance['bounding_box']
           puts "  Bounding box:"
           puts "    Top:        #{box.top}"
           puts "    Left:       #{box.left}"
           puts "    Width:      #{box.width}"
           puts "    Height:     #{box.height}"
           puts "  Confidence: #{instance.confidence}"
         end
         puts "Parents:"
         label.parents.each do |parent|
           puts "  #{parent.name}"
         end
         puts "------------"
         puts ""
       end
   ```

------
#### [ Java V2 ]

   Esse código foi retirado do GitHub repositório de exemplos do SDK de AWS documentação. Veja o exemplo completo [aqui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/DetectLabels.java).

   ```
   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.*;
   
   import java.io.FileInputStream;
   import java.io.FileNotFoundException;
   import java.io.InputStream;
   import java.util.List;
   
   /**
    * Before running this Java V2 code example, set up your development
    * environment, including your credentials.
    *
    * For more information, see the following documentation topic:
    *
    * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
    */
   public class DetectLabels {
       public static void main(String[] args) {
           final String usage = """
               Usage: <bucketName> <sourceImage>
   
               Where:
                   bucketName - The name of the Amazon S3 bucket where the image is stored
                   sourceImage - The name of the image file (for example, pic1.png).\s
               """;
   
           if (args.length != 2) {
               System.out.println(usage);
               System.exit(1);
           }
   
           String bucketName = args[0] ;
           String sourceImage = args[1] ;
           Region region = Region.US_WEST_2;
           RekognitionClient rekClient = RekognitionClient.builder()
                   .region(region)
                   .build();
   
           detectImageLabels(rekClient, bucketName, sourceImage);
           rekClient.close();
       }
   
       /**
        * Detects the labels in an image stored in an Amazon S3 bucket using the Amazon Rekognition service.
        *
        * @param rekClient     the Amazon Rekognition client used to make the detection request
        * @param bucketName    the name of the Amazon S3 bucket where the image is stored
        * @param sourceImage   the name of the image file to be analyzed
        */
       public static void detectImageLabels(RekognitionClient rekClient, String bucketName, String sourceImage) {
           try {
               S3Object s3ObjectTarget = S3Object.builder()
                       .bucket(bucketName)
                       .name(sourceImage)
                       .build();
   
               Image souImage = Image.builder()
                       .s3Object(s3ObjectTarget)
                       .build();
   
               DetectLabelsRequest detectLabelsRequest = DetectLabelsRequest.builder()
                       .image(souImage)
                       .maxLabels(10)
                       .build();
   
               DetectLabelsResponse labelsResponse = rekClient.detectLabels(detectLabelsRequest);
               List<Label> labels = labelsResponse.labels();
               System.out.println("Detected labels for the given photo");
               for (Label label : labels) {
                   System.out.println(label.name() + ": " + label.confidence().toString());
               }
   
           } catch (RekognitionException e) {
               System.out.println(e.getMessage());
               System.exit(1);
           }
       }
   }
   ```

------

# Usando JavaScript
<a name="image-bytes-javascript"></a>

O exemplo de JavaScript página da web a seguir permite que um usuário escolha uma imagem e visualize a idade estimada dos rostos detectados na imagem. As idades estimativas são retornadas por uma chamada à [DetectFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectFaces.html). 

A imagem escolhida é carregada usando a JavaScript `FileReader.readAsDataURL` função, que codifica a imagem em base64. Isso é útil para exibir a imagem em uma tela HTML. Porém, isso significa que os bytes da imagem precisam ser descodificados antes de serem passados para uma operação do Amazon Rekognition Image. Este exemplo mostra como decodificar os bytes da imagem carregada. Se os bytes da imagem codificada não forem úteis para você, use `FileReader.readAsArrayBuffer` no lugar, porque a imagem carregada não está codificada. Isso significa que as operações do Amazon Rekognition Image podem ser chamadas sem primeiro descodificar os bytes da imagem. Para ver um exemplo, consulte [Usando o readAsArray Buffer](#image-bytes-javascript-unencoded).

**Para executar o JavaScript exemplo**

1. Carregue o código-fonte de exemplo em um editor.

1. Selecione o banco de identidades de identidade do Amazon Cognito. Para obter mais informações, consulte [Selecione o banco de identidades do Amazon Cognito.](#image-bytes-javascript-auth).

1. Na função `AnonLog` do código de exemplo, altere `IdentityPoolIdToUse` e `RegionToUse` para os valores que você anotou na etapa 9 de [Selecione o banco de identidades do Amazon Cognito.](#image-bytes-javascript-auth). 

1. Na função `DetectFaces`, altere `RegionToUse` para o valor que você usou na etapa anterior.

1. Salve o código fonte de exemplo como um arquivo `.html`.

1. Carregue o arquivo em seu navegador.

1. Escolha o botão **Procurar...** e escolha uma imagem que contenha uma ou mais faces. Uma tabela é mostrada contendo as idades estimadas de cada face detectada na imagem. 

**nota**  
O exemplo de código a seguir usa dois scripts que não fazem mais parte do Amazon Cognito. [Para obter esses arquivos, siga os links para [ aws-cognito-sdk.min.js e .min.js](https://raw.githubusercontent.com/aws/amazon-cognito-identity-js/master/dist/aws-cognito-sdk.js) e amazon-cognito-identity salve o texto de cada um como arquivos separados.](https://raw.githubusercontent.com/aws/amazon-cognito-identity-js/master/dist/amazon-cognito-identity.min.js) `.js` 

## JavaScript código de exemplo
<a name="image-bytes-javascript-code"></a>

O exemplo de código a seguir usa JavaScript V2. Para ver um exemplo na JavaScript V3, consulte [o exemplo no repositório de exemplos GitHub do SDK de AWS documentação](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javascriptv3/example_code/rekognition/estimate-age-example/src).

```
<!--
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.)
-->
<!DOCTYPE html>
<html>
<head>
  <script src="aws-cognito-sdk.min.js"></script>
  <script src="amazon-cognito-identity.min.js"></script>
  <script src="https://sdk.amazonaws.com/js/aws-sdk-2.16.0.min.js"></script>
  <meta charset="UTF-8">
  <title>Rekognition</title>
</head>

<body>
  <H1>Age Estimator</H1>
  <input type="file" name="fileToUpload" id="fileToUpload" accept="image/*">
  <p id="opResult"></p>
</body>
<script>

  document.getElementById("fileToUpload").addEventListener("change", function (event) {
    ProcessImage();
  }, false);
  
  //Calls DetectFaces API and shows estimated ages of detected faces
  function DetectFaces(imageData) {
    AWS.region = "RegionToUse";
    var rekognition = new AWS.Rekognition();
    var params = {
      Image: {
        Bytes: imageData
      },
      Attributes: [
        'ALL',
      ]
    };
    rekognition.detectFaces(params, function (err, data) {
      if (err) console.log(err, err.stack); // an error occurred
      else {
       var table = "<table><tr><th>Low</th><th>High</th></tr>";
        // show each face and build out estimated age table
        for (var i = 0; i < data.FaceDetails.length; i++) {
          table += '<tr><td>' + data.FaceDetails[i].AgeRange.Low +
            '</td><td>' + data.FaceDetails[i].AgeRange.High + '</td></tr>';
        }
        table += "</table>";
        document.getElementById("opResult").innerHTML = table;
      }
    });
  }
  //Loads selected image and unencodes image bytes for Rekognition DetectFaces API
  function ProcessImage() {
    AnonLog();
    var control = document.getElementById("fileToUpload");
    var file = control.files[0];

    // Load base64 encoded image 
    var reader = new FileReader();
    reader.onload = (function (theFile) {
      return function (e) {
        var img = document.createElement('img');
        var image = null;
        img.src = e.target.result;
        var jpg = true;
        try {
          image = atob(e.target.result.split("data:image/jpeg;base64,")[1]);

        } catch (e) {
          jpg = false;
        }
        if (jpg == false) {
          try {
            image = atob(e.target.result.split("data:image/png;base64,")[1]);
          } catch (e) {
            alert("Not an image file Rekognition can process");
            return;
          }
        }
        //unencode image bytes for Rekognition DetectFaces API 
        var length = image.length;
        imageBytes = new ArrayBuffer(length);
        var ua = new Uint8Array(imageBytes);
        for (var i = 0; i < length; i++) {
          ua[i] = image.charCodeAt(i);
        }
        //Call Rekognition  
        DetectFaces(ua);
      };
    })(file);
    reader.readAsDataURL(file);
  }
  //Provides anonymous log on to AWS services
  function AnonLog() {
    
    // Configure the credentials provider to use your identity pool
    AWS.config.region = 'RegionToUse'; // Region
    AWS.config.credentials = new AWS.CognitoIdentityCredentials({
      IdentityPoolId: 'IdentityPoolIdToUse',
    });
    // Make the call to obtain credentials
    AWS.config.credentials.get(function () {
      // Credentials will be available when this function is called.
      var accessKeyId = AWS.config.credentials.accessKeyId;
      var secretAccessKey = AWS.config.credentials.secretAccessKey;
      var sessionToken = AWS.config.credentials.sessionToken;
    });
  }
</script>
</html>
```

### Usando o readAsArray Buffer
<a name="image-bytes-javascript-unencoded"></a>

O trecho de código a seguir é uma implementação alternativa da `ProcessImage` função no código de amostra, usando JavaScript V2. Ele usa `readAsArrayBuffer` para carregar uma imagem e chamar `DetectFaces`. Como `readAsArrayBuffer` não codifica o arquivo carregado em base64, não é necessário decodificar os bytes da imagem antes de chamar uma operação do Amazon Rekognition Image.

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

function ProcessImage() {
    AnonLog();
    var control = document.getElementById("fileToUpload");
    var file = control.files[0];

    // Load base64 encoded image for display 
    var reader = new FileReader();
    reader.onload = (function (theFile) {
      return function (e) {
        //Call Rekognition  
        AWS.region = "RegionToUse";  
        var rekognition = new AWS.Rekognition();
        var params = {
          Image: {
          Bytes: e.target.result
        },
        Attributes: [
        'ALL',
      ]
    };
    rekognition.detectFaces(params, function (err, data) {
      if (err) console.log(err, err.stack); // an error occurred
      else {
       var table = "<table><tr><th>Low</th><th>High</th></tr>";
        // show each face and build out estimated age table
        for (var i = 0; i < data.FaceDetails.length; i++) {
          table += '<tr><td>' + data.FaceDetails[i].AgeRange.Low +
            '</td><td>' + data.FaceDetails[i].AgeRange.High + '</td></tr>';
        }
        table += "</table>";
        document.getElementById("opResult").innerHTML = table;
      }
    });

      };
    })(file);
    reader.readAsArrayBuffer(file);
  }
```

## Selecione o banco de identidades do Amazon Cognito.
<a name="image-bytes-javascript-auth"></a>

Para simplificar, o exemplo usa um banco de identidades anônimo do Amazon Cognito para fornecer acesso não autenticado à API Amazon Rekognition Image. Isso pode ser adequado para suas necessidades. Por exemplo, você pode usar o acesso não autenticado para fornecer acesso gratuito ou avaliação gratuita a seu site antes de os usuários se cadastrarem. Para fornecer acesso autenticado, use um grupo de usuários do Amazon Cognito. Para obter mais informações, consulte [grupo de usuários do Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html). 

O procedimento a seguir mostra como criar um grupo de identidades que permite acesso a identidades não autenticadas e como obter o identificador do grupo de identidades que é necessário no código de exemplo.

**Para obter o identificador do grupo de identidades**

1. Abra o [console do Amazon Cognito](https://console.aws.amazon.com/cognito/federated).

1. Escolha **Criar novo banco de identidades**.

1. Em **Identity pool name\$1** (Nome do grupo de identidades), digite um nome para o grupo de identidades.

1. Em **Unauthenticated identities (Identidades não autenticadas)**, escolha **Enable access to unauthenticated identities (Permitir acesso a identidades não autenticadas)**.

1. Selecione **Criar grupo**.

1. Escolha **View Details** (Visualizar detalhes) e anote o nome da função para identidades não autenticadas.

1. Selecione **Permitir**.

1. Em **Plataforma**, escolha **JavaScript**.

1. Em **Get AWS Credentials (Obter credenciais da AWS)**, anote os valores de `AWS.config.region` e `IdentityPooldId` que são mostrados no trecho de código.

1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação, escolha **Perfis**.

1. Escolha o nome da função que você anotou na etapa 6.

1. Na guia **Permissions (Permissões)**, escolha **Attach policies (Anexar políticas)**.

1. Selecione **AmazonRekognitionReadOnlyAccess**.

1. Escolha **Attach Policy**.