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

Dieses Tutorial führt Sie durch die Erstellung einer Python-Beispielanwendung, mit der Sie E-Mails an Personen senden können, basierend auf Bildern, die auf eine Website hochgeladen wurden. Die Beispielanwendung wurde entwickelt, um Benutzer in eine Social-Media-Marketingkampagne einzubeziehen, indem ihnen personalisierte E-Mails mit Reiseangeboten gesendet werden, wenn Sehenswürdigkeiten auf ihren Fotos erkannt werden.

Die Lösung integriert verschiedene AWS Dienste, darunter Amazon Rekognition, Amazon S3, DynamoDB und Amazon SES CloudWatch. Die Anwendung verwendet Amazon Rekognition, um Labels in Bildern zu erkennen, die von Konten hochgeladen wurden, die in einer DynamoDB-Datenbank erkannt wurden. Anschließend erhält der Kontoinhaber eine Marketing-E-Mail, die auf den im Bild erkannten Labels basiert. Die vollständige Lösungsarchitektur sieht wie folgt aus:

• Speichern Sie Benutzerdaten in der DynamoDB-Datenbank.

• Der Benutzer lädt Bilddaten und Metadaten (Benutzerkontonummer) auf Amazon S3 hoch.

• Eine Lambda-Funktion wird aufgerufen, DetectLabelsum die Labels im hochgeladenen Bild zu identifizieren und aufzuzeichnen, die Benutzer-E-Mail-Adresse in DynamoDB nachzuschlagen und eine Marketing-E-Mail an den Benutzer zu senden, der das Bild hochgeladen hat.

• Die Ergebnisse der Lambda-Funktion werden CloudWatch zur späteren Überprüfung protokolliert.

Hier ist eine Übersicht über alle Schritte des Tutorials:

1. Erstellen Sie eine DynamoDB-Tabelle und füllen Sie sie auf.

2. Schreiben Sie eine Lambda-Funktion mit Logging und Notification.

3. Richten Sie die Lambda-Funktion und die Berechtigungen ein.

4. Laden Sie Bilder und Metadaten mit Amazon S3 hoch.

5. CloudWatch Umfrageprotokolle.

Voraussetzungen

Bevor Sie mit diesem Tutorial beginnen, benötigen Sie:

• Ein AWS Konto und die entsprechenden IAM-Berechtigungen.

• Python und Boto3 sind in Ihrer Entwicklungsumgebung installiert.

• Grundlegendes Verständnis von Lambda, Amazon S3, DynamoDB, Amazon SES und. CloudWatch

• Grundkenntnisse in Lambda und Amazon SES

DynamoDB-Tabelle erstellen und auffüllen

Zu Beginn dieses Tutorials erstellen wir eine DynamoDB-Tabelle zum Speichern von Kundendaten wie E-Mail-Adresse, Alter, Telefonnummer und Mitgliedschaftsstatus, wobei eine "AccountNumber" -Variable als Primärschlüssel verwendet wird. Wir werden auch einige Beispieldaten in die Tabelle einfügen.

DynamoDB-Tabelle erstellen

Zuerst erstellen wir die DynamoDB-Tabelle. So richten Sie es mit Python und Boto3 ein. Wir erstellen eine aufgerufene Funktion create_user_table und stellen eine Verbindung zu der darin DynamoDB DynamoDB-Ressource her. Ersetzen Sie im folgenden Codebeispiel den Wert von „region_name“ durch den Namen der Region, in der Ihr Konto tätig ist, und führen Sie dann die Codezelle aus, um Ihre Tabelle zu erstellen.

import boto3
def create_user_table(dynamodb=None):
    if not dynamodb:
        dynamodb = boto3.resource('dynamodb', region_name='us-east-1')

    table = dynamodb.create_table(
        TableName='CustomerDataTable',
        KeySchema=[
            {
                'AttributeName': 'AccountNumber',
                'KeyType': 'HASH'  # Partition key
            },
        ],
        AttributeDefinitions=[
            {
                'AttributeName': 'AccountNumber',
                'AttributeType': 'S'
            },
        ],
        ProvisionedThroughput={
            'ReadCapacityUnits': 10,
            'WriteCapacityUnits': 10
        }
    )

    # Wait until the table exists.
    table.wait_until_exists()
    print("Table status:", table.table_status)

# Create the DynamoDB table.
create_user_table()
     

Durch die Ausführung dieses Skripts wurde eine DynamoDB-Tabelle CustomerDataTable mit dem Namen mit AccountNumber als Primärschlüssel eingerichtet.

Beispieldaten werden eingefügt

Jetzt wollen wir einige Beispieldaten in die Tabelle einfügen. Diese Beispieldaten helfen uns, die gesamte Funktionalität der Anwendung zu testen.

Wir werden eine zweite Funktion erstellen, die Beispieldaten zu den zuvor CustomerDataTable erstellten Funktionen hinzufügt. Mit dem folgenden Code werden drei Beispieleinträge erstellt, und jeder Eintrag enthält eine Kontonummer, eine E-Mail-Adresse, ein Alter, eine Telefonnummer und einen Mitgliedsstatus. Ersetzen Sie im folgenden Codebeispiel den Wert von region_name durch den Namen der Region, in der Ihr Konto tätig ist, und führen Sie dann die Codezelle aus, um Ihre Tabelle zu erstellen. Wenn Sie den Teil der App für die E-Mail-Zustellung testen möchten, ersetzen Sie den Wert von EmailAddress im ersten Kundeneintrag unten durch eine E-Mail-Adresse, unter der Sie E-Mails empfangen können. Speichern Sie den Code und führen Sie ihn aus.

import boto3

def insert_sample_data(dynamodb=None):
    if not dynamodb:
        dynamodb = boto3.resource('dynamodb', region_name='us-east-1')

    table = dynamodb.Table('CustomerDataTable')

    # Sample data
    customers = [
        {
            'AccountNumber': 'ACC1000',
            'EmailAddress': 'email-for-delivery-here',
            'Age': 30,
            'PhoneNumber': '123-456-7890',
            'MembershipStatus': 'Active'
        },
        {
            'AccountNumber': 'ACC1001',
            'EmailAddress': '[e-mail]',
            'Age': 25,
            'PhoneNumber': '098-765-4321',
            'MembershipStatus': 'Inactive'
        },
        {
            'AccountNumber': 'ACC1002',
            'EmailAddress': '[e-mail]',
            'Age': 35,
            'PhoneNumber': '555-555-5555',
            'MembershipStatus': 'Active'
        }
    ]
        # Inserting data
    for customer in customers:
            print(f"Adding customer: {customer['AccountNumber']}")
            table.put_item(Item=customer)

# Insert sample data into DynamoDB
insert_sample_data()
     

Nachdem die DynamoDB-Tabelle eingerichtet und gefüllt ist, können wir nun damit fortfahren, diesen Datenabruf in die Lambda-Funktion zu integrieren. Auf diese Weise kann unsere Anwendung Benutzerdaten auf der Grundlage der Kontonummer abrufen, die im nächsten Bildverarbeitungs-Workflow identifiziert wird.

Eine Lambda-Funktion mit Protokollierung und Benachrichtigung erstellen

Jetzt können wir eine Lambda-Funktion erstellen. Wir möchten sicherstellen, dass die Lambda-Funktion, die beim Bild-Upload ausgelöst wird, sowohl die Bilddaten als auch die Konto-Metadaten lesen und damit eine Suche in der DynamoDB-Tabelle nach den zugehörigen Benutzerdaten durchführen kann. Das bedeutet, dass wir nicht nur die Funktion von Amazon Rekognition aufrufen müssen, sondern auch eine DetectLabels Funktion benötigen, die das aufnimmt AccountNumber und verwendet, um die zugehörige E-Mail-Adresse von DynamoDB abzurufen. Zusätzlich benötigen wir eine Funktion, die mit Amazon SES eine E-Mail an die E-Mail-Adresse sendet. Schließlich verwenden wir einen Logger, um Informationen über den Prozess zu protokollieren. Diese Daten werden von angezeigt CloudWatch.

Erstellen der Lambda-Funktion

Im Folgenden finden Sie einen Überblick darüber, wie eine Lambda-Funktion mit diesen Anforderungen umgehen könnte. Stellen Sie im folgenden Codebeispiel sicher, dass die richtige DynamoDB-Tabelle angegeben ist, wenn Sie etwas anderes CustomerDataTable als den Namen Ihrer Tabelle verwendet haben. Darüber hinaus sollten Sie in der Funktion „send_marketing_email“ den Wert des Arguments „Source“ durch eine E-Mail-Adresse ersetzen, auf die Sie Zugriff haben und die als sendende E-Mail fungiert.

import json
import boto3
import logging

logger = logging.getLogger()
logger.setLevel(logging.INFO)

def lambda_handler(event, context):
    s3_bucket = event['Records'][0]['s3']['bucket']['name']
    s3_object_key = event['Records'][0]['s3']['object']['key']
    print(s3_bucket)
    print(s3_object_key)
    
    s3 = boto3.client('s3')
    try:
        s3_response = s3.head_object(Bucket=s3_bucket, Key=s3_object_key)
        account_number = s3_response['Metadata']['account_number']
    except Exception as e:
        logger.error(f"Failed to retrieve object or metadata: {str(e)}")
        raise e  # Optionally re-raise to handle the error upstream or signal a failure
    
    rekognition = boto3.client('rekognition')
    try:
        labels_response = rekognition.detect_labels(Image={'S3Object': {'Bucket': s3_bucket, 'Name': s3_object_key}})
        #logger.info(f"Detected labels: {json.dumps(labels_response['Labels'], indent=4)}")
    except Exception as e:
        #logger.info(f"Detected label: {label['Name']}")
        raise e
    
    #logger.info(f"Detected labels: {json.dumps(labels_response['Labels'], indent=4)}")

    landmark_detected = any(label['Name'] == 'Landmark' and label['Confidence'] > 20 for label in labels_response['Labels'])
    if landmark_detected:
        result = notify_user_based_on_landmark(account_number)
        print(result)
        #logger.info(f"Detected label: {label['Name']}")
        #logger.info(f"Notification sent: {result}")
    return {
        'statusCode': 200,
        'body': json.dumps('Process completed successfully!')
    }

def notify_user_based_on_landmark(account_number):
     # Retrieve user data from DynamoDB
    dynamodb = boto3.resource('dynamodb')
    table = dynamodb.Table('CustomerDataTable')
    user_info = table.get_item(Key={'AccountNumber': account_number})

    # Send email if user is found
    if 'Item' in user_info:
        send_marketing_email(user_info['Item']['EmailAddress'])
    return "User notified with relevant travel information."

def send_marketing_email(email):
    ses = boto3.client('ses')
    response = ses.send_email(
        Source='[e-mail]',
        Destination={'ToAddresses': [email]},
        Message={
            'Subject': {'Data': 'Explore New Destinations!'},
            'Body': {
                'Text': {'Data': 'Check out our exclusive travel packages inspired by the landmark in your uploaded image!'}
            }
        }
    )
    return f"Email sent to {email} with status {response['ResponseMetadata']['HTTPStatusCode']}"
    print("succeess")
     

Nachdem wir die Lambda-Funktion geschrieben haben, müssen wir die Berechtigungen für Lambda konfigurieren und eine Instanz unserer Lambda-Funktion in der AWS Management Console erstellen.

Berechtigungen und die Lambda-Funktion einrichten

IAM-Rolle erstellen oder aktualisieren

Bevor wir eine Lambda-Funktion verwenden können, um von Benutzern hochgeladene Bilder zu verarbeiten, müssen wir die entsprechenden Berechtigungen verwalten. Die Lambda-Funktion benötigt eine auf sie zugeschnittene IAM-Rolle mit Richtlinien, die es ihr ermöglichen, mit Amazon S3, DynamoDB, Amazon SES, Amazon Rekognition und zu interagieren. CloudWatch

So konfigurieren Sie Ihre IAM-Rolle für die Lambda-Funktion:

1. Öffnen Sie die AWS Management Console.

2. Gehen Sie zu IAM > Rollen > Rolle erstellen.

   Wählen Sie „Rolle erstellen“.

3. Wählen Sie Lambda als Dienst aus, der diese Rolle verwenden soll. Klicken Sie auf „Weiter“.

4. Fügen Sie die folgenden Richtlinien bei (Beachten Sie, dass diese Richtlinien ausschließlich zu Demonstrationszwecken ausgewählt wurden. In einer echten Produktionsumgebung sollten Sie die Berechtigungen nur auf diejenigen beschränken, die benötigt werden. ):

   • Amazonen S 3 ReadOnlyAccess

   • AmazonRekognitionReadOnlyAccess

   • AmazonDynamoDBFullZugriff

   • SESFullZugriff auf Amazon

   • AWSLambdaAusführen

   • AWSLambdaBasicExecutionRole (zum CloudWatch Loggen)

   Klicken Sie auf „Weiter“.

5. Geben Sie der Rolle einen Namen und eine Beschreibung und erstellen Sie dann die Rolle, indem Sie „Rolle erstellen“ wählen.

6. Sobald wir die richtigen Berechtigungen für Lambda konfiguriert haben, können wir mit der AWS Management Console eine Instanz der Lambda-Funktion erstellen.

   Rufen Sie den Lambda-Service in der AWS-Managementkonsole auf.

7. Klicken Sie auf „Funktion erstellen“. Wählen Sie „Von Grund auf neu erstellen“.

8. Geben Sie einen Funktionsnamen ein und wählen Sie die Python-Laufzeit aus. Wählen Sie unter „Standardausführungsrolle ändern“ die Option „Eine bestehende Rolle verwenden“ und wählen Sie dann die IAM-Rolle aus, die Sie zuvor erstellt haben.

9. Jetzt müssen Sie den Code auf der Registerkarte Lambda-Funktionen erstellen und aktualisieren. Gehen Sie zur Registerkarte „lambda_function“ und ersetzen Sie den dortigen Code durch das nachfolgende Lambda-Codebeispiel.

   Speichern Sie die Änderungen und stellen Sie die Änderungen bereit.

10. Jetzt müssen Sie ein Amazon S3 S3-Ereignis als Lambda-Trigger konfigurieren.

    Gehen Sie auf der Registerkarte bzw. Seite „Konfiguration“ Ihrer Lambda-Funktion zu Trigger und klicken Sie auf „Trigger hinzufügen“.

11. Wählen Sie Amazon S3 aus der Liste der verfügbaren Auslöser aus.

12. Um den Trigger zu konfigurieren: Wählen Sie den Bucket aus, von dem aus die Funktion ausgelöst werden soll.

    Wählen Sie den Ereignistyp PUT. Optional können Sie ein Präfix oder Suffix angeben, wenn Sie nur Dateien mit bestimmten Namen oder Typen verarbeiten möchten.

13. Aktivieren Sie den Trigger, indem Sie auf „Hinzufügen“ klicken und speichern Sie die Konfiguration.

Amazon SES SES-E-Mail-Adressen verifizieren

Bevor Sie Amazon SES zum Senden von E-Mails verwenden können, müssen Sie die E-Mail-Adressen sowohl des Absenders als auch des Empfängers überprüfen. So gehen Sie vor:

1. Gehen Sie zur Amazon SES SES-Konsole. Navigieren Sie zu „Identity Management“ und dann zu „E-Mail-Adressen“.

2. Klicken Sie auf „Neue E-Mail-Adresse verifizieren“. Geben Sie die E-Mail-Adresse ein, die Sie verifizieren möchten, und klicken Sie auf „Diese E-Mail-Adresse verifizieren“. Sie erhalten eine E-Mail mit einem Bestätigungslink. Klicken Sie auf den Link, um den Bestätigungsprozess abzuschließen.

3. Nachdem Sie die E-Mail-Adressen für beide Konten verifiziert, Ihre Lambda-Funktion mit den richtigen Berechtigungen eingerichtet und einige Beispielkundendaten erstellt haben, können Sie die Lambda-Funktion testen, indem Sie ein Testimage in den ausgewählten Amazon S3 S3-Bucket hochladen.

Bilder mit Metadaten auf Amazon S3 hochladen

Jetzt können wir mithilfe der AWS Konsole oder des zuvor erstellten Skripts ein Test-Image in den von uns ausgewählten Amazon S3 S3-Bucket hochladen. Schreiben Sie ein Skript, das ein Bild in den Amazon S3 S3-Bucket hochlädt, den Sie zuvor in Ihrer Lambda-Funktion angegeben haben. Geben Sie im folgenden Codebeispiel den Pfad Ihres Images als erstes Argument für „upload_image_to_s3", den Bucket-Namen als zweites Argument und die Kontonummer des Benutzers, der das Bild hochlädt, als letztes Argument an.

import boto3
def upload_image_to_s3(file_name, bucket, account_number):
    s3 = boto3.client('s3')
    try:
        with open(file_name, 'rb') as data:
            s3.upload_fileobj(
                Fileobj=data,
                Bucket=bucket,
                Key=file_name,
                ExtraArgs={
                    'Metadata': {'account_number': account_number}
                }
            )
        print("Image uploaded successfully with metadata.")
    except Exception as e:
        print("Failed to upload image")
        print(e)

# Usage
upload_image_to_s3('path-to-image-here', 's3-bucket-name-here', 'user-account-number-here')
     

In dieser Funktion wird der ExtraArgs Parameter in der upload_fileobj Methode verwendet, um benutzerdefinierte Metadaten () zusammen mit dem Bild einzuschließen. account_number Diese Metadaten können später verwendet werden AWS , um das Bild entsprechend zu verarbeiten.

Speichern Sie das Skript und führen Sie es aus. Dadurch wird das Bild hochgeladen.

Wenige Minuten nach dem Hochladen des Bildes sollten Sie eine E-Mail an die Adresse erhalten, die Sie zuvor mit dem hier angegebenen Konto verknüpft haben.

CloudWatch Abfrageprotokolle vom Client

Prüfen Sie in den CloudWatch Protokollen Ihrer Lambda-Funktion, ob sie wie erwartet ausgelöst und ausgeführt wurde. Protokolle finden Sie unter CloudWatch > Logs > Log groups >/AWS/lambda/your_function_name. Sie können auch ein Skript schreiben, um auf die Protokolle zuzugreifen und sie auszudrucken. Das folgende Codebeispiel fragt die Lambda-Gruppe nach Protokollen ab und druckt die Protokolle aus, die in der letzten Stunde generiert wurden. Speichern Sie den Code und führen Sie ihn aus.

import boto3
import time

def fetch_lambda_logs(log_group_name, start_time):
    client = boto3.client('logs')
    query = "fields @timestamp, @message | sort @timestamp desc | limit 20"
    start_query_response = client.start_query(
        logGroupName=log_group_name,
        startTime=int(start_time),
        endTime=int(time.time()),
        queryString=query,
    )
    query_id = start_query_response['queryId']
    response = None
    while response is None or response['status'] == 'Running':
        time.sleep(1)  # Wait for 1 second before checking the query status again
        response = client.get_query_results(queryId=query_id)
    return response['results']

# Usage
log_group = '/aws/lambda/RekMediaFunction'
logs = fetch_lambda_logs(log_group, int(time.time()) - 3600)  # Fetch logs from the last hour
print("Retrieving logs")
for log in logs:
    #print(log)
    print(log[1]['value'])
     

Wenn Sie den Code ausführen, sollten die Protokolle ausgedruckt werden und Sie sollten sehen können, dass der Benutzer per E-Mail mit den entsprechenden Reiseinformationen benachrichtigt wurde.

Sie haben erfolgreich eine Anwendung erstellt, die Labels in Bildern erkennen kann, die in einen Amazon S3 S3-Bucket hochgeladen wurden, und anschließend dem Benutzer, der das Bild hochgeladen hat, eine Werbebotschaft per E-Mail senden kann. Stellen Sie sicher, dass Sie alle Ressourcen löschen, die Sie nicht mehr benötigen, damit sie Ihnen nicht in Rechnung gestellt werden.