Erstellen einer Lambda-Funktion (Konsole) (Optional) Erstellen einer Ebene (Konsole) Python-Code hinzufügen (Konsole) So fügen Sie Python-Code hinzu (Konsole)

Label in einem Bild mit Lambda und Python erkennen

AWS Lambda ist ein Rechendienst, mit dem Sie Code ausführen können, ohne Server bereitstellen oder verwalten zu müssen. Sie können Rekognition-API-Operationen von einer Lambda-Funktion aus aufrufen. Die folgenden Anweisungen zeigen, wie eine Lambda-Funktion in Python erstellt wird, die DetectLabels aufruft.

Die Lambda-Funktion ruft DetectLabels auf und gibt ein Array der im Bild erkannten Markierungen zurück, sowie den Vertrauensgrad, mit dem sie erkannt wurden.

Die Anweisungen enthalten einen Python-Beispielcode, der Ihnen zeigt, wie Sie die Lambda-Funktion aufrufen und sie mit einem Bild versorgen, das aus einem Amazon-S3-Bucket oder Ihrem lokalen Computer stammt.

Stellen Sie sicher, dass die von Ihnen ausgewählten Bilder die Limits von Rekognition einhalten. Informationen zu Bilddateityp - und Größenbeschränkungen finden Sie unter Richtlinien und Kontingente in Rekognition und in der DetectLabels API-Referenz.

Erstellen einer Lambda-Funktion (Konsole)

In diesem Schritt erstellen Sie eine leere Lambda-Funktion und eine IAM-Ausführungsrolle, mit der Ihre Lambda-Funktion die DetectLabels-Operation aufrufen kann. In späteren Schritten fügen Sie den Quellcode und optional eine Ebene zur Lambda-Funktion hinzu.

Wenn Sie Dokumente verwenden, die in einem Amazon-S3-Bucket gespeichert sind, zeigt dieser Schritt auch, wie Sie Zugriff auf den Bucket gewähren, in dem Ihre Dokumente gespeichert sind.

So erstellen Sie eine AWS Lambda Funktion (Konsole)

Melden Sie sich bei der an AWS Management Console 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 Von Grund auf neu schreiben aus.
- Geben Sie einen Wert für Funktionsname ein.
- Wählen Sie für Laufzeit die neueste Version von Python aus.
- Wählen Sie für Architektur x86_64 aus.
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 einen Namen für die Richtlinie ein, zum Beispiel DetectLabels-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. B. S3Bucket-access.

(Optional) Erstellen einer Ebene (Konsole)

Sie müssen diesen Schritt nicht ausführen, um eine Lambda-Funktion zu verwenden und DetectLabels aufzurufen.

Die DetectLabels Operation ist in der standardmäßigen Lambda-Python-Umgebung als Teil des AWS SDK für Python (Boto3) enthalten.

Wenn für andere Teile Ihrer Lambda-Funktion aktuelle AWS Service-Updates erforderlich sind, die sich nicht in der Standard-Lambda-Python-Umgebung befinden, können Sie diesen Schritt ausführen, um die neueste Boto3-SDK-Version als Ebene zu Ihrer Funktion hinzuzufügen.

Um das SDK als Ebene hinzuzufügen, erstellen Sie zunächst ein ZIP-Dateiarchiv, das das Boto3-SDK enthält. Anschließend erstellen Sie eine Ebene und fügen der Ebene das ZIP-Dateiarchiv hinzu. Weitere Informationen finden Sie unter Verwenden von Ebenen mit Ihrer Lambda-Funktion.

So erstellen Sie eine Ebene und fügen eine hinzu (Konsole)

Öffnen Sie eine Befehlszeile und geben Sie die folgenden Befehle ein, um ein Bereitstellungspaket mit der neuesten Version des SDK zu erstellen. AWS
```
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 die neueste Version von Python aus.
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 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.

Python-Code hinzufügen (Konsole)

In diesem Schritt fügen Sie Ihren Python-Code über den Code-Editor der Lambda-Konsole zu Ihrer Lambda-Funktion hinzu. Der Code erkennt mithilfe der DetectLabels-Operation Labels in einem Bild. Er gibt eine Reihe von Label zurück, die im Bild erkannt wurden, sowie den Grad der Zuverlässigkeit der erkannten Label.

Das Dokument, das Sie für die DetectLabels-Operation bereitstellen, kann sich in einem Amazon-S3-Bucket oder auf einem lokalen Computer befinden.

So fügen Sie Python-Code hinzu (Konsole)

Navigieren Sie zur Registerkarte Code.

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


import boto3
import logging
from botocore.exceptions import ClientError
import json
import base64

# Instantiate logger
logger = logging.getLogger(__name__)

# connect to the Rekognition client
rekognition = boto3.client('rekognition')

def lambda_handler(event, context):

    try:
        image = None
        if 'S3Bucket' in event and 'S3Object' in event:
            s3 = boto3.resource('s3')
            s3_object = s3.Object(event['S3Bucket'], event['S3Object'])
            image = s3_object.get()['Body'].read()

        elif 'image' in event:
            image_bytes = event['image'].encode('utf-8')
            img_b64decoded = base64.b64decode(image_bytes)
            image = img_b64decoded


        elif image is None:
            raise ValueError('Missing image, check image or bucket path.')

        else:
            raise ValueError("Only base 64 encoded image bytes or S3Object are supported.")

        response = rekognition.detect_labels(Image={'Bytes': image})
        lambda_response = {
            "statusCode": 200,
            "body": json.dumps(response)
        }
        labels = [label['Name'] for label in response['Labels']]
        print("Labels found:")
        print(labels)

    except ClientError as client_err:

       error_message = "Couldn't analyze image: " + client_err.response['Error']['Message']

       lambda_response = {
           'statusCode': 400,
           'body': {
               "Error": client_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 Bereitstellen aus, um Ihre Lambda-Funktion bereitzustellen.

So fügen Sie Python-Code hinzu (Konsole)

Nach dem Erstellen Ihrer Lambda-Funktion können Sie sie aufrufen, um Labels in einem Bild zu erkennen.

In diesem Schritt führen Sie Python-Code auf Ihrem Computer aus, der ein lokales Bild oder ein Bild in einem Amazon-S3-Bucket an Ihre Lambda-Funktion übergibt.

Stellen Sie sicher, dass Sie den Code in derselben AWS Region ausführen, in der Sie die Lambda-Funktion erstellt haben. Sie können die AWS Region für Ihre Lambda-Funktion in der Navigationsleiste der Funktionsdetailseite in der Lambda-Konsole anzeigen.

Wenn die Lambda-Funktion einen Zeitüberschreitungsfehler zurückgibt, verlängern Sie den Zeitüberschreitungs-Zeitraum für die Lambda-Funktion. Weitere Informationen erhalten Sie unter Zeitüberschreitung der Funktion konfigurieren (Konsole).

Weitere Informationen zum Aufrufen einer Lambda-Funktion aus Ihrem Code finden Sie unter Aufrufen von AWS-Lambda-Funktionen.

So testen Sie Ihre Lambda-Funktion

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 AWS CLI und ein AWS SDKs.

Speichern Sie den folgenden Code in eine Datei mit dem Namen client.py:


import boto3
import json
import base64
import pprint

# Replace with the name of your S3 bucket and image object key
bucket_name = "name of bucket"
object_key = "name of file in s3 bucket"
# If using a local file, supply the file name as the value of image_path below
image_path = ""

# Create session and establish connection to client['
session = boto3.Session(profile_name='developer-role')
s3 = session.client('s3', region_name="us-east-1")
lambda_client = session.client('lambda',  region_name="us-east-1")

# Replace with the name of your Lambda function
function_name = 'RekDetectLabels'

def analyze_image_local(img_path):

    print("Analyzing local image:")

    with open(img_path, 'rb') as image_file:
        image_bytes = image_file.read()
        data = base64.b64encode(image_bytes).decode("utf8")

        lambda_payload = {"image": data}

        # Invoke the Lambda function with the event payload
        response = lambda_client.invoke(
            FunctionName=function_name,
            Payload=(json.dumps(lambda_payload))
        )

        decoded = json.loads(response['Payload'].read().decode())
        pprint.pprint(decoded)

def analyze_image_s3(bucket_name, object_key):

    print("Analyzing image in S3 bucket:")

    # Load the image data from S3 into memory
    response = s3.get_object(Bucket=bucket_name, Key=object_key)
    image_data = response['Body'].read()
    image_data = base64.b64encode(image_data).decode("utf8")

     # Create the Lambda event payload
    event = {
        'S3Bucket': bucket_name,
        'S3Object': object_key,
        'ImageBytes': image_data
    }

    # Invoke the Lambda function with the event payload
    response = lambda_client.invoke(
            FunctionName=function_name,
            InvocationType='RequestResponse',
            Payload=json.dumps(event),
            )

    decoded = json.loads(response['Payload'].read().decode())
    pprint.pprint(decoded)

def main(path_to_image, name_s3_bucket, obj_key):

    if str(path_to_image) != "":
        analyze_image_local(path_to_image)
    else:
        analyze_image_s3(name_s3_bucket, obj_key)

if __name__ == "__main__":
    main(image_path, bucket_name, object_key)

Führen Sie den Code aus. 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 von angegeben haben.

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

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Verwendung von Amazon Rekognition (REK) zur Erkennung von Etiketten für Marketinganwendungen

Codebeispiele