Utilizzo di Amazon Rekognition (REK) per rilevare le etichette per le applicazioni di marketing

Questo tutorial ti guida nella creazione di un'applicazione Python di esempio che potrebbe essere utilizzata per inviare e-mail a persone, sulla base di immagini caricate su un sito Web. L'applicazione di esempio è progettata per coinvolgere gli utenti in una campagna di marketing sui social media inviando loro e-mail personalizzate sulle offerte di viaggio se nelle loro foto vengono riconosciuti dei punti di riferimento.

La soluzione integra vari AWS servizi, tra cui Amazon Rekognition, Amazon S3, DynamoDB e Amazon SES CloudWatch. L'applicazione utilizza Amazon Rekognition per rilevare le etichette nelle immagini caricate da account riconosciuti in un database DynamoDB, quindi al titolare dell'account viene inviata un'e-mail di marketing basata sulle etichette rilevate nell'immagine. L'architettura completa della soluzione è la seguente:

• Archivia i dati degli utenti nel database DynamoDB.

• L'utente carica i dati delle immagini e i metadati (numero di account utente) su Amazon S3.

• Una funzione Lambda richiama DetectLabelsper identificare e registrare le etichette nell'immagine caricata, cercare l'e-mail dell'utente in DynamoDB e inviare un'e-mail di marketing all'utente che ha caricato l'immagine.

• I risultati della funzione Lambda vengono registrati CloudWatch per una revisione successiva.

Ecco una panoramica di tutti i passaggi del tutorial:

1. Crea e compila una tabella DynamoDB.

2. Scrivi una funzione Lambda con Logging and Notification.

3. Configura la funzione Lambda e le autorizzazioni.

4. Carica immagini e metadati con Amazon S3.

5. Registri dei sondaggi CloudWatch .

Prerequisiti

Prima di iniziare questo tutorial, avrai bisogno di:

• Un AWS account e autorizzazioni IAM appropriate.

• Python e Boto3 installati nel tuo ambiente di sviluppo.

• Conoscenze di base di Lambda, Amazon S3, DynamoDB, Amazon SES e. CloudWatch

• Familiarità di base con Lambda e Amazon SES.

Creazione e compilazione di una tabella DynamoDB

Per iniziare questo tutorial, creeremo una tabella DynamoDB per archiviare i dati dei clienti come: indirizzo e-mail, età, numero di telefono e stato di iscrizione, utilizzando una variabile AccountNumber "" come chiave primaria. Inseriremo anche alcuni dati di esempio nella tabella.

Creazione della tabella DynamoDB

Per prima cosa, creeremo la tabella DynamoDB. Ecco come configurarlo usando Python e Boto3. Creiamo una funzione chiamata create_user_table e ci connettiamo alla risorsa DynamoDB al suo interno. Nell'esempio di codice riportato di seguito, sostituisci il valore di «region_name» con il nome della regione in cui opera l'account, quindi esegui la cella di codice per creare la tabella.

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()
     

L'esecuzione di questo script ha impostato una tabella DynamoDB CustomerDataTable denominata AccountNumber con come chiave primaria.

Inserimento di dati di esempio

Ora vorremo inserire alcuni dati di esempio nella tabella. Questi dati di esempio ci aiuteranno a testare la funzionalità completa dell'applicazione.

Creeremo una seconda funzione che aggiunge dati di esempio alla stessa che CustomerDataTable abbiamo creato in precedenza. Il codice seguente crea tre voci di esempio e ogni voce include un numero di account, un indirizzo e-mail, un'età, un numero di telefono e lo stato dell'iscrizione. Nell'esempio di codice riportato di seguito, sostituisci il valore di region_name con il nome della regione in cui opera l'account, quindi esegui la cella di codice per creare la tabella. Se desideri testare la parte dell'app relativa alla consegna delle e-mail, sostituisci il valore riportato EmailAddress nella prima voce relativa al cliente di seguito con un indirizzo e-mail a cui puoi ricevere e-mail. Salva ed esegui il codice.

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()
     

Con la tabella DynamoDB impostata e compilata, possiamo ora procedere all'integrazione di questo recupero dei dati nella funzione Lambda. Ciò consente alla nostra applicazione di recuperare i dettagli dell'utente in base al numero di account che verrà identificato nel prossimo flusso di lavoro di elaborazione delle immagini.

Creazione di una funzione Lambda con registrazione e notifica

Ora possiamo creare una funzione Lambda. Vogliamo assicurarci che la funzione Lambda, che viene attivata al caricamento dell'immagine, possa leggere sia i dati dell'immagine che i metadati dell'account e utilizzarla per eseguire una ricerca nella tabella DynamoDB per i dati utente associati. Ciò significa che non solo avremo bisogno di richiamare la funzione di Amazon Rekognition, ma anche di una DetectLabels funzione che la accolga AccountNumber e la utilizzi per recuperare l'indirizzo e-mail associato da DynamoDB. Inoltre, abbiamo bisogno di una funzione che invii un'e-mail all'indirizzo e-mail utilizzando Amazon SES. Infine, utilizziamo un logger per registrare le informazioni sul processo. Questi dati verranno visualizzati da CloudWatch.

Creazione di una funzione Lambda

Ecco uno schema di come una funzione Lambda potrebbe gestire questi requisiti. Nel seguente esempio di codice, assicuratevi che sia specificata la tabella DynamoDB corretta, se avete usato qualcosa di CustomerDataTable diverso da quello utilizzato come nome della tabella. Inoltre, nella funzione «send_marketing_email», dovreste sostituire il valore dell'argomento «Source» con un indirizzo e-mail a cui avete accesso che funga da e-mail di invio.

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")
     

Ora che abbiamo scritto la funzione Lambda, dobbiamo configurare le autorizzazioni per Lambda e creare un'istanza della nostra funzione Lambda nella console di gestione. AWS

Impostazione delle autorizzazioni e della funzione Lambda

Crea o aggiorna il ruolo IAM

Prima di poter utilizzare una funzione Lambda per gestire qualsiasi immagine caricata dagli utenti, dobbiamo gestirne le autorizzazioni. La funzione Lambda necessita di un ruolo IAM specifico con policy che le consentano di interagire con Amazon S3, DynamoDB, Amazon SES, Amazon Rekognition e. CloudWatch

Per configurare il tuo ruolo IAM per la funzione Lambda:

1. Console AWS di gestione aperta.

2. Vai a IAM > Ruoli > Crea ruolo.

   Scegli «Crea ruolo».

3. Seleziona Lambda come servizio che utilizzerà questo ruolo. Fai clic su «Avanti».

4. Allega le seguenti politiche (nota che queste politiche sono selezionate esclusivamente a scopo dimostrativo, in un ambiente di produzione reale dovresti limitare le autorizzazioni solo a quelle necessarie. ):

   • Amazon S3 ReadOnlyAccess

   • AmazonRekognitionReadOnlyAccess

   • AmazonDynamoDBFullAccesso

   • SESFullAccesso Amazon

   • AWSLambdaEsegui

   • AWSLambdaBasicExecutionRole (per la CloudWatch registrazione)

   Fai clic su «Avanti».

5. Assegna un nome al ruolo e una descrizione, quindi crea il ruolo scegliendo «Crea ruolo».

6. Dopo aver configurato le autorizzazioni appropriate per Lambda, possiamo creare un'istanza della funzione Lambda utilizzando la console di gestione. AWS

   Accedi al servizio Lambda nella Console di gestione AWS.

7. Fai clic su «Crea funzione». Scegli «Autore da zero».

8. Immettete il nome di una funzione e selezionate il runtime di Python. In «Modifica il ruolo di esecuzione predefinito», seleziona «Usa un ruolo esistente», quindi scegli il ruolo IAM che hai creato in precedenza.

9. Ora devi creare e aggiornare il codice nella scheda della funzione lambda. Vai alla scheda chiamata «lambda_function» e sostituisci il codice con l'esempio di codice Lambda precedente.

   Salva le modifiche e distribuiscile.

10. Ora devi configurare un evento Amazon S3 come Lambda Trigger.

    Nella scheda/pagina di configurazione della funzione Lambda, vai su Trigger, fai clic su «Aggiungi trigger».

11. Seleziona Amazon S3 dall'elenco dei trigger disponibili.

12. Per configurare il trigger: seleziona il bucket da cui deve essere attivata la funzione.

    Scegli il tipo di evento, PUT. Facoltativamente, è possibile specificare un prefisso o un suffisso se si desidera elaborare solo file con determinati nomi o tipi.

13. Attiva il trigger facendo clic su «Aggiungi» e salva la configurazione.

Verifica degli indirizzi e-mail di Amazon SES

Prima di poter utilizzare Amazon SES per inviare e-mail, devi verificare gli indirizzi e-mail del mittente e del destinatario. Per farlo:

1. Vai alla console Amazon SES. Vai a «Gestione delle identità», quindi a «Indirizzi e-mail».

2. Fai clic su «Verifica un nuovo indirizzo e-mail». Inserisci l'indirizzo email che desideri verificare e fai clic su «Verifica questo indirizzo e-mail». Riceverai un'email con un link di verifica. Fai clic sul link per completare la procedura di verifica.

3. Dopo aver verificato gli indirizzi e-mail di entrambi gli account, impostato la funzione Lambda con le autorizzazioni corrette e creato alcuni dati cliente di esempio, puoi testare la funzione Lambda caricando un'immagine di prova nel bucket Amazon S3 scelto.

Caricamento di immagini su Amazon S3 con metadati

Ora possiamo caricare un'immagine di prova nel bucket Amazon S3 che abbiamo scelto utilizzando la AWS console o lo script che abbiamo preparato in precedenza. Scrivi uno script che carichi un'immagine nel bucket Amazon S3 precedentemente specificato nella funzione Lambda. Nell'esempio di codice riportato di seguito, specifica il percorso dell'immagine come primo argomento di «upload_image_to_s3", il nome del bucket come secondo argomento e il numero di account dell'utente che carica l'immagine come argomento finale.

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 questa funzione, il ExtraArgs parametro del upload_fileobj metodo viene utilizzato per includere i metadati definiti dall'utente () insieme all'immagine. account_number Questi metadati possono essere successivamente utilizzati per elaborare l' AWS immagine di conseguenza.

Salva ed esegui lo script. Questo caricherà l'immagine.

Pochi minuti dopo aver caricato l'immagine, dovresti ricevere un'email all'indirizzo che hai precedentemente associato all'account specificato qui.

CloudWatch Registri dei sondaggi del client

Controlla CloudWatch i log della tua funzione Lambda per vedere se è stata attivata ed eseguita come previsto. I log sono disponibili in CloudWatch > Logs > Log groups >//lambda/your_function_name.AWS Puoi anche scrivere uno script per accedere e stampare i log. Il seguente esempio di codice analizza i log del gruppo Lambda, stampando i log generati nell'ultima ora. Salva ed esegui il codice.

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'])
     

L'esecuzione del codice dovrebbe stampare i log e dovrebbe essere possibile vedere che l'utente è stato avvisato tramite un'e-mail contenente le informazioni di viaggio pertinenti.

Hai creato con successo un'applicazione in grado di rilevare le etichette nelle immagini caricate in un bucket Amazon S3 e quindi inviare un'e-mail all'utente che ha caricato l'immagine con un messaggio promozionale. Assicurati di eliminare tutte le risorse che non ti servono più in modo che non ti vengano addebitati costi.