Utilisation d'Amazon Rekognition (REK) pour détecter les étiquettes destinées aux applications marketing

Ce didacticiel vous explique comment créer un exemple d'application Python qui pourrait être utilisée pour envoyer des e-mails à des personnes, sur la base d'images téléchargées sur un site Web. L'exemple d'application est conçu pour impliquer les utilisateurs dans une campagne de marketing sur les réseaux sociaux en leur envoyant des e-mails personnalisés sur les offres de voyage si des points de repère sont reconnus sur leurs photos.

La solution intègre différents AWS services, notamment Amazon Rekognition, Amazon S3 CloudWatch, DynamoDB et Amazon SES. L'application utilise Amazon Rekognition pour détecter les étiquettes sur les images téléchargées par des comptes reconnus dans une base de données DynamoDB, puis le titulaire du compte reçoit un e-mail marketing basé sur les étiquettes détectées dans l'image. L'architecture complète de la solution est la suivante :

• Stockez les données utilisateur dans la base de données DynamoDB.

• L'utilisateur télécharge les données d'image et les métadonnées (numéro de compte utilisateur) sur Amazon S3.

• Une fonction Lambda permet d'identifier et DetectLabelsd'enregistrer les libellés de l'image téléchargée, de rechercher l'adresse e-mail de l'utilisateur dans DynamoDB et d'envoyer un e-mail marketing à l'utilisateur qui a téléchargé l'image.

• Les résultats de la fonction Lambda sont enregistrés CloudWatch pour un examen ultérieur.

Voici un aperçu de toutes les étapes du didacticiel :

1. Créez et renseignez une table DynamoDB.

2. Écrivez une fonction Lambda avec Logging et Notification.

3. Configurez la fonction Lambda et les autorisations.

4. Téléchargez des images et des métadonnées avec Amazon S3.

5. CloudWatch Journaux de sondages.

Prérequis

Avant de commencer ce didacticiel, vous aurez besoin des éléments suivants :

• Un AWS compte et les autorisations IAM appropriées.

• Python et Boto3 installés sur votre environnement de développement.

• Compréhension de base de Lambda, Amazon S3, DynamoDB, Amazon SES et. CloudWatch

• Connaissance de base de Lambda et d'Amazon SES.

Création et remplissage d'une table DynamoDB

Pour commencer ce didacticiel, nous allons créer une table DynamoDB pour stocker les données des clients telles que l'adresse e-mail, l'âge, le numéro de téléphone et le statut d'adhésion, en utilisant une variable AccountNumber « » comme clé primaire. Nous allons également insérer des exemples de données dans le tableau.

Création de la table DynamoDB

Nous allons d'abord créer la table DynamoDB. Voici comment le configurer à l'aide de Python et de Boto3. Nous créons une fonction appelée create_user_table et nous nous connectons à la ressource DynamoDB qu'elle contient. Dans l'exemple de code ci-dessous, remplacez la valeur de « region_name » par le nom de la région dans laquelle votre compte opère, puis exécutez la cellule de code pour créer votre tableau.

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'exécution de ce script a permis de configurer une table DynamoDB CustomerDataTable nommée AccountNumber avec comme clé primaire.

Insertion d'échantillons de données

Nous allons maintenant insérer des exemples de données dans le tableau. Ces exemples de données nous aideront à tester toutes les fonctionnalités de l'application.

Nous allons créer une deuxième fonction qui ajoutera des exemples de données à celles que CustomerDataTable nous avons créées précédemment. Trois exemples d'entrées sont créés à l'aide du code ci-dessous, et chaque entrée inclut un numéro de compte, une adresse e-mail, un âge, un numéro de téléphone et un statut de membre. Dans l'exemple de code ci-dessous, remplacez la valeur de region_name par le nom de la région dans laquelle votre compte opère, puis exécutez la cellule de code pour créer votre tableau. Si vous souhaitez tester la partie de l'application dédiée à la livraison par e-mail, remplacez la valeur de EmailAddress la première entrée client ci-dessous par une adresse e-mail à laquelle vous pouvez recevoir des e-mails. Enregistrez et exécutez le code.

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

Une fois la table DynamoDB configurée et remplie, nous pouvons maintenant intégrer cette récupération de données dans la fonction Lambda. Cela permet à notre application de récupérer les informations de l'utilisateur en fonction du numéro de compte qui sera identifié dans le prochain flux de traitement d'image.

Création d'une fonction Lambda avec journalisation et notification

Nous pouvons maintenant créer une fonction Lambda. Nous voulons nous assurer que la fonction Lambda, qui est déclenchée lors du téléchargement de l'image, peut lire à la fois les données d'image et les métadonnées du compte et les utiliser pour effectuer une recherche dans la table DynamoDB pour les données utilisateur associées. Cela signifie que nous devrons non seulement invoquer la fonction d'Amazon Rekognition, mais également une DetectLabels fonction qui l'intègre AccountNumber et l'utilise pour récupérer l'adresse e-mail associée dans DynamoDB. De plus, nous avons besoin d'une fonction qui envoie un e-mail à l'adresse e-mail via Amazon SES. Enfin, nous utilisons un enregistreur pour enregistrer les informations relatives au processus. Ces données seront affichées par CloudWatch.

Création de la fonction Lambda

Voici un aperçu de la manière dont une fonction Lambda peut répondre à ces exigences. Dans l'exemple de code suivant, assurez-vous que la table DynamoDB correcte est spécifiée, si vous avez utilisé un autre nom CustomerDataTable que le nom de votre table. De plus, dans la fonction « send_marketing_email », vous devez remplacer la valeur de l'argument « Source » par une adresse e-mail à laquelle vous avez accès et qui servira d'e-mail d'envoi.

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

Maintenant que nous avons écrit la fonction Lambda, nous devons configurer les autorisations pour Lambda et créer une instance de notre fonction Lambda dans la console de gestion. AWS

Configuration des autorisations et de la fonction Lambda

Créer ou mettre à jour un rôle IAM

Avant de pouvoir utiliser une fonction Lambda pour gérer les images téléchargées par les utilisateurs, nous devons gérer les autorisations correspondantes. La fonction Lambda a besoin d'un rôle IAM défini et doté de politiques lui permettant d'interagir avec Amazon S3, DynamoDB, Amazon SES, Amazon Rekognition et. CloudWatch

Pour configurer votre rôle IAM pour la fonction Lambda :

1. Ouvrez AWS la console de gestion.

2. Accédez à IAM > Rôles > Créer un rôle.

   Choisissez « Créer un rôle ».

3. Sélectionnez Lambda comme service qui utilisera ce rôle. Cliquez sur « Suivant ».

4. Joignez les politiques suivantes (Notez que ces politiques sont sélectionnées uniquement à des fins de démonstration. Dans un environnement de production réel, vous souhaiteriez limiter les autorisations uniquement à celles qui sont nécessaires. ) :

   • Amazon S3 ReadOnlyAccess

   • AmazonRekognitionReadOnlyAccess

   • AmazonDynamoDBFullAccès

   • Amazon SESFull Access

   • AWSLambdaExécuter

   • AWSLambdaBasicExecutionRole (pour la CloudWatch journalisation)

   Cliquez sur « Suivant ».

5. Nommez le rôle et donnez-lui une description, puis créez-le en choisissant « Créer un rôle ».

6. Une fois que nous avons configuré les autorisations appropriées pour Lambda, nous pouvons créer une instance de la fonction Lambda à l'aide de la console de gestion. AWS

   Accédez au service Lambda dans l'AWS Management Console.

7. Cliquez sur « Créer une fonction ». Choisissez « Auteur à partir de zéro ».

8. Entrez le nom de la fonction et sélectionnez le moteur d'exécution Python. Sous « Modifier le rôle d'exécution par défaut », sélectionnez « Utiliser un rôle existant », puis choisissez le rôle IAM que vous avez créé précédemment.

9. Vous devez maintenant créer et mettre à jour le code dans l'onglet de la fonction Lambda. Accédez à l'onglet appelé « lambda_function » et remplacez le code par l'exemple de code Lambda suivant.

   Enregistrez les modifications et déployez-les.

10. Vous devez maintenant configurer un événement Amazon S3 en tant que déclencheur Lambda.

    Sur l'onglet/la page de configuration de votre fonction Lambda, accédez à Déclencheur, cliquez sur « Ajouter un déclencheur ».

11. Sélectionnez Amazon S3 dans la liste des déclencheurs disponibles.

12. Pour configurer le déclencheur : sélectionnez le compartiment à partir duquel la fonction doit être déclenchée.

    Choisissez le type d'événement, PUT. Vous pouvez éventuellement spécifier un préfixe ou un suffixe si vous souhaitez traiter uniquement des fichiers portant certains noms ou types.

13. Activez le déclencheur en cliquant sur « Ajouter » et enregistrez la configuration.

Vérification des adresses e-mail Amazon SES

Avant de pouvoir utiliser Amazon SES pour envoyer des e-mails, vous devez vérifier les adresses e-mail de l'expéditeur et du destinataire. Pour cela :

1. Accédez à la console Amazon SES. Accédez à « Gestion des identités », puis à « Adresses e-mail ».

2. Cliquez sur « Vérifier une nouvelle adresse e-mail ». Entrez l'adresse e-mail que vous souhaitez vérifier, puis cliquez sur « Vérifier cette adresse e-mail ». Vous recevrez un e-mail contenant un lien de vérification. Cliquez sur le lien pour terminer le processus de vérification.

3. Après avoir vérifié les adresses e-mail des deux comptes, configuré votre fonction Lambda avec les autorisations appropriées et créé des exemples de données clients, vous pouvez tester la fonction Lambda en téléchargeant une image de test dans le compartiment Amazon S3 de votre choix.

Chargement d'images vers Amazon S3 avec des métadonnées

Nous pouvons désormais télécharger une image de test dans le compartiment Amazon S3 de notre choix à l'aide de la AWS console ou du script que nous avons préparé précédemment. Écrivez un script qui télécharge une image dans le compartiment Amazon S3 que vous avez précédemment spécifié dans votre fonction Lambda. Dans l'exemple de code ci-dessous, spécifiez le chemin de votre image comme premier argument de « upload_image_to_s3 », le nom du bucket comme deuxième argument et le numéro de compte de l'utilisateur qui télécharge l'image comme dernier argument.

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

Dans cette fonction, le ExtraArgs paramètre de la upload_fileobj méthode est utilisé pour inclure des métadonnées définies par l'utilisateur (account_number) avec l'image. Ces métadonnées peuvent ensuite être utilisées AWS pour traiter l'image en conséquence.

Enregistrez et exécutez le script. Cela téléchargera l'image.

Quelques minutes après le téléchargement de l'image, vous devriez recevoir un e-mail à l'adresse que vous avez précédemment associée au compte indiqué ici.

CloudWatch Journaux de sondage fournis par le client

Consultez les CloudWatch journaux de votre fonction Lambda pour voir si elle a été déclenchée et exécutée comme prévu. Les journaux se trouvent sous CloudWatch > Journaux > Groupes de journaux >/AWS/lambda/your_function_name. Vous pouvez également écrire un script pour accéder aux journaux et les imprimer. L'exemple de code suivant interroge le groupe Lambda à la recherche de journaux et imprime les journaux générés au cours de la dernière heure. Enregistrez et exécutez le code.

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'exécution du code devrait imprimer les journaux et vous devriez être en mesure de voir que l'utilisateur a été averti par e-mail contenant les informations de voyage pertinentes.

Vous avez créé avec succès une application capable de détecter les étiquettes dans les images téléchargées dans un compartiment Amazon S3, puis d'envoyer un message promotionnel à l'utilisateur qui a chargé l'image. Assurez-vous de supprimer toutes les ressources dont vous n'avez plus besoin afin qu'elles ne vous soient pas facturées.