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 de la documentation d'identité avec Amazon Textract
<a name="analyzing-document-identity"></a>

Pour analyser des documents d'identité, vous utilisez l'opération d'API AnalyzeID et vous transmettez un fichier de document en entrée. `AnalyzeID`renvoie une structure JSON qui contient le texte analysé. Pour de plus amples informations, veuillez consulter [Analyse des documents d'identité](how-it-works-identity.md).

Vous pouvez fournir un document d'entrée sous la forme d'un tableau d'octets d'image (octets d'image codés en base64) ou d'un objet Amazon S3. Dans cette procédure, vous chargez un fichier image dans votre compartiment S3 et vous spécifiez le nom du fichier.

**Pour analyser une pièce d'identité (API)**

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

   1. Accordez à un utilisateur les `AmazonS3ReadOnlyAccess` autorisations `AmazonTextractFullAccess` et. Pour de plus amples informations, veuillez consulter [Étape 1 : Configurer un compte AWS et créer un utilisateur](setting-up.md).

   1. Installez et configurez le AWS CLI et les AWS kits de développement logiciel. Pour de plus amples informations, veuillez consulter [Étape 2 : Configurez le AWS CLI and AWS Kits SDK](setup-awscli-sdk.md).

1. Téléchargez une image contenant un document dans votre compartiment S3. 

   Pour en savoir plus, consultez [Chargement d’objets dans Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UploadingObjectsintoAmazonS3.html) dans le *Guide de l’utilisateur Amazon Simple Storage Service*.

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

------
#### [ AWS CLI ]

   

   L'exemple suivant extrait un fichier d'entrée d'un compartiment S3 et exécute l'`AnalyzeID`opération sur celui-ci. Dans le code suivant, remplacez la valeur de `Bucket` par le nom de votre compartiment S3 et la valeur de `Name` par le nom du fichier de votre compartiment. `profile-name`Remplacez-le par le nom d'un profil qui peut assumer le rôle et `region` par la région dans laquelle vous souhaitez exécuter le code. 

   

   ```
   aws textract analyze-id \
       --document-pages '{"S3Object":{"Bucket":"{{bucket}}","Name":"{{name}}"}}' \
       --profile {{profile-name}} \
       --region {{region}}
   ```

   Vous pouvez également appeler l'API au recto et au verso d'un permis de conduire en ajoutant un autre objet Amazon S3 à l'entrée.

   ```
   aws textract analyze-id \
       --document-pages '[{"S3Object":{"Bucket":"{{bucket}}","Name":"{{name front}}"}}, {"S3Object":{"Bucket":"{{bucket}}","Name":"{{name back}}"}}]' \
       --profile {{profile-name}} \
       --region {{region}}
   ```

   Si vous accédez à la CLI sur un appareil Windows, utilisez des guillemets doubles au lieu de guillemets simples et évitez les guillemets doubles intérieurs par une barre oblique inverse (\\) pour corriger les erreurs d'analyse que vous pourriez rencontrer. Pour un exemple, consultez ce qui suit :

   ```
   aws textract analyze-id --document-pages "[{\"S3Object\":{\"Bucket\":\"{{bucket}}\",\"Name\":\"{{name}}\"}}]" --region {{region}}
   ```

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

   L'exemple suivant extrait un fichier d'entrée d'un compartiment S3 et exécute l'`AnalyzeID`opération sur celui-ci, en renvoyant les paires clé-valeur détectées. Dans le code suivant, remplacez la valeur de `bucket_name` par le nom de votre compartiment S3 et la valeur de `file_name` par le nom du fichier de votre compartiment. `profile-name`Remplacez-le par le nom d'un profil qui peut assumer le rôle et `region` par la région dans laquelle vous souhaitez exécuter le code.

   ```
   import boto3
   
   def analyze_id(client, bucket_name, file_name):
   
       # Analyze document
       # process using S3 object
       response = client.analyze_id(
           DocumentPages=[{'S3Object': {'Bucket': bucket_name, 'Name': file_name}}])
   
       for doc_fields in response['IdentityDocuments']:
           for id_field in doc_fields['IdentityDocumentFields']:
               for key, val in id_field.items():
                   if "Type" in str(key):
                       print("Type: " + str(val['Text']))
               for key, val in id_field.items():
                   if "ValueDetection" in str(key):
                       print("Value Detection: " + str(val['Text']))
               print()
   
   def main():
       session = boto3.Session(profile_name='profile-name')
       client = session.client('textract', region_name='region')
       bucket_name = "bucket"
       file_name = "file"
   
       analyze_id(client, bucket_name, file_name)
   
   if __name__ == "__main__":
       main()
   ```

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

   L'exemple suivant extrait un fichier d'entrée d'un compartiment S3 et exécute l'`AnalyzeID`opération sur celui-ci, renvoyant les données détectées. Dans la fonction principale, remplacez les valeurs `s3bucket` et `sourceDoc` par les noms du compartiment Amazon S3 et de l'image du document que vous avez utilisés à l'étape 2. Remplacez la valeur de `credentialsProvider` par le nom de votre profil de développeur.

   ```
   /*
      Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
      SPDX-License-Identifier: Apache-2.0
   */
   
   package com.amazonaws.samples;
   
   
   import com.amazonaws.auth.profile.ProfileCredentialsProvider;
   import com.amazonaws.regions.Regions;
   import com.amazonaws.services.textract.AmazonTextractClient;
   import com.amazonaws.services.textract.AmazonTextractClientBuilder;
   import com.amazonaws.services.textract.model.*;
   import java.util.ArrayList;
   import java.util.List;
   
   public class AppTest1 {
   
    public static void main(String[] args) {
   
        final String USAGE = "\n" +
                "Usage:\n" +
                "    <s3bucket><sourceDoc> \n\n" +
                "Where:\n" +
                "    s3bucket - the Amazon S3 bucket where the document is located. \n" +
                "    sourceDoc - the name of the document. \n";
   
        if (args.length != 1) {
            System.out.println(USAGE);
            System.exit(1);
        }
        
        
     // set provider credentials
        AWSCredentialsProvider credentialsProvider = new ProfileCredentialsProvider("default");
   
        String s3bucket = "bucket-name"; //args[0];
        String sourceDoc = "sourcedoc-name";  //args[1];
        AmazonTextractClient textractClient = (AmazonTextractClient) AmazonTextractClientBuilder.standard().withCredentials(credentialsProvider)
                .withRegion(Regions.US_EAST_1)
                .build();
   
        getDocDetails(textractClient, s3bucket, sourceDoc);
    }
   
    public static void getDocDetails(AmazonTextractClient textractClient, String s3bucket, String sourceDoc ) {
   
       try {
   
            S3Object s3 = new S3Object();
            s3.setBucket(s3bucket);
            s3.setName(sourceDoc);
   
            com.amazonaws.services.textract.model.Document myDoc = new com.amazonaws.services.textract.model.Document();
            myDoc.setS3Object(s3);
   
            List<Document> list1 = new ArrayList();
            list1.add(myDoc);
   
            AnalyzeIDRequest idRequest = new AnalyzeIDRequest();
            idRequest.setDocumentPages(list1);
   
            AnalyzeIDResult result = textractClient.analyzeID(idRequest);
            List<IdentityDocument> docs =  result.getIdentityDocuments();
            for (IdentityDocument doc: docs) {
   
                List<IdentityDocumentField>idFields = doc.getIdentityDocumentFields();
                for (IdentityDocumentField field: idFields) {
                    System.out.println("Field type is "+ field.getType().getText());
                    System.out.println("Field value is "+ field.getValueDetection().getText());
                }
            }
   
       } catch (Exception e) {
            e.printStackTrace();
       }
    }
   }
   ```

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

   L'exemple suivant extrait un fichier d'entrée d'un compartiment S3 et exécute l'`AnalyzeID`opération sur celui-ci, renvoyant les données détectées. Dans la fonction principale, remplacez les valeurs `s3bucket` et `sourceDoc` par les noms du compartiment S3 et de l'image du document que vous avez utilisés à l'étape 2. 

   `profile-name`Dans la ligne qui crée le, remplacez `TextractClient` par le nom de votre profil de développeur.

   ```
   import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
   import software.amazon.awssdk.core.SdkBytes;
   import software.amazon.awssdk.regions.Region;
   import software.amazon.awssdk.services.textract.TextractClient;
   import software.amazon.awssdk.services.textract.model.*;
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.FileNotFoundException;
   import java.io.InputStream;
   import java.util.ArrayList;
   import java.util.Iterator;
   import java.util.List;
   // snippet-end:[textract.java2._analyze_doc.import]
   import java.util.Optional;
   
   import org.json.JSONObject;
   
   /**
    * 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 DetectCelebrityVideo {
   
       public static void main(String[] args) {
   
           final String usage = "\n" +
                    "Usage:\n" +
                    "    <bucketName> <docName> \n\n" +
                    "Where:\n" +
                    "    bucketName - The name of the Amazon S3 bucket that contains the document. \n\n" +
                    "    docName - The document name (must be an image, i.e., book.png). \n";
   
           if (args.length != 2) {
                    System.out.println(usage);
                    System.exit(1);
           }
   
          String bucketName = args[0];
          String docName = args[1];
          Region region = Region.US_WEST_2;
          TextractClient textractClient = TextractClient.builder()
                   .region(region)
                   .credentialsProvider(ProfileCredentialsProvider.create("default"))
                   .build();
   
           analyzeID(textractClient, bucketName, docName);
           textractClient.close();
       }
   
       // snippet-start:[textract.java2._analyze_doc.main]
       public static void analyzeID(TextractClient textractClient, String bucketName, String docName) {
   
           try {
               S3Object s3Object = S3Object.builder()
                       .bucket(bucketName)
                       .name(docName)
                       .build();
   
                   // Create a Document object and reference the s3Object instance
               Document myDoc = Document.builder()
                       .s3Object(s3Object)
                       .build();
               
               AnalyzeIdRequest analyzeIdRequest = AnalyzeIdRequest.builder()
                       .documentPages(myDoc).build();
               
               AnalyzeIdResponse analyzeId = textractClient.analyzeID(analyzeIdRequest);
               
              // System.out.println(analyzeExpense.toString());          
               List<IdentityDocument> Docs = analyzeId.identityDocuments();
               for (IdentityDocument doc: Docs) {
                  System.out.println(doc);
               }
               
               
           } catch (TextractException e) {
   
               System.err.println(e.getMessage());
               System.exit(1);
           }
       }
       // snippet-end:[textract.java2._analyze_doc.main]
   }
   ```

------

1. Cela vous fournira la sortie JSON pour l'`AnalyzeID`opération.