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. # Almacenamiento de datos de Amazon Rekognition con Amazon RDS y DynamoDB Al utilizar Amazon Rekognition APIs, es importante recordar que las operaciones de la API no guardan ninguna de las etiquetas generadas. Puede guardar estas etiquetas colocándolas en la base de datos, junto con los identificadores de las imágenes respectivas. En este tutorial se muestra cómo detectar etiquetas y cómo guardarlas en una base de datos. La aplicación de ejemplo desarrollada en este tutorial leerá imágenes de un bucket de [Amazon S3](https://docs.aws.amazon.com/s3/index.html), realizará la [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html)operación en estas imágenes y almacenará las etiquetas resultantes en una base de datos. La aplicación almacenará los datos en una instancia de base de datos de Amazon RDS o en una base de datos de DynamoDB, según el tipo de base de datos que desee utilizar. Usará el [AWS SDK para Python](https://aws.amazon.com/sdk-for-python/) en este tutorial. También puedes consultar el [GitHub repositorio](https://github.com/awsdocs/aws-doc-sdk-examples) de ejemplos del SDK de AWS documentación para ver más tutoriales de Python. **Topics** + [Requisitos previos](#storage-tutorial-prerequisites) + [Cómo obtener etiquetas para imágenes en bucket de Amazon S3](#storage-tutorial-getting-labels) + [Creación de una tabla de Amazon DynamoDB](#storage-tutorial-creating-dynamodb) + [Carga de datos a DynamoDB](#storage-tutorial-uploading-dynamodb) + [Creación de una base de datos de MySQL en Amazon RDS](#storage-tutorial-creating-mysql) + [Carga de datos a una tabla MySQL de Amazon RDS](#storage-tutorial-uploading-mysql) ## Requisitos previos Antes de comenzar este tutorial, necesitará instalar Python y completar los pasos necesarios para [configurar el AWS SDK de Python](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html). Además de esto, asegúrese de que: [Ha creado una cuenta de AWS y un rol de IAM](https://docs.aws.amazon.com/rekognition/latest/dg/setting-up.html) [Ha instalado el SDK de Python (Boto3)](https://aws.amazon.com/sdk-for-python/) [Has configurado correctamente tus credenciales de AWS acceso](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html) [Ha creado un bucket de Amazon S3 y lo ha llenado de imágenes](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) [Ha creado una instancia de base de datos de RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateDBInstance.html), si utiliza RDS para almacenar datos ## Cómo obtener etiquetas para imágenes en bucket de Amazon S3 Comience por escribir una función que tome el nombre de una imagen de su bucket de Amazon S3 y recupere esa imagen. Esta imagen se mostrará para confirmar que se están transfiriendo las imágenes correctas a una llamada [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html)que también está incluida en la función. 1. Busque el bucket de Amazon S3 que desee usar y anote su nombre. Realizará llamadas a este bucket de Amazon S3 y leerá las imágenes que contiene. Asegúrese de que su depósito contenga algunas imágenes para pasarlas a la [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html)operación. 1. Escriba el código para conectarse a su bucket de Amazon S3. Puede conectarse al recurso de Amazon S3 con Boto3 para recuperar una imagen de un bucket de Amazon S3. Una vez se haya conectado al recurso de Amazon S3, puede acceder a su bucket proporcionando el método del bucket con el nombre de su bucket de Amazon S3. Tras conectarse al bucket de Amazon S3, puede recuperar las imágenes del bucket mediante el método Object. Mediante Matplotlib, puede utilizar esta conexión para visualizar las imágenes a medida que se procesan. Boto3 también se utiliza para conectarse al cliente de Rekognition. En el siguiente código, introduzca su región en el parámetro region\_name. Pasarás el nombre del bucket de Amazon S3 y el nombre de la imagen a [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html), que devolverá las etiquetas de la imagen correspondiente. Tras seleccionar solo las etiquetas de la respuesta, se devolverán tanto el nombre de la imagen como las etiquetas. ``` import boto3 from io import BytesIO from matplotlib import pyplot as plt from matplotlib import image as mp_img boto3 = boto3.Session() def read_image_from_s3(bucket_name, image_name): # Connect to the S3 resource with Boto 3 # get bucket and find object matching image name s3 = boto3.resource('s3') bucket = s3.Bucket(name=bucket_name) Object = bucket.Object(image_name) # Downloading the image for display purposes, not necessary for detection of labels # You can comment this code out if you don't want to visualize the images file_name = Object.key file_stream = BytesIO() Object.download_fileobj(file_stream) img = mp_img.imread(file_stream, format="jpeg") plt.imshow(img) plt.show() # get the labels for the image by calling DetectLabels from Rekognition client = boto3.client('rekognition', region_name="region-name") response = client.detect_labels(Image={'S3Object': {'Bucket': bucket_name, 'Name': image_name}}, MaxLabels=10) print('Detected labels for ' + image_name) full_labels = response['Labels'] return file_name, full_labels ``` 1. Guarde este código en un archivo llamado get\_images.py. ## Creación de una tabla de Amazon DynamoDB El código siguiente usa Boto3 para conectarse a DynamoDB y usa el método `CreateTable` de DynamoDB para crear una tabla denominada Images. La tabla tiene una clave primaria compuesta de una clave de partición denominada Image y de una clave de clasificación denominada Labels. La clave Image contiene el nombre de la imagen, mientras que la clave Labels almacena las etiquetas asignadas a esa imagen. ``` import boto3 def create_new_table(dynamodb=None): dynamodb = boto3.resource( 'dynamodb',) # Table defination table = dynamodb.create_table( TableName='Images', KeySchema=[ { 'AttributeName': 'Image', 'KeyType': 'HASH' # Partition key }, { 'AttributeName': 'Labels', 'KeyType': 'RANGE' # Sort key } ], AttributeDefinitions=[ { 'AttributeName': 'Image', 'AttributeType': 'S' }, { 'AttributeName': 'Labels', 'AttributeType': 'S' }, ], ProvisionedThroughput={ 'ReadCapacityUnits': 10, 'WriteCapacityUnits': 10 } ) return table if __name__ == '__main__': device_table = create_new_table() print("Status:", device_table.table_status) ``` Guarde este código en un editor y ejecútelo una vez para crear una tabla de DynamoDB. ## Carga de datos a DynamoDB Ahora que se ha creado la base de datos de DynamoDB y tiene una función para obtener etiquetas para las imágenes, puede almacenar las etiquetas en DynamoDB. El siguiente código recupera todas las imágenes de un bucket de S3, obtiene las etiquetas para ellas y almacena los datos en DynamoDB. 1. Deberá escribir el código para subir los datos en DynamoDB. Se utiliza una función llamada `get_image_names` para conectarse a su bucket de Amazon S3, que devuelve los nombres de todas las imágenes del bucket en forma de lista. Pasará esta lista a la función `read_image_from_S3`, que se importará del archivo `get_images.py` que creó. ``` import boto3 import json from get_images import read_image_from_s3 boto3 = boto3.Session() def get_image_names(name_of_bucket): s3_resource = boto3.resource('s3') my_bucket = s3_resource.Bucket(name_of_bucket) file_list = [] for file in my_bucket.objects.all(): file_list.append(file.key) return file_list ``` 1. La función `read_image_from_S3` que creamos anteriormente devolverá el nombre de la imagen que se está procesando y el diccionario de etiquetas asociadas a esa imagen. Se usa una función llamada `find_values` para obtener solo las etiquetas de la respuesta. A continuación, el nombre de la imagen y sus etiquetas estarán listos para subirse en la tabla de DynamoDB. ``` def find_values(id, json_repr): results = [] def _decode_dict(a_dict): try: results.append(a_dict[id]) except KeyError: pass return a_dict json.loads(json_repr, object_hook=_decode_dict) # Return value ignored. return results ``` 1. Utilizará una tercera función, llamada `load_data`, para subir las imágenes y etiquetas en la tabla de DynamoDB que ha creado. ``` def load_data(image_labels, dynamodb=None): if not dynamodb: dynamodb = boto3.resource('dynamodb') table = dynamodb.Table('Images') print("Adding image details:", image_labels) table.put_item(Item=image_labels) print("Success!!") ``` 1. Aquí es donde se llaman las tres funciones que definimos anteriormente y se llevan a cabo las operaciones. Añada las tres funciones definidas anteriormente, junto con el código siguiente, a un archivo de Python. Ejecute el código. ``` bucket = "bucket_name" file_list = get_image_names(bucket) for file in file_list: file_name = file print("Getting labels for " + file_name) image_name, image_labels = read_image_from_s3(bucket, file_name) image_json_string = json.dumps(image_labels, indent=4) labels=set(find_values("Name", image_json_string)) print("Labels found: " + str(labels)) labels_dict = {} print("Saving label data to database") labels_dict["Image"] = str(image_name) labels_dict["Labels"] = str(labels) print(labels_dict) load_data(labels_dict) print("Success!") ``` Acabas de generar etiquetas para tus imágenes y las has almacenado en una instancia de DynamoDB. [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html) Asegúrese de eliminar todos los recursos que ha creado mientras sigue este tutorial. Eso evitará que le cobren por los recursos que no utilice. ## Creación de una base de datos de MySQL en Amazon RDS Antes de continuar, asegúrese de haber completado el [procedimiento de configuración](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SettingUp.html) de Amazon RDS y de haber [creado una instancia de base de datos de MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_GettingStarted.CreatingConnecting.MySQL.html) con Amazon RDS. El siguiente código utiliza la biblioteca [PyMySQL](https://pypi.org/project/PyMySQL/) y su instancia de base de datos de Amazon RDS. Crea una tabla que contiene los nombres de las imágenes y las etiquetas asociadas a esas imágenes. Amazon RDS recibe comandos para crear tablas e insertar datos en ellas. Para usar Amazon RDS, debe conectarse al host de Amazon RDS con su nombre de host, nombre de usuario y contraseña. Para conectarse a Amazon RDS, debe proporcionar estos argumentos a la `connect` función de PyMy SQL y crear una instancia de un cursor. 1. En el siguiente código, sustituya el valor de host por su punto de conexión de host de Amazon RDS y sustituya el valor de user por el nombre de usuario maestro asociado a su instancia de Amazon RDS. También tendrá que reemplazar la contraseña por la contraseña maestra de su usuario principal. ``` import pymysql host = "host-endpoint" user = "username" password = "master-password" ``` 1. Cree una base de datos y una tabla para insertar sus datos de imagen y etiqueta. Para ello, ejecute y confirme una consulta de creación. El siguiente código crea una base de datos. Ejecute este código solo una vez. ``` conn = pymysql.connect(host=host, user=user, passwd=password) print(conn) cursor = conn.cursor() print("Connection successful") # run once create_query = "create database rekogDB1" print("Creation successful!") cursor.execute(create_query) cursor.connection.commit() ``` 1. Una vez creada la base de datos, debe crear una tabla en la que insertar los nombres y etiquetas de las imágenes. Para crear una tabla, primero debe pasar el comando use de SQL, junto con el nombre de la base de datos, a la función `execute`. Una vez realizada la conexión, se ejecuta una consulta para crear una tabla. El siguiente código se conecta a la base de datos y, a continuación, crea una tabla con una clave principal, denominada `image_id`, y un atributo de texto que almacena las etiquetas. Utilice las importaciones y variables que definió anteriormente y ejecute este código para crear una tabla en la base de datos. ``` # connect to existing DB cursor.execute("use rekogDB1") cursor.execute("CREATE TABLE IF NOT EXISTS test_table(image_id VARCHAR (255) PRIMARY KEY, image_labels TEXT)") conn.commit() print("Table creation - Successful creation!") ``` ## Carga de datos a una tabla MySQL de Amazon RDS Tras crear la base de datos de Amazon RDS y una tabla en la base de datos, puede obtener etiquetas para sus imágenes y almacenarlas en la base de datos de Amazon RDS. 1. Conéctese a su bucket de Amazon S3 y recupere los nombres de todas las imágenes del bucket. Estos nombres de imágenes se pasarán a la función `read_image_from_s3` que creó anteriormente para obtener las etiquetas de todas sus imágenes. El siguiente código se conecta a su bucket de Amazon S3 y devuelve una lista de todas las imágenes de su bucket. ``` import pymysql from get_images import read_image_from_s3 import json import boto3 host = "host-endpoint" user = "username" password = "master-password" conn = pymysql.connect(host=host, user=user, passwd=password) print(conn) cursor = conn.cursor() print("Connection successful") def get_image_names(name_of_bucket): s3_resource = boto3.resource('s3') my_bucket = s3_resource.Bucket(name_of_bucket) file_list = [] for file in my_bucket.objects.all(): file_list.append(file.key) return file_list ``` 1. La respuesta de la [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html)API contiene algo más que las etiquetas, así que escriba una función para extraer únicamente los valores de las etiquetas. La siguiente función devuelve una lista que únicamente contiene las etiquetas. ``` def find_values(id, json_repr): results = [] def _decode_dict(a_dict): try: results.append(a_dict[id]) except KeyError: pass return a_dict json.loads(json_repr, object_hook=_decode_dict) # Return value ignored. return results ``` 1. Necesitará una función para insertar los nombres y etiquetas de las imágenes en la tabla. La siguiente función ejecuta una consulta de inserción e inserta cualquier par de nombres y etiquetas de imagen determinados. ``` def upload_data(image_id, image_labels): # insert into db cursor.execute("use rekogDB1") query = "INSERT IGNORE INTO test_table(image_id, image_labels) VALUES (%s, %s)" values = (image_id, image_labels) cursor.execute(query, values) conn.commit() print("Insert successful!") ``` 1. Por último, debe ejecutar las funciones que ha definido anteriormente. En el siguiente código, se recopilan los nombres de todas las imágenes del depósito y se proporcionan a la función que las invoca [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html). Después, las etiquetas y el nombre de la imagen a la que se aplican se cargan en la base de datos de Amazon RDS. Copie las tres funciones definidas anteriormente, junto con el código siguiente, a un archivo de Python. Ejecute el archivo Python. ``` bucket = "bucket-name" file_list = get_image_names(bucket) for file in file_list: file_name = file print("Getting labels for " + file_name) image_name, image_labels = read_image_from_s3(bucket, file_name) image_json = json.dumps(image_labels, indent=4) labels=set(find_values("Name", image_json)) print("Labels found: " + str(labels)) unique_labels=set(find_values("Name", image_json)) print(unique_labels) image_name_string = str(image_name) labels_string = str(unique_labels) upload_data(image_name_string, labels_string) print("Success!") ``` Ha utilizado DetectLabels correctamente la generación de etiquetas para sus imágenes y las ha almacenado en una base de datos MySQL mediante Amazon RDS. Asegúrese de eliminar todos los recursos que ha creado mientras sigue este tutorial. Esto evitará que le cobren por los recursos que no utilice. [Para ver más ejemplos de AWS varios servicios, consulte el repositorio de ejemplos GitHub del SDK de AWS documentación.](https://github.com/awsdocs/aws-doc-sdk-examples)