Créer une fonction Lambda (console) (Facultatif) Création d’une couche (console) Ajouter le code Python (console) Pour ajouter le code Python (console)

Détection d’étiquettes dans une image à l’aide de Lambda et Python

AWS Lambda est un service de calcul que vous pouvez utiliser pour exécuter du code sans provisionner ni gérer de serveurs. Vous pouvez appeler les opérations de l’API Rekognition depuis une fonction Lambda. Les instructions suivantes montrent comment créer une fonction Lambda dans Python qui appelle DetectLabels.

La fonction Lambda appelle DetectLabels et renvoie un tableau d’étiquettes détectées dans l’image qui indique le niveau de fiabilité de la détection.

Les instructions incluent un exemple de code Python qui explique comment appeler la fonction Lambda et lui fournir une image provenant d’un compartiment Amazon S3 ou de votre ordinateur local.

Assurez-vous que les images que vous avez choisies respectent les limites de Rekognition. Consultez les directives et les quotas dans Rekognition et le manuel de référence des API pour plus d'informations sur DetectLabels le type de fichier image et les limites de taille.

Créer une fonction Lambda (console)

Au cours de cette étape, vous créez une fonction Lambda vide et un rôle d’exécution IAM qui permet à votre fonction Lambda d’appeler l’opération DetectLabels. Dans les étapes suivantes, vous ajoutez le code source, et en option une couche à la fonction Lambda.

Si vous utilisez des documents stockés dans un compartiment Amazon S3, cette étape explique également comment accorder l’accès au compartiment qui stocke vos documents.

Pour créer une AWS Lambda fonction (console)

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 à partir de zéro.
- Saisissez une valeur relative à Nom de fonction.
- Pour Exécution, choisissez la version la plus récente de Python.
- Pour Architecture, choisissez x86_64.
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 Autorisations, sous Rôle d’exécution, choisissez le nom du rôle pour ouvrir le rôle dans la console IAM.
Sous l’onglet Autorisations, choisissez Ajouter des autorisations puis Créer une politique en ligne.

Choisissez l’onglet JSON et remplacez la politique par la politique suivante :


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

Choisissez Review policy (Examiner une politique).
Entrez un nom pour la politique, par exemple DetectLabels-access.
Choisissez Create Policy (Créer une politique).
Si vous stockez des documents à des fins d’analyse dans un compartiment Amazon S3, vous devez ajouter une stratégie d'accès Amazon S3. Pour ce faire, répétez les étapes 7 à 11 dans la console AWS Lambda et apportez les modifications suivantes.
1. Pour l’étape 8, appliquez la politique suivante. bucket/folder pathRemplacez-le par le chemin du compartiment et du dossier Amazon S3 vers les documents 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 10, choisissez un autre nom de politique, tel que S3Bucket-Access.

(Facultatif) Création d’une couche (console)

Il n’est pas nécessaire d’effectuer cette étape pour utiliser une fonction Lambda et un appel DetectLabels.

L'DetectLabelsopération est incluse dans l'environnement Lambda Python par défaut dans le cadre du AWS SDK pour Python (Boto3).

Si d'autres parties de votre fonction Lambda nécessitent des mises à jour de AWS service récentes qui ne figurent pas dans l'environnement Lambda Python par défaut, vous pouvez effectuer cette étape pour ajouter la dernière version du SDK Boto3 en tant que couche à votre fonction.

Pour ajouter le SDK en tant que couche, vous devez d’abord créer une archive de fichier zip contenant le SDK Boto3. Ensuite, vous créez une couche et ajoutez l’archive du fichier zip à la couche. Pour plus d’informations, voir Utilisation de couches avec votre fonction Lambda.

Pour créer et ajouter une couche (console)

Ouvrez une invite de commande et entrez les commandes suivantes pour créer un package de déploiement avec la version la plus récente du AWS SDK.
```
pip install boto3 --target python/.
zip boto3-layer.zip -r python/
                
```
Notez le nom du fichier zip (boto3-layer.zip) que vous utilisez à l’étape 8 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.
Dans Type d’entrée de code, choisissez Charger un fichier .zip et sélectionnez Charger.
Dans la boîte de dialogue, choisissez l’archive de fichiers zip (boto3-layer.zip) que vous avez créée à l’étape 1 de cette procédure.
Pour les exécutions compatibles, choisissez la version la plus récente de Python.
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 précédemment dans .
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.

Ajouter le code Python (console)

Au cours de cette étape, vous allez ajouter votre code Python à votre fonction Lambda via l’éditeur de code de la console Lambda. Le code détecte les étiquettes dans une image à l’aide de l’opération DetectLabels. Il renvoie un tableau d’étiquettes détectées dans l’image, ainsi que le niveau de confiance dans les étiquettes détectées.

Le document que vous fournissez pour l’opération DetectLabels peut se trouver dans un compartiment Amazon S3 ou sur un ordinateur local.

Pour ajouter le code Python (console)

Accédez à l’onglet Code.

Dans l’éditeur de code, remplacez le code dans lambda_function.py par le code suivant :


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

Pour déployer votre fonction Lambda, choisissez Deploy.

Pour ajouter le code Python (console)

Maintenant que vous avez créé votre fonction Lambda, vous pouvez l’invoquer pour détecter des étiquettes dans une image.

Au cours de cette étape, vous exécutez du code Python sur votre ordinateur, qui transmet une image locale ou une image d’un compartiment Amazon S3 à votre fonction Lambda.

Assurez-vous d'exécuter le code dans la même AWS région que celle dans laquelle vous avez créé la fonction Lambda. Vous pouvez consulter la AWS région de votre fonction Lambda dans la barre de navigation de la page de détails de la fonction de la console Lambda.

Si la fonction Lambda renvoie une erreur d’expiration, prolongez le délai d’expiration de la fonction Lambda. Pour plus d’informations, consultez Configuration du délai d’expiration d’une fonction (console).

Pour plus d’informations sur l’appel d’une fonction Lambda depuis votre code, consultez Invoquer fonctions AWS Lambda.

Pour essayer votre fonction Lambda

Si vous ne l’avez pas déjà fait, effectuez les opérations suivantes :
1. Assurez-vous que l’utilisateur dispose des autorisations lambda:InvokeFunction nécessaires. 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 l’ARN de votre fonction Lambda à partir de l’aperçu des fonctions dans la console Lambda.
  
  Pour activer l’accès, ajoutez des autorisations à vos utilisateurs, groupes ou rôles :
  - Utilisateurs et groupes dans AWS IAM Identity Center :
    
    Créez un jeu d’autorisations. Suivez les instructions de la rubrique Création d’un jeu d’autorisations du Guide de l’utilisateur AWS IAM Identity Center .
  - Utilisateurs gérés dans IAM par un fournisseur d’identité :
    
    Créez un rôle pour la fédération d’identité. Suivez les instructions de la rubrique Création d’un rôle pour un fournisseur d’identité tiers (fédération) dans le Guide de l’utilisateur IAM.
  - Utilisateurs IAM :
    Créez un rôle que votre utilisateur peut assumer. Suivez les instructions de la rubrique Création d’un rôle pour un utilisateur IAM dans le Guide de l’utilisateur IAM.
    
    (Non recommandé) Attachez une politique directement à un utilisateur ou ajoutez un utilisateur à un groupe d’utilisateurs. Suivez les instructions de la rubrique Ajout d’autorisations à un utilisateur (console) du Guide de l’utilisateur IAM.
2. Installez et configurez le AWS SDK pour Python. Pour de plus amples informations, veuillez consulter Étape 2 : configurer le AWS CLI et AWS SDKs.

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

Exécutez le code. Si le document se trouve dans un compartiment Amazon S3, assurez-vous qu’il s’agit du même compartiment que celui que vous avez spécifié précédemment à l’étape 12 de .

En cas de succès, votre code renvoie une réponse JSON partielle pour chaque type de bloc détecté dans le document.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

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

Exemples de code