Étape 1 : Création d'un AWS Lambda fonction (console)Étape 2 : (Facultatif) Créer une couche (console)Étape 3 : Ajouter le code Python (console)Étape 4 : Essayer votre fonction Lambda

Détection de texte à l'aide d'un AWS Lambda fonction

AWS Lambda est un service de calcul que vous pouvez utiliser pour exécuter du code sans provisionner ni gérer de serveurs. Vous pouvez appeler les opérations d'API Amazon Textract depuis une fonction AWS Lambda. Les instructions suivantes montrent comment créer une fonction Lambda dans Python qui appelle DetectDocumentText.

La fonction Lambda renvoie une liste d'objets Block contenant des informations sur les mots et les lignes de texte détectés. Les instructions incluent un exemple de code Python qui vous montre comment appeler la fonction Lambda avec un document fourni par un compartiment Amazon S3 ou votre ordinateur local. Les images stockées dans Amazon S3 doivent être au format PDF ou TIFF d'une seule page, ou au format JPEG ou PNG. Les images locales doivent être au format PDF ou TIFF d'une seule page. Le code Python renvoie une partie de la réponse JSON pour chaque type de bloc détecté dans le document.

Pour un exemple d'utilisation des fonctions Lambda pour traiter des documents à grande échelle, consultez Amazon Textract IDP CDK Constructs et Use machine learning pour automatiser et traiter des documents à grande échelle.

Rubriques

Étape 1 : Création d'un AWS Lambda fonction (console)
Étape 2 : (Facultatif) Créer une couche (console)
Étape 3 : Ajouter le code Python (console)
Étape 4 : Essayer votre fonction Lambda

Étape 1 : Création d'un AWS Lambda fonction (console)

Au cours de cette étape, vous créez une AWS Lambda fonction vide et un rôle d'exécution IAM qui permet à votre fonction d'appeler l'DetectDocumentTextopération. Si vous fournissez des documents depuis Amazon S3, cette étape vous montre également comment accorder l'accès au compartiment qui stocke vos documents.

Plus tard, vous ajoutez le code source et ajoutez éventuellement une couche à la fonction Lambda.

Pour créer un AWS Lambda fonction (console)

Connectez-vous à la AWS Lambda console Console de gestion AWS et ouvrez-la à l'adresse https://console.aws.amazon.com/lambda/.
Choisissez Créer une fonction. Pour plus d’informations, consultez Créer une fonction Lambda à l’aide de la console.
Choisissez les options suivantes :
- Choisissez Créer à partir de zéro.
- Saisissez une valeur relative à Nom de fonction.
- Pour Runtime (Environnement d'exécution), choisissez Python 3.9.
- Pour Architecture, choisissez x86_64.
Choisissez Créer une fonction pour créer la fonction AWS Lambda .
Sur la page de la fonction, choisissez l’onglet Configuration.
Dans le volet Autorisations, sous Rôle d’exécution, choisissez le nom du rôle pour ouvrir le rôle dans la console IAM.
Sous l’onglet Autorisations, choisissez Ajouter des autorisations puis Créer une politique en ligne.

Choisissez l’onglet JSON et remplacez la politique par la politique suivante :

Choisissez Examiner une politique.
Entrez un nom pour la politique, par exemple DetectDocumentText-access.
Choisissez Create Policy (Créer une politique).
Si vous stockez des documents à des fins d’analyse dans un compartiment Amazon S3, vous devez ajouter une stratégie d'accès Amazon S3. Pour ce faire, répétez les étapes 7 à 11 dans la console AWS Lambda et apportez les modifications suivantes.
1. Pour l’étape 8, appliquez la politique suivante. bucket/folder pathRemplacez-le par le chemin du compartiment et du dossier Amazon S3 vers les documents que vous souhaitez analyser.
  JSON
  { "Version":"2012-10-17", "Statement": [ { "Sid": "S3Access", "Effect": "Allow", "Action": "s3:GetObject", "Resource": "arn:aws:s3:::bucket/folder path/*" } ] }
2. Pour l'étape 10, choisissez un autre nom de politique, tel que S3Bucket-access.

Étape 2 : (Facultatif) Créer une couche (console)

Pour exécuter cet exemple, il n'est pas nécessaire de suivre cette étape. L'DetectDocumentTextopération est incluse dans l'environnement Lambda Python par défaut dans le cadre du AWS SDK pour Python (Boto3). Si d'autres parties de votre fonction Lambda nécessitent des mises à jour de AWS service récentes qui ne figurent pas dans l'environnement Lambda Python par défaut, effectuez cette étape pour ajouter la dernière version du SDK Boto3 en tant que couche à votre fonction.

Tout d'abord, vous créez une archive de fichier zip contenant le SDK Boto3. Ensuite, vous créez une couche et ajoutez l’archive du fichier zip à la couche. Pour plus d’informations, voir Utilisation de couches avec votre fonction Lambda.

Pour créer et ajouter une couche (console)

Ouvrez une invite de commande et entrez les commandes suivantes pour créer un package de déploiement avec la version la plus récente du SDK AWS.
```
pip install boto3 --target python/.
zip boto3-layer.zip -r python/
                
```
Notez le nom du fichier zip (boto3-layer.zip) que vous utilisez à l’étape 8 de cette procédure.
Ouvrez la AWS Lambda console à l'adresse https://console.aws.amazon.com/lambda/.
Choisissez Layers dans le volet de navigation.
Choisissez Créer un calque.
Saisissez un Name (Nom) et une Description pour la règle.
Dans Type d’entrée de code, choisissez Charger un fichier .zip et sélectionnez Charger.
Dans la boîte de dialogue, choisissez l’archive de fichiers zip (boto3-layer.zip) que vous avez créée à l’étape 1 de cette procédure.
Pour les environnements d'exécution compatibles, choisissez Python 3.9.
Choisissez Créer pour créer la couche.
Choisissez l’icône du menu du volet de navigation.
Dans le volet de navigation, choisissez Fonctions.
Dans la liste des ressources, choisissez la fonction que vous avez créée précédemment dans Étape 1 : Création d'un AWS Lambda fonction (console).
Cliquez sur l’onglet Code.
Dans la zone Couches, choisissez Ajouter une couche.
Choisissez Couches personnalisées.
Dans Couches personnalisées, choisissez le nom de couche que vous avez saisi à l’étape 6.
Dans Version, choisissez la version de la couche, qui doit être 1.
Choisissez Ajouter.

Étape 3 : Ajouter le code Python (console)

Au cours de cette étape, vous ajoutez le code Python à votre fonction Lambda à l’aide de l’éditeur de code de la console Lambda. Le code détecte le texte dans un document contenant DetectDocumentText et renvoie une liste d'objets Block contenant des informations sur le texte détecté. Le document peut se trouver dans un compartiment Amazon S3 ou sur un ordinateur local. Les images stockées dans Amazon S3 doivent être des documents au format PDF ou TIFF d'une seule page ou au format JPEG ou PNG. Les images locales doivent être au format PDF ou TIFF d'une seule page.

Pour ajouter le code Python (console)

Accédez à l’onglet Code.

Dans l’éditeur de code, remplacez le code dans lambda_function.py par le code suivant :



# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0

"""
Purpose
An AWS lambda function that analyzes documents with Amazon Textract.
"""
import json
import base64
import logging
import boto3

from botocore.exceptions import ClientError

# Set up logging.
logger = logging.getLogger(__name__)

# Get the boto3 client.
textract_client = boto3.client('textract')


def lambda_handler(event, context):
    """
    Lambda handler function
    param: event: The event object for the Lambda function.
    param: context: The context object for the lambda function.
    return: The list of Block objects recognized in the document
    passed in the event object.
    """

    try:

        # Determine document source.
        if 'image' in event:
            # Decode the image
            image_bytes = event['image'].encode('utf-8')
            img_b64decoded = base64.b64decode(image_bytes)
            image = {'Bytes': img_b64decoded}


        elif 'S3Object' in event:
            image = {'S3Object':
                     {'Bucket':  event['S3Object']['Bucket'],
                      'Name': event['S3Object']['Name']}
                     }

        else:
            raise ValueError(
                'Invalid source. Only image base 64 encoded image bytes or S3Object are supported.')


        # Analyze the document.
        response = textract_client.detect_document_text(Document=image)

        # Get the Blocks
        blocks = response['Blocks']

        lambda_response = {
            "statusCode": 200,
            "body": json.dumps(blocks)
        }

    except ClientError as err:
        error_message = "Couldn't analyze image. " + \
            err.response['Error']['Message']

        lambda_response = {
            'statusCode': 400,
            'body': {
                "Error": err.response['Error']['Code'],
                "ErrorMessage": error_message
            }
        }
        logger.error("Error function %s: %s",
            context.invoked_function_arn, error_message)

    except ValueError as val_error:
        lambda_response = {
            'statusCode': 400,
            'body': {
                "Error": "ValueError",
                "ErrorMessage": format(val_error)
            }
        }
        logger.error("Error function %s: %s",
            context.invoked_function_arn, format(val_error))

    return lambda_response

Pour déployer votre fonction Lambda, choisissez Deploy.

Étape 4 : Essayer votre fonction Lambda

Maintenant que vous avez créé votre fonction Lambda, vous pouvez l'invoquer pour détecter du texte dans un document. Au cours de cette étape, vous utilisez du code Python sur votre ordinateur pour transmettre un document local ou un document d'un compartiment Amazon S3 à votre fonction Lambda. La taille des documents transmis depuis un ordinateur local doit être inférieure à 6291456 octets. Si vos documents sont plus volumineux, chargez-les dans un compartiment Amazon S3 et appelez le script avec le chemin Amazon S3 vers l'image. Pour plus d’informations sur le chargement des fichiers image dans un compartiment Amazon S3, consultez Chargement d’objets.

Assurez-vous d'exécuter le code dans la même AWS région que celle dans laquelle vous avez créé la fonction Lambda. Vous pouvez consulter la région AWS de votre fonction Lambda dans la barre de navigation de la page de détails de la fonction de la console Lambda.

Si la AWS Lambda fonction renvoie une erreur de temporisation, prolongez le délai d'expiration de la fonction Lambda. Pour plus d’informations, consultez Configuration du délai d’expiration d’une fonction (console).

Pour plus d'informations sur l'appel d'une fonction Lambda à partir de votre code, consultez AWS Lambda Invoking Functions.

Pour essayer votre fonction Lambda

Si vous ne l’avez pas déjà fait, effectuez les opérations suivantes :
1. Assurez-vous que l’utilisateur dispose des autorisations lambda:InvokeFunction nécessaires. Vous pouvez utiliser la politique suivante :
  
  Vous pouvez obtenir l’ARN de votre fonction Lambda à partir de l’aperçu des fonctions dans la console Lambda.
  
  Pour activer l’accès, ajoutez des autorisations à vos utilisateurs, groupes ou rôles :
  - Utilisateurs et groupes dans AWS IAM Identity Center :
    
    Créez un jeu d’autorisations. Suivez les instructions de la rubrique Création d’un jeu d’autorisations du Guide de l’utilisateur AWS IAM Identity Center .
  - Utilisateurs gérés dans IAM par un fournisseur d’identité :
    
    Créez un rôle pour la fédération d’identité. Suivez les instructions de la rubrique Création d’un rôle pour un fournisseur d’identité tiers (fédération) dans le Guide de l’utilisateur IAM.
  - Utilisateurs IAM :
    Créez un rôle que votre utilisateur peut assumer. Suivez les instructions de la rubrique Création d’un rôle pour un utilisateur IAM dans le Guide de l’utilisateur IAM.
    
    (Non recommandé) Attachez une politique directement à un utilisateur ou ajoutez un utilisateur à un groupe d’utilisateurs. Suivez les instructions de la rubrique Ajout d’autorisations à un utilisateur (console) du Guide de l’utilisateur IAM.
2. Installez et configurez le AWS SDK pour Python. Pour de plus amples informations, veuillez consulter Étape 2 : configurer le AWS CLI and AWS Kits SDK.

Copiez le code JSON suivant dans un fichier nommé client.py.


# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0

"""
Purpose
Test code for running the Amazon Textract Lambda
function example code.
"""

import argparse
import logging
import base64
import json
import io
import boto3

from botocore.exceptions import ClientError
from PIL import Image, ImageDraw


logger = logging.getLogger(__name__)


def analyze_image(function_name, image):
    """Analyzes a document with an AWS Lambda function.
    :param image: The document that you want to analyze.
    :return The list of Block objects in JSON format.
    """

    lambda_client = boto3.client('lambda')

    lambda_payload = {}

    if image.startswith('s3://'):
        logger.info("Analyzing document from S3 bucket: %s", image)
        bucket, key = image.replace("s3://", "").split("/", 1)
        s3_object = {
            'Bucket': bucket,
            'Name': key
        }

        lambda_payload = {"S3Object": s3_object}

    else:
        with open(image, 'rb') as image_file:
            logger.info("Analyzing local document: %s ", image)
            image_bytes = image_file.read()
            data = base64.b64encode(image_bytes).decode("utf8")

            lambda_payload = {"image": data}

    # Call the lambda function with the document.

    response = lambda_client.invoke(FunctionName=function_name,
                                    Payload=json.dumps(lambda_payload))

    return json.loads(response['Payload'].read().decode())


def add_arguments(parser):
    """
    Adds command line arguments to the parser.
    :param parser: The command line parser.
    """

    parser.add_argument(
        "function", help="The name of the AWS Lambda function that you want " \
        "to use to analyze the document.")
    parser.add_argument(
        "image", help="The document that you want to analyze.") 


def main():
    """
    Entrypoint for script.
    """
    try:
        logging.basicConfig(level=logging.INFO,
                            format="%(levelname)s: %(message)s")

        # Get command line arguments.
        parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
        add_arguments(parser)
        args = parser.parse_args()

        # Get analysis results.
        result = analyze_image(args.function, args.image)
        status = result['statusCode']

        blocks = result['body']
        blocks = json.loads(blocks)

        if status == 200:

            for block in blocks:
                print('Type: ' + block['BlockType'])
                if block['BlockType'] != 'PAGE':
                    print('Detected: ' + block['Text'])
                    print('Confidence: ' + "{:.2f}".format(block['Confidence']) + "%")

                print('Id: {}'.format(block['Id']))
                if 'Relationships' in block:
                    print('Relationships: {}'.format(block['Relationships']))
                print('Bounding Box: {}'.format(block['Geometry']['BoundingBox']))
                print('Polygon: {}'.format(block['Geometry']['Polygon']))
                print()
            print("Blocks detected: " + str(len(blocks)))
        else:
            print(f"Error: {result['statusCode']}")
            print(f"Message: {result['body']}")

    except ClientError as error:
        logging.error(error)
        print(error)


if __name__ == "__main__":
    main()

Exécutez le code. Pour l'argument de ligne de commande, indiquez le nom de la fonction Lambda et le document que vous souhaitez analyser. Vous pouvez fournir un chemin d'accès à un document local ou utiliser le chemin Amazon S3 vers un document stocké dans un compartiment Amazon S3. Par exemple :
```
python client.py function_name s3://bucket/path/document.jpg
```
Si le document se trouve dans un compartiment Amazon S3, assurez-vous qu’il s’agit du même compartiment que celui que vous avez spécifié précédemment à l’étape 12 de Étape 1 : Création d'un AWS Lambda fonction (console).

En cas de succès, votre code renvoie une réponse JSON partielle pour chaque type de bloc détecté dans le document.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Exportation de tableaux dans un fichier CSV

Extraction et envoi de texte vers AWS Comprehend à des fins d'analyse