Creazione di una funzione Lambda (console) (Opzionale) Creazione di un livello (console) Aggiungere codice Python (console) Aggiungere codice Python (console)

Rilevamento di etichette in un'immagine usando Lambda e Python

AWS Lambda è un servizio di elaborazione che è possibile utilizzare per eseguire codice senza effettuare il provisioning o gestire server. Puoi chiamare le operazioni dell'API Rekognition dall'interno di una funzione Lambda. Le seguenti istruzioni mostrano come creare una funzione Lambda in Python che chiama DetectLabels.

La funzione Lambda chiama DetectLabels e restituisce una matrice di etichette rilevate nell'immagine e anche il livello di affidabilità con cui sono state rilevate.

Le istruzioni includono un codice Python di esempio che mostra come chiamare la funzione Lambda e fornirle un'immagine proveniente da un bucket Amazon S3 o dal computer locale.

Assicurati che le immagini scelte soddisfino i limiti di Rekognition. Consulta le linee guida e le quote in Rekognition e l'API Reference per informazioni sui limiti di tipo e dimensione DetectLabels dei file di immagine.

Creazione di una funzione Lambda (console)

In questo passaggio, crea una funzione Lambda vuota e un ruolo di esecuzione IAM che consente alla funzione Lambda di chiamare l'operazione DetectLabels. Nei passaggi successivi aggiungete il codice sorgente e, facoltativamente, aggiungete un livello alla funzione Lambda.

Se utilizzi documenti archiviati in un bucket Amazon S3, questo passaggio dimostra anche come concedere l'accesso al bucket in cui sono archiviati i documenti.

Per creare una funzione (console AWS Lambda )

Accedi a AWS Management Console e apri la AWS Lambda console all'indirizzo https://console.aws.amazon.com/lambda/.
Scegli Crea funzione. Per ulteriori informazioni, consulta Creare una funzione Lambda con la console.
Scegliere le opzioni seguenti:
- Scegli Crea da zero.
- Inserire un valore per Nome della funzione.
- Per Runtime, scegliere la versione più recente di Python.
- In Architecture (Architettura), scegli x86_64.
Scegliere Crea funzione per creare una funzione AWS Lambda .
Nella pagina della funzione, scegli la scheda Configurazione.
Nel riquadro Autorizzazioni, in Ruolo di esecuzione, scegli il nome del ruolo per aprire il ruolo nella console IAM.
Nella scheda Autorizzazioni, scegli Aggiungi autorizzazioni, poi Crea policy inline.

Scegliere la scheda JSON e sostituire la policy con la policy seguente:


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Action": "rekognition:DetectLabels",
            "Resource": "*",
            "Effect": "Allow",
            "Sid": "DetectLabels"
        }
    ]
}

Scegli Verifica policy.
Inserisci un nome per la policy, ad esempio DetectLabels-access.
Scegli Create Policy (Crea policy).
Se stai archiviando documenti per l'analisi in un bucket Amazon S3, devi aggiungere una policy di accesso Amazon S3. A tale scopo, ripeti i passaggi da 7 a 11 nella console AWS Lambda e apporta le seguenti modifiche.
1. Per il passaggio 8, utilizza la seguente policy. Sostituisci bucket/folder path con il bucket Amazon S3 e il percorso della cartella i documenti che desideri analizzare.
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "S3Access",
            "Effect": "Allow",
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::bucket/folder path/*"
        }
    ]
}
```
2. Per la fase 10, scegli un nome di policy diverso, ad esempio S3Bucket-access.

(Opzionale) Creazione di un livello (console)

Non è necessario eseguire questo passaggio per utilizzare una funzione Lambda e una chiamata DetectLabels.

L'DetectLabelsoperazione è inclusa nell'ambiente Lambda Python predefinito come parte di AWS SDK for Python (Boto3).

Se altre parti della tua funzione Lambda richiedono aggiornamenti recenti del AWS servizio che non si trovano nell'ambiente Lambda Python predefinito, puoi eseguire questo passaggio per aggiungere la versione più recente di Boto3 SDK come livello alla tua funzione.

Per aggiungere l'SDK come livello, devi prima creare un archivio di file zip contenente l'SDK Boto3. Quindi, crea un livello e aggiungi l'archivio di file zip al livello. Per ulteriori informazioni, consulta la sezione Utilizzo dei livelli con la funzione Lambda.

Per creare un livello (console)

Apri un prompt dei comandi e inserisci i seguenti comandi per creare un pacchetto di distribuzione con la versione più recente dell'SDK. AWS
```
pip install boto3 --target python/.
zip boto3-layer.zip -r python/
                
```
Prendete nota del nome del file zip (boto3-layer.zip), utilizzato nel passaggio 8 di questa procedura.
Apri la AWS Lambda console all'indirizzo. https://console.aws.amazon.com/lambda/
Nel riquadro di navigazione scegli Layers (Livelli).
Scegli Create layer (Crea livello).
Immetti i valori per Nome (Nome) e Description (Descrizione).
In Tipo di voce del codice, scegli Carica un file .zip e seleziona Carica.
Nella finestra di dialogo, scegliete l'archivio di file zip (boto3-layer.zip) che avete creato nel passaggio 1 di questa procedura.
Per Compatible Runtimes, scegliere la versione più recente di Python.
Scegliere Crea per creare il livello.
Scegli l'icona del menu del pannello di navigazione.
Nel riquadro di navigazione, seleziona Funzioni.
Nell'elenco delle risorse, scegliere la funzione creata in precedenza in.
Scegli la scheda Codice.
Nella sezione Livelli, scegli Aggiungi un livello.
Scegliete Livelli personalizzati.
In Livelli personalizzati, scegli il nome del livello che hai inserito nel passaggio 6.
In Versione scegli la versione del livello, che dovrebbe essere 1.
Scegli Aggiungi.

Aggiungere codice Python (console)

In questo passaggio, aggiungi il codice Python alla funzione Lambda tramite l'editor di codice della console Lambda. Il codice rileva le etichette in un'immagine utilizzando l'operazione DetectLabels. Restituisce una matrice di etichette rilevate nell'immagine e anche il livello di affidabilità nelle etichette rilevate.

Il documento fornito per l'operazione DetectLabels può trovarsi in un bucket Amazon S3 o in un computer locale.

Aggiungere codice Python (console)

Passa alla scheda Codice.

Nell'editor di codice, sostituisci il codice in lambda_function.py con il seguente codice:


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

Per distribuire la funzione Lambda, scegli Deploy.

Aggiungere codice Python (console)

Ora che hai creato la tua funzione Lambda, puoi richiamarla per rilevare le etichette in un'immagine.

In questo passaggio, esegui il codice Python sul tuo computer, che passa un'immagine locale o un'immagine in un bucket Amazon S3 alla tua funzione Lambda.

Assicurati di eseguire il codice nella stessa AWS regione in cui hai creato la funzione Lambda. Puoi visualizzare la AWS regione per la tua funzione Lambda nella barra di navigazione della pagina dei dettagli della funzione nella console Lambda.

Se la funzione Lambda restituisce un errore di timeout, estendi il periodo di timeout per la funzione Lambda. Per ulteriori informazioni, consulta Configurazione del timeout della funzione (console).

Per ulteriori informazioni sulla chiamata di una funzione Lambda dal codice, consulta Chiamata delle funzioni AWS Lambda.

Prova la funzione Lambda

Se non lo hai ancora fatto, esegui queste operazioni:
1. Assicurati che l'utente disponga dell'autorizzazione lambda:InvokeFunction. Si più usare la seguente policy:
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "InvokeLambda",
            "Effect": "Allow",
            "Action": "lambda:InvokeFunction",
            "Resource": "ARN for lambda function"
        }
    ]
}
```
  Puoi ottenere l'ARN per la tua funzione Lambda dalla panoramica delle funzioni nella console Lambda.
  
  Per fornire l'accesso, aggiungi autorizzazioni agli utenti, gruppi o ruoli:
  - Utenti e gruppi in: AWS IAM Identity Center
    
    Crea un set di autorizzazioni. Segui le istruzioni riportate nella pagina Create a permission set (Creazione di un set di autorizzazioni) nella Guida per l'utente di AWS IAM Identity Center .
  - Utenti gestiti in IAM tramite un provider di identità:
    
    Crea un ruolo per la federazione delle identità. Segui le istruzioni riportate nella pagina Create a role for a third-party identity provider (federation) della Guida per l'utente IAM.
  - Utenti IAM:
    Crea un ruolo che l'utente possa assumere. Segui le istruzioni riportate nella pagina Create a role for an IAM user della Guida per l'utente IAM.
    
    (Non consigliato) Collega una policy direttamente a un utente o aggiungi un utente a un gruppo di utenti. Segui le istruzioni riportate nella pagina Aggiunta di autorizzazioni a un utente (console) nella Guida per l'utente IAM.
2. Installa e configura AWS SDK per Python. Per ulteriori informazioni, consulta Passaggio 2: configura AWS CLI e AWS SDKs.

Salva il seguente codice in un file denominato 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)

Eseguire il codice. Se il documento si trova in un bucket Amazon S3, assicurati che sia lo stesso bucket specificato in precedenza nel passaggio 12 di .

In caso di successo, il codice restituisce una risposta JSON parziale per ogni tipo di blocco rilevato nel documento.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

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

Esempi di codice