Erkennen von Text mit einem AWS Lambda function

Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die AWS Lambda Konsole unter https://console.aws.amazon.com/lambda/.

Wählen Sie Funktion erstellen. Weitere Informationen zur Verwendung von Lambda finden Sie unter Erstellen einer Lambda-Funktion mit der Konsole.

Wählen Sie aus den folgenden Optionen:

Wählen Sie Funktion erstellen, um die AWS Lambda -Funktion zu erstellen.

Wählen Sie auf der Seite der Funktion die Registerkarte Konfiguration.

Wählen Sie im Bereich Berechtigungen unter Ausführungsrolle den Rollennamen aus, um die Rolle in der IAM-Konsole zu öffnen.

Wählen Sie auf der Registerkarte Berechtigungen die Optionen Berechtigungen hinzufügen und dann (Inline-Richtlinie erstellen aus.

Wählen Sie die Registerkarte JSON und ersetzen Sie die Richtlinie durch die folgende Richtlinie:

Wählen Sie Richtlinie prüfen.

Geben Sie beispielsweise einen Namen für die Richtlinie ein DetectDocumentText-access.

Wählen Sie Richtlinie erstellen aus.

Wenn Sie Dokumente zur Analyse in einem Amazon-S3-Bucket speichern, müssen Sie eine Amazon-S3-Zugriffsrichtlinie hinzufügen. Wiederholen Sie dazu die Schritte 7 bis 11 in der AWS Lambda -Konsole und nehmen Sie die folgenden Änderungen vor.

1. Verwenden Sie für Schritt 8 die folgende Richtlinie. bucket/folder pathErsetzen Sie durch den Amazon S3 S3-Bucket und den Ordnerpfad zu den Dokumenten, die Sie analysieren möchten.

   JSON

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

2. Wählen Sie für Schritt 10 einen anderen Richtliniennamen, z. S3Bucket-accessB.

Öffnen Sie eine Befehlszeile und geben Sie die folgenden Befehle ein, um ein Bereitstellungspaket mit der neuesten Version des AWS-SDK zu erstellen.

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

Notieren Sie sich den Namen der ZIP-Datei (boto3-layer.zip), die Sie in Schritt 8 dieses Verfahrens verwenden.

Öffnen Sie die AWS Lambda Konsole unter https://console.aws.amazon.com/lambda/.

Wählen Sie im Navigationsbereich Ebenen aus.

Wählen Sie Ebene erstellen aus.

Geben Sie einen Namen und eine Beschreibung ein.

Wählen Sie als Code-Eingabetyp Hochladen einer ZIP-Datei und wählen Sie Hochladen.

Wählen Sie im Dialogfeld das ZIP-Dateiarchiv (boto3-layer.zip) aus, das Sie in Schritt 1 dieses Verfahrens erstellt haben.

Wählen Sie für Kompatible Laufzeiten Python 3.9.

Wählen Sie Erstellen, um die Ebene zu erstellen.

Wählen Sie das Menüsymbol im Navigationsbereich.

Wählen Sie im Navigationsbereich Funktionen aus.

Wählen Sie in der Ressourcenliste die Funktion aus, die Sie zuvor in Schritt 1: Erstellen Sie ein AWS Lambda Funktion (Konsole) erstellt haben.

Wählen Sie die Registerkarte Code.

Wählen Sie im Bereich Ebenen die Option Ebene hinzufügen aus.

Wählen Sie Benutzerdefinierte Ebenen.

Wählen Sie unter Benutzerdefinierte Ebenen den Namen der Ebene aus, den Sie in Schritt 6 eingegeben haben.

Wählen Sie unter Version die Version der Ebene aus, die 1 sein sollte.

Wählen Sie Hinzufügen aus.

Navigieren Sie zur Registerkarte Code.

Ersetzen Sie im Code-Editor den Code in lambda_function.py durch den folgenden Code:

# 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

Wählen Sie Implementieren aus, um Ihre Lambda-Funktion bereitzustellen.

Sofern Sie das noch nicht getan haben, führen Sie die folgenden Schritte aus:

1. Stellen Sie sicher, dass der Benutzer über die entsprechende lambda:InvokeFunction-Berechtigung verfügt. Sie können die folgende Richtlinie verwenden:

   Sie können den ARN für Ihre Lambda-Funktion in der Funktionsübersicht in der Lambda-Konsole abrufen.

   Um Zugriff zu gewähren, fügen Sie Ihren Benutzern, Gruppen oder Rollen Berechtigungen hinzu:

   • Benutzer und Gruppen in: AWS IAM Identity Center

     Erstellen Sie einen Berechtigungssatz. Befolgen Sie die Anweisungen unter Erstellen eines Berechtigungssatzes im AWS IAM Identity Center -Benutzerhandbuch.

   • Benutzer, die in IAM über einen Identitätsanbieter verwaltet werden:

     Erstellen Sie eine Rolle für den Identitätsverbund. Befolgen Sie die Anleitung unter Eine Rolle für einen externen Identitätsanbieter (Verbund) erstellen im IAM-Benutzerhandbuch.

   • IAM-Benutzer:

     • Erstellen Sie eine Rolle, die Ihr Benutzer annehmen kann. Befolgen Sie die Anleitung unter Eine Rolle für einen IAM-Benutzer erstellen im IAM-Benutzerhandbuch.

     • (Nicht empfohlen) Weisen Sie einem Benutzer eine Richtlinie direkt zu oder fügen Sie einen Benutzer zu einer Benutzergruppe hinzu. Befolgen Sie die Anweisungen unter Hinzufügen von Berechtigungen zu einem Benutzer (Konsole) im IAM-Benutzerhandbuch.

2. Installieren und konfigurieren Sie AWS das SDK für Python. Weitere Informationen finden Sie unter Schritt 2: Richten Sie das ein AWS CLI und AWS SDKs.

Speichern Sie den folgenden Code in eine Datei mit dem Namen 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()

Führen Sie den Code aus. Geben Sie für das Befehlszeilenargument den Namen der Lambda-Funktion und das Dokument an, das Sie analysieren möchten. Sie können einen Pfad zu einem lokalen Dokument angeben oder den Amazon S3 S3-Pfad zu einem Dokument verwenden, das in einem Amazon S3 S3-Bucket gespeichert ist. Beispiel:

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

Wenn sich das Dokument in einem Amazon-S3-Bucket befindet, stellen Sie sicher, dass es sich um denselben Bucket handelt, den Sie zuvor in Schritt 12 Schritt 1: Erstellen Sie ein AWS Lambda Funktion (Konsole) von angegeben haben.

Bei Erfolg gibt Ihr Code für jeden im Dokument erkannten Blocktyp eine teilweise JSON-Antwort zurück.