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 en Rekognition y en la referencia de la API para obtener información sobre DetectLabels los 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 AWS Management Console y abra la AWS Lambda consola en https://console.aws.amazon.com/lambda/.

2. Elija Crear función. Para obtener más información, consulte Crear una función de Lambda con la consola.

3. 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.

4. Elija Crear función para crear la función de AWS Lambda .

5. En la página de la función, seleccione la pestaña Configuración.

6. En el panel Permisos, en Rol de ejecución, elija el nombre del rol para abrir el rol en la consola de IAM.

7. En la pestaña Permisos, elija Añadir permisos y después Crear política insertada.

8. 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"
           }
       ]
   }
   

9. Elija Revisar política.

10. Introduzca un nombre para la política, por ejemplo DetectLabels-access.

11. Elija Crear política.

12. 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 pathSustitú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/*"
               }
           ]
       }
       

    2. 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.

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/
                   

2. Anote el nombre del archivo zip (boto3-layer.zip), que utilizará en el paso 8 de este procedimiento.

3. Abre la AWS Lambda consola en https://console.aws.amazon.com/lambda/.

4. En el panel de navegación, elija Capas.

5. Elija Crear capa.

6. Introduzca valores para Nombre y Descripción.

7. Para Tipo de entrada de código, elija Cargar un archivo .zip y seleccione Cargar.

8. En el cuadro de diálogo, elija el archivo .zip (boto3-layer.zip) que creó en el paso 1 de este procedimiento.

9. Para Tiempo de ejecución compatibles, elige la versión más reciente de Python.

10. Elija Crear para crear la capa.

11. Elija el icono del menú del panel de navegación.

12. Seleccione Funciones en el panel de navegación.

13. En la lista de recursos, elija la función que haya creado anteriormente en .

14. Elija la pestaña Código.

15. En la sección Capas, elija Agregar una capa.

16. Elija Capas personalizadas.

17. En Capas personalizadas, elija el nombre de la capa que escogió en el paso 6.

18. En Versión, elija la versión de la capa, que debe ser 1.

19. 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.

2. 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
   
   

3. 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).

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.

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.

      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 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) 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 en la Guía del usuario de IAM.

        • (No recomendado) Adjunte una política directamente a un usuario o añada un usuario a un grupo de usuarios. Siga las instrucciones descritas en Adición de permisos a un usuario (consola) de la Guía del usuario de IAM.

   2. Instale y configure el AWS SDK para Python. Para obtener más información, consulte Paso 2: Configure y AWS CLIAWS SDKs.

2. 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)

3. 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 .

   Si se ejecuta correctamente, el código devuelve una respuesta JSON parcial para cada tipo de bloque detectado en el documento.