SDK y DynamoDB
Contenido del curso
Wilson Montenegro
Mario Alexander Vargas Celis
Cristian Camilo Echeverri
Bryan Castano
ANDRES ALFONSO MIRA MEJIA
Juan Camilo Salazar Serna
JUAN PABLO MAYORGA MENDIETA
JUAN PABLO MAYORGA MENDIETA
JUAN PABLO MAYORGA MENDIETA
Angel Hernandez
Alejandro Chavez
Santiago Espinel
Juan Camilo Salazar Serna
JUAN PABLO MAYORGA MENDIETA
JUAN PABLO MAYORGA MENDIETA
Codigo del reto para traer tablas, por si alguien anda perdido.
client = boto3.client('dynamodb') response_tables = client.list_tables( Limit=100 ) print(response_tables)```
El SDK (Software Development Kit) de AWS te permite interactuar con DynamoDB desde distintos lenguajes de programación como Python, JavaScript, Java, Go, etc.
Aquí te explico cómo usarlo con el lenguaje más común: Python, usando el paquete boto3.
🧰 1. Instalación del SDK para Python (boto3)
pip install boto3
🔐 2. Configurar credenciales de AWS
Puedes hacerlo con el siguiente comando:
aws configure
Esto guarda tus credenciales de acceso (Access Key, Secret Key, región, y formato) en ~/.aws/credentials.
📁 3. Crear una tabla DynamoDB con SDK (Python)
import boto3
dynamodb = boto3.resource('dynamodb')
table = dynamodb.create_table( TableName='Estudiantes', KeySchema=[ { 'AttributeName': 'EstudianteId', 'KeyType': 'HASH' # Clave primaria } ], AttributeDefinitions=[ { 'AttributeName': 'EstudianteId', 'AttributeType': 'N' } ], ProvisionedThroughput={ 'ReadCapacityUnits': 5, 'WriteCapacityUnits': 5 } )
print("Esperando a que la tabla esté disponible...") table.wait_until_exists() print("Tabla creada con éxito")
📥 4. Insertar un ítem en la tabla
table = dynamodb.Table('Estudiantes')
table.put_item( Item={ 'EstudianteId': 1, 'Nombre': 'Mario Vargas', 'Curso': 'Ingeniería' } )
📤 5. Consultar un ítem
response = table.get_item( Key={ 'EstudianteId': 1 } ) print(response['Item'])
🧹 6. Eliminar una tabla
table = dynamodb.Table('Estudiantes') table.delete()
Si estás usando profiles para que tome el correcto debes hacer una modificación en la creación de la variable dynamodb:
session = boto3.Session(profile_name='TU-PERFIL') dynamodb = session.resource('dynamodb')
it is my table_Fetcher.py
import boto3 def list_tables_resource(): """ Lista las tablas de DynamoDB usando el recurso de alto nivel. """ # El recurso de alto nivel te da una interfaz más orientada a objetos. dynamodb = boto3.resource('dynamodb') table_names = [] print("\nTablas encontradas:") # Esto es mucho más directo y limpio for table in dynamodb.tables.all(): print(f"- {table.name}") table_names.append(table.name) return table_names if __name__ =='__main__' : all_tables_resource = list_tables_resource() print("\nNúmero de tablas encontradas (recurso):", len(all_tables_resource)) print("\n" + "="*40 + "\n") print("Script terminado.")
✅
##imprimo lista con todas mis tabalas client = boto3.client('dynamodb') responseListTable = client.list_tables() print(responseListTable)
Boto3 es una biblioteca de Python que proporciona una interfaz para interactuar con los servicios de Amazon Web Services (AWS). En particular, Boto3 tiene módulos específicos para interactuar con diferentes servicios de AWS, como DynamoDB.
La principal diferencia entre boto3.client('dynamodb') y boto3.resource('dynamodb') es el nivel de abstracción y la complejidad de la API que se utiliza para interactuar con DynamoDB.
boto3.client('dynamodb') proporciona una API de nivel bajo para interactuar con DynamoDB. Esta API se basa en llamadas directas a los métodos del servicio de DynamoDB y devuelve las respuestas en formato JSON. Con esta API, se tiene un control más granular sobre las solicitudes realizadas a DynamoDB, lo que permite ajustar mejor el rendimiento y reducir los costos de la operación.
Por otro lado, boto3.resource('dynamodb') proporciona una API de nivel alto para interactuar con DynamoDB. Esta API se basa en objetos de Python que representan las tablas de DynamoDB, lo que facilita la realización de operaciones comunes como poner, obtener o eliminar elementos. Con esta API, se ocultan detalles técnicos como la serialización de datos o la creación de solicitudes HTTP, lo que hace que sea más fácil de usar para desarrolladores que no están familiarizados con los detalles de DynamoDB.
En resumen, boto3.client('dynamodb') ofrece una API más flexible y personalizable para interactuar con DynamoDB, mientras que boto3.resource('dynamodb') proporciona una API más fácil de usar y de nivel alto para realizar operaciones comunes con DynamoDB. La elección de qué API utilizar dependerá de los requisitos específicos de cada proyecto y del nivel de abstracción que se prefiera utilizar.
solución al reto: en este metodo se obtiene una lista con los nombre de las tablas en dynamoDB:
def list_tables(self): tables = [] for table in self.db.tables.all(): # print(table.name) tables.append(table.name) return tables
más ejemplos de codigo en: galeria de codigo boto3 python
Asi quedo mi codigo para mostrar las tablas que tengo disponibles:
import boto3 def list_dynamodb_tables(): # Creando un cliente para DynamoDb dynamodb = boto3.client('dynamodb') # Llamando al metodo list_tables para obtener todas las tablas response = dynamodb.list_tables() # Imprimiendo las tablas: # Extracting the 'TableNames' key from the response dictionary # 'TableNames' is a predefined key in the response that contains a list of table names tables = response['TableNames'] print('Tablas existentes en mi cuenta de AWS:') for table in tables: print(table) if __name__ == "__main__": list_dynamodb_tables()
Documentación para hacerlo con Node.js:
Para traer todos los elementos:
table.scan()
##imprimo lista con todas mis tabalas client = boto3.client('dynamodb') responseListTable = client.list_tables() print(responseListTable) ``` ##imprimo lista con todas mis tabalas client = boto3.client('dynamodb') responseListTable = client.list\_tables() print(responseListTable)
El SDK permite el uso de varios lenguajes de programación, en esta caso se va usar python y la librería boto3
ejemplo de creación y consulta de items usando POO con un clase que tiene dos métodos llamados en el modulo principal:
import boto3 from boto3.dynamodb.conditions import Key, Attr class ManagePersonajes: def __init__(self) -> None: self.db = boto3.resource('dynamodb') self.table = self.db.Table('Personajes') def get_item_by_id(self, id): response = self.table.query(KeyConditionExpression=Key('Id').eq(id)) return response def create_item(self): self.table.put_item( Item = { 'Id': 123, 'Gender': 'F', 'Status': 'Alive' } ) if __name__ == '__main__': p = ManagePersonajes() p.create_item() print(p.get_item_by_id(123))
