Usar o Amazon Rekognition (REK) para detectar rótulos para aplicativos de marketing

Este tutorial orienta você na criação de uma aplicação do Python de amostra que pode ser usada para enviar e-mails para pessoas com base nas imagens enviadas para um site. A aplicação de amostra foi projetada para envolver os usuários em uma campanha de marketing em rede social enviando e-mails personalizados sobre ofertas de viagens caso pontos turísticos sejam reconhecidos em suas fotos.

A solução integra vários AWS serviços, incluindo Amazon Rekognition, Amazon S3, DynamoDB e Amazon SES. CloudWatch A aplicação usa o Amazon Rekognition para detectar rótulos em imagens carregadas por contas reconhecidas em um banco de dados do DynamoDB, então o titular da conta recebe um e-mail de marketing com base nos rótulos detectados na imagem. A arquitetura completa da solução é a seguinte:

• Armazenar dados do usuário no banco de dados do DynamoDB.

• O usuário carrega dados de imagem e metadados (número da conta do usuário) para o Amazon S3.

• Uma função Lambda é invocada DetectLabelspara identificar e registrar os rótulos na imagem carregada, pesquisar o e-mail do usuário no DynamoDB e enviar um e-mail de marketing para o usuário que fez o upload da imagem.

• Os resultados da função Lambda são registrados CloudWatch para análise posterior.

Veja uma visão geral de todas as etapas do tutorial:

1. Crie e preencha uma tabela do DynamoDB.

2. Escreva uma função do Lambda com registro e notificação.

3. Configure permissões e a função do Lambda.

4. Faça o upload de imagens e metadados com o Amazon S3.

5. CloudWatch Registros de pesquisas.

Pré-requisitos

Antes de começar este tutorial, você precisará de:

• Uma AWS conta e as permissões apropriadas do IAM.

• Python e Boto3 instalados em seu ambiente de desenvolvimento.

• Compreensão básica do Lambda, Amazon S3, DynamoDB, Amazon SES e. CloudWatch

• Familiaridade básica com o Lambda e o Amazon SES.

Criação e preenchimento de uma tabela do DynamoDB

Para começar este tutorial, criaremos uma tabela do DynamoDB para armazenar dados do cliente, como: endereço de e-mail, idade, número de telefone e status da associação, usando uma variável AccountNumber "" como chave primária. Também inseriremos alguns dados de amostra na tabela.

Criar a tabela do DynamoDB

Primeiro, criaremos uma tabela do DynamoDB. Veja como configurá-la usando Python e Boto3. Criamos uma função chamada create_user_table e conectamo-nos ao recurso do DynamoDB nela. No exemplo de código abaixo, substitua o valor de “region_name” pelo nome da região em que sua conta opera e execute a célula de código para criar sua tabela.

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

A execução desse script configurou uma tabela do DynamoDB chamada CustomerDataTable com AccountNumber como chave primária.

Inserção de dados de amostra

Agora, o ideal é inserir alguns dados de amostra na tabela. Esses dados de amostra ajudarão a testar a funcionalidade completa do aplicativo.

Criaremos uma segunda função que adiciona dados de amostra à mesma CustomerDataTable que criamos antes. O código abaixo cria três exemplos de entradas, e cada entrada inclui um número de conta, endereço de e-mail, idade, número de telefone e status de membro. No exemplo de código abaixo, substitua o valor de region_name pelo nome da região em que sua conta opera e execute a célula de código para criar sua tabela. Se você quiser testar a parte de entrega de e-mail do aplicativo, substitua o valor EmailAddress na primeira entrada do cliente abaixo por um endereço de e-mail no qual você possa receber e-mails. Salve e execute o código.

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

Com a tabela do DynamoDB configurada e preenchida, agora podemos continuar integrando essa recuperação de dados à função do Lambda. Isso permite que nosso aplicativo recupere os detalhes do usuário com base no número da conta que será identificado no próximo fluxo de trabalho de processamento de imagens.

Criar uma função do Lambda com registro em log e notificação.

Agora, podemos criar uma função do Lambda. Queremos garantir que a função do Lambda, que é acionada no upload da imagem, possa ler os dados da imagem e os metadados da conta e usá-los para realizar uma pesquisa na tabela do DynamoDB para os dados associados do usuário. Isso significa que não só precisaremos invocar a função do Amazon Rekognition, mas também de uma DetectLabels função que a receba AccountNumber e a use para recuperar o endereço de e-mail associado do DynamoDB. Além disso, precisaremos de uma função que envie um e-mail para o endereço de e-mail usando o Amazon SES. Por fim, usaremos um registrador para registrar em log informações sobre o processo. Esses dados serão exibidos por CloudWatch.

Criar a função do Lambda

Aqui está um resumo de como uma função do Lambda pode lidar com esses requisitos. No exemplo de código a seguir, verifique se a tabela correta do DynamoDB está especificada, caso você tenha usado algo CustomerDataTable diferente do nome da tabela. Além disso, na função “send_marketing_email”, você deve substituir o valor do argumento “Source” por um endereço de e-mail ao qual você tenha acesso e que funcionará como o e-mail de envio.

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

Agora que escrevemos a função Lambda, precisamos configurar as permissões para o Lambda e criar uma instância da nossa função Lambda no Management Console. AWS

Configurar permissões e a função do Lambda.

Criar ou atualizar o perfil do IAM

Antes de usar uma função do Lambda para lidar com qualquer imagem enviada pelos usuários, é preciso lidar com as permissões para ela. A função Lambda precisa de uma função do IAM com escopo específico que tenha políticas que permitam a interação com o Amazon S3, o DynamoDB, o Amazon SES, o Amazon Rekognition e. CloudWatch

Para configurar o perfil do IAM para a função do Lambda:

1. Abra o console AWS de gerenciamento.

2. Acesse IAM > Funções > Criar função.

   Selecione “Criar função”.

3. Selecione Lambda como o serviço que usará essa função. Clique em “Avançar”.

4. Anexe as seguintes políticas (observe que essas políticas são selecionadas apenas para demonstração. Em uma configuração de produção real, o ideal é limitar as permissões somente às necessárias.):

   • Amazon S3 ReadOnlyAccess

   • AmazonRekognitionReadOnlyAccess

   • AmazonDynamoDBFullAcesso

   • Amazon SESFull Access

   • AWSLambdaExecutar

   • AWSLambdaBasicExecutionRole (para CloudWatch registro)

   Clique em “Avançar”.

5. Dê um nome à função e uma descrição, e crie-a escolhendo “Criar função”.

6. Depois de configurarmos as permissões adequadas para o Lambda, podemos criar uma instância da função Lambda usando o Management Console. AWS

   Vá para o serviço do Lambda no Console de Gerenciamento da AWS.

7. Clique em “Criar função”. Escolha “Criar do zero”.

8. Insira um nome de função e selecione o runtime do Python. Em “Alterar função de execução padrão”, selecione “Usar uma função existente” e escolha o perfil do IAM criado antes.

9. Agora você precisa criar e atualizar o código na guia da função do lambda. Vá até a guia chamada “lambda_function” e substitua o código lá pelo exemplo de código Lambda a seguir.

   Salve e implante as alterações.

10. Agora você precisa configurar um evento do Amazon S3 como o Gatilho do Lambda.

    Na guia/página de configuração da função do Lambda, acesse Gatilho e clique em “Adicionar gatilho”.

11. Selecione Amazon S3 na lista de gatilhos disponíveis.

12. Para configurar o gatilho: selecione o bucket do qual a função deve ser acionada.

    Escolha o tipo de evento, PUT. Opcionalmente, você pode especificar um prefixo ou sufixo se quiser processar apenas arquivos com determinados nomes ou tipos.

13. Ative o gatilho clicando em “Adicionar” e salve a configuração.

Verificar endereços de e-mail no Amazon SES

Antes de usar o Amazon SES para enviar e-mails, verifique os endereços de e-mail do remetente e do destinatário. Para fazer isso:

1. Vá para o console do Amazon SES. Navegue até “Gerenciamento de identidade” e depois até “Endereços de e-mail”.

2. Clique em “Verificar um novo endereço de e-mail”. Insira o endereço de e-mail que você quer verificar e clique em “Verificar este endereço de e-mail”. Você receberá um e-mail com um link de verificação. Clique no link para concluir o processo de verificação.

3. Depois de verificar os endereços de e-mail de ambas as contas, configurar sua função do Lambda com as permissões corretas e criar alguns exemplos de dados do cliente, você pode testar a função do Lambda fazendo o upload de uma imagem de teste para o bucket do Amazon S3 escolhido.

Fazer o upload de imagens e metadados com o Amazon S3.

Agora podemos fazer o upload de uma imagem de teste para o bucket Amazon S3 escolhido usando o AWS console ou o script que preparamos anteriormente. Escreva um script que carregue uma imagem no bucket do Amazon S3 que você especificou antes em sua função do Lambda. No exemplo de código abaixo, especifique o caminho da sua imagem como o primeiro argumento para “upload_image_to_s3", o nome do bucket como o segundo argumento e o número da conta do usuário que está fazendo o upload da imagem como argumento final.

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

Nessa função, o parâmetro ExtraArgs no método upload_fileobj é usado para incluir metadados definidos pelo usuário (account_number) junto com a imagem. Esses metadados podem ser usados posteriormente AWS para processar a imagem adequadamente.

Salve e execute o script: Isso fará o upload da imagem.

Alguns minutos após o upload da imagem, você deverá receber um e-mail no endereço já associado à conta especificada aqui.

CloudWatch Registros de pesquisa do cliente

Verifique os CloudWatch registros da sua função Lambda para ver se ela foi acionada e executada conforme o esperado. Os registros podem ser encontrados em CloudWatch > Logs > Grupos de registros >/AWS/lambda/your_function_name. Você também pode escrever um script para acessar e imprimir os registros. O exemplo de código a seguir pesquisa o grupo Lambda em busca de logs, imprimindo os logs gerados na última hora. Salve e execute o código.

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

A execução do código deve imprimir os registros e você deve poder ver que o usuário foi notificado por meio de um e-mail contendo as informações de viagem relevantes.

Você criou um aplicativo capaz de detectar rótulos em imagens carregadas em um bucket do Amazon S3 e enviou uma mensagem promocional ao usuário que fez o upload da imagem. Se não precisar mais de algum recurso, lembre-se de excluí-lo.