Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Análisis de una imagen subida desde un sistema de archivos local
<a name="images-bytes"></a>

Las operaciones de Amazon Rekognition Image pueden analizar imágenes suministradas como bytes de imagen o almacenadas en un bucket de Amazon S3.

En estos temas se ofrecen ejemplos sobre el suministro de bytes de imágenes a operaciones de API de Amazon Rekognition Image mediante un archivo subido a partir de un sistema de archivos local. Puede transferir bytes de imágenes a una operación API de Amazon Rekognition; utilizando el parámetro de entrada [Image](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Image.html). Dentro de `Image`, especifique la propiedad `Bytes` para transferir bytes de imágenes con codificación en base64.

Los bytes de imagen transferidos a una operación API de Amazon Rekognition; utilizando el parámetro de entrada `Bytes` deben estar cifrados en base64. La AWS SDKs que utilizan estos ejemplos codifica automáticamente las imágenes en base64. No es necesario codificar bytes de imágenes antes de llamar a una operación API de Amazon Rekognition. Para obtener más información, consulte [Especificaciones de imagen](images-information.md). 

En esta solicitud de ejemplo de JSON para `DetectLabels`, los bytes de imagen de origen se pasan al parámetro de entrada `Bytes`. 

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

En los siguientes ejemplos se utilizan varios AWS SDKs y el to call. AWS CLI `DetectLabels` Para obtener más información sobre la respuesta de la operación `DetectLabels`, consulte [DetectLabels respuesta](labels-detect-labels-image.md#detectlabels-response).

Para ver un JavaScript ejemplo del lado del cliente, consulte. [Usando JavaScript](image-bytes-javascript.md)

**Para detectar las etiquetas en una imagen local**

1. Si aún no lo ha hecho:

   1. Cree o actualice un usuario con los permisos `AmazonRekognitionFullAccess` y `AmazonS3ReadOnlyAccess`. Para obtener más información, consulte [Paso 1: Configurar una cuenta de AWS y crear un usuario](setting-up.md#setting-up-iam).

   1. Instale y configure el AWS CLI y el. AWS SDKs Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md).

1. Consulte los siguientes ejemplos para llamar a la operación `DetectLabels`.

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

   El siguiente ejemplo de Java muestra cómo subir una imagen desde el sistema de archivos local y detectar etiquetas mediante la operación [detectLabels](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/rekognition/model/DetectLabelsRequest.html) del SDK de AWS. Cambie el valor de `photo` por la ruta y el nombre de un archivo de imagen (en formato .jpg o .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 ]

   El siguiente ejemplo de [AWS SDK for Python](https://aws.amazon.com/sdk-for-python/) muestra cómo subir una imagen desde el sistema de archivos local y llamar a la operación [detect\$1labels](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rekognition.html#Rekognition.Client.detect_labels). Cambie el valor de `photo` por la ruta y el nombre de un archivo de imagen (en formato .jpg o .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 ]

   El siguiente ejemplo de muestra cómo subir una imagen desde el sistema de archivos local y detectar etiquetas utilizando la operación `DetectLabels`. Cambie el valor de `photo` por la ruta y el nombre de un archivo de imagen (en formato .jpg o .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 ]

   El siguiente ejemplo de [AWS SDK for PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/welcome.html#getting-started) muestra cómo cargar una imagen desde el sistema de archivos local y llamar a la operación [DetectFaces](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-rekognition-2016-06-27.html#detectfaces)API. Cambie el valor de `photo` por la ruta y el nombre de un archivo de imagen (en formato .jpg o .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 ejemplo muestra una lista de las etiquetas que se han detectado en la imagen de entrada. Cambie el valor de `photo` por la ruta y el nombre de un archivo de imagen (en formato .jpg o .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 ]

   Este código se ha tomado del GitHub repositorio de ejemplos del SDK de AWS documentación. Consulte el ejemplo completo [aquí](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>

El siguiente ejemplo de JavaScript página web permite al usuario elegir una imagen y ver las edades estimadas de los rostros que se detectan en la imagen. Las edades estimadas se devuelven mediante una llamada a [DetectFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectFaces.html). 

La imagen elegida se carga mediante la JavaScript `FileReader.readAsDataURL` función, que codifica la imagen en base64. Esto resulta útil para mostrar la imagen en un lienzo HTML. Pero implica que los bytes de imagen se tienen que descodificar antes de transferirlos a una operación de Amazon Rekognition Image. En este ejemplo se muestra cómo descodificar los bytes de imagen subidos. Si los bytes de imagen codificados no le resultan útiles, use `FileReader.readAsArrayBuffer` en su lugar porque la imagen subida no está codificada. Esto significa que se puede llamar a las operaciones de Amazon Rekognition Image sin codificar primero los bytes de imagen. Para ver un ejemplo, consulta [Uso de Buffer readAsArray](#image-bytes-javascript-unencoded).

**Para ejecutar el ejemplo JavaScript**

1. Cargue el código fuente de ejemplo en un editor.

1. Obtenga el identificador de grupo de identidades de Amazon Cognito. Para obtener más información, consulte [Obtener el identificador de grupo de identidades de Amazon Cognito](#image-bytes-javascript-auth).

1. En la función `AnonLog` del código de ejemplo, cambie `IdentityPoolIdToUse` y `RegionToUse` por los valores que anotó en el paso 9 de [Obtener el identificador de grupo de identidades de Amazon Cognito](#image-bytes-javascript-auth). 

1. En la función `DetectFaces`, cambie `RegionToUse` por el valor que usó en el paso anterior.

1. Guarde el código fuente de ejemplo como un archivo `.html`.

1. Cargue el archivo en su navegador.

1. Haga clic en el botón **Examinar...** y elija una imagen que contenga una o más caras. Se muestra una tabla que contiene las edades estimadas para cada rostro detectado en la imagen. 

**nota**  
El siguiente ejemplo de código utiliza dos scripts que ya no forman parte de Amazon Cognito. [Para obtener estos archivos, siga los enlaces para [ aws-cognito-sdk.min.js y .min.js](https://raw.githubusercontent.com/aws/amazon-cognito-identity-js/master/dist/aws-cognito-sdk.js) y amazon-cognito-identity, a continuación, guarde el texto de cada uno como archivos separados.](https://raw.githubusercontent.com/aws/amazon-cognito-identity-js/master/dist/amazon-cognito-identity.min.js) `.js` 

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

El siguiente ejemplo de código usa JavaScript V2. Para ver un ejemplo de la JavaScript versión 3, consulte [el ejemplo en el GitHub repositorio de ejemplos del SDK de AWS documentación](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>
```

### Uso de Buffer readAsArray
<a name="image-bytes-javascript-unencoded"></a>

El siguiente fragmento de código es una implementación alternativa de la `ProcessImage` función en el código de ejemplo, utilizando JavaScript V2. Utiliza `readAsArrayBuffer` para subir una imagen y llama a `DetectFaces`. Dado que `readAsArrayBuffer` no codifica en base64 el archivo subido, no es necesario descodificar los bytes de imagen antes de llamar a una operación de 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);
  }
```

## Obtener el identificador de grupo de identidades de Amazon Cognito
<a name="image-bytes-javascript-auth"></a>

Para simplificar, el ejemplo utiliza un grupo de identidades de Amazon Cognito anónimas para proporcionar acceso sin autenticar a la API de Amazon Rekognition Image. Esto podría ser adecuado para sus necesidades. Por ejemplo, puede utilizar el acceso sin autenticar para proporcionar acceso gratuito, o de prueba, a su sitio web antes de que los usuarios se inscriban. Para proporcionar acceso autenticado, utilice un grupo de usuarios de Amazon Cognito. Para obtener más información, consulte [Grupos de usuarios de Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html). 

En el siguiente procedimiento se muestra cómo crear un grupo de identidades que permite el acceso a identidades sin autenticar y cómo obtener el identificador de grupo de identidades que se necesita en el código de ejemplo.

**Para obtener el identificador de grupo de identidades**

1. Abra la [consola de Amazon Cognito](https://console.aws.amazon.com/cognito/federated).

1. Elija **Crear nuevo grupo de identidades**.

1. En **Nombre de grupo de identidades\$1**, escriba un nombre para su grupo de identidades.

1. En **Identidades sin autenticar**, elija **Habilitar el acceso a identidades sin autenticar**.

1. Elija **Crear grupo**.

1. Elija **Ver detalles** y anote el nombre de rol de las identidades sin autenticar.

1. Elija **Permitir**.

1. En **Plataforma, elija**. **JavaScript**

1. En **Obtener credenciales de AWS**, anote los valores de `AWS.config.region` y `IdentityPooldId` que se muestran en el fragmento de código.

1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Seleccione **Roles** en el panel de navegación.

1. Elija el nombre de rol que anotó en el paso 6.

1. En la pestaña **Permisos**, elija **Asociar políticas**.

1. Elija **AmazonRekognitionReadOnlyAccess**.

1. Elija **Adjuntar política**.