Analyse d'images à l'aide d'une AWS Lambda fonction

Connectez-vous à la AWS Lambda console AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/lambda/.

Sélectionnez Create function (Créer une fonction). Pour plus d’informations, consultez Créer une fonction Lambda à l’aide de la console.

Choisissez les options suivantes.

Choisissez Créer une fonction pour créer la fonction AWS Lambda .

Sur la page de la fonction, choisissez l’onglet Configuration.

Dans le volet Variables d’environnement, choisissez Modifier.

Ajoutez les variables d’environnement suivantes. Pour chaque variable, choisissez Ajouter des variables d’environnement, puis entrez la clé et la valeur de la variable.

Choisissez Enregistrer pour enregistrer les variables d’environnement.

Dans le volet Autorisations, sous Nom du rôle, choisissez le rôle d'exécution pour ouvrir le rôle dans la IAM console.

Dans l’onglet Autorisations, choisissez Ajouter des autorisations, puis Créer une politique en ligne.

Choisissez JSONet remplacez la politique existante par la politique suivante.

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

Choisissez Suivant.

Dans Détails de la politique, entrez le nom de la politique, tel que DetectCustomLabels-access.

Choisissez Create Policy (Créer une politique).

Si vous stockez des images à des fins d’analyse dans un compartiment Amazon S3, répétez les étapes 10 à 14.

1. Pour l’étape 11, utilisez la politique suivante. Remplacez bucket/folder path avec le chemin du compartiment et du dossier Amazon S3 vers les images que vous souhaitez analyser.

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

2. Pour l’étape 13, choisissez un autre nom de politique, tel que S3Bucket-access.

Ouvrez une invite de commande et entrez les commandes suivantes.

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

Notez le nom du fichier zip (boto3-layer.zip). Vous en aurez besoin à l’étape 6 de cette procédure.

Ouvrez la AWS Lambda console à l'adresse https://console.aws.amazon.com/lambda/.

Choisissez Layers dans le volet de navigation.

Choisissez Créer un calque.

Saisissez un Name (Nom) et une Description pour la règle.

Choisissez Charger un fichier .zip, puis Charger.

Dans la boîte de dialogue, sélectionnez l’archive de fichiers .zip (boto3-layer.zip) que vous avez créée à l’étape 1 de cette procédure.

Pour des environnements d’exécution compatibles, choisissez Python 3.9.

Choisissez Créer pour créer la couche.

Choisissez l’icône du menu du volet de navigation.

Dans le volet de navigation, choisissez Fonctions.

Dans la liste des ressources, choisissez la fonction que vous avez créée dans Étape 1 : Création d'une AWS Lambda fonction (console).

Cliquez sur l’onglet Code.

Dans la zone Couches, choisissez Ajouter une couche.

Choisissez Couches personnalisées.

Dans Couches personnalisées, choisissez le nom de couche que vous avez saisi à l’étape 6.

Dans Version, choisissez la version de la couche, qui doit être 1.

Choisissez Ajouter.

Si vous n’êtes pas dans la console Lambda, procédez comme suit :

1. Ouvrez la AWS Lambda console à l'adresse https://console.aws.amazon.com/lambda/.

2. Ouvrez la fonction Lambda que vous avez créée dans Étape 1 : Création d'une AWS Lambda fonction (console).

Cliquez sur l’onglet Code.

Dans Source du code, remplacez le code dans lambda_function.py par le code suivant :

# 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

Choisissez Déployer pour déployer votre fonction Lambda.

Veillez à disposer de l’autorisations lambda:InvokeFunction. Vous pouvez utiliser la politique suivante.

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

Vous pouvez obtenir le code correspondant ARN à votre fonction Lambda dans la vue d'ensemble des fonctions dans la console Lambda.

Pour activer l’accès, ajoutez des autorisations à vos utilisateurs, groupes ou rôles :

Installez et configurez AWS SDK pour Python. Pour de plus amples informations, veuillez consulter Étape 4 : Configuration des AWS SDK AWS CLI et.

Démarrez le modèle que vous avez spécifié à l’étape 7 de l’Étape 1 : Création d'une AWS Lambda fonction (console).

Enregistrez le code suivant dans un fichier nommé 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()

Exécutez le code. Pour l’argument de ligne de commande, indiquez le nom de la fonction Lambda et l’image que vous souhaitez analyser. Vous pouvez fournir un chemin vers une image locale ou le chemin S3 vers une image stockée dans un compartiment Amazon S3. Par exemple :

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

Si l’image se trouve dans un compartiment Amazon S3, assurez-vous qu’il s’agit du même compartiment que celui que vous avez spécifié à l’étape 15 de l’Étape 1 : Création d'une AWS Lambda fonction (console).

En cas de réussite, le résultat est une liste d’étiquettes présentes dans l’image. Si aucune étiquette n’est renvoyée, pensez à réduire la valeur de confiance que vous avez définie à l’étape 7 de l’Étape 1 : Création d'une AWS Lambda fonction (console).

Si vous avez terminé avec la fonction Lambda et que le modèle n’est pas utilisé par d’autres applications, arrêtez le modèle. N’oubliez pas de démarrer le modèle la prochaine fois que vous utiliserez la fonction Lambda.