Mendeteksi teks dengan AWS Lambda Fungsi

Masuk ke Konsol Manajemen AWS dan buka AWS Lambda konsol di https://console.aws.amazon.com/lambda/.

Pilih Buat fungsi. Untuk informasi selengkapnya, lihat Membuat Fungsi Lambda dengan Konsol.

Pilih opsi berikut:

Pilih Buat fungsi untuk membuat AWS Lambda fungsi.

Pada halaman fungsi, pilih tab Konfigurasi.

Pada panel Izin, di bawah Peran eksekusi, pilih nama peran untuk membuka peran di konsol IAM.

Di tab Izin, pilih Tambahkan izin, lalu Buat kebijakan sebaris.

Pilih tab JSON dan ganti kebijakan dengan kebijakan berikut:

Pilih Tinjau kebijakan.

Masukkan nama untuk kebijakan tersebut, misalnya DetectDocumentText-access.

Pilih Buat kebijakan.

Jika Anda menyimpan dokumen untuk analisis dalam bucket Amazon S3, Anda harus menambahkan kebijakan akses Amazon S3. Untuk melakukan ini, ulangi langkah 7 hingga 11 di AWS Lambda konsol dan buat perubahan berikut.

1. Untuk langkah 8, gunakan kebijakan berikut. Ganti bucket/folder path dengan bucket Amazon S3 dan path folder ke dokumen yang ingin Anda analisis.

   JSON

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

2. Untuk langkah 10, pilih nama kebijakan yang berbeda, seperti S3Bucket-access.

Buka prompt perintah dan masukkan perintah berikut untuk membuat paket penerapan dengan AWS SDK versi terbaru.

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

Perhatikan nama file zip (boto3-layer.zip), yang Anda gunakan pada langkah 8 prosedur ini.

Buka AWS Lambda konsol di https://console.aws.amazon.com/lambda/.

Di panel navigasi, pilih Layers (Lapisan).

Pilih Buat lapisan.

Masukkan nilai untuk Nama dan Deskripsi.

Untuk jenis entri Kode, pilih Unggah file.zip dan pilih Unggah.

Di kotak dialog, pilih arsip file zip (boto3-layer.zip) yang Anda buat di langkah 1 prosedur ini.

Untuk runtime yang Kompatibel, pilih Python 3.9.

Pilih Create untuk membuat layer.

Pilih ikon menu panel navigasi.

Di panel navigasi, pilih Fungsi.

Dalam daftar sumber daya, pilih fungsi yang Anda buat sebelumnyaLangkah 1: Buat AWS Lambda fungsi (konsol).

Pilih tab Kode.

Di bagian Layers, pilih Add a layer.

Pilih Custom Layers.

Di Custom layers, pilih nama layer yang Anda masukkan pada langkah 6.

Di Versi pilih versi layer, yang seharusnya 1.

Pilih Tambahkan.

Arahkan ke tab Kode.

Di editor kode, ganti kode di lambda_function.py dengan kode berikut:

# 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

Pilih Deploy untuk menerapkan fungsi Lambda Anda.

Jika Anda belum melakukannya, lakukan hal berikut:

1. Pastikan bahwa pengguna memiliki lambda:InvokeFunction izin. Anda dapat menggunakan kebijakan berikut:

   Anda bisa mendapatkan ARN untuk fungsi Lambda Anda dari ikhtisar fungsi di konsol Lambda.

   Untuk memberikan akses dan menambahkan izin bagi pengguna, grup, atau peran Anda:

   • Pengguna dan grup di AWS IAM Identity Center:

     Buat rangkaian izin. Ikuti instruksi di Buat rangkaian izin dalam Panduan Pengguna AWS IAM Identity Center .

   • Pengguna yang dikelola di IAM melalui penyedia identitas:

     Buat peran untuk federasi identitas. Ikuti instruksi dalam Buat peran untuk penyedia identitas pihak ketiga (federasi) dalam Panduan Pengguna IAM.

   • Pengguna IAM:

     • Buat peran yang dapat diambil pengguna Anda. Ikuti instruksi dalam Buat peran untuk pengguna IAM dalam Panduan Pengguna IAM.

     • (Tidak disarankan) Lampirkan kebijakan langsung ke pengguna atau tambahkan pengguna ke grup pengguna. Ikuti petunjuk dalam Menambahkan izin ke pengguna (konsol) dalam Panduan Pengguna IAM.

2. Instal dan konfigurasikan AWS SDK untuk Python. Untuk informasi selengkapnya, lihat Langkah 2: Siapkan AWS CLI and AWS SDK.

Simpan kode berikut ke file bernamaclient.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()

Jalankan kode tersebut. Untuk argumen baris perintah, berikan nama fungsi Lambda dan dokumen yang ingin Anda analisis. Anda dapat menyediakan jalur ke dokumen lokal, atau Anda dapat menggunakan jalur Amazon S3 ke dokumen yang disimpan dalam bucket Amazon S3. Contoh:

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

Jika dokumen ada di ember Amazon S3. pastikan itu adalah ember yang sama dengan yang Anda tentukan sebelumnya di langkah 12 dari. Langkah 1: Buat AWS Lambda fungsi (konsol)

Jika berhasil, kode Anda mengembalikan sebagian respons JSON untuk setiap jenis Blok yang terdeteksi dalam dokumen.