Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# 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](https://docs.aws.amazon.com/rekognition/latest/dg/limits.html) dans Rekognition et le manuel de référence des [API pour plus d'informations sur DetectLabels le type](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html) 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)**
1. Connectez-vous à la AWS Lambda console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Choisissez **Créer une fonction**. Pour plus d’informations, consultez [Créer une fonction Lambda à l’aide de la console](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html).
1. 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**.
1. Choisissez **Créer une fonction** pour créer la fonction AWS Lambda .
1. Sur la page de la fonction, choisissez l’onglet **Configuration**.
1. 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.
1. Sous l’onglet **Autorisations**, choisissez **Ajouter des autorisations** puis **Créer une politique en ligne**.
1. Choisissez l’onglet **JSON** et remplacez la politique par la politique suivante :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": "rekognition:DetectLabels",
"Resource": "*",
"Effect": "Allow",
"Sid": "DetectLabels"
}
]
}
```
------
1. Choisissez **Examiner une politique**.
1. Entrez un nom pour la politique, par exemple *DetectLabels-access*.
1. Choisissez **Create Policy** (Créer une politique).
1. 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 path}}Remplacez-le par le chemin du compartiment et du dossier Amazon S3 vers les documents que vous souhaitez analyser.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "S3Access",
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::{{bucket/folder path}}/*"
}
]
}
```
------
1. 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'`DetectLabels`opé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](https://docs.aws.amazon.com/lambda/latest/dg/invocation-layers.html#invocation-layers-using).
**Pour créer et ajouter une couche (console)**
1. 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/
```
1. Notez le nom du fichier zip (boto3-layer.zip) que vous utilisez à l’étape 8 de cette procédure.
1. Ouvrez la AWS Lambda console à l'adresse [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Choisissez **Layers** dans le volet de navigation.
1. Choisissez **Créer un calque**.
1. Saisissez un **Name** (Nom) et une **Description** pour la règle.
1. Dans **Type d’entrée de code**, choisissez **Charger un fichier .zip** et sélectionnez **Charger**.
1. 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.
1. Pour les **exécutions compatibles**, choisissez la version la plus récente de Python.
1. Choisissez **Créer** pour créer la couche.
1. Choisissez l’icône du menu du volet de navigation.
1. Dans le volet de navigation, choisissez **Fonctions**.
1. Dans la liste des ressources, choisissez la fonction que vous avez créée précédemment dans [](#lambda-s3-tutorial-python-create).
1. Cliquez sur l’onglet **Code**.
1. Dans la zone **Couches**, choisissez **Ajouter une couche**.
1. Choisissez **Couches personnalisées**.
1. Dans **Couches personnalisées**, choisissez le nom de couche que vous avez saisi à l’étape 6.
1. Dans **Version**, choisissez la version de la couche, qui doit être 1.
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)**
1. Accédez à l’onglet **Code**.
1. 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
```
1. 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)](https://docs.aws.amazon.com/lambda/latest/dg/configuration-function-common.html#configuration-timeout-console).
Pour plus d’informations sur l’appel d’une fonction Lambda depuis votre code, consultez [Invoquer fonctions AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-invocation.html).
**Pour essayer votre fonction Lambda**
1. 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 :
Vous pouvez obtenir l’ARN de votre fonction Lambda à partir de l’aperçu des fonctions dans la [console Lambda.](https://console.aws.amazon.com/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](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) 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)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) 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](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) 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)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) du *Guide de l’utilisateur IAM*.
1. Installez et configurez le AWS SDK pour Python. Pour de plus amples informations, veuillez consulter [Étape 2 : configurer le AWS CLI et AWS SDKs](setup-awscli-sdk.md).
1. 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)
```
1. 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 [](#lambda-s3-tutorial-python-create).
En cas de succès, votre code renvoie une réponse JSON partielle pour chaque type de bloc détecté dans le document.