Analisi delle immagini con una funzione 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.

Scegli le opzioni seguenti.

Scegli Crea funzione per creare la funzione AWS Lambda .

Nella pagina della funzione, scegli la scheda Configurazione.

Nella sezione Variabili di ambiente, scegli Modifica.

Aggiungi le seguenti variabili di ambiente. Per ogni variabile, scegli Aggiungi variabile di ambiente, quindi immetti la chiave e il valore della variabile.

Scegli Salva per salvare le variabili di ambiente.

Nel riquadro Autorizzazioni, in Nome ruolo, scegli il ruolo di esecuzione per aprire il ruolo nella console. IAM

Nella scheda Autorizzazioni, scegli Aggiungi autorizzazioni, poi Crea policy inline.

Scegli JSONe sostituisci la politica esistente con la seguente politica.

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

Scegli Next (Successivo).

Nei dettagli della politica, inserisci un nome per la politica, ad esempio DetectCustomLabels-access.

Scegli Create Policy (Crea policy).

Se stai archiviando immagini per l'analisi in un bucket Amazon S3, ripeti i passaggi da 10 a 14.

1. Per il passaggio 11, utilizza la seguente policy. Replace (Sostituisci) bucket/folder path con il bucket Amazon S3 e il percorso della cartella verso le immagini che desideri analizzare.

   {
       "Version": "2012-10-17",
       "Statement": [
           {
               "Sid": "S3Access",
               "Effect": "Allow",
               "Action": "s3:GetObject",
               "Resource": "arn:aws:s3:::bucket/folder path/*"
           }
       ]
   }

2. Per il passaggio 13, scegli un nome di policy diverso, ad esempio S3Bucket-access.

Apri un prompt di comandi e inserisci il comando seguente.

pip install boto3 --target python/.
zip boto3-layer.zip -r python/
                

Annota il nome del file .zip (boto3-layer.zip). Questo valore sarà necessario nel passaggio 6 di questa procedura.

Apri la console all' AWS Lambda 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).

Seleziona Carica file .zip, quindi scegli Carica.

Nella finestra di dialogo, scegli l'archivio di file .zip (boto3-layer.zip) creato nel passaggio 1 di questa procedura.

Per runtime compatibili, scegli Python 3.9.

Scegli Crea per creare lo strato.

Scegli l'icona del menu del pannello di navigazione.

Nel riquadro di navigazione, seleziona Funzioni.

Nell'elenco delle risorse, scegli la funzione in cui è stata creata Fase 1: Creare una AWS Lambda funzione (console).

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.

Se non ti trovi nella console Lambda, esegui quanto segue:

1. Apri la AWS Lambda console all'indirizzo https://console.aws.amazon.com/lambda/.

2. Apri la funzione Lambda che hai creato in Fase 1: Creare una AWS Lambda funzione (console).

Scegli la scheda Codice.

In Codice sorgente, sostituisci il codice in lambda_function.py con quanto segue:

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0

"""
Purpose
An AWS lambda function that analyzes images with an the Amazon Rekognition
Custom Labels model.
"""
import json
import base64
from os import environ
import logging
import boto3

from botocore.exceptions import ClientError

# Set up logging.
logger = logging.getLogger(__name__)

# Get the model ARN and confidence.
model_arn = environ['MODEL_ARN']
min_confidence = int(environ.get('CONFIDENCE', 50))

# Get the boto3 client.
rek_client = boto3.client('rekognition')


def lambda_handler(event, context):
    """
    Lambda handler function
    param: event: The event object for the Lambda function.
    param: context: The context object for the lambda function.
    return: The labels found in the image passed in the event
    object.
    """

    try:

        # Determine image source.
        if 'image' in event:
            # Decode the image
            image_bytes = event['image'].encode('utf-8')
            img_b64decoded = base64.b64decode(image_bytes)
            image = {'Bytes': img_b64decoded}


        elif 'S3Object' in event:
            image = {'S3Object':
                     {'Bucket':  event['S3Object']['Bucket'],
                      'Name': event['S3Object']['Name']}
                     }

        else:
            raise ValueError(
                'Invalid source. Only image base 64 encoded image bytes or S3Object are supported.')


        # Analyze the image.
        response = rek_client.detect_custom_labels(Image=image,
            MinConfidence=min_confidence,
            ProjectVersionArn=model_arn)

        # Get the custom labels
        labels = response['CustomLabels']

        lambda_response = {
            "statusCode": 200,
            "body": json.dumps(labels)
        }

    except ClientError as err:
        error_message = f"Couldn't analyze image. " + \
            err.response['Error']['Message']

        lambda_response = {
            'statusCode': 400,
            'body': {
                "Error": 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 il codice della funzione Lambda, scegli Distribuisci.

Assicurati di disporre dell’autorizzazione lambda:InvokeFunction. Puoi usare la seguente policy.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "InvokeLambda",
            "Effect": "Allow",
            "Action": "lambda:InvokeFunction",
            "Resource": "ARN for lambda function"
        }
    ]
}

Puoi ottenere la funzione ARN per la tua funzione Lambda dalla panoramica delle funzioni nella console Lambda.

Per fornire l'accesso, aggiungi autorizzazioni ai tuoi utenti, gruppi o ruoli:

Installa e configura AWS SDK per Python. Per ulteriori informazioni, consulta Passaggio 4: configura il AWS CLI e AWS SDKs.

Avvia il modello specificato nel passaggio 7 di Fase 1: Creare una AWS Lambda funzione (console).

Salva il seguente codice in un file denominato client.py.

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0

"""
Purpose
Test code for running the Amazon Rekognition Custom Labels Lambda
function example code.
"""

import argparse
import logging
import base64
import json
import boto3

from botocore.exceptions import ClientError


logger = logging.getLogger(__name__)


def analyze_image(function_name, image):
    """Analyzes an image with an AWS Lambda function.
    :param image: The image that you want to analyze.
    :return The status and classification result for
    the image analysis.
    """

    lambda_client = boto3.client('lambda')

    lambda_payload = {}

    if image.startswith('s3://'):
        logger.info("Analyzing image from S3 bucket: %s", image)
        bucket, key = image.replace("s3://", "").split("/", 1)
        s3_object = {
            'Bucket': bucket,
            'Name': key
        }
        lambda_payload = {"S3Object": s3_object}

    # Call the lambda function with the image.
    else:
        with open(image, 'rb') as image_file:
            logger.info("Analyzing local image image: %s ", image)
            image_bytes = image_file.read()
            data = base64.b64encode(image_bytes).decode("utf8")

            lambda_payload = {"image": data}

    response = lambda_client.invoke(FunctionName=function_name,
                                    Payload=json.dumps(lambda_payload))

    return json.loads(response['Payload'].read().decode())


def add_arguments(parser):
    """
    Adds command line arguments to the parser.
    :param parser: The command line parser.
    """

    parser.add_argument(
        "function", help="The name of the AWS Lambda function that you want " \
        "to use to analyze the image.")
    parser.add_argument(
        "image", help="The local image that you want to analyze.")


def main():
    """
    Entrypoint for script.
    """
    try:
        logging.basicConfig(level=logging.INFO,
                            format="%(levelname)s: %(message)s")

        # Get command line arguments.
        parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
        add_arguments(parser)
        args = parser.parse_args()

        # Get analysis results.
        result = analyze_image(args.function, args.image)
        status = result['statusCode']

        if status == 200:
            labels = result['body']
            labels = json.loads(labels)
            print(f"There are {len(labels)} labels in the image.")
            for custom_label in labels:
                confidence = int(round(custom_label['Confidence'], 0))
                print(
                    f"Label: {custom_label['Name']}: Confidence: {confidence}%")
        else:
            print(f"Error: {result['statusCode']}")
            print(f"Message: {result['body']}")

    except ClientError as error:
        logging.error(error)
        print(error)


if __name__ == "__main__":
    main()

Eseguire il codice. Per l'argomento della riga di comando, fornisci il nome della funzione Lambda e l'immagine che desideri analizzare. È possibile fornire un percorso per un'immagine locale o il percorso S3 per un'immagine archiviata in un bucket Amazon S3. Per esempio:

python client.py function_name s3://bucket/path/image.jpg

Se l'immagine è archiviata in un bucket Amazon S3, assicurati che sia lo stesso bucket specificato nel passaggio 15 di Fase 1: Creare una AWS Lambda funzione (console).

In caso di esito positivo, l'output è un elenco di etichette trovate nell'immagine. Se non viene restituita alcuna etichetta, valuta la possibilità di ridurre il valore di affidabilità impostato nel passaggio 7 di Fase 1: Creare una AWS Lambda funzione (console).

Se hai completato il processo con la funzione Lambda e il modello non viene utilizzato da altre applicazioni, interrompi il modello. Ricordati di avviare il modello la prossima volta che desideri utilizzare la funzione Lambda.