Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Label in einem Bild mit Lambda und Python erkennen
AWS Lambda ist ein Rechendienst, mit dem Sie Code ausführen können, ohne Server bereitzustellen oder zu verwalten. 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](https://docs.aws.amazon.com/rekognition/latest/dg/limits.html) in Rekognition und in der [DetectLabels API-Referenz](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html).
## 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)**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die AWS Lambda Konsole unter [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Wählen Sie **Funktion erstellen**. Weitere Informationen zur Verwendung von Lambda finden Sie unter [Erstellen einer Lambda-Funktion mit der Konsole](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html).
1. 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.
1. Wählen Sie **Funktion erstellen**, um die AWS Lambda -Funktion zu erstellen.
1. Wählen Sie auf der Seite der Funktion die Registerkarte **Konfiguration**.
1. Wählen Sie im Bereich **Berechtigungen** unter **Ausführungsrolle** den Rollennamen aus, um die Rolle in der IAM-Konsole zu öffnen.
1. Wählen Sie auf der Registerkarte **Berechtigungen** die Optionen **Berechtigungen hinzufügen** und dann **(Inline-Richtlinie erstellen** aus.
1. Wählen Sie die Registerkarte **JSON** und ersetzen Sie die Richtlinie durch die folgende Richtlinie:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": "rekognition:DetectLabels",
"Resource": "*",
"Effect": "Allow",
"Sid": "DetectLabels"
}
]
}
```
------
1. Wählen Sie **Richtlinie prüfen**.
1. Geben Sie einen Namen für die Richtlinie ein, zum Beispiel *DetectLabels-access*.
1. Wählen Sie **Richtlinie erstellen** aus.
1. 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 path}}Ersetzen 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}}/*"
}
]
}
```
------
1. 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](https://docs.aws.amazon.com/lambda/latest/dg/invocation-layers.html#invocation-layers-using).
**So erstellen Sie eine Ebene und fügen eine hinzu (Konsole)**
1. Ö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/
```
1. Notieren Sie sich den Namen der ZIP-Datei (boto3-layer.zip), die Sie in Schritt 8 dieses Verfahrens verwenden.
1. Öffnen Sie die AWS Lambda Konsole unter [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Wählen Sie im Navigationsbereich **Ebenen** aus.
1. Wählen Sie **Ebene erstellen** aus.
1. Geben Sie einen **Namen** und eine **Beschreibung** ein.
1. Wählen Sie als **Code-Eingabetyp** **Hochladen einer ZIP-Datei** und wählen Sie **Hochladen**.
1. Wählen Sie im Dialogfeld das ZIP-Dateiarchiv (boto3-layer.zip) aus, das Sie in Schritt 1 dieses Verfahrens erstellt haben.
1. Wählen Sie für **Kompatible Laufzeiten** die neueste Version von Python aus.
1. Wählen Sie **Erstellen**, um die Ebene zu erstellen.
1. Wählen Sie das Menüsymbol im Navigationsbereich.
1. Wählen Sie im Navigationsbereich **Funktionen** aus.
1. Wählen Sie in der Ressourcenliste die Funktion aus, die Sie zuvor in [](#lambda-s3-tutorial-python-create) erstellt haben.
1. Wählen Sie die Registerkarte **Code**.
1. Wählen Sie im Bereich **Ebenen** die Option **Ebene hinzufügen** aus.
1. Wählen Sie **Benutzerdefinierte Ebenen**.
1. Wählen Sie unter **Benutzerdefinierte Ebenen** den Namen der Ebene aus, den Sie in Schritt 6 eingegeben haben.
1. Wählen Sie unter **Version** die Version der Ebene aus, die 1 sein sollte.
1. 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)**
1. Navigieren Sie zur Registerkarte **Code**.
1. 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
```
1. 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)](https://docs.aws.amazon.com/lambda/latest/dg/configuration-function-common.html#configuration-timeout-console).
Weitere Informationen zum Aufrufen einer Lambda-Funktion aus Ihrem Code finden Sie unter [Aufrufen von AWS-Lambda-Funktionen](https://docs.aws.amazon.com/lambda/latest/dg/lambda-invocation.html).
**So testen Sie Ihre Lambda-Funktion**
1. 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](https://console.aws.amazon.com/lambda/) 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](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) 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](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) 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](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) 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)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) im *IAM-Benutzerhandbuch*.
1. 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](setup-awscli-sdk.md).
1. 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)
```
1. 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 [](#lambda-s3-tutorial-python-create) von angegeben haben.
Bei Erfolg gibt Ihr Code für jeden im Dokument erkannten Blocktyp eine teilweise JSON-Antwort zurück.