SDK y DynamoDB

Clase 14 de 23 • Curso de Amazon DynamoDB

Wilson Montenegro

student•

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)```

Mario Alexander Vargas Celis

student•

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()

Cristian Camilo Echeverri

student•

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')

Bryan Castano

student•

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

ANDRES ALFONSO MIRA MEJIA

student•

✅

Juan Camilo Salazar Serna

student•

 ##imprimo lista con todas mis tabalas
client = boto3.client('dynamodb')
responseListTable = client.list_tables()
print(responseListTable)

JUAN PABLO MAYORGA MENDIETA

student•

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.

JUAN PABLO MAYORGA MENDIETA

student•

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.

JUAN PABLO MAYORGA MENDIETA

student•

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

Angel Hernandez

student•

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()

Alejandro Chavez

student•

Documentación para hacerlo con Node.js:

AWS Documentation

Santiago Espinel

student•

Para traer todos los elementos:

table.scan()

Juan Camilo Salazar Serna

student•

 ##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)

JUAN PABLO MAYORGA MENDIETA

student•

El SDK permite el uso de varios lenguajes de programación, en esta caso se va usar python y la librería boto3

JUAN PABLO MAYORGA MENDIETA

student•

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

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

    

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()

 ##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)

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

SDK y DynamoDB

Introduccion a bases de datos con AWS

Bienvenida a DynamoDB

¿Qué es una base de datos?

Amazon DynamoDB

El núcleo de DynamoDB

Crear una tabla en DynamoDB: primary keys

Hot partitions

Usuarios y permisos IAM en DynamoDB

Instalación de SDK y AWS CLI

Crear tablas y cargar datos en DynamoDB

Consultar y eliminar tablas en DynamoDB

Índices locales

Consultas con índices locales

Índices globales

Unidades de lectura y escritura

Integrando DynamoDB en AWS

SDK y DynamoDB

Creación de AWS Lambda

DynamoDB Streams

Integrar API Gateway con DynamoDB

Casos de uso de DynamoDB

Exportación de datos a S3

Soporte a DynamoDB

Monitoreo de DynamoDB con CloudWatch

Mantenimiento

Escalabilidad

Cierre

Conclusión