Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Detección de etiquetas en una imagen mediante Lambda y Python
AWS Lambda es un servicio informático que puede utilizar para ejecutar código sin aprovisionar ni administrar servidores. Puede llamar a las operaciones de la API de Rekognition desde una función de Lambda. En las instrucciones siguientes se explica cómo crear una función de Lambda en Python que llame a `DetectLabels`.
La función de Lambda llama a `DetectLabels` y devuelve una matriz de etiquetas detectadas en la imagen y el nivel de confianza por el que se detectan.
Las instrucciones incluyen un ejemplo de código de Python que muestra cómo llamar a la función de Lambda y proporcionarle una imagen procedente de un bucket de Amazon S3 o de su ordenador local.
Asegúrese de que las imágenes que ha elegido cumplen los límites de Rekognition. Consulte [las directrices y las cuotas](https://docs.aws.amazon.com/rekognition/latest/dg/limits.html) en Rekognition y en la referencia de la [API para obtener información sobre DetectLabels los](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html) límites de tamaño y tipo de archivo de imagen.
## Creación de una función de Lambda (consola)
En este paso, se crea una función de Lambda vacía y una función de ejecución de IAM que permita a la función llamar a la operación `DetectLabels`. En pasos posteriores, añadirá el código fuente y, si lo desea, una capa a la función de Lambda.
Si utiliza documentos almacenados en un bucket de Amazon S3, en este paso también se muestra cómo conceder acceso al bucket que almacena los documentos.
**Para crear una AWS Lambda función (consola)**
1. Inicie sesión en Consola de administración de AWS y abra la AWS Lambda consola en [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Seleccione **Creación de función**. Para obtener más información, consulte [Crear una función de Lambda con la consola](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html).
1. Elija las siguientes opciones:
+ Elija **Crear desde cero**.
+ Ingrese un valor en **Nombre de la función**.
+ Para **Tiempo de ejecución**, elige la versión más reciente de Python.
+ En **Arquitectura**, elija **x86\_64**.
1. Elija **Crear función** para crear la función de AWS Lambda .
1. En la página de la función, seleccione la pestaña **Configuración**.
1. En el panel **Permisos**, en **Rol de ejecución**, elija el nombre del rol para abrir el rol en la consola de IAM.
1. En la pestaña **Permisos**, elija **Añadir permisos** y después **Crear política insertada**.
1. Elija la pestaña **JSON** y reemplace la política por la siguiente política:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": "rekognition:DetectLabels",
"Resource": "*",
"Effect": "Allow",
"Sid": "DetectLabels"
}
]
}
```
------
1. Elija **Revisar política**.
1. Introduzca un nombre para la política, por ejemplo *DetectLabels-access*.
1. Elija **Crear política**.
1. Si va a almacenar documentos para analizarlos en un bucket de Amazon S3, debe añadir una política de acceso a Amazon S3. Para ello, repita los pasos 7 a 11 en la consola de AWS Lambda y realice los siguientes cambios.
1. En el paso 8, utilice la siguiente política. {{bucket/folder path}}Sustitúyala por la ruta del depósito y la carpeta de Amazon S3 a los documentos que desee analizar.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "S3Access",
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::{{bucket/folder path}}/*"
}
]
}
```
------
1. En el paso 10, elija un nombre de política diferente, como *S3Bucket-access*.
## (Opcional) Crear una capa (consola)
No es necesario realizar este paso para utilizar una función de Lambda y realizar una llamada a `DetectLabels`.
La `DetectLabels` operación se incluye en el entorno Lambda Python predeterminado como parte del AWS SDK para Python (Boto3).
Si otras partes de la función Lambda requieren actualizaciones de AWS servicio recientes que no están en el entorno Lambda Python predeterminado, puede realizar este paso para añadir la versión más reciente del SDK de Boto3 como capa a su función.
Para añadir SDK como una capa, primero se crea un archivo de archivo .zip con el SDK de Boto3. A continuación, tendrá que crear una capa y añadir el archivo de zip a la capa. Para obtener más información, consulte [Uso de capas de Lambda](https://docs.aws.amazon.com/lambda/latest/dg/invocation-layers.html#invocation-layers-using).
**Cómo crear y añadir una capa (consola)**
1. Abra una línea de comandos e introduzca los siguientes comandos para crear un paquete de despliegue con la versión más reciente del SDK. AWS
```
pip install boto3 --target python/.
zip boto3-layer.zip -r python/
```
1. Anote el nombre del archivo zip (boto3-layer.zip), que utilizará en el paso 8 de este procedimiento.
1. Abre la AWS Lambda consola en [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. En el panel de navegación, elija **Capas**.
1. Elija **Crear capa**.
1. Introduzca valores para **Nombre** y **Descripción**.
1. Para **Tipo de entrada de código**, elija **Cargar un archivo .zip** y seleccione **Cargar**.
1. En el cuadro de diálogo, elija el archivo .zip (boto3-layer.zip) que creó en el paso 1 de este procedimiento.
1. Para **Tiempo de ejecución compatibles**, elige la versión más reciente de Python.
1. Elija **Crear** para crear la capa.
1. Elija el icono del menú del panel de navegación.
1. Seleccione **Funciones** en el panel de navegación.
1. En la lista de recursos, elija la función que haya creado anteriormente en [](#lambda-s3-tutorial-python-create).
1. Elija la pestaña **Código**.
1. En la sección **Capas**, elija **Agregar una capa**.
1. Elija **Capas personalizadas**.
1. En **Capas personalizadas**, elija el nombre de la capa que escogió en el paso 6.
1. En **Versión**, elija la versión de la capa, que debe ser 1.
1. Elija **Agregar**.
## Añadir código Python (consola)
En este paso, añada código Python a la función de Lambda mediante el editor de código de la consola de Lambda. El código detecta las etiquetas de una imagen mediante la operación `DetectLabels`. Devuelve una matriz de etiquetas detectadas en la imagen, así como el nivel de confianza en las etiquetas detectadas.
El documento que proporcione a la operación `DetectLabels` puede estar ubicado en un bucket de Amazon S3 o en un ordenador local.
**Cómo añadir código Python (consola)**
1. Navegue hasta la pestaña **Código**.
1. En el editor de código, sustituya el código del archivo **lambda\_function.py** por el código siguiente:
```
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. Elija **Implementar** para implementar la función de Lambda.
## Cómo añadir código Python (consola)
Ahora que creó la función de Lambda, puede invocarla para detectar etiquetas en una imagen.
En este paso, ejecute el código Python de su ordenador, que pasa una imagen local, o la imagen de un bucket de Amazon S3, a la función de Lambda.
Asegúrese de ejecutar el código en la misma AWS región en la que creó la función Lambda. Puede ver la AWS región de la función Lambda en la barra de navegación de la página de detalles de la función en la consola Lambda.
Si la función de Lambda devuelve un error de tiempo de espera, amplíe el período de tiempo de espera de la función de Lambda. Para obtener más información, consulte [Configuración del tiempo de espera de la función (consola)](https://docs.aws.amazon.com/lambda/latest/dg/configuration-function-common.html#configuration-timeout-console).
Para obtener más información sobre cómo invocar una función de Lambda mediante el código, consulte [Invocación de funciones de Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-invocation.html).
**Cómo probar la función de Lambda**
1. Si aún no lo ha hecho, haga lo siguiente:
1. Asegúrese de que el usuario tiene el permiso `lambda:InvokeFunction`. Puede utilizar la siguiente política:
Puede obtener el ARN de la función de Lambda en la descripción general de la función en la [consola de Lambda](https://console.aws.amazon.com/lambda/).
Para dar acceso, agregue permisos a los usuarios, grupos o roles:
+ Usuarios y grupos en: AWS IAM Identity Center
Cree un conjunto de permisos. Siga las instrucciones de [Creación de un conjunto de permisos](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) en la *Guía del usuario de AWS IAM Identity Center *.
+ Usuarios gestionados en IAM a través de un proveedor de identidades:
Cree un rol para la federación de identidades. Siga las instrucciones descritas en [Creación de un rol para un proveedor de identidad de terceros (federación)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) en la *Guía del usuario de IAM*.
+ Usuarios de IAM:
+ Cree un rol que el usuario pueda aceptar. Siga las instrucciones descritas en [Creación de un rol para un usuario de IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) en la *Guía del usuario de IAM*.
+ (No recomendado) Adjunte una política directamente a un usuario o agregue un usuario a un grupo de usuarios. Siga las instrucciones descritas en [Adición de permisos a un usuario (consola)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) de la *Guía del usuario de IAM*.
1. Instale y configure el AWS SDK para Python. Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md).
1. Guarde el siguiente código en un archivo denominado `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. Ejecute el código. Si el documento está en un bucket de Amazon S3, asegúrese de que es el mismo bucket que indicó anteriormente en el paso 12 de [](#lambda-s3-tutorial-python-create).
Si se ejecuta correctamente, el código devuelve una respuesta JSON parcial para cada tipo de bloque detectado en el documento.