Detectando texto com um AWS Lambda função

Faça login no Console de gerenciamento da AWS e abra o AWS Lambda console em https://console.aws.amazon.com/lambda/.

Escolha a opção Criar função. Para obter mais informações, consulte Criar uma função do Lambda com o console.

Escolha as seguintes opções:

Escolha Criar função para criar a função do AWS Lambda .

Na página da função, escolha a guia Configuração.

No painel Permissões, em Função de execução, escolha o nome do perfil para abrir o perfil no console do IAM.

Na guia Permissões, escolha Adicionar permissões e, em seguida, Criar política em linha.

Escolha a guia JSON e substitua a política pela seguinte política:

Selecione Revisar política.

Insira um nome para a política, por exemplo DetectDocumentText-access.

Selecione Criar política.

Se você estiver armazenando documentos para análise em um bucket do Amazon S3, deverá adicionar uma política de acesso do Amazon S3. Para fazer isso, repita as etapas 7 a 11 no console da AWS Lambda e faça as seguintes alterações.

1. Para a etapa 8, use a política a seguir. bucket/folder pathSubstitua pelo bucket e pelo caminho da pasta do Amazon S3 até os documentos que você deseja analisar.

   JSON

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

2. Para a etapa 10, escolha um nome de política diferente, como S3Bucket-access.

Abra um prompt de comando e insira os comandos a seguir para criar um pacote de implantação com a versão mais recente do SDK da AWS.

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

Anote o nome do arquivo zip (boto3-layer.zip), que você usa na etapa 8 deste procedimento.

Abra o AWS Lambda console em https://console.aws.amazon.com/lambda/.

No painel de navegação, escolha Camadas.

Escolha Criar camada.

Insira valores para Nome e Descrição.

Em Tipo de entrada de código, escolha Carregar um arquivo.zip e selecione Upload.

Na caixa de diálogo, escolha o arquivo zip (boto3-layer.zip) que você criou na etapa 1 deste procedimento.

Para tempos de execução compatíveis, escolha Python 3.9.

Escolha Criar para criar a camada.

Escolha o ícone do menu do painel de navegação.

Selecione Funções no painel de navegação.

Na lista de recursos, escolha a função que você criou anteriormente em Etapa 1: criar um AWS Lambda função (console).

Escolha a guia Código.

Na seção Camadas, escolha Adicionar uma camada.

Escolha camadas personalizadas.

Em Camadas personalizadas, escolha o nome da camada que você inseriu na etapa 6.

Em Versão, escolha a versão da camada, que deve ser 1.

Escolha Adicionar.

Navegue até a guia Código .

No editor de código, substitua o código em lambda_function.py pelo código a seguir:

# 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

Escolha Implantar para implantar sua função do Lambda.

Se você ainda não fez isso, faça o seguinte:

1. Certifique-se de que o usuário tenha permissão lambda:InvokeFunction. Você pode usar a seguinte política:

   Você pode obter o ARN da sua função do Lambda na visão geral da função no console do Lambda.

   Para conceder acesso, adicione as permissões aos seus usuários, grupos ou perfis:

   • Usuários e grupos em Centro de Identidade do AWS IAM:

     Crie um conjunto de permissões. Siga as instruções em Criação de um conjunto de permissões no Guia do usuário do Centro de Identidade do AWS IAM .

   • Usuários gerenciados no IAM com provedor de identidades:

     Crie um perfil para a federação de identidades. Siga as instruções em Criando um perfil para um provedor de identidades de terceiros (federação) no Guia do Usuário do IAM.

   • Usuários do IAM:

     • Crie um perfil que seu usuário possa assumir. Siga as instruções em Criação de um perfil para um usuário do IAM no Guia do usuário do IAM.

     • (Não recomendado) Vincule uma política diretamente a um usuário ou adicione um usuário a um grupo de usuários. Siga as instruções em Adição de permissões a um usuário (console) no Guia do usuário do IAM.

2. Instale e configure o AWS SDK para Python. Para obter mais informações, consulte Etapa 2: configurar o AWS CLI and AWS SDKs.

Salve o código a seguir em um arquivo chamado 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()

Execute o código. Para o argumento da linha de comando, forneça o nome da função Lambda e o documento que você deseja analisar. Você pode fornecer um caminho para um documento local ou usar o caminho do Amazon S3 para um documento armazenado em um bucket do Amazon S3. Por exemplo:

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

Se o documento estiver em um bucket do Amazon S3, certifique-se de que seja o mesmo bucket que você especificou anteriormente na etapa 12 do Etapa 1: criar um AWS Lambda função (console).

Se for bem-sucedido, seu código retornará uma resposta JSON parcial para cada tipo de bloco detectado no documento.