Detectar texto con un AWS Lambda función

Inicie sesión en Consola de administración de AWS y abra la AWS Lambda consola en https://console.aws.amazon.com/lambda/.

Seleccione Creación de función. Para obtener más información, consulte Crear una función de Lambda con la consola.

Elija las siguientes opciones:

Elija Crear función para crear la función de AWS Lambda .

En la página de la función, seleccione la pestaña Configuración.

En el panel Permisos, en Rol de ejecución, elija el nombre del rol para abrir el rol en la consola de IAM.

En la pestaña Permisos, elija Añadir permisos y después Crear política insertada.

Elija la pestaña JSON y reemplace la política por la siguiente política:

Elija Revisar política.

Introduzca un nombre para la política, por ejemplo DetectDocumentText-access.

Elija Crear política.

Si va a almacenar documentos para analizarlos en un bucket de Amazon S3, debe añadir una política de acceso a Amazon S3. Para ello, repita los pasos 7 a 11 en la consola de AWS Lambda y realice los siguientes cambios.

1. En el paso 8, utilice la siguiente política. bucket/folder pathSustitúyala por la ruta del depósito y la carpeta de Amazon S3 a los documentos que desee analizar.

   JSON

   {
       "Version":"2012-10-17",
       "Statement": [
           {
               "Sid": "S3Access",
               "Effect": "Allow",
               "Action": "s3:GetObject",
               "Resource": "arn:aws:s3:::bucket/folder path/*"
           }
       ]
   }
   

2. Para el paso 10, elija un nombre de política diferente, como S3Bucket-access.

Abra una línea de comandos e introduzca los siguientes comandos para crear un paquete de implementación con la versión más reciente del SDK de AWS.

pip install boto3 --target python/.
zip boto3-layer.zip -r python/
                

Anote el nombre del archivo zip (boto3-layer.zip), que utilizará en el paso 8 de este procedimiento.

Abra la AWS Lambda consola en https://console.aws.amazon.com/lambda/.

En el panel de navegación, elija Capas.

Elija Crear capa.

Introduzca valores para Nombre y Descripción.

Para Tipo de entrada de código, elija Cargar un archivo .zip y seleccione Cargar.

En el cuadro de diálogo, elija el archivo .zip (boto3-layer.zip) que creó en el paso 1 de este procedimiento.

En Tiempos de ejecución compatibles, elija Python 3.9.

Elija Crear para crear la capa.

Elija el icono del menú del panel de navegación.

Seleccione Funciones en el panel de navegación.

En la lista de recursos, elija la función que haya creado anteriormente en Paso 1: Crear un AWS Lambda función (consola).

Elija la pestaña Código.

En la sección Capas, elija Agregar una capa.

Elija Capas personalizadas.

En Capas personalizadas, elija el nombre de la capa que escogió en el paso 6.

En Versión, elija la versión de la capa, que debe ser 1.

Elija Agregar.

Navegue hasta la pestaña Código.

En el editor de código, sustituya el código del archivo lambda_function.py por el código siguiente:

# 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

Elija Implementar para implementar la función de Lambda.

Si aún no lo ha hecho, haga lo siguiente:

1. Asegúrese de que el usuario tiene el permiso lambda:InvokeFunction. Puede utilizar la siguiente política:

   Puede obtener el ARN de la función de Lambda en la descripción general de la función en la consola de Lambda.

   Para dar acceso, agregue permisos a los usuarios, grupos o roles:

   • Usuarios y grupos en: AWS IAM Identity Center

     Cree un conjunto de permisos. Siga las instrucciones de Creación de un conjunto de permisos en la Guía del usuario de AWS IAM Identity Center .

   • Usuarios gestionados en IAM a través de un proveedor de identidades:

     Cree un rol para la federación de identidades. Siga las instrucciones descritas en Creación de un rol para un proveedor de identidad de terceros (federación) en la Guía del usuario de IAM.

   • Usuarios de IAM:

     • Cree un rol que el usuario pueda aceptar. Siga las instrucciones descritas en Creación de un rol para un usuario de IAM en la Guía del usuario de IAM.

     • (No recomendado) Adjunte una política directamente a un usuario o agregue un usuario a un grupo de usuarios. Siga las instrucciones descritas en Adición de permisos a un usuario (consola) de la Guía del usuario de IAM.

2. Instale y configure el AWS SDK para Python. Para obtener más información, consulte Paso 2: configurar el AWS CLI and AWS SDK.

Guarde el siguiente código en un archivo denominado 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()

Ejecute el código. Para el argumento de la línea de comandos, proporcione el nombre de la función Lambda y el documento que desee analizar. Puede proporcionar una ruta a un documento local o puede usar la ruta de Amazon S3 a un documento almacenado en un bucket de Amazon S3. Por ejemplo:

python client.py function_name s3://bucket/path/document.jpg

Si el documento está en un bucket de Amazon S3, asegúrese de que es el mismo bucket que indicó anteriormente en el paso 12 de Paso 1: Crear un AWS Lambda función (consola).

Si se ejecuta correctamente, el código devuelve una respuesta JSON parcial para cada tipo de bloque detectado en el documento.