Rilevamento del testo con un AWS Lambda funzione

Accedi a Console di gestione AWS e apri la AWS Lambda console all'indirizzo https://console.aws.amazon.com/lambda/.

Scegli Crea funzione. Per ulteriori informazioni, consulta Creare una funzione Lambda con la console.

Scegliere le opzioni seguenti:

Scegliere Crea funzione per creare una funzione AWS Lambda .

Nella pagina della funzione, scegli la scheda Configurazione.

Nel riquadro Autorizzazioni, in Ruolo di esecuzione, scegli il nome del ruolo per aprire il ruolo nella console IAM.

Nella scheda Autorizzazioni, scegli Aggiungi autorizzazioni, poi Crea policy inline.

Scegliere la scheda JSON e sostituire la policy con la policy seguente:

Scegliere Esamina policy.

Ad esempio, inserisci un nome per la politica DetectDocumentText-access.

Scegli Crea policy.

Se stai archiviando documenti per l'analisi in un bucket Amazon S3, devi aggiungere una policy di accesso Amazon S3. A tale scopo, ripeti i passaggi da 7 a 11 nella console AWS Lambda e apporta le seguenti modifiche.

1. Per il passaggio 8, utilizza la seguente policy. Sostituisci bucket/folder path con il bucket Amazon S3 e il percorso della cartella i documenti che desideri analizzare.

   JSON

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

2. Per la fase 10, scegli un nome di policy diverso, ad esempio. S3Bucket-access

Apri un prompt dei comandi e inserisci i seguenti comandi per creare un pacchetto di distribuzione con la versione più recente dell'SDK AWS.

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

Prendete nota del nome del file zip (boto3-layer.zip), utilizzato nel passaggio 8 di questa procedura.

Apri la AWS Lambda console all'indirizzo. https://console.aws.amazon.com/lambda/

Nel riquadro di navigazione scegli Layers (Livelli).

Scegli Create layer (Crea livello).

Immetti i valori per Nome (Nome) e Description (Descrizione).

In Tipo di voce del codice, scegli Carica un file .zip e seleziona Carica.

Nella finestra di dialogo, scegliete l'archivio di file zip (boto3-layer.zip) che avete creato nel passaggio 1 di questa procedura.

Per i runtime compatibili, scegli Python 3.9.

Scegli Crea per creare lo strato.

Scegli l'icona del menu del pannello di navigazione.

Nel riquadro di navigazione, seleziona Funzioni.

Nell'elenco delle risorse, scegliere la funzione creata in precedenza inFase 1: Creare un AWS Lambda funzione (console).

Scegli la scheda Codice.

Nella sezione Livelli, scegli Aggiungi un livello.

Scegliete Livelli personalizzati.

In Livelli personalizzati, scegli il nome del livello che hai inserito nel passaggio 6.

In Versione scegli la versione del livello, che dovrebbe essere 1.

Scegli Aggiungi.

Passa alla scheda Codice.

Nell'editor di codice, sostituisci il codice in lambda_function.py con il seguente codice:

# 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

Per distribuire la funzione Lambda, scegli Deploy.

Se non lo hai ancora fatto, esegui queste operazioni:

1. Assicurati che l'utente disponga dell'autorizzazione lambda:InvokeFunction. Si più usare la seguente policy:

   Puoi ottenere l'ARN per la tua funzione Lambda dalla panoramica delle funzioni nella console Lambda.

   Per fornire l’accesso, aggiungi autorizzazioni agli utenti, gruppi o ruoli:

   • Utenti e gruppi in: Centro identità AWS IAM

     Crea un set di autorizzazioni. Segui le istruzioni riportate nella pagina Create a permission set (Creazione di un set di autorizzazioni) nella Guida per l’utente di Centro identità AWS IAM .

   • Utenti gestiti in IAM tramite un provider di identità:

     Crea un ruolo per la federazione delle identità. Segui le istruzioni riportate nella pagina Create a role for a third-party identity provider (federation) della Guida per l’utente IAM.

   • Utenti IAM:

     • Crea un ruolo che l’utente possa assumere. Segui le istruzioni riportate nella pagina Create a role for an IAM user della Guida per l’utente IAM.

     • (Non consigliato) Collega una policy direttamente a un utente o aggiungi un utente a un gruppo di utenti. Segui le istruzioni riportate nella pagina Aggiunta di autorizzazioni a un utente (console) nella Guida per l’utente IAM.

2. Installa e configura AWS SDK per Python. Per ulteriori informazioni, consulta Passaggio 2: configura il AWS CLI and AWS SDK.

Salva il seguente codice in un file denominato 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()

Eseguire il codice. Per l'argomento della riga di comando, fornisci il nome della funzione Lambda e il documento che desideri analizzare. Puoi fornire un percorso a un documento locale oppure puoi utilizzare il percorso Amazon S3 per un documento archiviato in un bucket Amazon S3. Ad esempio:

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

Se il documento si trova in un bucket Amazon S3, assicurati che sia lo stesso bucket specificato in precedenza nel passaggio 12 di Fase 1: Creare un AWS Lambda funzione (console).

In caso di successo, il codice restituisce una risposta JSON parziale per ogni tipo di blocco rilevato nel documento.