Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Analyse d’une image chargée à partir d’un système de fichiers local
<a name="images-bytes"></a>

Les opérations Image Amazon Rekognition peuvent analyser les images fournies sous forme d’octets d’image ou les images stockées dans un compartiment Amazon S3.

Ces rubriques proposent des exemples où des octets d’image sont fournis aux opérations d’API Image Amazon Rekognition en utilisant un fichier chargé à partir d’un système de fichiers local. Pour transmettre des octets d’image à une opération d’API Amazon Rekognition, vous utilisez le paramètre d’entrée [Image](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Image.html). Dans `Image`, vous spécifiez la propriété `Bytes` pour transmettre des octets d’image encodés en base64.

Les octets d’image transmis à une opération d’API Amazon Rekognition à l’aide du paramètre d’entrée `Bytes` doivent être encodés en base64. L'AWS SDKs que ces exemples utilisent automatiquement pour encoder les images en base64. Vous n’avez pas besoin de coder les octets d’image avant d’appeler une opération d’API Amazon Rekognition. Pour de plus amples informations, veuillez consulter [Spécifications d’images](images-information.md). 

Dans cet exemple de demande JSON `DetectLabels`, les octets d’image source sont transmis dans le paramètre d’entrée `Bytes`. 

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

Les exemples suivants utilisent various AWS SDKs et AWS CLI to call`DetectLabels`. Pour en savoir plus sur la réponse d’opération `DetectLabels`, consultez [DetectLabels réponse](labels-detect-labels-image.md#detectlabels-response).

Pour un JavaScript exemple côté client, voir. [En utilisant JavaScript](image-bytes-javascript.md)

**Pour détecter des étiquettes dans une image locale**

1. Si vous ne l’avez pas déjà fait :

   1. Créez ou mettez à jour un utilisateur avec `AmazonRekognitionFullAccess` et autorisations `AmazonS3ReadOnlyAccess`. Pour de plus amples informations, veuillez consulter [Étape 1 : configurer un compte AWS et créer un utilisateur](setting-up.md#setting-up-iam).

   1. Installez et configurez le AWS CLI et le AWS SDKs. Pour de plus amples informations, veuillez consulter [Étape 2 : configurer le AWS CLI et AWS SDKs](setup-awscli-sdk.md).

1. Utilisez les exemples suivants pour appeler l’opération `DetectLabels`.

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

   L’exemple Java suivant montre comment charger une image à partir du système de fichiers local et comment détecter les étiquettes à l’aide de l’opération [detectLabels](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/rekognition/model/DetectLabelsRequest.html) de l'AWS SDK. Remplacez la valeur de `photo` par le chemin et le nom d’un fichier image (au format .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 ]

   L’exemple [AWS SDK pour Python](https://aws.amazon.com/sdk-for-python/) suivant montre comment charger une image à partir du système de fichiers local et comment appeler l’opération [detect\$1labels](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rekognition.html#Rekognition.Client.detect_labels). Remplacez la valeur de `photo` par le chemin et le nom d’un fichier image (au format .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 ]

   L’exemple suivant montre comment charger une image à partir du système de fichiers local et détecter les étiquettes à l’aide de l’opération `DetectLabels`. Remplacez la valeur de `photo` par le chemin et le nom d’un fichier image (au format .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 ]

   L'exemple de [SDK AWS pour](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/welcome.html#getting-started) PHP suivant montre comment charger une image depuis le système de fichiers local et appeler [DetectFaces](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-rekognition-2016-06-27.html#detectfaces)l'opération d'API. Remplacez la valeur de `photo` par le chemin et le nom d’un fichier image (au format .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 ]

   Cet exemple affiche la liste des étiquettes qui ont été détectées dans l’image d’entrée. Remplacez la valeur de `photo` par le chemin et le nom d’un fichier image (au format .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 ]

   Ce code est extrait du GitHub référentiel d'exemples du SDK de AWS documentation. Voir l’exemple complet [ici](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);
           }
       }
   }
   ```

------

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

L'exemple de JavaScript page Web suivant permet à un utilisateur de choisir une image et de visualiser l'âge estimé des visages détectés sur l'image. Les âges estimés sont renvoyés par un appel à [DetectFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectFaces.html). 

L'image choisie est chargée à l'aide de la JavaScript `FileReader.readAsDataURL` fonction qui code l'image en base64. Cela permet d’afficher l’image sur un canevas HTML. Mais cela signifie que les octets d’image doivent être décodés avant d’être transmis à une opération Image Amazon Rekognition. Cet exemple montre comment décoder les octets d’image chargés. Si les octets d’image codés ne sont pas utiles pour vous, utilisez plutôt `FileReader.readAsArrayBuffer`, car l’image chargée n’est pas codée. Cela signifie que les opérations Image Amazon Rekognition peuvent être appelées sans que les octets d’image soient décodés au préalable. Pour obtenir un exemple, consultez [Utilisation de readAsArray Buffer](#image-bytes-javascript-unencoded).

**Pour exécuter l' JavaScript exemple**

1. Chargez l’exemple de code source dans un éditeur.

1. Obtenez l’ID de la réserve d'identités Amazon Cognito. Pour de plus amples informations, veuillez consulter [Obtenir l’ID de la réserve d'identités Amazon Cognito](#image-bytes-javascript-auth).

1. Dans la fonction `AnonLog` de l’exemple de code, remplacez `IdentityPoolIdToUse` et `RegionToUse` par les valeurs que vous avez notées à l’étape 9 de [Obtenir l’ID de la réserve d'identités Amazon Cognito](#image-bytes-javascript-auth). 

1. Dans la fonction `DetectFaces`, remplacez `RegionToUse` par la valeur que vous avez utilisée à l’étape précédente.

1. Enregistrez l’exemple de code source en tant que fichier `.html`.

1. Chargez le fichier dans votre navigateur.

1. Choisissez le bouton **Parcourir...**, puis choisissez une image qui contient un ou plusieurs visages. La table qui s’affiche contient les âges estimés pour chaque visage détecté dans l’image. 

**Note**  
L’exemple de code suivant utilise deux scripts qui ne font plus partie d’ Amazon Cognito. Pour obtenir ces fichiers, suivez les liens pour [ aws-cognito-sdk.min.js et [ amazon-cognito-identity.min.js](https://raw.githubusercontent.com/aws/amazon-cognito-identity-js/master/dist/amazon-cognito-identity.min.js)](https://raw.githubusercontent.com/aws/amazon-cognito-identity-js/master/dist/aws-cognito-sdk.js), puis enregistrez le texte de chacun sous forme de fichiers séparés. `.js` 

## JavaScript exemple de code
<a name="image-bytes-javascript-code"></a>

L'exemple de code suivant utilise la JavaScript version V2. Pour un exemple dans la JavaScript version 3, consultez [l'exemple dans le référentiel d'exemples GitHub du SDK de AWS documentation](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>
```

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

L'extrait de code suivant est une implémentation alternative de la `ProcessImage` fonction dans l'exemple de code, à l'aide JavaScript de la version V2. Il utilise `readAsArrayBuffer` pour charger une image et appeler `DetectFaces`. Comme `readAsArrayBuffer` n’encode pas le fichier chargé en base64, il n’est pas nécessaire de décoder les octets d’image avant d’appeler une opération Image Amazon Rekognition.

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

## Obtenir l’ID de la réserve d'identités Amazon Cognito
<a name="image-bytes-javascript-auth"></a>

Pour plus de simplicité, l’exemple utilise une réserve d'identités anonyme Amazon Cognito pour fournir un accès non authentifié à l’API Image Amazon Rekognition. Cela peut répondre à vos besoins. Par exemple, vous pouvez utiliser un accès non authentifié pour offrir un accès gratuit ou un accès test à votre site web avant que les utilisateurs ne s’inscrivent. Pour fournir un accès authentifié, utilisez un groupe d’utilisateurs Amazon Cognito. Pour plus d’informations, consultez [Groupe d’utilisateurs dans Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html). 

La procédure suivante montre comment créer une réserve d'identités qui permet d’accéder à des identités non authentifiées, et comment obtenir l’identifiant de la réserve d'identités requis dans l’exemple de code.

**Pour obtenir l’identifiant de la réserve d'identités**

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

1. Sélectionnez **Create new identity pool**.

1. Pour **Identity pool name\$1** (Nom de la réserve d'identités\$1), tapez un nom pour votre réserve d'identités.

1. Dans **Identités non authentifiées**, choisissez **Activer l’accès aux identités non authentifiées**.

1. Sélectionnez **Créer une réserve**.

1. Choisissez **View Details** (Afficher les détails) et notez le nom du rôle pour les identités non authentifiées.

1. Sélectionnez **Allow (Autoriser)**.

1. Dans **Plateforme**, sélectionnez **JavaScript**.

1. Dans **Obtenir les informations d’identification AWS**, notez les valeurs de `AWS.config.region` et `IdentityPooldId` qui sont affichées dans l’extrait de code.

1. Ouvrez la console IAM à l’adresse [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Dans le panneau de navigation, choisissez **Rôles**.

1. Choisissez le nom du rôle que vous avez noté à l’étape 6.

1. Dans l’onglet **Autorisations**, choisissez **Attacher des stratégies**.

1. Sélectionnez **AmazonRekognitionReadOnlyAccess**.

1. Choisissez **Attach Policy** (Attacher une politique).