Dynamodb DG
Dynamodb DG
Dynamodb DG
Las marcas comerciales y la imagen comercial de Amazon no se pueden utilizar en relación con ningún producto o
servicio que no sea de Amazon de ninguna manera que pueda causar confusión entre los clientes y que menosprecie
o desacredite a Amazon. Todas las demás marcas comerciales que no son propiedad de Amazon son propiedad de
sus respectivos propietarios, que pueden o no estar afiliados, conectados o patrocinados por Amazon.
Amazon DynamoDB Guía para desarrolladores
Table of Contents
¿Qué es Amazon DynamoDB? ............................................................................................................. 1
Alta disponibilidad y durabilidad .................................................................................................... 1
Introducción a DynamoDB ........................................................................................................... 1
Cómo funciona ........................................................................................................................... 2
Componentes básicos ......................................................................................................... 2
API de DynamoDB ............................................................................................................ 10
Reglas de nomenclatura y tipos de datos ............................................................................. 13
Consistencia de lectura ...................................................................................................... 17
Modo de capacidad de lectura/escritura ............................................................................... 18
Partitions y distribución de datos ......................................................................................... 23
De SQL a NoSQL ..................................................................................................................... 26
¿Base de datos relacional o NoSQL? .................................................................................. 26
Características de las bases de datos .................................................................................. 28
Creación de una tabla ....................................................................................................... 30
Obtención de información sobre una tabla ............................................................................ 31
Escritura de datos en una tabla .......................................................................................... 33
Lectura de datos de una tabla ............................................................................................ 36
Administración de índices ................................................................................................... 41
Modificación de los datos de una tabla ................................................................................ 45
Eliminación de datos de una tabla ....................................................................................... 46
Eliminación de una tabla .................................................................................................... 48
Recursos adicionales de Amazon DynamoDB ............................................................................... 48
Entradas de blog, repositorios y guías ................................................................................. 48
Creación de modelos de datos y patrones de diseño .............................................................. 49
Advanced Design Patterns con la participación de Rick Houlihan .............................................. 49
Cursos de formación técnica .............................................................................................. 49
Herramientas de programación y visualización ...................................................................... 49
Configuración de DynamoDB .............................................................................................................. 50
Configuración de DynamoDB Local (versión descargable) ............................................................... 50
Implementación de ............................................................................................................ 50
Notas de uso ................................................................................................................... 54
Configuración de DynamoDB (servicio web) .................................................................................. 57
Inscripción en AWS ........................................................................................................... 58
Obtención deAWSClave de acceso ..................................................................................... 58
Configuración de las credenciales ....................................................................................... 59
Acceso a DynamoDB ........................................................................................................................ 60
Mediante la consola .................................................................................................................. 60
Trabajo con las preferencias del usuario .............................................................................. 61
Mediante AWS CLI ................................................................................................................... 62
Descarga y configuración de la AWS CLI ............................................................................. 62
Mediante laAWS CLIcon DynamoDB ................................................................................... 63
Mediante laAWS CLIcon DynamoDB descargable .................................................................. 64
Uso de la API .......................................................................................................................... 64
Uso de NoSQL Workbench ........................................................................................................ 64
Rangos de direcciones IP .......................................................................................................... 64
Introducción a DynamoDB .................................................................................................................. 66
Conceptos básicos .................................................................................................................... 66
Requisitos previos ..................................................................................................................... 66
Paso 1: Crear una tabla ............................................................................................................. 66
Paso 2: Escribir datos ................................................................................................................ 69
Paso 3: Leer datos .................................................................................................................... 71
Paso 4: Actualización de datos ................................................................................................... 72
Paso 5: Consulta de los datos .................................................................................................... 74
Paso 6: Creación de un índice secundario global ........................................................................... 76
Amazon DynamoDB es un servicio de base de datos NoSQL totalmente administrado que ofrece un
rendimiento rápido y predecible, así como una perfecta escalabilidad. DynamoDB le permite transferir las
cargas administrativas que supone tener que utilizar y escalar bases de datos distribuidas, para que no
tenga que preocuparse del provisionamiento, la instalación ni la configuración del hardware, ni tampoco de
las tareas de replicación, aplicación de parches de software o escalado de clústeres. DynamoDB también
ofrece el cifrado en reposo, que elimina la carga y la complejidad operativa que conlleva la protección de
información confidencial. Para obtener más información, consulte DynamoDB ado en reposo (p. 884).
Con DynamoDB, puede crear tablas de base de datos capaces de almacenar y recuperar cualquier
cantidad de datos, así como de atender cualquier nivel de tráfico de solicitudes. Puede escalar la
capacidad de desempeño de las tablas para aumentarla o reducirla sin tiempos de inactividad ni reducción
del desempeño. Puede usar laAWS Management Consolepara supervisar la utilización de recursos y las
métricas de rendimiento.
DynamoDB proporciona una funcionalidad de backup bajo demanda. Le permite crear backups completos
de las tablas para una retención y archivado a largo plazo con el objetivo de cumplir los requisitos de
conformidad normativa. Para obtener más información, consulte Backup bajo demanda y restauración para
DynamoDB (p. 701).
Puede crear copias de seguridad bajo demanda y habilitar la recuperación a un momento dado de las
tablas de Amazon DynamoDB. La recuperación a un momento dado ayuda a proteger las tablas de de
operaciones accidentales de escritura o eliminación. Con la recuperación a un momento dado, puede
restaurar una tabla a cualquier momento de los últimos 35 días. Para obtener más información, consulte
Recuperación a un momento dado: Cómo funciona (p. 715).
DynamoDB permite eliminar automáticamente los elementos vencidos de las tablas, para ayudarle a
reducir el consumo de almacenamiento y el costo que suponen los datos que ya no son pertinentes. Para
obtener más información, consulte Vencimiento de elementos mediante el uso de tiempo de vida (TL) de
DynamoDB (p. 446).
Introducción a DynamoDB
Le recomendamos que comience leyendo las secciones siguientes:
• Amazon DynamoDB: Cómo funciona (p. 2)—Para conocer los conceptos esenciales de DynamoDB.
• Configuración de DynamoDB (p. 50)—Para obtener información acerca de cómo configurar
DynamoDB (la versión descargable o el servicio web).
• Acceso a DynamoDB (p. 60)—Para obtener información sobre cómo obtener acceso DynamoDB
mediante la consola de,AWS CLI, o API.
Para obtener más información sobre el desarrollo de aplicaciones, consulte los enlaces siguientes:
Para encontrar con rapidez recomendaciones que le permitan maximizar el desempeño y minimizar sus
costos, consultePrácticas recomendadas para el diseño y la arquitectura con DynamoDB (p. 993). Para
obtener información sobre cómo etiquetar los recursos de DynamoDB, consulteAgregar etiquetas a los
recursos (p. 394).
Para obtener información sobre las prácticas recomendadas, guías de instrucciones y herramientas de,
consulte.Recursos de Amazon DynamoDB.
Puede usarAWS Database Migration Service(AWSDMS) para migrar datos de una base de datos
relacional o MongoDB a una tabla de DynamoDB. Para obtener más información, consulte la Guía del
usuario de AWS Database Migration Service.
Para obtener información sobre cómo utilizar MongoDB como origen de migración, consulteUso de
MongoDB como origen paraAWS Database Migration Service. Para obtener información sobre cómo
utilizar DynamoDB como destino de migración, consulteUso de una base de datos de Amazon DynamoDB
como destino paraAWS Database Migration Service.
Después de leer esta introducción, intente seguir la sección Creación de tablas y carga de datos para
ejemplos de código en DynamoDB (p. 333), en la que se explican paso a paso el proceso de creación de
ejemplos de tablas, carga de datos y realización de algunas operaciones básicas con la base de datos.
Para ver tutoriales específicos del lenguaje con código de muestra, consulte Introducción a DynamoDB
yAWSSDK de (p. 82).
Temas
• Componentes básicos de Amazon DynamoDB (p. 2)
• API de DynamoDB (p. 10)
• Reglas de nomenclatura y tipos de datos (p. 13)
• Consistencia de lectura (p. 17)
• Modo de capacidad de lectura/escritura (p. 18)
• Partitions y distribución de datos (p. 23)
Existen límites en DynamoDB. Para obtener más información, consulte Cuotas de servicio, cuenta y tabla
en Amazon DynamoDB (p. 1066).
Temas
• Tablas, elementos y atributos (p. 3)
• Clave principal (p. 6)
• Índices secundarios (p. 7)
• DynamoDB Streams (p. 9)
• TablasAl igual que otros sistemas de bases de datos, DynamoDB almacena datos en tablas. Una tabla
es una colección de datos. Por ejemplo, consulte la tabla de ejemplo denominada People, que puede
utilizar para almacenar información de contacto personal sobre amigos, familiares u otras personas
de interés. También podría utilizar una tabla Cars para almacenar información sobre los vehículos que
conducen las personas.
• Elementos: cada tabla contiene cero o más elementos. Un elemento es un grupo de atributos que puede
identificarse de forma exclusiva entre todos los demás elementos. En una tabla People, cada elemento
representa a una persona. En una tabla Cars, cada elemento representa un vehículo. Los elementos de
DynamoDB son similares en muchos aspectos a las filas, los registros o las tuplas de otros sistemas de
bases de datos. En DynamoDB, no existe ningún límite respecto al número de elementos que pueden
almacenarse en una tabla.
• Atributos: cada elemento se compone de uno o varios atributos. Un atributo es un componente
fundamental de los datos, que no es preciso dividir más. Por ejemplo, un elemento de una tabla People
contiene los atributos PersonID, LastName, FirstName, etc. En una tabla Department, un elemento
podría tener atributos tales como DepartmentID, Name,Manager, etc. Los atributos de DynamoDB son
similares en muchos aspectos a los campos o columnas de otros sistemas de bases de datos.
En el siguiente diagrama se muestra una tabla denominada People que contiene algunos ejemplos de
elementos y atributos.
• Cada elemento de la tabla tiene un identificador único, o clave principal, que lo distingue de todos los
demás. En la tabla People, la clave principal consta de un atributo (PersonID).
• Dejando a un lado la clave principal, la tabla People no tiene esquema. Esto significa que no es preciso
definir de antemano los atributos ni sus tipos de datos. Cada elemento puede tener sus propios atributos
diferentes.
• La mayoría de los atributos son escalares, lo que significa que solo pueden tener un valor. Las cadenas
y los números son ejemplos comunes de escalares.
• Algunos de los elementos tienen un atributo anidado (Address). DynamoDB admite atributos anidados
de hasta 32 niveles de profundidad.
A continuación se muestra otro ejemplo de tabla denominada Music que podría utilizar para llevar un
registro de una colección de música.
• La clave principal de Music consta de dos atributos (Artist y SongTitle). Cada elemento de la tabla debe
tener estos dos atributos. La combinación de Artist y SongTitle distingue a cada elemento de la tabla de
todos los demás.
• Dejando a un lado la clave principal, la tabla Music no tiene esquema. Esto significa que no es preciso
definir de antemano los atributos ni sus tipos de datos. Cada elemento puede tener sus propios atributos
diferentes.
• Uno de los elementos tiene un atributo anidado (PromotionInfo), que contiene otros atributos anidados.
DynamoDB admite atributos anidados de hasta 32 niveles de profundidad.
Para obtener más información, consulte Uso de tablas y datos en DynamoDB (p. 344).
Clave principal
Al crear una tabla, además de asignarle un nombre, debe especificar su clave principal. La clave principal
identifica de forma única a cada elemento de la tabla, de manera que no puede haber dos elementos con
la misma clave.
• Clave de partición: una clave principal simple que consta de un solo atributo denominado clave de
partición.
DynamoDB utiliza el valor de clave de partición como información de entrada a una función hash interna.
El resultado de la función hash determina la partición (almacenamiento físico interno de DynamoDB)
donde se almacenará el elemento.
En una tabla que solo tiene una clave de partición, no puede haber dos elementos que tengan el mismo
valor de clave de partición.
La tabla People descrita en Tablas, elementos y atributos (p. 3) es un ejemplo de una tabla con
una clave principal simple (PersonID). Puede obtener acceso a cualquier elemento de la tabla People
directamente al proporcionar el valor de PersonId de dicho elemento.
• Clave de partición y clave de ordenación— Se denominaclave principal compuesta, este tipo de clave
se compone de dos atributos. El primer atributo es la clave de partición y el segundo, la clave de
ordenación.
DynamoDB utiliza el valor de clave de partición como información de entrada a una función hash interna.
El resultado de la función hash determina la partición (almacenamiento físico interno de DynamoDB)
donde se almacenará el elemento. Todos los elementos con el mismo valor de clave de partición se
almacenan en posiciones contiguas, ordenados según el valor de la clave de ordenación.
En una tabla que tenga una clave de partición y una clave de ordenación, es posible que dos elementos
tengan el mismo valor de clave de partición. Sin embargo, esos dos elementos deben tener valores de
clave de ordenación distintos.
La tabla Music descrita en Tablas, elementos y atributos (p. 3) es un ejemplo de una tabla con una
clave principal compuesta (Artist y SongTitle). Puede obtener acceso a cualquier elemento de la tabla
Music directamente al proporcionar los valores de Artist y SongTitle de dicho elemento.
Una clave principal compuesta ofrece más flexibilidad a la hora de consultar datos. Por ejemplo,
si proporciona el valor deArtista, DynamoDB recupera todas las canciones de ese intérprete. Para
recuperar solo un subconjunto de canciones de un intérprete determinado, proporcione un valor de Artist
y un intervalo de valores de SongTitle.
Note
Cada atributo de clave principal debe ser escalar (es decir, solo puede contener un único valor). Los únicos
tipos de datos que se permiten para los atributos de clave principal son String, Number y Binary. A los
demás atributos sin clave no se les aplican restricciones de esta índole.
Índices secundarios
Puede crear uno o varios índices secundarios en una tabla. Aíndice secundariopermite consultar los datos
de la tabla usando una clave alternativa, además de realizar consultas basadas en la clave principal.
DynamoDB no requiere que se usen índices; sin embargo, estos ofrecen a las aplicaciones mayor
flexibilidad a la hora de consultar los datos. Después de crear un índice secundario en una tabla, podrá leer
los datos en el índice prácticamente de la misma forma que en la tabla.
• Índice secundario global: índice con una clave de partición y una clave de ordenación que pueden diferir
de las claves de la tabla.
• Índice secundario local: índice que tiene la misma clave de partición que la tabla, pero una clave de
ordenación distinta.
Cada tabla de DynamoDB tiene una cuota de 20 índices secundarios globales (cuota predeterminada) y 5
índices secundarios locales por tabla.
En el ejemplo de la tabla Music mostrado anteriormente, puede consultar los elementos de datos por Artist
(clave de partición) o por Artist y SongTitle (claves de partición y ordenación). ¿Qué sucede si también
desea consultar los datos por género musical (Genre) y título de álbum (AlbumTitle)? Para ello, puede
crear un índice basado en Genre y AlbumTitle y, a continuación, consultarlo prácticamente de la misma
forma que se consultaría la tabla Music.
El siguiente diagrama muestra la tabla Music de ejemplo, con un nuevo índice llamado GenreAlbumTitle.
En el índice, Genre es la clave de partición y AlbumTitle es la clave de ordenación.
• Cada índice pertenece a una tabla, que se denomina la tabla base del índice. En el ejemplo anterior,
Music es la tabla base del índice GenreAlbumTitle.
• DynamoDB mantiene los índices automáticamente. Al agregar, actualizar o eliminar un elemento de
la tabla base, DynamoDB agrega, actualiza o elimina el elemento correspondiente en los índices que
pertenecen a dicha tabla.
• Al crear un índice, se especifica qué atributos de la tabla base se copiarán, o proyectarán, en el índice.
Como mínimo, DynamoDB proyecta en el índice los atributos de clave de la tabla base. Esto es lo que
sucede con el índice GenreAlbumTitle, en el que únicamente se proyectan los atributos de clave de la
tabla Music.
Puede consultar el índice GenreAlbumTitle para encontrar todos los álbumes de un género musical
determinado (por ejemplo, todos los álbumes de música Rock). También puede consultar el índice para
encontrar todos los álbumes de un determinado género musical que tengan un título de álbum específico
(por ejemplo, todos los álbumes de música Country cuyo título comience por la letra H).
Para obtener más información, consulte Uso de índices secundarios para mejorar el acceso a los
datos (p. 567).
DynamoDB Streams
DynamoDB Streams es una característica opcional que captura los eventos de modificación de datos
que se producen en las tablas de DynamoDB. Los datos de estos eventos aparecen en la secuencia
prácticamente en tiempo real y en el orden en que se han producido.
Cada evento se representa mediante un registro de secuencia. Si habilita una secuencia en una tabla,
DynamoDB Streams escribe un registro de secuencia cada vez que se produzcan los siguientes eventos:
• Se añade un nuevo elemento a la tabla: En la secuencia se captura una imagen del elemento completo,
incluidos todos sus atributos.
• Se actualiza un elemento: La secuencia captura las imágenes de «antes» y «después» de los atributos
del elemento que se han modificado.
• Se elimina un elemento de la tabla: La secuencia captura una imagen del elemento completo antes de
eliminarlo.
Cada registro de secuencia también contiene el nombre de la tabla, la marca temporal del evento y
otros metadatos. Los registros de secuencia tienen una vida útil de 24 horas; después, se eliminan
automáticamente de la secuencia.
Puede utilizar DynamoDB Streams junto conAWS LambdaPara crear unDisparador: código que se
ejecuta automáticamente cada vez que aparezca un evento de interés en una secuencia. Por ejemplo,
tomemos una tabla Customers que contiene la información de clientes de una compañía. Supongamos
que desea enviar un mensaje de correo electrónico de bienvenida a cada nuevo cliente. Podría habilitar
una secuencia en esa tabla y, a continuación, asociar la secuencia con una función Lambda. La función
Lambda se ejecutaría cada vez que apareciese un nuevo registro en la secuencia, pero solamente
procesaría los nuevos elementos agregados alClientesTabla INTO. Para cualquier elemento que tenga
unEmailAddress, la función Lambda podría invocar Amazon Simple Email Service (Amazon SES) para
que enviase un mensaje de correo electrónico a esa dirección.
Note
En este ejemplo, observe que el último cliente, Craig Roe, no recibirá un mensaje de correo
electrónico, porque no tiene el atributoEmailAddress.
Además de los disparadores, DynamoDB Streams permite utilizar soluciones sumamente eficientes, tales
como replicación de datos en el seno deAWSRegiones, vistas materializadas de datos en las tablas de
DynamoDB, análisis de datos mediante vistas materializadas de Kinesis, entre otras.
Para obtener más información, consulte Captura de datos de cambio para DynamoDB Streams (p. 661).
API de DynamoDB
Para trabajar con Amazon DynamoDB, la aplicación debe utilizar algunas operaciones de API sencillas. A
continuación se ofrece un resumen de estas operaciones, organizadas por categorías.
Temas
• Plano de control (p. 10)
• Plano de datos (p. 11)
• DynamoDB Streams (p. 12)
• Transactions (p. 12)
Plano de control
Plano de controlLas operaciones permiten crear y administrar tablas de DynamoDB. También permiten
usar índices, secuencias y otros objetos que dependen de las tablas.
• CreateTable: crea una nueva tabla. Si lo prefiere, puede crear uno o varios índices secundarios y
habilitar las DynamoDB Streams para la tabla.
• DescribeTable: devuelve información sobre una tabla, como su esquema de clave principal, ajustes
de desempeño e información de índice.
• ListTables: devuelve los nombres de todas las tablas en una lista.
• UpdateTable: modifica los ajustes de una tabla o sus índices, crea o elimina nuevos índices en una
tabla o modifica los ajustes de DynamoDB Streams para una tabla.
• DeleteTable: elimina de DynamoDB una tabla y todos los objetos que dependen de ella.
Plano de datos
Las operaciones del plano de datos permiten llevar a cabo acciones de creación, lectura, actualización
y eliminación (también denominadas operaciones CRUD, por sus siglas en inglés) con los datos de una
tabla. Algunas de las operaciones del plano de datos permiten también leer datos de un índice secundario.
Puede usarPartiQL: un lenguaje de consulta compatible con SQL para Amazon DynamoDB (p. 537), para
realizar estas operaciones CRUD o puede usar las API CRUD clásicas de DynamoDB que separa cada
operación en una llamada a API distinta.
API clásicas
Creación de datos
• PutItem: escribe un solo elemento en una tabla. Debe especificar los atributos de clave principal, pero
no es preciso especificar otros atributos.
• BatchWriteItem: escribe hasta 25 elementos en una tabla. Resulta más eficiente que llamar a
PutItem varias veces, porque la aplicación solo tiene que completar un único recorrido de ida y
vuelta para escribir todos los elementos. También puede usar BatchWriteItem para eliminar varios
elementos de una o varias tablas.
Lectura de datos
• GetItem: recupera un solo elemento de una tabla. Es preciso especificar la clave principal del elemento
que se desea recuperar. Puede recuperar la totalidad del elemento o solo un subconjunto de sus
atributos.
• BatchGetItem: recupera hasta 100 elementos de una o varias tablas. Resulta más eficiente que llamar
a GetItem varias veces, porque la aplicación solo tiene que completar un único recorrido de ida y vuelta
para leer todos los elementos.
• Query: recupera todos los elementos que tienen una clave de partición determinada. Debe especificar el
valor de clave de partición. Puede recuperar la totalidad de los elementos o solo un subconjunto de sus
atributos. De forma opcional, puede aplicar una condición a los valores de la clave de ordenación de tal
forma que solo se recupere un subconjunto de los datos que tienen la misma clave de partición. Puede
utilizar esta operación en una tabla, siempre y cuando esta tenga tanto una clave de partición como una
clave de ordenación. También puede utilizar esta operación en un índice, siempre y cuando este tenga
tanto una clave de partición como una clave de ordenación.
• Scan: recupera todos los elementos de la tabla o el índice especificados. Puede recuperar la totalidad
de los elementos o solo un subconjunto de sus atributos. Si lo desea, puede aplicar una condición de
filtrado para devolver solamente aquellos valores que le interesan y descartar los demás.
Actualización de datos
• UpdateItem: modifica uno o varios atributos de un elemento. Es preciso especificar la clave principal
del elemento que se desea modificar. Puede agregar nuevos atributos, así como modificar o eliminar
los existentes. También puede realizar actualizaciones condicionales, de tal forma que la actualización
solamente se lleve a cabo cuando se cumpla una condición definida por el usuario. Si lo desea, puede
implementar un contador atómico, que incrementa o disminuye el valor de un atributo numérico sin
interferir con las demás solicitudes de escritura.
Eliminación de datos
• DeleteItem: elimina un solo elemento de una tabla. Es preciso especificar la clave principal del
elemento que se desea eliminar.
• BatchWriteItem: elimina hasta 25 elementos de una o varias tablas. Resulta más eficiente que llamar
a DeleteItem varias veces, porque la aplicación solo tiene que completar un único recorrido de ida y
vuelta para eliminar todos los elementos. También puede usar BatchWriteItem para añadir varios
elementos a una o varias tablas.
DynamoDB Streams
DynamoDB StreamsLas operaciones de permiten habilitar o deshabilitar una secuencia en una tabla y
obtener acceso a los registros de modificación de datos contenidos en una secuencia.
• ListStreams: devuelve una lista de todas las secuencias o solamente la secuencia de una tabla
concreta.
• DescribeStream: devuelve información sobre una secuencia, como su nombre de recurso de Amazon
(ARN) y sobre dónde puede comenzar la aplicación a leer los primeros registros de la secuencia.
• GetShardIterator: devuelve un iterador de fragmentos, que es una estructura de datos que la
aplicación utiliza para recuperar los registros de la secuencia.
• GetRecords: recupera uno o varios registros de secuencia mediante el iterador de fragmentos
especificado.
Transactions
Las transacciones proporcionan atomicidad, coherencia, aislamiento y durabilidad (ACID, atomicity,
consistency, isolation, and durability), lo que le permite mantener la exactitud de los datos en sus
aplicaciones más fácilmente.
Puede usarPartiQL: un lenguaje de consulta compatible con SQL para Amazon DynamoDB (p. 537), para
realizar operaciones transaccionales o puede usar las API CRUD clásicas de DynamoDB que separa cada
operación en una llamada a API distinta.
API clásicas
• TransactWriteItems— Una operación por lotes que permitePut,Update, yDeleteOperaciones de
varios elementos dentro de y a través de tablas con un resultado garantizado de todo o nada.
• TransactGetItems— Una operación por lotes que permiteGetpara recuperar varios elementos de una
o varias tablas.
Temas
• Reglas de nomenclatura (p. 13)
• Tipos de datos (p. 14)
Reglas de nomenclatura
Las tablas, los atributos y otros objetos de DynamoDB deben tener nombres. Los nombres deben ser
significativos y concisos; por ejemplo, Products, Books y Authors son nombres que indican claramente su
significado.
• Todos los nombres deben codificarse mediante UTF-8 y distinguen entre mayúsculas y minúsculas.
• Los nombres de las tablas y los índices deben tener entre 3 y 255 caracteres, que solo pueden ser los
siguientes:
• a-z
• A-Z
• 0-9
• _ (guion bajo)
• - (guion)
• . (punto)
• Los nombres de atributo deben tener un carácter como mínimo y su tamaño máximo no debe superar los
64 KB.
A continuación se muestran las excepciones. Los siguientes nombres de atributo no pueden tener más
de 255 caracteres:
• Los nombres de las claves de partición de índice secundario
• Los nombres de las claves de ordenación de índices secundarios
• Los nombres de los atributos proyectados especificados por el usuario (aplicables solo a los índices
secundarios locales).
Aunque DynamoDB permite utilizar estas palabras reservadas y caracteres especiales en los nombres,
recomendamos que evite hacerlo, porque tendría que definir variables de marcador de posición cada
vez que utilizase estos nombres en una expresión. Para obtener más información, consulte Nombres de
atributos de expresión en DynamoDB (p. 425).
Tipos de datos
DynamoDB admite muchos tipos de datos para los atributos de una tabla. Se pueden categorizar como se
indica a continuación:
• Tipos escalares: un tipo escalar puede representar exactamente un valor. Los tipos escalares son
Number, String, Binary, Boolean y Null.
• Tipos de documentos: un tipo de documento puede representar una estructura compleja con atributos
anidados, como los que se encontraría en un documento JSON. Los tipos de documentos son List y
Map.
• Tipos de conjunto: un tipo de conjunto puede representar varios valores escalares. Los tipos de
conjuntos son String Set, Number Set y Binary Set.
Al crear una tabla o un índice secundario, debe especificar los nombres y los tipos de datos de cada uno
de los atributos de clave principal (clave de partición y clave de ordenación). Además, cada atributo de
clave principal debe definirse como de tipo String, Number o Binary.
DynamoDB es una base de datos NoSQL y essin esquemas. Esto significa que, a excepción de los
atributos de clave principal, no tiene que definir atributos ni tipos de datos cuando crea las tablas. En
comparación, las bases de datos relacionales requieren que se definan los nombres y los tipos de datos de
cada columna al crear la tabla.
A continuación se muestran las descripciones de cada tipo de datos, junto con ejemplos en formato JSON.
Tipos escalares
Los tipos escalares son Number, String, Binary, Boolean y Null.
Number
Los números pueden ser positivos, negativos o cero. Los números pueden tener hasta 38 dígitos de
precisión. Si excede este tope, se generará una excepción.
En DynamoDB, los números se representan con longitud variable. Los ceros iniciales y finales se recortan.
Todos los números se envían a través de la red a DynamoDB como cadenas, para maximizar la
compatibilidad entre lenguajes y bibliotecas. Sin embargo, DynamoDB los trata como atributos de tipo
Number en las operaciones matemáticas.
Note
Si la precisión del número es importante, debe pasar los números a DynamoDB utilizando
cadenas que se conviertan a partir del tipo de número.
Puede utilizar el tipo de datos Number para representar una fecha o una marca temporal. Una forma de
hacerlo es utilizar fechas en formato de tiempo Unix, es decir, el número de segundos desde las 00:00:00
UTC del 1 de enero de 1970. Por ejemplo, la fecha de inicio 1437136300 representa las 12:31:40 UTC del
17 de julio de 2015.
String
Los valores de tipo String son Unicode con codificación binaria UTF-8. La longitud mínima de una cadena
puede ser cero si el atributo no se utiliza como clave de un índice o tabla y tiene un límite de tamaño
máximo de 400 KB de DynamoDB.
Las siguientes restricciones adicionales son aplicables a atributos de clave principal definidos como
cadena de tipo:
• Para una clave principal simple, la longitud máxima del valor del primer atributo (clave de partición) es de
2048 bytes.
• Para una clave principal compuesta, la longitud máxima del valor del segundo atributo (clave de
ordenación) es de 1024 bytes.
DynamoDB recopila y compara las cadenas utilizando los bytes de la codificación de cadena UTF-8
subyacente. Por ejemplo, "a" (0x61) es mayor que "A" (0x41) y "¿" (0xC2BF) es mayor que "z" (0x7A).
Puede utilizar el tipo de datos String para representar una fecha o una marca temporal. Una forma de
hacerlo es utilizar cadenas ISO 8601, tal y como se muestra en estos ejemplos:
• 2016-02-15
• 2015-12-21T17:42:34Z
• 20150311T122706Z
Binary
Los atributos de tipo Binary pueden almacenar cualquier tipo de datos binarios, como texto comprimidos,
datos cifrados o imágenes. Siempre que DynamoDB compara valores de tipo Binary, trata cada byte de los
datos binarios como sin signo.
La longitud de un atributo binario puede ser cero si el atributo no se utiliza como clave de un índice o tabla
y tiene un límite de tamaño máximo de 400 KB de DynamoDB.
Si define un atributo de clave principal como atributo de tipo Binary, se aplican las siguientes restricciones
adicionales:
• Para una clave principal simple, la longitud máxima del valor del primer atributo (clave de partición) es de
2048 bytes.
• Para una clave principal compuesta, la longitud máxima del valor del segundo atributo (clave de
ordenación) es de 1024 bytes.
Las aplicaciones deben codificar los valores de tipo Binary en formato codificado en base64 antes de
enviarlos a DynamoDB. Al recibirlos, DynamoDB decodifica los datos y los convierte a matrices de bytes
sin signo; a continuación, utiliza ese resultado como longitud del atributo de tipo Binary.
El siguiente ejemplo es un atributo de tipo Binary en el que se utiliza texto con la codificación en base64.
dGhpcyB0ZXh0IGlzIGJhc2U2NC1lbmNvZGVk
Boolean
Null
Tipos de documentos
Los tipos de documentos son List y Map. Estos tipos de datos pueden anidarse unos en otros para
representar estructuras de datos complejas con un máximo de 32 niveles de profundidad.
No existe ningún límite respecto al número de valores de una lista o un mapa, siempre y cuando el
elemento que contenga los valores se ajuste al límite de tamaño de elemento de DynamoDB (400 KB).
El valor de un atributo puede ser una cadena vacía o un valor binario vacío si el atributo no se utiliza en
una tabla o clave de índice. El valor de un atributo no puede ser un conjunto vacío (conjunto de cadenas,
conjunto de números o conjunto binario); sin embargo, sí se permiten listas y mapas vacíos. Se pueden
utilizar valores binarios y de cadena vacíos en las listas y los mapas. Para obtener más información,
consulte Attributes (p. 1072).
List
Un atributo de tipo List puede almacenar una colección ordenada de valores. Las listas deben ir entre
corchetes: [ ... ].
Una lista es similar a una matriz JSON. No hay ninguna limitación respecto a los tipos de datos que se
pueden almacenar en una entrada de lista y no es preciso que las entradas de una entrada de lista sean
del mismo tipo.
En el siguiente ejemplo se muestra una lista que contiene dos cadenas y un número.
Note
DynamoDB permite usar entradas individuales contenidas en las listas, aunque estas entradas
estén anidadas a gran profundidad. Para obtener más información, consulte Uso de expresiones
en DynamoDB (p. 421).
Map
Un atributo de tipo Map puede almacenar una colección desordenada de pares nombre-valor. Los mapas
deben ir entre llaves: { ... }.
Un mapa es similar a un objeto JSON. No hay ninguna limitación respecto a los tipos de datos que se
pueden almacenar en una entrada de mapa y no es preciso que las entradas de un mapa sean del mismo
tipo.
Los mapas son idóneos para almacenar documentos JSON en DynamoDB. En el siguiente ejemplo se
muestra un mapa que contiene una cadena, un número y una lista anidada que contiene otro mapa.
{
Day: "Monday",
UnreadEmails: 42,
ItemsOnMyDesk: [
"Coffee Cup",
"Telephone",
{
Pens: { Quantity : 3},
Note
DynamoDB permite usar entradas individuales contenidas en los mapas, aunque estas entradas
estén anidadas a gran profundidad. Para obtener más información, consulte Uso de expresiones
en DynamoDB (p. 421).
Sets
DynamoDB admite tipos que representan conjuntos de valores de tipo number, string o binary. Todas las
entradas de un conjunto deben ser del mismo tipo. Por ejemplo, un atributo de tipo Number Set solo puede
contener números, de tipo String Set solo puede contener cadenas y así sucesivamente.
No existe ningún límite respecto al número de valores de un conjunto, siempre y cuando el elemento que
contenga los valores se ajuste al límite de tamaño de elemento de DynamoDB (400 KB).
Cada valor contenido en un conjunto debe ser único. No se conserva el orden de los valores dentro de un
conjunto. Por lo tanto, sus aplicaciones no deben confiar en ningún orden particular de elementos dentro
del conjunto. DynamoDB no admite conjuntos vacíos; sin embargo, sí se pueden utilizar valores binarios y
de cadena vacíos dentro de un conjunto.
Consistencia de lectura
Amazon DynamoDB está disponible en variosAWSRegiones de todo el mundo. Cada región es
independiente y se encuentra aislada de otrasAWSRegiones de. Por ejemplo, si tenemos una tabla
denominada People en la región us-east-2 y otra tabla denominada People en la región us-west-2, se
consideran dos tablas completamente independientes. Para ver una lista de todos losAWSLas regiones en
las que DynamoDB está disponible, consulte.AWSRegiones y puntos de enlace deen laReferencia general
de Amazon Web Services.
Todas lasAWSCada región consta de varias ubicaciones distintas denominadas zonas de disponibilidad.
Cada zona de disponibilidad está aislada de los errores que se produzcan en otras zonas de disponibilidad
y proporciona conectividad de red de baja latencia económica con otras zonas de disponibilidad de la
misma región. Esto permite la replicación rápida de los datos entre varias zonas de disponibilidad de una
región.
Cuando la aplicación escribe datos en una tabla de DynamoDB y recibe una respuesta HTTP 200 (OK),
la escritura ha ocurrido y es duradera. Los datos presentan consistencia final en todas las ubicaciones de
almacenamiento, normalmente en el plazo de un segundo o menos.
Al leer datos de una tabla de DynamoDB, la respuesta podría no reflejar los resultados de una operación
de escritura reciente. La respuesta podría incluir algunos datos anticuados. Si repite la solicitud de lectura
tras un breve intervalo de tiempo, la respuesta debería devolver los datos más recientes.
Cuando se solicita una lectura de consistencia alta, DynamoDB devuelve una respuesta con los datos más
actualizados, de tal forma que refleja las actualizaciones de todas las operaciones de escritura anteriores
que se han llevado a cabo correctamente. No obstante, esta coherencia conlleva algunas desventajas:
• Una lectura de consistencia alta podría no estar disponible si se produce un retraso o una interrupción en
la red. En este caso, DynamoDB puede devolver un error de servidor (HTTP 500).
• Las lecturas con coherencia alta pueden tener mayor latencia que las lecturas con coherencia final.
• Las lecturas altamente consistentes no se admiten para los índices secundarios globales.
• Las lecturas con coherencia alta utilizan mayor capacidad de rendimiento que las lecturas
con coherencia final. Para obtener más información, consulte Modo de capacidad de lectura/
escritura (p. 18).
Note
DynamoDB utiliza las lecturas consistentes finales a menos que especifique lo contrario.
Las operaciones de lectura (como GetItem, Queryy Scan) proporcionan un parámetro
ConsistentRead. Si establece este parámetro en true, DynamoDB utiliza lecturas de
consistencia alta durante la operación.
• Bajo demanda
• Capacidad aprovisionada (valor predeterminado, apta para capa gratuita)
Los índices secundarios locales heredan el modo de capacidad de lectura/escritura de la tabla base. Para
obtener más información, consulte Consideraciones sobre el cambio del modo de capacidad de lectura/
escritura (p. 349).
Temas
• Modo bajo demanda (p. 18)
• Modo aprovisionado (p. 20)
Al elegir el modo bajo demanda, DynamoDB se adapta de forma instantánea a sus cargas de trabajo a
medida que aumentan o disminuyen a cualquier nivel de tráfico alcanzado previamente. Si el nivel de
tráfico de una carga de trabajo alcanza un nuevo nivel máximo, DynamoDB se adapta rápidamente para
acomodar la carga de trabajo. Las tablas que usan el modo bajo demanda proporcionan la misma latencia
de milisegundos de un solo dígito, compromiso de acuerdo de nivel de servicio (SLA) y seguridad que
DynamoDB ya ofrece. Puede elegir el modo bajo demanda para las tablas nuevas y existentes, y puede
seguir usando las API de DynamoDB existentes sin cambiar el código.
El modo bajo demanda es una opción interesante si se da cualquiera de las condiciones siguientes:
La única limitación de la tasa de solicitudes son las cuotas predeterminadas de las tablas respecto al
rendimiento de DynamoDB, pero se puede elevar bajo petición. Para obtener más información, consulte
Cuotas de rendimiento predeterminadas (p. 1067).
Si desea comenzar a utilizar el modo bajo demanda, puede crear o actualizar una tabla para ello. Para
obtener más información, consulte Operaciones básicas en tablas de DynamoDB (p. 344).
Puede cambiar entre los modos de capacidad de lectura/escritura una vez cada 24 horas. Para conocer los
asuntos que es preciso tener en cuenta al cambiar a otro modo de capacidad de lectura/escritura, consulte
Consideraciones sobre el cambio del modo de capacidad de lectura/escritura (p. 349).
Temas
• Unidades de solicitud de lectura y de escritura (p. 19)
• Picos de tráfico y propiedades de escalado (p. 20)
• Rendimiento inicial del modo de capacidad bajo demanda (p. 20)
• Comportamiento de las tablas al cambiar el modo de capacidad de lectura/escritura (p. 20)
Para obtener más información sobre los modelos de consistencia de lectura de DynamoDB,
consulteConsistencia de lectura (p. 17).
• Oneunidad de solicitud de escriturarepresenta una escritura para un elemento con un tamaño de hasta
1 KB. Para escribir un elemento mayor que 1 KB, DynamoDB necesita consumir unidades de solicitud
de escritura adicionales. Las solicitudes de escritura transaccionales requieren dos unidades de solicitud
de escritura para realizar una escritura respecto a los elementos de hasta 1 KB. El número total de
unidades de solicitud de escritura necesarias depende del tamaño del elemento. Por ejemplo, si el
tamaño de elemento es de 2 KB, se necesitan 2 unidades de solicitud de lectura para sostener una
solicitud de escritura o 4 unidades de solicitud de lectura para una solicitud de lectura transaccional.
Para obtener una lista deAWSLas regiones en las que DynamoDB bajo demanda está disponible,
consultePrecios de Amazon DynamoDB.
Si se necesita más del doble del tráfico máximo anterior para una tabla, DynamoDB asigna
automáticamente más capacidad a medida que aumenta el volumen de tráfico, para asegurarse de que
la carga de trabajo no sufra ninguna limitación controlada. Sin embargo, esta limitación controlada podría
producirse si supera el doble del pico anterior en el plazo de 30 minutos. Por ejemplo, si el patrón de tráfico
de una tabla varía entre 25 000 y 50 000 lecturas de consistencia alta por segundo y el tráfico máximo
alcanzado anteriormente ha sido de 50 000 lecturas, DynamoDB recomienda espaciar el aumento del
tráfico a lo largo de al menos 30 minutos antes de subir por encima de las 100 000 lecturas por segundo.
• Tabla recién creada con modo de capacidad bajo demanda: El máximo anterior es de 2000 unidades de
solicitud de escritura o 6.000 unidades de solicitud de lectura. Puede aumentar el tráfico máximo anterior
al doble de inmediato, lo que permite que las tablas creadas directamente con el modo bajo demanda
atiendan hasta 4000 unidades de solicitud de escritura o 12 000 unidades de solicitud de lectura, o
cualquier combinación de ambas.
• Tabla existente cambiada al modo de capacidad bajo demanda: El tráfico máximo anterior equivale a la
mitad de las unidades de capacidad de escritura y de lectura aprovisionadas desde que se creó la tabla,
o a los valores de una tabla recién creada con el modo de capacidad bajo demanda, lo que sea mayor.
En otras palabras, la tabla ofrecerá, como mínimo, el mismo rendimiento que tenía antes de cambiar al
modo de capacidad bajo demanda.
Modo aprovisionado
Si elige el modo aprovisionado, usted especifica el número de lecturas y escrituras por segundo que
necesita para su aplicación. Puede utilizar el escalado automático para ajustar automáticamente la
capacidad aprovisionada de la tabla en respuesta a los patrones de tráfico. Esto le ayuda a controlar el
uso de DynamoDB para que se mantenga igual o menor que la velocidad de solicitudes definida y, de esta
forma, poder predecir los costos.
• OneUnidad de capacidad de lecturarepresenta una lectura de consistencia alta por segundo, o bien
dos lecturas consistentes finales por segundo, para un elemento con un tamaño de hasta 4 KB. Las
solicitudes de lectura transaccionales requieren dos unidades de capacidad de lectura por segundo
respecto a los elementos de hasta 4 KB. Para leer un elemento mayor que 4 KB, DynamoDB debe
consumir unidades de capacidad de lectura adicionales. El número total de unidades de capacidad
de lectura necesarias depende del tamaño del elemento y de si se desea utilizar lecturas consistentes
finales o de consistencia alta. Por ejemplo, si el tamaño de elemento es de 8 KB, se necesitan
2 unidades de capacidad de lectura para sostener una lectura de consistencia alta por segundo,
1 unidad de capacidad de lectura si opta por las lecturas consistentes finales o 4 unidades de capacidad
de lectura para una solicitud de lectura transaccional. Para obtener más información, consulte Consumo
de unidades de capacidad para las lecturas (p. 351).
Note
Para obtener más información sobre los modelos de consistencia de lectura de DynamoDB,
consulteConsistencia de lectura (p. 17).
• Oneunidad de capacidad de escriturarepresenta una escritura por segundo para un elemento con un
tamaño de hasta 1 KB. Para escribir un elemento mayor que 1 KB, DynamoDB debe consumir unidades
de capacidad de escritura adicionales. Las solicitudes de escritura transaccionales requieren dos
unidades de capacidad de escritura para realizar una escritura por segundo respecto a los elementos de
hasta 1 KB. El número total de unidades de capacidad de escritura necesarias depende del tamaño del
elemento. Por ejemplo, si el tamaño de elemento es de 2 KB, se necesitan 2 unidades de capacidad de
escritura para sostener una solicitud de escritura por segundo o 4 unidades de capacidad de escritura
para una solicitud de escritura transaccional. Para obtener más información, consulte Consumo de
unidades de capacidad para las escrituras (p. 352).
Important
Al llamar a DescribeTable en una tabla bajo demanda, las unidades de capacidad de lectura y
de escritura se establecen en 0.
Si la aplicación lee o escribe elementos mayores (hasta el tamaño de elemento máximo de DynamoDB de
400 KB), consumirá más unidades de capacidad.
Por ejemplo, supongamos que creamos una tabla aprovisionada con 6 unidades de capacidad de lectura y
6 unidades de capacidad de escritura. Con estos ajustes, la aplicación podría hacer lo siguiente:
El rendimiento aprovisionado es la cantidad máxima de capacidad que una tabla o un índice de una
aplicación pueden consumir. Si la aplicación supera la capacidad de rendimiento aprovisionada en una
tabla o un índice, las solicitudes podrían ser objeto de una limitación controlada.
La limitación controlada impide que la aplicación consuma demasiadas unidades de capacidad. Cuando se
aplica una limitación controlada a una solicitud, se produce un error en ella con el código HTTP 400 (Bad
Request) y se genera una excepción ProvisionedThroughputExceededException. LaAWSLos
SDK incluyen compatibilidad integrada para reintentar las solicitudes que han sido objeto de una limitación
limitada (consulteReintentos de error y retardo exponencial (p. 229)), por lo que no necesita escribir
personalmente esta lógica.
Puede utilizar la AWS Management Console para monitorizar el rendimiento aprovisionado y real y
modificar los ajustes de rendimiento si es preciso.
Con la función Auto Scaling de DynamoDB, una tabla o índice secundario global pueden aumentar su
capacidad de lectura y escritura provisionada para hacer frente a los aumentos repentinos de tráfico,
sin que se utilice la limitación regulada a las solicitudes. Cuando la carga de trabajo disminuye, el
escalado automático de DynamoDB puede reducir el desempeño para evitar que tenga que pagar por una
capacidad provisionada que no se utiliza.
Note
Si usa elAWS Management ConsolePara crear una tabla o un índice secundario global, la función
Auto Scaling de DynamoDB se habilita de forma predeterminada.
Puede administrar los ajustes de Auto Scaling en cualquier momento mediante la consola, laAWS
CLI, o una de lasAWSSDK.
Para obtener más información, consulte Administración automática de la capacidad de desempeño con la
función Auto Scaling de DynamoDB (p. 355).
Capacidad reservada
Como cliente de DynamoDB, puede comprarCapacidad reservadapor adelantado, como se describe
enPrecios de Amazon DynamoDB. Con la capacidad reservada, se abona una tarifa inicial única y
se adquiere el compromiso de utilizar un nivel mínimo aprovisionado durante un periodo concreto. La
capacidad reservada se factura según la tarifa de capacidad reservada por hora. Al reservar las unidades
de capacidad de lectura y escritura por adelantado, logrará un ahorro importante en comparación con los
ajustes de desempeño provisionado o bajo demanda. Cualquier capacidad que aprovisione que supere la
capacidad reservada se cobrará de acuerdo con la tarifa de capacidad aprovisionada estándar.
Note
Puede impedir que los usuarios vean o adquieran capacidad reservada pero que sí puedan
obtener acceso al resto de la consola. Para obtener más información, consulte cómo conceder
permisos para evitar la adquisición de ofertas de capacidad reservada en Identity and Access
Management (p. 894).
Al crear una tabla, su estado inicial es CREATING. Durante esta fase, DynamoDB asigna particiones
suficientes a la tabla para que pueda satisfacer los requisitos de desempeño provisionado. Puede
comenzar a escribir y leer datos en la tabla una vez que su estado haya cambiado a ACTIVE.
• Si aumenta los ajustes de rendimiento aprovisionado de la tabla de tal forma que se supere el límite
admitido por las particiones existentes.
• Si una partición existente se llena al límite de su capacidad y se requiere más espacio de
almacenamiento.
La administración de las particiones tiene lugar automáticamente en segundo plano y es transparente para
las aplicaciones. La tabla permanece disponible a lo largo del proceso y responde en todo momento a los
requisitos de rendimiento aprovisionado.
Para obtener más información, consulte Diseño de claves de partición (p. 996).
Los índices secundarios globales de DynamoDB también constan de particiones. Los datos de un índice
secundario global se almacenan de forma independiente de los datos de la tabla base, pero las particiones
de índices se comportan prácticamente igual que las particiones de tablas.
Para escribir un elemento en la tabla, DynamoDB utiliza el valor de la clave de partición como información
de entrada para una función hash interna. El valor del resultado de la función hash determina la partición
donde se almacenará el elemento.
Para leer un elemento de la tabla, debe especificar el valor de clave de partición del elemento. DynamoDB
utiliza este valor como información de entrada para la función hash para obtener la partición en la que se
encuentra el elemento.
En el siguiente diagrama se muestra una tabla denominada Pets que abarca varias particiones. La clave
principal de la tabla esAnimalType(solo se muestra este atributo de clave). DynamoDB utiliza la función
hash para determinar dónde se almacenará un nuevo elemento, en este caso de acuerdo con el valor hash
de la cadenaPerro. Tenga en cuenta que los elementos no se almacenan de forma ordenada. La ubicación
de cada elemento viene determinada por el valor hash de su clave de partición.
Note
DynamoDB está optimizado para distribuir los elementos uniformemente entre las particiones
de una tabla, con independencia del número de particiones que haya. Recomendamos elegir
una clave de partición que pueda tener un amplio abanico de valores distintos en relación con el
número de elementos de la tabla.
Para escribir un elemento en la tabla, DynamoDB calcula el valor hash de la clave de partición, con el fin
de determinar qué partición debe contener el elemento. En dicha partición, varios elementos podrían tener
el mismo valor de clave de partición. Por tanto, DynamoDB almacena el elemento con los otros que tienen
la misma clave de partición, en orden ascendente por clave de ordenación.
Para leer un elemento de la tabla, debe especificar los valores de sus claves de partición y ordenación.
DynamoDB calcula el valor hash de la clave de partición para obtener la partición en la que se encuentra el
elemento.
Puede leer varios elementos de la tabla en una misma operación (Query) si los elementos que desea
obtener tienen el mismo valor de clave de partición. DynamoDB devuelve todos los elementos que
contienen ese valor de clave de partición. De forma opcional, puede aplicar una condición a la clave
de ordenación para que devuelva solamente los elementos comprendidos en un rango de valores
determinado.
Supongamos que la tabla Pets tiene una clave principal compuesta que consta de AnimalType (clave
de partición) y Name (clave de ordenación). En el siguiente diagrama se ilustra lo que ocurre cuando
DynamoDB escribe un elemento con un valor de clave de particiónPerroy un valor de clave de ordenación
deFido.
Para leer ese mismo elemento de laMascotas, DynamoDB calcula el valor hash dePerro, produciendo la
partición en la que están almacenados estos elementos. A continuación, DynamoDB examina los valores
de los atributos de clave de ordenación hasta que encuentraFido.
Para leer todos los elementos cuyo valor de AnimalType es Dog, puede emitir una operación Query sin
especificar una condición de clave de ordenación. De forma predeterminada, los elementos se devuelven
en el orden en el que están almacenados (es decir, en orden ascendente, según su clave de ordenación).
Si lo prefiere, puede solicitar que se muestren por orden descendente.
Para consultar solo algunos de los elementos Dog, puede aplicar una condición a la clave de ordenación
(por ejemplo, solo los elementos Dog cuyo valor de Name comience por una letra comprendida entre la A y
la K).
Note
En una tabla de DynamoDB, no existe ningún límite superior respecto al número de valores
diferentes de clave de ordenación por cada valor de clave de partición. Si necesita almacenar
muchos miles de millones dePerroelementos de laMascotasEn, DynamoDB asignaría
almacenamiento suficiente para satisfacer este requisito automáticamente.
De SQL a NoSQL
Si es desarrollador de aplicaciones, es posible que tenga alguna experiencia con el sistema de
administración de bases de datos relacionales (RDBMS, por sus siglas en inglés) y con el lenguaje de
consulta estructurada SQL. Cuando comience a utilizar Amazon DynamoDB, observará numerosas
similitudes, pero también bastantes diferencias. En esta sección se describen las tareas que suelen
llevarse a cabo con las bases de datos y se comparan y contrastan las instrucciones de SQL con las
operaciones de
El término NoSQL se utiliza para describir los sistemas de bases de datos no relacionales que tienen un
alto grado de disponibilidad y escalabilidad y están optimizados para ofrecer un rendimiento elevado. En
lugar del modelo relacional, las bases de datos NoSQL (como DynamoDB) utilizan modelos alternativos
de administración de datos, como los pares clave-valor o el almacenamiento de documentos. Para obtener
más información, consulte http://aws.amazon.com/nosql.
Note
Los ejemplos de SQL de esta sección son compatibles con el RDBMS MySQL.
En los ejemplos de DynamoDB de esta sección se muestra el nombre de la operación de
DynamoDB, junto con los parámetros de dicha operación en formato JSON. Para obtener
ejemplos de código en los que se utilizan estas operaciones, consulte Introducción a DynamoDB
yAWSSDK de (p. 82).
Temas
• ¿Base de datos relacional (SQL) o NoSQL? (p. 26)
• Características de las bases de datos (p. 28)
• Creación de una tabla (p. 30)
• Obtención de información sobre una tabla (p. 31)
• Escritura de datos en una tabla (p. 33)
• Diferencias clave al leer datos de una tabla (p. 36)
• Administración de índices (p. 41)
• Modificación de los datos de una tabla (p. 45)
• Eliminación de datos de una tabla (p. 46)
• Eliminación de una tabla (p. 48)
Amazon DynamoDB es apropiada para cargas de trabajo de este tipo. Como desarrollador, puede
comenzar a pequeña escala y aumentar gradualmente a medida que su aplicación adquiera popularidad.
DynamoDB se escala de manera fluida hasta administrar enormes cantidades de datos y de usuarios.
En la siguiente tabla se muestran algunas diferencias generales de alto nivel entre un RDBMS y un
DynamoDB.
En el siguiente diagrama se muestra la interacción de un cliente con una base de datos relacional y con
Amazon DynamoDB.
En la tabla siguiente se muestra más información acerca de las tareas de interacción del cliente.
Temas
• SQL (p. 30)
• DynamoDB (p. 30)
SQL
Use la instrucción CREATE TABLE para crear una tabla, como se muestra en el ejemplo siguiente.
Debe definir la clave principal, así como todas las columnas y tipos de datos de la tabla. Puede usar la
instrucción ALTER TABLE para cambiar estas definiciones más adelante si fuera preciso.
DynamoDB
Use la acción CreateTable para crear una tabla en modo aprovisionado; para ello, especifique los
parámetros que se muestran a continuación:
{
TableName : "Music",
KeySchema: [
{
AttributeName: "Artist",
La clave principal de esta tabla consta de Artist (clave de partición) y SongTitle (clave de ordenación).
Note
Para obtener ejemplos de código en los que se utiliza CreateTable, consulte Introducción a
DynamoDB yAWSSDK de (p. 82).
Temas
• SQL (p. 31)
• DynamoDB (p. 32)
SQL
La mayoría de los sistemas de administración de bases de datos relacionales (RDBMS) permiten describir
una estructura de tabla; a saber, columnas, tipos de datos, definición de clave principal, etc. No existe una
manera estándar de realizar esta tarea en SQL. Sin embargo, en muchos sistemas de base de datos se
proporciona un comando DESCRIBE. A continuación se muestra un ejemplo de MySQL.
DESCRIBE Music;
Este código devuelve la estructura de la tabla, con todos los nombres de columnas, los tipos de datos y los
tamaños.
+------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+------------+-------------+------+-----+---------+-------+
| Artist | varchar(20) | NO | PRI | NULL | |
| SongTitle | varchar(30) | NO | PRI | NULL | |
| AlbumTitle | varchar(25) | YES | | NULL | |
| Year | int(11) | YES | | NULL | |
| Price | float | YES | | NULL | |
| Genre | varchar(10) | YES | | NULL | |
| Tags | text | YES | | NULL | |
+------------+-------------+------+-----+---------+-------+
DynamoDB
DynamoDB posee unaDescribeTableacción, que es parecida. El único parámetro es el nombre de la
tabla.
{
TableName : "Music"
}
{
"Table": {
"AttributeDefinitions": [
{
"AttributeName": "Artist",
"AttributeType": "S"
},
{
"AttributeName": "SongTitle",
"AttributeType": "S"
}
],
"TableName": "Music",
"KeySchema": [
{
"AttributeName": "Artist",
"KeyType": "HASH" //Partition key
},
{
"AttributeName": "SongTitle",
"KeyType": "RANGE" //Sort key
}
],
...
DescribeTable también proporciona información acerca de los índices de la tabla, los ajustes de
rendimiento aprovisionado, el recuento de elementos aproximado y otros metadatos.
En esta sección se describe cómo escribir una fila (o un elemento) en una tabla.
Temas
• SQL (p. 33)
• DynamoDB (p. 33)
SQL
Una tabla de una base de datos relacional es una estructura de datos bidimensional formada por filas y
columnas. Algunos sistemas de administración de bases de datos también ofrecen compatibilidad con
datos semiestructurados, normalmente con los tipos de datos de JSON o XML nativos. Sin embargo, los
detalles de implementación varían según el proveedor.
En SQL, se utiliza la instrucción INSERT para agregar una fila a una tabla.
La clave principal de esta tabla consta de Artist y SongTitle. Debe especificar los valores de estas
columnas.
Note
En este ejemplo se utiliza la columna Tags para almacenar datos semiestructurados relativos
a las canciones de la tabla Music. La columna Tags se define como el tipo TEXT, que permite
almacenar hasta 65,535 caracteres en MySQL.
DynamoDB
En Amazon DynamoDB, se utiliza PartiQL, un lenguaje de consulta compatible con SQL o las API clásicas
de DynamoDB para agregar un elemento a una tabla.
PartiQL
En Amazon DynamoDB, se utiliza elExecuteStatementPara agregar un elemento a una tabla, utilizando
la herramienta deInserteInstrucción PartiQL.
La clave principal de esta tabla consta de Artist y SongTitle. Debe especificar los valores de estos
atributos.
Note
{
TableName: "Music",
Item: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today",
"AlbumTitle":"Somewhat Famous",
"Year": 2015,
"Price": 2.14,
"Genre": "Country",
"Tags": {
"Composers": [
"Smith",
"Jones",
"Davis"
],
"LengthInSeconds": 214
}
}
}
La clave principal de esta tabla consta de Artist y SongTitle. Debe especificar los valores de estos
atributos.
A continuación se indican algunos aspectos clave que es preciso tener en cuenta sobre este ejemplo de
PutItem:
• DynamoDB proporciona compatibilidad nativa con documentos mediante JSON. Por ello, DynamoDB es
idóneo para almacenar datos semiestructurados, comoTags (Etiquetas):. Además, puede recuperar y
manipular los datos contenidos en los documentos JSON.
• La tabla Music no tiene atributos predefinidos aparte de la clave principal (Artist y SongTitle).
• La mayoría de las bases de datos SQL están orientadas a transacciones. Cuando se emite una
instrucción INSERT, las modificaciones de los datos no son permanentes hasta que se emite una
instrucción COMMIT. Con Amazon DynamoDB, los efectos de unPutItemLa acción es permanente
cuando DynamoDB responde con un código de estado HTTP 200 (OK).
Note
Para obtener ejemplos de código en los que se utiliza PutItem, consulte Introducción a
DynamoDB yAWSSDK de (p. 82).
{
TableName: "Music",
Item: {
"Artist": "No One You Know",
"SongTitle": "My Dog Spot",
"AlbumTitle":"Hey Now",
"Price": 1.98,
"Genre": "Country",
"CriticRating": 8.4
}
}
{
TableName: "Music",
Item: {
"Artist": "No One You Know",
"SongTitle": "Somewhere Down The Road",
"AlbumTitle":"Somewhat Famous",
"Genre": "Country",
"CriticRating": 8.4,
"Year": 1984
}
}
{
TableName: "Music",
Item: {
"Artist": "The Acme Band",
"SongTitle": "Still In Love",
"AlbumTitle":"The Buck Starts Here",
"Price": 2.47,
"Genre": "Rock",
"PromotionInfo": {
"RadioStationsPlaying":[
"KHCR", "KBQX", "WTNR", "WJJH"
],
"TourDates": {
"Seattle": "20150625",
"Cleveland": "20150630"
},
"Rotation": "Heavy"
}
}
}
{
TableName: "Music",
Item: {
"Artist": "The Acme Band",
"SongTitle": "Look Out, World",
"AlbumTitle":"The Buck Starts Here",
"Price": 0.99,
"Genre": "Rock"
}
}
Note
Amazon DynamoDB ofrece las siguientes operaciones para leer los datos:
• ExecuteStatement— Recupera uno o varios elementos de una tabla utilizando PartiQL (un lenguaje
de consulta compatible con SQL). DynamoDB también proporciona laBatchExecuteStatementLa
operación permite recuperar varios elementos de tablas diferentes en una sola operación.
• GetItem: recupera un solo elemento de una tabla. Se trata de la forma más eficiente de leer un único
elemento, ya que proporciona acceso directo a la ubicación física del elemento. (DynamoDB también
proporciona elBatchGetItemoperación, que permite llevar a cabo hasta 100GetItemllama en una sola
operación.)
• Query: recupera todos los elementos que tienen una clave de partición determinada. Dentro del
conjunto de esos elementos, puede aplicar una condición a la clave de ordenación y recuperar
únicamente un subconjunto de los datos. Query proporciona un acceso rápido y eficiente a las
particiones en las que se almacenan los datos. (Para obtener más información, consulte Partitions y
distribución de datos (p. 23).)
• Scan: recupera todos los elementos de la tabla especificada. (Esta operación no debe utilizarse con
grandes tablas, ya que puede consumir gran cantidad de recursos del sistema).
Note
En una base de datos relacional, puede usar la instrucción SELECT para unir los datos de varias
tablas y devolver los resultados. Las uniones son fundamentales para el modelo relacional. Para
garantizar que las uniones se lleven a cabo de forma eficiente, es preciso ajustar continuamente
el desempeño de la base de datos y de sus aplicaciones. DynamoDB es una base de datos
NoSQL no relacional que no admite uniones de tablas. En lugar de ello, las aplicaciones leen los
datos de una tabla cada vez.
En las siguientes secciones se describen varios casos de uso de la lectura de datos y se explica cómo
realizar estas tareas con una base de datos relacional y con DynamoDB.
Temas
• Lectura de un elemento usando su clave principal (p. 36)
• Consulta de una tabla (p. 38)
• Examen de una tabla (p. 40)
Temas
• SQL (p. 36)
• DynamoDB (p. 37)
SQL
En SQL, se utiliza la instrucción SELECT para recuperar datos de una tabla. Puede solicitar una o varias
columnas en el resultado (o todas ellas, si se utiliza el operador *). La cláusula WHERE determina qué filas
se devolverán.
A continuación se muestra una instrucción SELECT que recupera una sola fila de la tabla Music. La
cláusula WHERE especifica los valores de la clave principal.
SELECT *
FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'
Puede modificar esta consulta para recuperar tan solo un subconjunto de las columnas:
DynamoDB
PartiQL
DynamoDB proporciona laExecuteStatementLa acción para recuperar un elemento por su clave
principal mediante la instrucción SELECT.
De forma predeterminada, GetItem devuelve el elemento completo con todos sus atributos.
{
TableName: "Music",
Key: {
"Artist": "No One You Know",
"SongTitle": "Call Me Today"
}
}
Puede agregar un parámetro ProjectionExpression para que solo se devuelvan algunos de los
atributos.
{
TableName: "Music",
Key: {
"Artist": "No One You Know",
"SongTitle": "Call Me Today"
},
"ProjectionExpression": "AlbumTitle, Year, Price"
}
DynamoDBGetItemla acción es muy eficiente: Utiliza los valores de clave principal para determinar la
ubicación de almacenamiento exacta del elemento en cuestión y lo recupera directamente desde ella. La
eficiencia de la instrucción SELECT de SQL es parecida para recuperar elementos por sus valores de clave
principal.
La instrucción SELECT de SQL puede llevar a cabo uniones de tablas para permitirle recuperar datos de
varias tablas al mismo tiempo. Las uniones son más eficaces cuando las tablas de base de datos están
normalizadas y las relaciones entre las tablas están claras. Sin embargo, si se unen demasiadas tablas en
una misma instrucción SELECT, el rendimiento de la aplicación podría verse afectado. Puede solucionar
este problema utilizando la replicación de bases de datos, las vistas materializadas o las reescrituras de
consultas.
DynamoDB es una base de datos no relacional que no admite uniones de tablas. Si va a migrar una
aplicación existente a partir de una base de datos relacional a DynamoDB, debe desnormalizar el modelo
de datos para eliminar la necesidad de uniones.
Note
Para obtener ejemplos de código en los que se utiliza GetItem, consulte Introducción a
DynamoDB yAWSSDK de (p. 82).
Temas
• SQL (p. 38)
• DynamoDB (p. 39)
SQL
La instrucción SELECT de SQL permite realizar consultas por columnas de clave, columnas que no son
de clave o cualquier combinación de ellas. La cláusula WHERE determina qué filas se devuelven, como se
muestra en los ejemplos siguientes.
/* Return all of the songs by an artist, with a particular word in the title...
...but only if the price is less than 1.00 */
DynamoDB
PartiQL
DynamoDB proporciona laExecuteStatementpara recuperar varios elementos mediante la instrucción
select.
Tenga en cuenta que esta declaración devolverá todos los elementos para el artista especificado.
Puede usar Query con cualquier tabla que tenga una clave principal compuesta (una clave de partición
y una clave de ordenación). Debe especificar una condición de igualdad para la clave de partición y, si lo
desea, puede proporcionar otra condición para la clave de ordenación.
El parámetro KeyConditionExpression especifica los valores de clave que se desea consultar. Puede
utilizar una expresión FilterExpression opcional para eliminar algunos elementos de los resultados
antes de que se devuelvan.
{
TableName: "Music",
KeyConditionExpression: "Artist = :a and SongTitle = :t",
ExpressionAttributeValues: {
":a": "No One You Know",
":t": "Call Me Today"
}
}
{
TableName: "Music",
KeyConditionExpression: "Artist = :a",
ExpressionAttributeValues: {
":a": "No One You Know"
}
}
{
TableName: "Music",
KeyConditionExpression: "Artist = :a and begins_with(SongTitle, :t)",
ExpressionAttributeValues: {
":a": "No One You Know",
":t": "Call"
}
}
Note
Para obtener ejemplos de código en los que se utiliza Query, consulte Introducción a DynamoDB
yAWSSDK de (p. 82).
Tanto si va a usar una base de datos SQL o NoSQL, los exámenes deben utilizarse con moderación, ya
que puede consumir gran cantidad de recursos del sistema. En ocasiones, un examen es lo apropiado (por
ejemplo, para examinar una tabla pequeña) o algo inevitable (por ejemplo, para realizar una exportación
masiva de datos). Sin embargo, por norma general, debe diseñar las aplicaciones de tal forma que se evite
la realización de exámenes.
Temas
• SQL (p. 40)
• DynamoDB (p. 41)
SQL
En SQL, puede examinar una tabla y recuperar todos sus datos utilizando una instrucción SELECT sin
especificar una cláusula WHERE. Puede solicitar una o más columnas en el resultado. O bien puede solicitar
todas ellas si utiliza el carácter comodín (*).
DynamoDB
PartiQL
DynamoDB proporciona laExecuteStatementpara devolver todo el contenido de una tabla mediante la
instrucción select.
Tenga en cuenta que esta declaración devolverá todos los elementos de la tabla Música.
La acción Scan proporciona además un parámetro FilterExpression, que se puede usar para
descartar elementos que no desee que aparezcan en los resultados. AFilterExpressionse aplica
después de que se realiza la exploración, pero antes de que se devuelvan los resultados. (Esto no se
recomienda en tablas de gran tamaño, Todavía se le cobrará por todo elScan, aunque solo se devuelvan
algunos elementos coincidentes).
Note
Para obtener ejemplos de código en los que se utiliza Scan, consulte Introducción a DynamoDB
yAWSSDK de (p. 82).
Administración de índices
Los índices permiten obtener acceso a patrones de consulta alternativos y agilizar las consultas. En esta
sección se compara y contrasta la creación y el uso de índices entre SQL y Amazon DynamoDB.
Tanto si está utilizando una base de datos relacional o DynamoDB, la creación de índices debe realizarse
con cautela. Cada vez que se produce una escritura en una tabla, es preciso actualizar todos los índices
de esa tabla. En un entorno con uso intensivo de escrituras y grandes tablas, esto puede consumir
gran cantidad de recursos del sistema. Esto no es motivo de preocupación en entornos de solo lectura
o principalmente de lectura. Sin embargo, hay que asegurarse de que la aplicación utilice los índices
realmente, de tal forma que estos no se limiten a consumir espacio.
Temas
• Creación de un índice (p. 42)
Creación de un índice
Compare laCREATE INDEXinstrucción en SQL con la instrucciónUpdateTableoperación en Amazon
DynamoDB.
Temas
• SQL (p. 42)
• DynamoDB (p. 42)
SQL
En las bases de datos relacionales, los índices son estructuras de datos que permiten realizar consultas
rápidas en diferentes columnas de una tabla. Puede usar la instrucción CREATE INDEX de SQL para
agregar un índice a una tabla existente y especificar las columnas que se van a indexar. Una vez que se
ha creado el índice, puede consultar los datos de la tabla como de costumbre, si bien ahora la base de
datos podrá utilizar el índice para encontrar rápidamente las filas especificadas de la tabla, en lugar de
tener que examinar la tabla completa.
Después de crear un índice, la base de datos lo mantiene automáticamente. Cada vez que se modifica
algún dato de la tabla, el índice se modifica automáticamente para reflejar los cambios de la tabla.
DynamoDB
En DynamoDB, puede crear y utilizar uníndice secundario secundariopara fines semejantes.
Los índices de DynamoDB son diferentes de sus homólogos relacionales. Al crear un índice secundario,
hay que especificar sus atributos de clave: una clave de partición y una clave de ordenación. Después
de crear el índice secundario, puedeQueryella oScanComo si se tratase de una mesa. DynamoDB no
tiene un optimizador de consultas, de modo que el índice secundario solo se utiliza cuando se utilizan las
operacionesQueryella oScanél.
• Los índices secundarios globales: la clave principal del índice puede constar de dos atributos
cualesquiera de la tabla a la que pertenece.
• Los índices secundarios locales: la clave de partición del índice debe ser igual que la clave de partición
de la tabla a la que pertenece. Sin embargo, la clave de ordenación puede ser cualquier otro atributo.
DynamoDB se asegura de que los datos de un índice secundario presenten consistencia final con la tabla
a la que pertenece. Puede solicitar una fuerte coherenciaQueryorScanAcciones en una tabla o un índice
secundario local. No obstante, los índices secundarios globales solo admiten la consistencia final.
{
TableName: "Music",
AttributeDefinitions:[
{AttributeName: "Genre", AttributeType: "S"},
Parte de esta operación implica reponer datos de la tabla en el nuevo índice. Durante la reposición, la
tabla permanece disponible. Sin embargo, el índice no está preparado hasta que el atributo Backfilling
cambia de true a false. Puede utilizar la acción DescribeTable para ver este atributo.
Note
Para obtener ejemplos de código en los que se utiliza UpdateTable, consulte Introducción a
DynamoDB yAWSSDK de (p. 82).
Temas
• SQL (p. 43)
• DynamoDB (p. 44)
SQL
En una base de datos relacional, no se trabajar directamente con los índices. En lugar de ello, se consultan
las tablas mediante instrucciones SELECT y el optimizador de consultas utiliza los índices, si los hay.
A continuación se muestran algunas instrucciones SQL en las que se puede utilizar GenreAndPriceIndex
para mejorar el rendimiento. Damos por hecho que la tabla Music contiene suficientes datos para que el
optimizador de consultas decida utilizar el índice en lugar de examinar la tabla completa.
DynamoDB
En DynamoDB, realizaQueryLas operaciones que consultan el índice directamente, exactamente igual que
se haría en una tabla. Debe especificar tanto TableName como IndexName.
{
TableName: "Music",
IndexName: "GenreAndPriceIndex",
KeyConditionExpression: "Genre = :genre",
ExpressionAttributeValues: {
":genre": "Rock"
},
};
{
TableName: "Music",
IndexName: "GenreAndPriceIndex",
KeyConditionExpression: "Genre = :genre and Price < :price",
ExpressionAttributeValues: {
":genre": "Country",
":price": 0.50
},
ProjectionExpression: "Artist, SongTitle, Price"
};
En este ejemplo se utiliza una expresión ProjectionExpression para indicar que solamente deseamos
que aparezcan en los resultados algunos de los atributos y no todos ellos.
También puede realizar la ejecución deScanEn un índice secundario, exactamente igual que se haría en
una tabla. A continuación se muestra un examen de GenreAndPriceIndex.
{
TableName: "Music",
IndexName: "GenreAndPriceIndex"
}
Temas
• SQL (p. 45)
• DynamoDB (p. 45)
SQL
En SQL, se utiliza la instrucción UPDATE para modificar una o varias filas. La cláusula SET especifica
los nuevos valores de una o varias columnas y la cláusula WHERE determina qué filas se modifican. A
continuación se muestra un ejemplo.
UPDATE Music
SET RecordLabel = 'Global Records'
WHERE Artist = 'No One You Know' AND SongTitle = 'Call Me Today';
Si no hay ninguna fila que coincida con la cláusula WHERE, la instrucción UPDATE no surte efecto.
DynamoDB
En DynamoDB, se utiliza la herramientaUpdateItempara modificar un solo elemento. Si desea modificar
varios elementos, debe utilizar varias operaciones UpdateItem.
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET RecordLabel = :label",
ExpressionAttributeValues: {
":label": "Global Records"
}
}
UpdateItem admite las escrituras condicionales, en las que la operación únicamente se lleva a cabo
correctamente si una expresión ConditionExpression determinada se evalúa en true. Por ejemplo,
la acción UpdateItem siguiente no lleva a cabo la actualización a no ser que el precio de la canción sea
mayor o igual que 2,00:
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET RecordLabel = :label",
ConditionExpression: "Price >= :p",
ExpressionAttributeValues: {
":label": "Global Records",
":p": 2.00
}
}
UpdateItem también admite los contadores atómicos, que son atributos del tipo Number que se pueden
incrementar o reducir. Los contadores atómicos se parecen en muchos aspectos a los generadores de
secuencia, las columnas de identidad o los campos de incremento automático de las bases de datos SQL.
A continuación se muestra un ejemplo de acción UpdateItem utilizada para inicializar un nuevo atributo
(Plays) que permite realizar el seguimiento del número de veces que se ha reproducido una canción.
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET Plays = :val",
ExpressionAttributeValues: {
":val": 0
},
ReturnValues: "UPDATED_NEW"
}
El parámetro ReturnValues se establece en UPDATED_NEW, que devuelve los nuevos valores de todos
los atributos que se han actualizado. En este caso, devuelve 0 (cero).
Cada vez que alguien reproduce esta canción, podemos usar la acción UpdateItem para incrementar
Plays en una unidad.
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET Plays = Plays + :incr",
ExpressionAttributeValues: {
":incr": 1
},
ReturnValues: "UPDATED_NEW"
}
Note
Para obtener ejemplos de código en los que se utiliza UpdateItem, consulte Introducción a
DynamoDB yAWSSDK de (p. 82).
Temas
• SQL (p. 47)
• DynamoDB (p. 47)
SQL
En SQL, se utiliza la instrucción DELETE para eliminar una o varias filas. La cláusula WHERE determina qué
filas se van a modificar. A continuación se muestra un ejemplo.
Puede modificar la cláusula WHERE para eliminar varias filas. Por ejemplo, puede eliminar todas las
canciones de un determinado intérprete, como se muestra en el siguiente ejemplo.
Note
Si omite la cláusula WHERE, la base de datos intentará eliminar todas las filas de la tabla.
DynamoDB
En DynamoDB, se utiliza la herramientaDeleteItemPara eliminar datos de una tabla, de elemento en
elemento. Debe especificar los valores de clave principal del elemento.
{
TableName: "Music",
Key: {
Artist: "The Acme Band",
SongTitle: "Look Out, World"
}
}
Note
DeleteItem admite las escrituras condicionales, en las que la operación únicamente se lleva a cabo
correctamente si una expresión ConditionExpression determinada se evalúa en true. Por ejemplo, la
acción DeleteItem siguiente elimina un elemento únicamente si tiene el atributo RecordLabel.
{
TableName: "Music",
Key: {
Artist: "The Acme Band",
SongTitle: "Look Out, World"
},
ConditionExpression: "attribute_exists(RecordLabel)"
}
Note
Para obtener ejemplos de código en los que se utiliza DeleteItem, consulte Introducción a
DynamoDB yAWSSDK de (p. 82).
Temas
• SQL (p. 48)
• DynamoDB (p. 48)
SQL
Cuando ya no necesita una tabla y se desea descartarla de forma permanente, se utiliza la instrucción
DROP TABLE de SQL.
Después de eliminar una tabla, ya no se puede recuperar. En algunas bases de datos relacionales se
permite deshacer una operación DROP TABLE, pero se trata de una funcionalidad específica del proveedor
que no se implementa de manera generalizada.
DynamoDB
DynamoDB posee una acción parecida, DeleteTable. En el siguiente ejemplo, se elimina la tabla de
forma permanente.
{
TableName: "Music"
}
Note
Para obtener ejemplos de código en los que se utiliza DeleteTable, consulte Introducción a
DynamoDB yAWSSDK de (p. 82).
• De la base de datos relacional a una sola tabla de DynamoDB: Una exploración paso a paso— Un post
en profundidad deForrest Brasileñoque incluye un enfoque paso a paso para pasar a un diseño de una
mesa estilo DynamoDB.
Note
Configuración de DynamoDB
Además del servicio web de Amazon DynamoDB,AWSproporciona una versión descargable de DynamoDB
que se puede ejecutar en el equipo y es perfecta para el desarrollo y las pruebas de su código. La versión
descargable le permite crear y probar aplicaciones localmente sin obtener acceso al servicio web de
DynamoDB.
En los temas de esta sección se describe cómo configurar DynamoDB (versión descargable) y el servicio
web de DynamoDB.
Temas
• Configuración de DynamoDB Local (versión descargable) (p. 50)
• Configuración de DynamoDB (servicio web) (p. 57)
Disponer de esta versión local supone un ahorro en cuanto a rendimiento, almacenamiento de datos y
tarifas de transferencia de datos. Además, no es necesario disponer de una conexión a Internet mientras
se desarrolla la aplicación.
DynamoDB Local está disponible como descarga (requiere JRE), como una dependencia de Apache
Maven o como imagen de Docker.
Temas
• Implementación de DynamoDB localmente en el equipo (p. 50)
• Notas de uso local de DynamoDB (p. 54)
DynamoDB también está disponible como parte deAWS Toolkit for Eclipse. Para obtener más
información, consulte AWS Toolkit for Eclipse.
Important
Note
Puede utilizar el comando aws configure de la AWS CLI para configurar las credenciales. Para
obtener más información, consulte Mediante AWS CLI (p. 62).
5. Comience a escribir aplicaciones. Para acceder a DynamoDB que se ejecuta localmente con
elAWS CLI, use la--endpoint-urlParámetro. Por ejemplo, utilice el siguiente comando para
enumerar las tablas de DynamoDB.
Docker
Para obtener un ejemplo del uso de DynamoDB local como parte de una aplicación REST construida
en la pestañaAWS Serverless Application Model(AWS SAM), consulteAplicación SAM DynamoDB
para administrar pedidos. Esta aplicación de ejemplo demuestra cómo utilizar DynamoDB local para
pruebas.
Si desea ejecutar una aplicación multicontenedor que también utilice el contenedor local de
DynamoDB, utilice Docker Compose para definir y ejecutar todos los servicios de la aplicación,
incluido DynamoDB local.
version: '3.8'
services:
dynamodb-local:
command: "-jar DynamoDBLocal.jar -sharedDb -optimizeDbBeforeStartup -dbPath ./
data"
image: "amazon/dynamodb-local:latest"
container_name: dynamodb-local
ports:
- "8000:8000"
volumes:
- "./docker/dynamodb:/home/dynamodblocal/data"
working_dir: /home/dynamodblocal
version: '3.8'
services:
dynamodb-local:
command: "-jar DynamoDBLocal.jar -sharedDb -optimizeDbBeforeStartup -dbPath ./
data"
image: "amazon/dynamodb-local:latest"
container_name: dynamodb-local
ports:
- "8000:8000"
volumes:
- "./docker/dynamodb:/home/dynamodblocal/data"
working_dir: /home/dynamodblocal
app-node:
depends_on:
- dynamodb-local
image: banst/awscli
container_name: app-node
ports:
- "8080:8080"
environment:
AWS_ACCESS_KEY_ID: 'DUMMYIDEXAMPLE'
AWS_SECRET_ACCESS_KEY: 'DUMMYEXAMPLEKEY'
command:
dynamodb describe-limits --endpoint-url http://dynamodb-local:8000 --region
us-west-2
Para utilizar con su propia imagen de aplicación, reemplace laimageEn el ejemplo siguiente con
el de su aplicación.
version: '3.8'
services:
dynamodb-local:
command: "-jar DynamoDBLocal.jar -sharedDb -optimizeDbBeforeStartup -dbPath ./
data"
image: "amazon/dynamodb-local:latest"
container_name: dynamodb-local
ports:
- "8000:8000"
volumes:
- "./docker/dynamodb:/home/dynamodblocal/data"
working_dir: /home/dynamodblocal
app-node:
image: location-of-your-dynamodb-demo-app:latest
container_name: app-node
ports:
- "8080:8080"
depends_on:
- "dynamodb-local"
links:
- "dynamodb-local"
environment:
AWS_ACCESS_KEY_ID: 'DUMMYIDEXAMPLE'
AWS_SECRET_ACCESS_KEY: 'DUMMYEXAMPLEKEY'
REGION: 'eu-west-1'
Note
docker-compose up
Apache Maven
Siga estos pasos para utilizar Amazon DynamoDB en su aplicación como dependencia.
1. Descargue e instale Apache Maven. Para obtener más información, consulte Downloading
Apache Maven e Installing Apache Maven.
2. Agregue el repositorio de DynamoDB Maven al archivo POM (Project Object Model) de la
aplicación.
<!--Dependency:-->
<dependencies>
<dependency>
<groupId>com.amazonaws</groupId>
<artifactId>DynamoDBLocal</artifactId>
<version>[1.12,2.0)</version>
</dependency>
</dependencies>
<!--Custom repository:-->
<repositories>
<repository>
<id>dynamodb-local-oregon</id>
<name>DynamoDB Local Release Repository</name>
<url>https://s3-us-west-2.amazonaws.com/dynamodb-local/release</url>
</repository>
</repositories>
Note
También puede usar una de las direcciones URL de repositorio siguientes, según cuál
sea suAWSRegión .
id Repository URL
dynamodb-local-mumbai https://s3.ap-south-1.amazonaws.com/
dynamodb-local-mumbai/release
dynamodb-local-singapur https://s3.ap-
southeast-1.amazonaws.com/dynamodb-
local-singapore/release
dynamodb-local-tokyo https://s3.ap-northeast-1.amazonaws.com/
dynamodb-local-tokyo/release
dynamodb-local-frankfurt https://s3.eu-central-1.amazonaws.com/
dynamodb-local-frankfurt/release
dynamodb-local-sao-paulo https://s3.sa-east-1.amazonaws.com/
dynamodb-local-sao-paulo/release
Temas
• Opciones de la línea de comandos (p. 55)
• Configuración del punto de enlace local (p. 56)
• Diferencias entre DynamoDB descargable y el servicio web de DynamoDB (p. 56)
• -cors value: habilita la compatibilidad con el uso compartido de recursos entre orígenes (CORS, por
sus siglas en inglés) para JavaScript. Debe proporcionar una lista de dominios específicos "permitidos"
separados por comas. El ajuste predeterminado para -cors es el asterisco (*), que permite el acceso
público.
• -dbPath value: directorio donde DynamoDB escribe el archivo de base de datos. Si no especifica esta
opción, el archivo se escribe en el directorio actual. Puede especificar tanto -dbPath como -inMemory
a la vez.
• -delayTransientStatuses: hace que DynamoDB introduzca retardos para algunas operaciones.
DynamoDB (versión descargable) puede realizar algunas tareas casi instantáneamente, como
operaciones de creación, actualización y eliminación en tablas e índices. Sin embargo, el servicio
DynamoDB requiere más tiempo para estas tareas. El establecimiento de este parámetro ayuda a que
DynamoDB ejecutándose en su equipo simule mejor el comportamiento del servicio web de DynamoDB.
En la actualidad, este parámetro introduce retardos solo para los índices secundarios globales que se
encuentran en el estado CREATING o DELETING.
• -help: imprime un resumen de uso y las opciones posibles.
• -inMemory: DynamoDB se ejecuta en memoria, en lugar de usar un archivo de base de datos. Cuando
se detenga DynamoDB, no se guardará ninguno de los datos. Puede especificar tanto -dbPath como -
inMemory a la vez.
• -optimizeDbBeforeStartup: optimiza las tablas de la base de datos subyacente antes de iniciar
DynamoDB en el equipo. Si utiliza este parámetro, también debe especificar -dbPath.
• -port value: número de puerto que DynamoDB utiliza para comunicarse con la aplicación. Si no
especifica esta opción, el puerto predeterminado es 8000.
Note
http://localhost:8000
Note
LaAWS CLINo puede usar la versión descargable de DynamoDB como punto de enlace
predeterminado. Por lo tanto, debe especificar --endpoint-url con cada comando de la AWS
CLI.
SDK de AWS
La forma de especificar un punto de enlace depende del lenguaje de programación y del lenguaje de
programación.AWSSDK que utiliza. En las secciones siguientes se describe cómo hacerlo:
• Java: Configuración deAWSRegión y punto de enlace (p. 340)(DynamoDB Local admiteAWSSDK for
Java V1 y V2)
• .NET: Configuración deAWSRegión y punto de enlace (p. 342)
Note
Si planea interactuar con DynamoDB solo a través deAWS Management Console, no necesita
unAWSclave de acceso, y puede pasar directamente aMediante la consola (p. 60).
3. Configuración de sus credenciales (p. 59)(utilizado para obtener acceso a DynamoDB mediante
programación).
Inscripción en AWS
Para utilizar el servicio DynamoDB, debe disponer deAWSaccount. Si aún no tiene una, se le pedirá que
la cree cuando se inscriba. No se le cobrará por ningunaAWSServicios en los que se inscriba, salvo si los
utiliza.
1. Abra https://portal.aws.amazon.com/billing/signup.
2. Siga las instrucciones en línea.
Parte del procedimiento de inscripción consiste en recibir una llamada telefónica e indicar un código de
verificación en el teclado del teléfono.
Las claves de acceso constan de un ID de clave de acceso y una clave de acceso secreta, que se utilizan
para firmar las solicitudes que se realizan aAWS. Si no tiene claves de acceso, puede crearlas desde la
ventana deAWS Management Console. Como práctica recomendada, no utilice laAWSPara cualquier tarea
en la que no sea necesario usarlo. Instead, Crear un nuevo usuario de IAMcon claves de acceso para
usted.
La única vez que puede ver o descargar la clave de acceso secreta es cuando crea las claves. No puede
recuperarlas más adelante. Sin embargo, puede crear nuevas claves de acceso en cualquier momento.
También debe tener permisos para realizar las acciones de IAM requeridas. Para obtener más información,
consultePermisos obligatorios para obtener acceso a recursos de IAMen laGuía del usuario de IAM.
Mantenga la confidencialidad de las claves para proteger suAWScuenta y no las envíe nunca por
correo electrónico. No las comparta fuera de su organización, aunque reciba una petición que parezca
provenir de AWS o Amazon.com. Nadie que represente legítimamente a Amazon le pedirá nunca su
clave secreta.
7. Después de descargar el.csv, elijaClose. Cuando cree una clave de acceso, el par de claves se
activa de forma predeterminada, y puede utilizar el par de inmediato.
Temas relacionados
Puede hacer esto de varias formas. Por ejemplo, puede crear manualmente el archivo de credenciales
para almacenar el ID de clave de acceso y la clave de acceso secreta. También puede utilizar el comando
aws configure de la AWS CLI para crear automáticamente el archivo. Otra opción consiste en usar
variables de entorno. Para obtener más información sobre cómo configurar sus credenciales, consulte
laAWSguía para desarrolladores de SDK.
Para instalar y configurar la AWS CLI, consulte Mediante AWS CLI (p. 62).
Acceso a DynamoDB
Puede obtener acceso a Amazon DynamoDB mediante laAWS Management Console, elAWS Command
Line Interface(AWS CLI) o la API de DynamoDB.
Temas
• Mediante la consola (p. 60)
• Mediante AWS CLI (p. 62)
• Uso de la API (p. 64)
• Uso de NoSQL Workbench para DynamoDB (p. 64)
• Rangos de direcciones IP (p. 64)
Mediante la consola
Puede obtener acceso a laAWS Management Consolepara Amazon DynamoDB enhttps://
console.aws.amazon.com/dynamodb/home.
• Monitorizar las alertas recientes, la capacidad total, el estado del servicio y las últimas noticias de
DynamoDB en el panel de DynamoDB.
• Crear, actualizar y eliminar tablas. La calculadora de capacidad ofrece cálculos aproximados de cuántas
unidades de capacidad debe solicitar en función de la información de uso que proporcione.
• Administrar secuencias.
• Ver, añadir, actualizar y eliminar los elementos almacenados en las tablas. Administrar el tiempo de vida
(TTL) para definir cuándo vencen los elementos de una tabla y eliminarlos automáticamente de la base
de datos.
• Consultar y examinar una tabla.
• Configurar y ver alarmas para monitorizar el uso de la capacidad de la tabla. Ver las principales métricas
de monitorización de la tabla en gráficos de CloudWatch en tiempo real.
• Modificar la capacidad provisionada de una tabla.
• Crear y eliminar índices secundarios globales.
• Crear disparadores para conectar las secuencias de DynamoDB conAWS LambdaFunciones de .
• Aplicar etiquetas a los recursos para organizarlos e identificarlos mejor.
• Adquirir capacidad reservada.
La consola muestra una pantalla de introducción que le pide que cree la primera tabla. Para ver las tablas,
elija Tables (Tablas) en el panel de navegación del lado izquierdo de la consola.
A continuación encontrará información general sobre las acciones disponibles para las tablas en cada
pestaña de navegación:
Puede seguir cambiando los distintos ajustes de configuración en las páginas de la consola sin tener
preferencias de usuario almacenadas. Estas opciones se mantendrán hasta que cierre la ventana de la
consola. Al volver a la consola, se aplicarán todas las preferencias del usuario que se hayan guardado.
Note
Las preferencias de usuario solo están disponibles para los usuarios de IAM. No puede
configurarlas si usa acceso federado, acceso temporal o unAWSusuario raíz de la cuenta para
acceder a la consola.
• Modo de vista de detalles de la tabla: Ver toda la información específica de la tabla verticalmente,
horizontalmente o a pantalla completa (la barra de navegación se seguirá mostrando si se ha habilitado).
• Mostrar barra de navegación: Active esta opción para mostrar la barra de navegación en el lado
izquierdo (expandido). Deshabilítela para contraer automáticamente la barra de navegación (puede
expandirla con el cheurón derecho).
• Default entry page (Panel o Tablas) [Página de entradas predeterminada Elija la página que se carga
cuando obtiene acceso a DynamoDB. Esta opción carga automáticamente la página Panel o Tablas,
respectivamente.
• Modo de editor de elementos (árbol o texto): Elija el modo de editor predeterminado que se va a usar al
crear o editar un elemento.
• Tipo de consulta predeterminado de elementos (Escaneo o Consulta): Elija el tipo de consulta
predeterminado que se usa al obtener acceso a laElementos. Elija Scan (Analizar) si desea habilitar o
deshabilitar la operación de análisis automático que se produce al obtener acceso a la pestaña Items
(Elementos).
• Operación de exploración automática al acceder a la pestaña de elementos: SiScanEl tipo de consulta
predeterminado para los elementos y habilita esta configuración, se realiza una operación de análisis
automático cuando obtiene acceso a laElementos. Si deshabilita esta configuración, puede realizar un
análisis eligiendo Start search (Iniciar búsqueda) en la pestaña Items (Elementos).
Para ver y guardar las preferencias en la consola de DynamoDB para el usuario de IAM
Inicie sesión como usuario de IAM. No puede configurar las preferencias del usuario para otros tipos
de usuario.
2. En la navegación de la página, elijaPreferencias.
3. En Preferences (Preferencias), configure sus preferencias.
Para poder utilizar laAWS CLICon DynamoDB, debe obtener un ID de clave de acceso y una clave de
acceso secreta. Para obtener más información, consulte Obtención deAWSClave de acceso (p. 58).
Para obtener un listado completo de todos los comandos disponibles para DynamoDB en laAWS CLI,
consulte laAWS CLIReferencia de los comandos de la.
Temas
• Descarga y configuración de la AWS CLI (p. 62)
• Mediante laAWS CLIcon DynamoDB (p. 63)
• Mediante laAWS CLIcon DynamoDB descargable (p. 64)
Por ejemplo, el comando siguiente crea una tabla llamada Music. La clave de partición es Artist y la de
ordenación, SongTitle. Para facilitar la legibilidad, los comandos largos de esta sección se dividen en
líneas separadas.
Los comandos siguientes añaden nuevos elementos a la tabla. En estos ejemplos se usa una combinación
de sintaxis abreviada y JSON.
Puede ser difícil crear código JSON válido en la línea de comandos. Sin embargo, la AWS CLI puede leer
archivos JSON. Por ejemplo, fíjese en el fragmento de código JSON siguiente, que se almacena en un
archivo denominado key-conditions.json.
{
"Artist": {
"AttributeValueList": [
{
"S": "No One You Know"
}
],
"ComparisonOperator": "EQ"
},
"SongTitle": {
"AttributeValueList": [
{
"S": "Call Me Today"
}
],
"ComparisonOperator": "EQ"
}
}
Ahora puede emitir una solicitud de Query con la AWS CLI. En este ejemplo, el contenido del archivo key-
conditions.json se usa para el parámetro --key-conditions.
--endpoint-url http://localhost:8000
En e siguiente ejemplo se usa la AWS CLI para mostrar las tablas de una base de datos local:
Si DynamoDB utiliza un número de puerto distinto del predeterminado (8000), modifique la--endpoint-
urlen consecuencia.
Note
LaAWS CLIno puede utilizar la versión descargable de DynamoDB como punto de enlace
predeterminado. Por lo tanto, debe especificar --endpoint-url con cada comando.
Uso de la API
Puede utilizar laAWS Management Consoley laAWS Command Line Interfacepara trabajar de forma
interactiva con Amazon DynamoDB. Sin embargo, para sacar el máximo partido de DynamoDB, puede
escribir el código de aplicación mediante laAWSSDK de.
Para poder utilizar laAWSSDK con DynamoDB, debe obtener unAWSID de clave de acceso y clave
de acceso secreta. Para obtener más información, consulte Configuración de DynamoDB (servicio
web) (p. 57).
Para obtener información general sobre la programación de aplicaciones de DynamoDB con laAWSSDK
de, consulteProgramación con DynamoDB y elAWSSDK de (p. 214).
Rangos de direcciones IP
Amazon Web Services (AWS) publica sus rangos de direcciones IP actuales en formato JSON. Para ver
los rangos actuales, descargue ip-ranges.json. Para obtener más información, consulteAWSRangos de
direcciones IPen laAWSReferencia general de.
Para conocer los rangos de direcciones IP que se pueden utilizar para acceder a tablas e índices de
DynamoDB, busque la siguiente cadena en el archivo ip-ranges.json: "service": "DYNAMODB".
Note
Introducción a DynamoDB
Utilice los tutoriales prácticos de esta sección para ayudarle a empezar a utilizar y obtener más información
sobre Amazon DynamoDB.
Temas
• Conceptos básicos de DynamoDB (p. 66)
• Requisitos previos - Tutorial de introducción (p. 66)
• Paso 1: Crear una tabla (p. 66)
• Paso 2: Escribir datos en una tabla mediante la consola o la.AWS CLI (p. 69)
• Paso 3: Lectura de datos de una tabla (p. 71)
• Paso 4: Actualización de datos de una tabla (p. 72)
• Paso 5: Consulta de los datos de una tabla (p. 74)
• Paso 6: Creación de un índice secundario global (p. 76)
• Paso 7: Consulta del índice secundario global (p. 79)
• Paso 8: (Opcional) Limpieza de recursos (p. 80)
• Introducción a DynamoDB: Pasos siguientes (p. 81)
A continuación, siga por elRequisitos previospara obtener más información sobre la configuración de
DynamoDB.
• Si planea interactuar con DynamoDB solo a través delAWS Management Console, no necesita
unAWSClave de acceso de . Realice los pasos deInscripción enAWSA continuación, siga por
elPaso 1: Crear una tabla (p. 66).
• Si no desea registrarse para obtener una cuenta de la capa gratuita, puede configurar
DynamoDB Local (versión descargable). A continuación, siga por el Paso 1: Crear una
tabla (p. 66).
• Clave de partición:Artist
• Clave de ordenación:SongTitle
Para obtener más información sobre las operaciones con tablas, consulte Uso de tablas y datos en
DynamoDB (p. 344).
Note
Antes de comenzar, asegúrese de que ha realizado los pasos que se detallan en Requisitos
previos - Tutorial de introducción (p. 66).
AWS CLI
En el siguiente ejemplo de la AWS CLI, se crea una tabla denominada Music con create-table.
{
"TableDescription": {
"TableArn": "arn:aws:dynamodb:us-west-2:522194210714:table/Music",
"AttributeDefinitions": [
{
"AttributeName": "Artist",
"AttributeType": "S"
},
{
"AttributeName": "SongTitle",
"AttributeType": "S"
}
],
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"WriteCapacityUnits": 5,
"ReadCapacityUnits": 10
},
"TableSizeBytes": 0,
"TableName": "Music",
"TableStatus": "CREATING",
"TableId": "d04c7240-0e46-435d-b231-d54091fe1017",
"KeySchema": [
{
"KeyType": "HASH",
"AttributeName": "Artist"
},
{
"KeyType": "RANGE",
"AttributeName": "SongTitle"
}
],
"ItemCount": 0,
"CreationDateTime": 1558028402.69
}
}
Este comando devuelve el siguiente resultado. Cuando DynamoDB termina de crear la tabla, el valor de
la.TableStatusEl campo está establecido enACTIVE.
"TableStatus": "ACTIVE",
Después de crear la tabla, continúe en el Paso 2: Escribir datos en una tabla mediante la consola o la.AWS
CLI (p. 69).
Para obtener más información sobre las operaciones de escritura, consulte Escritura de un
elemento (p. 411).
8. Repita este proceso para crear un campo denominado AlbumTitle de tipo String (Cadena).
9. Elija los valores siguientes para el elemento:
11. Repita este proceso y cree otro elemento con los valores siguientes:
AWS CLI
En el siguiente ejemplo de la AWS CLI crea dos elementos en la tabla Music utilizando put-item.
Para obtener más información sobre los tipos de datos admitidos en DynamoDB, consulte.Tipos de datos.
Para obtener más información sobre cómo representar los tipos de datos de DynamoDB en JSON,
consulte.Valores de los atributos.
Después de escribir los datos en la tabla, continúe en el Paso 3: Lectura de datos de una tabla (p. 71).
Para obtener más información sobre las operaciones de lectura en DynamoDB, consulte.Lectura de un
elemento (p. 411).
El primer elemento de la lista es el que tiene la.Artist Banda Acmey laSongTitle Día feliz.
AWS CLI
En el siguiente ejemplo de la AWS CLI, se lee un elemento de la tabla Music utilizando get-item.
Note
{
"Item": {
"AlbumTitle": {
"S": "Songs About Life"
},
"Awards": {
"N": "10"
},
"SongTitle": {
"S": "Happy Day"
},
"Artist": {
"S": "Acme Band"
}
}
}
Para actualizar los datos de la tabla, continúe en el Paso 4: Actualización de datos de una tabla (p. 72).
Para obtener más información sobre las operaciones de escritura, consulte Escritura de un
elemento (p. 411).
AWS CLI
En el siguiente ejemplo de la AWS CLI, se actualiza un elemento de la tabla Music utilizando update-
item.
{
"Attributes": {
"AlbumTitle": {
"S": "Updated Album Title"
},
"Awards": {
"N": "10"
},
"SongTitle": {
"S": "Happy Day"
},
"Artist": {
"S": "Acme Band"
}
}
}
Para consultar los datos de la tabla Music, continúe en el Paso 5: Consulta de los datos de una
tabla (p. 74).
Para obtener más información sobre las operaciones de consulta, consulte Uso de consultas en
DynamoDB (p. 497).
6. En Partition key (Clave de partición), escriba Acme Band y, a continuación, elija Start search (Iniciar
búsqueda).
AWS CLI
En el siguiente ejemplo de la AWS CLI, se consulta un elemento de la tabla Music utilizando query.
{
"Count": 1,
"Items": [
{
"AlbumTitle": {
"S": "Updated Album Title"
},
"Awards": {
"N": "10"
},
"SongTitle": {
"S": "Happy Day"
},
"Artist": {
"S": "Acme Band"
}
}
],
"ScannedCount": 1,
"ConsumedCapacity": null
}
Para crear un índice secundario global para la tabla, continúe en el Paso 6: Creación de un índice
secundario global (p. 76).
Para obtener más información sobre los índices secundarios globales, consulte Uso de índices
secundarios en DynamoDB (p. 570).
6. En Partition key (Clave de partición), escriba AlbumTitle y, a continuación, elija Create index (Crear
índice).
AWS CLI
En el siguiente ejemplo de la AWS CLI, se crea un índice secundario global AlbumTitle-index para la
tabla Music utilizando update-table.
{
"TableDescription": {
"TableArn": "arn:aws:dynamodb:us-west-2:522194210714:table/Music",
"AttributeDefinitions": [
{
"AttributeName": "AlbumTitle",
"AttributeType": "S"
},
{
"AttributeName": "Artist",
"AttributeType": "S"
},
{
"AttributeName": "SongTitle",
"AttributeType": "S"
}
],
"GlobalSecondaryIndexes": [
{
"IndexSizeBytes": 0,
"IndexName": "AlbumTitle-index",
"Projection": {
"ProjectionType": "ALL"
},
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"WriteCapacityUnits": 5,
"ReadCapacityUnits": 10
},
"IndexStatus": "CREATING",
"Backfilling": false,
"KeySchema": [
{
"KeyType": "HASH",
"AttributeName": "AlbumTitle"
}
],
"IndexArn": "arn:aws:dynamodb:us-west-2:522194210714:table/Music/index/
AlbumTitle-index",
"ItemCount": 0
}
],
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"WriteCapacityUnits": 5,
"ReadCapacityUnits": 10
},
"TableSizeBytes": 0,
"TableName": "Music",
"TableStatus": "UPDATING",
"TableId": "d04c7240-0e46-435d-b231-d54091fe1017",
"KeySchema": [
{
"KeyType": "HASH",
"AttributeName": "Artist"
},
{
"KeyType": "RANGE",
"AttributeName": "SongTitle"
}
],
"ItemCount": 0,
"CreationDateTime": 1558028402.69
}
}
Este comando devuelve el siguiente resultado. El índice está listo para su uso cuando el valor del campo
IndexStatus devuelto se establece en ACTIVE.
"IndexStatus": "ACTIVE",
A continuación, puede consultar el índice secundario global. Para obtener más información, consulte Paso
7: Consulta del índice secundario global (p. 79).
Para obtener más información sobre los índices secundarios globales, consulte Uso de índices
secundarios en DynamoDB (p. 570).
6. En la lista desplegable situada junto aConsulta, elija[Index] Índice del título del álbum: AlbumTitle.
En AlbumTitle, escriba Somewhat Famous y, a continuación, elija Start search (Iniciar búsqueda).
AWS CLI
En el siguiente ejemplo de la AWS CLI, se consulta el índice secundario global AlbumTitle-index de la
tabla Music.
{
"Count": 1,
"Items": [
{
"AlbumTitle": {
"S": "Somewhat Famous"
},
"Awards": {
"N": "1"
},
"SongTitle": {
"S": "Call Me Today"
},
"Artist": {
"S": "No One You Know"
}
}
],
"ScannedCount": 1,
"ConsumedCapacity": null
}
Para obtener más información sobre las operaciones con tablas en DynamoDB, consulte.Uso de tablas y
datos en DynamoDB (p. 344).
AWS CLI
En el siguiente ejemplo de la AWS CLI, se elimina la tabla Music utilizando delete-table.
Los SDK de AWS están disponibles en una amplia variedad de idiomas. Para obtener una lista
completa, consulte Herramientas para Amazon Web Services.
Temas
• Introducción a Java y DynamoDB (p. 82)
• Introducción a JavaScript y DynamoDB (p. 102)
• Introducción a Node.js y DynamoDB (p. 124)
• Introducción a .NET y DynamoDB (p. 142)
• PHP y DynamoDB (p. 159)
• Introducción al desarrollo con Python y DynamoDB (p. 180)
• Ruby y DynamoDB (p. 194)
• Crear una tabla denominada Movies y cargar ejemplos de datos en formato JSON.
• Realizar operaciones de creación, lectura, actualización y eliminación en la tabla.
• Ejecutar consultas sencillas.
El SDK for Java ofrece varios modelos de programación para diferentes casos de uso. En este ejercicio, en
el código Java se utiliza el modelo de documento, que proporciona un nivel de abstracción que facilita el
trabajo con documentos JSON.
Mientras realiza este tutorial, puede consultar laAWS SDK for JavaDocumentación de.
DynamoDB descargable) también está disponible como parte deAWS Toolkit for Eclipse. Para obtener
más información, consulte AWS Toolkit for Eclipse.
Note
• Configurar unAWSpara utilizar la clave de accesoAWSSDK. Para obtener más información, consulte
Configuración de DynamoDB (servicio web) (p. 57).
• Configurar la AWS SDK for Java:
• Instale un entorno de desarrollo de Java. Si utiliza el IDE de Eclipse, instale AWS Toolkit for Eclipse.
• Instale la AWS SDK for Java.
• Configurar elAWSLas credenciales de seguridad para usarlas con el SDK for Java.
Para obtener instrucciones, consulteIntroducciónen laAWS SDK for JavaGuía para desarrolladores.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.gsg;
import java.util.Arrays;
import com.amazonaws.client.builder.AwsClientBuilder;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.services.dynamodbv2.model.ScalarAttributeType;
.build();
try {
System.out.println("Attempting to create table; please wait...");
Table table = dynamoDB.createTable(tableName,
Arrays.asList(new KeySchemaElement("year", KeyType.HASH), // Partition
// key
new KeySchemaElement("title", KeyType.RANGE)), // Sort key
Arrays.asList(new AttributeDefinition("year", ScalarAttributeType.N),
new AttributeDefinition("title", ScalarAttributeType.S)),
new ProvisionedThroughput(10L, 10L));
table.waitForActive();
System.out.println("Success. Table status: " +
table.getDescription().getTableStatus());
}
catch (Exception e) {
System.err.println("Unable to create table: ");
System.err.println(e.getMessage());
}
}
}
Note
• El punto de enlace debe configurarse de modo que indique que está creando la tabla en
DynamoDB en el equipo.
• En la llamada createTable, especifique el nombre de la tabla, los atributos de clave
principal y los tipos de datos.
• LaProvisionedThroughputEl parámetro es obligatorio; sin embargo, en la versión
descargable de DynamoDB se hace caso omiso de él. El desempeño provisionado está
fuera del alcance de este ejercicio.
2. Compile y ejecute el programa.
Para obtener más información sobre cómo administrar tablas, consulte Uso de tablas y datos en
DynamoDB (p. 344).
Temas
• Paso 2.1: Descargue el archivo de datos (p. 85)
• Paso 2.2: Cargue los ejemplos de datos en la tabla Movies (p. 86)
En este escenario se utiliza un ejemplo de archivo de datos que contiene información sobre varios miles de
películas de IMDb (Internet Movie Database). Los datos de las películas se encuentran en formato JSON,
tal y como se muestra en el siguiente ejemplo. Para cada película, se indican el año, year, el título, title
y un mapa JSON denominado info.
[
{
"year" : ... ,
"title" : ... ,
"info" : { ... }
},
{
"year" : ...,
"title" : ...,
"info" : { ... }
},
...
• year y title se utilizan como valores de atributos de clave principal de la tabla Movies.
• El resto de los valores info se almacenan en un único atributo denominado info. Este programa ilustra
cómo almacenar JSON en un atributo de Amazon DynamoDB.
{
"year" : 2013,
"title" : "Turn It Down, Or Else!",
"info" : {
"directors" : [
"Alice Smith",
"Bob Jones"
],
"release_date" : "2013-01-18T00:00:00Z",
"rating" : 6.2,
"genres" : [
"Comedy",
"Drama"
],
"image_url" : "http://ia.media-imdb.com/images/N/
O9ERWAU7FS797AJ7LU8HN09AMUP908RLlo5JF90EWR7LJKQ7@@._V1_SX400_.jpg",
"plot" : "A rock band plays their music at high volumes, annoying the neighbors.",
"rank" : 11,
"running_time_secs" : 5215,
"actors" : [
"David Matthewman",
"Ann Thomas",
"Jonathan G. Neff"
]
}
}
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.gsg;
import java.io.File;
import java.util.Iterator;
import com.amazonaws.client.builder.AwsClientBuilder;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
ObjectNode currentNode;
while (iter.hasNext()) {
currentNode = (ObjectNode) iter.next();
try {
table.putItem(new Item().withPrimaryKey("year", year, "title",
title).withJSON("info",
currentNode.path("info").toString()));
System.out.println("PutItem succeeded: " + year + " " + title);
}
catch (Exception e) {
System.err.println("Unable to add movie: " + year + " " + title);
System.err.println(e.getMessage());
break;
}
}
parser.close();
}
}
Este programa utiliza la biblioteca Jackson de código abierto para procesar JSON. Jackson se incluye
en el AWS SDK for Java. No es necesario instalarla por separado.
2. Compile y ejecute el programa.
Para obtener más información sobre cómo leer y escribir datos, consulte Uso de elementos y
atributos (p. 410).
Temas
• Paso 3.1: Creación de un elemento nuevo (p. 87)
• Paso 3.2: Lea un elemento (p. 89)
• Paso 3.3: Actualización de un elemento (p. 90)
• Paso 3.4: Incremento de un contador atómico (p. 92)
• Paso 3.5: Actualización de un elemento (condicionalmente) (p. 93)
• Paso 3.6: Eliminación de un elemento (p. 94)
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.gsg;
import java.util.HashMap;
import java.util.Map;
import com.amazonaws.client.builder.AwsClientBuilder;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.PutItemOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;
try {
System.out.println("Adding a new item...");
PutItemOutcome outcome = table
.putItem(new Item().withPrimaryKey("year", year, "title",
title).withMap("info", infoMap));
}
catch (Exception e) {
System.err.println("Unable to add item: " + year + " " + title);
System.err.println(e.getMessage());
}
}
}
Note
La clave principal es obligatoria. Este código agrega un elemento que tiene la clave principal
(year, title) y atributos info. El atributo info almacena un ejemplo de código JSON que
proporciona más información sobre la película.
2. Compile y ejecute el programa.
{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Nothing happens at all.",
rating: 0
}
}
Puede utilizar el método getItem para leer el elemento en la tabla Movies. Debe especificar los valores
de clave principal para poder leer cualquier elemento de Movies si conoce los valores de year y title.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.gsg;
import com.amazonaws.client.builder.AwsClientBuilder;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.GetItemSpec;
try {
System.out.println("Attempting to read the item...");
Item outcome = table.getItem(spec);
System.out.println("GetItem succeeded: " + outcome);
}
catch (Exception e) {
System.err.println("Unable to read item: " + year + " " + title);
System.err.println(e.getMessage());
}
}
}
{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Nothing happens at all.",
rating: 0
}
}
A esto:
{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Everything happens all at once.",
rating: 5.5,
actors: ["Larry", "Moe", "Curly"]
}
}
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.gsg;
import java.util.Arrays;
import com.amazonaws.client.builder.AwsClientBuilder;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.UpdateItemOutcome;
import com.amazonaws.services.dynamodbv2.document.spec.UpdateItemSpec;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;
import com.amazonaws.services.dynamodbv2.model.ReturnValue;
try {
System.out.println("Updating the item...");
UpdateItemOutcome outcome = table.updateItem(updateItemSpec);
System.out.println("UpdateItem succeeded:\n" +
outcome.getItem().toJSONPretty());
}
catch (Exception e) {
System.err.println("Unable to update item: " + year + " " + title);
System.err.println(e.getMessage());
}
}
}
Note
Este programa utiliza una expresión UpdateExpression para describir todas las
actualizaciones que desee realizar con el elemento especificado.
El programa siguiente muestra cómo aumentar el valor de rating para una película. Cada vez que se
ejecuta, el programa incrementa el valor de este atributo en una unidad.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.gsg;
import com.amazonaws.client.builder.AwsClientBuilder;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.UpdateItemOutcome;
import com.amazonaws.services.dynamodbv2.document.spec.UpdateItemSpec;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;
import com.amazonaws.services.dynamodbv2.model.ReturnValue;
.withValueMap(new ValueMap().withNumber(":val",
1)).withReturnValues(ReturnValue.UPDATED_NEW);
try {
System.out.println("Incrementing an atomic counter...");
UpdateItemOutcome outcome = table.updateItem(updateItemSpec);
System.out.println("UpdateItem succeeded:\n" +
outcome.getItem().toJSONPretty());
}
catch (Exception e) {
System.err.println("Unable to update item: " + year + " " + title);
System.err.println(e.getMessage());
}
}
}
En este caso, el elemento de película se actualiza solamente si hay más de tres actores.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.gsg;
import com.amazonaws.client.builder.AwsClientBuilder;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.PrimaryKey;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.UpdateItemOutcome;
import com.amazonaws.services.dynamodbv2.document.spec.UpdateItemSpec;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;
import com.amazonaws.services.dynamodbv2.model.ReturnValue;
.withEndpointConfiguration(new
AwsClientBuilder.EndpointConfiguration("http://localhost:8000", "us-west-2"))
.build();
}
catch (Exception e) {
System.err.println("Unable to update item: " + year + " " + title);
System.err.println(e.getMessage());
}
}
}
Esto se debe a que la película tiene tres actores, pero la condición busca un valor mayor que tres
actores.
3. Modifique el programa para que ConditionExpression tenga el aspecto siguiente.
/**
package com.amazonaws.codesamples.gsg;
import com.amazonaws.client.builder.AwsClientBuilder;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.PrimaryKey;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.DeleteItemSpec;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;
try {
System.out.println("Attempting a conditional delete...");
table.deleteItem(deleteItemSpec);
System.out.println("DeleteItem succeeded");
}
catch (Exception e) {
System.err.println("Unable to delete item: " + year + " " + title);
System.err.println(e.getMessage());
}
}
}
Para buscar todas las películas estrenadas durante un año, solo debe especificar el valor de year.
También puede indicar el valor de title si desea recuperar un subconjunto de películas basadas en una
condición determinada (la clave de ordenación). Por ejemplo, puede encontrar las películas estrenadas en
2014 cuyo título comienza por la "A".
Además del método query, hay también un método scan que permite recuperar todos los datos de la
tabla.
Para obtener más información sobre cómo consultar y examinar datos, consulte Uso de consultas en
DynamoDB (p. 497) y Uso de operaciones de examen en DynamoDB (p. 516), respectivamente.
Temas
• Paso 4.1: Consulta (p. 96)
• Paso 4.2: Examen (p. 98)
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.gsg;
import java.util.HashMap;
import java.util.Iterator;
import com.amazonaws.client.builder.AwsClientBuilder;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.ItemCollection;
import com.amazonaws.services.dynamodbv2.document.QueryOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec;
try {
System.out.println("Movies from 1985");
items = table.query(querySpec);
iterator = items.iterator();
while (iterator.hasNext()) {
item = iterator.next();
System.out.println(item.getNumber("year") + ": " +
item.getString("title"));
}
}
catch (Exception e) {
System.err.println("Unable to query movies from 1985");
System.err.println(e.getMessage());
}
valueMap.put(":yyyy", 1992);
valueMap.put(":letter1", "A");
valueMap.put(":letter2", "L");
try {
System.out.println("Movies from 1992 - titles A-L, with genres and lead
actor");
items = table.query(querySpec);
iterator = items.iterator();
while (iterator.hasNext()) {
item = iterator.next();
System.out.println(item.getNumber("year") + ": " +
item.getString("title") + " " + item.getMap("info"));
}
}
catch (Exception e) {
System.err.println("Unable to query movies from 1992:");
System.err.println(e.getMessage());
}
}
}
Note
• nameMap permite sustituir nombres. Esto se usa porqueyeares una palabra reservada
en Amazon DynamoDB. No puede usarlo directamente en ninguna expresión, incluida
KeyConditionExpression. Para solucionar este problema se utiliza el nombre de
atributo de expresión #yr.
• valueMap permite sustituir valores. Se utiliza porque no se pueden utilizar literales en
ninguna expresión, incluida KeyConditionExpression. Para solucionar este problema
se utiliza el valor de atributo de expresión :yyyy.
En primer lugar, se crea el objeto querySpec, que describe los parámetros de consulta. A
continuación, se pasa el objeto al método query.
2. Compile y ejecute el programa.
Note
El programa anterior muestra cómo consultar una tabla según sus atributos de clave principal. En
DynamoDB, puede crear si lo desea uno o varios índices secundarios en una tabla y consultarlos
de la misma forma que se consulta una tabla. Los índices secundarios ofrecen a las aplicaciones
mayor flexibilidad, porque permiten consultar atributos sin clave. Para obtener más información,
consulte Uso de índices secundarios para mejorar el acceso a los datos (p. 567).
elementos que coinciden con los criterios. No obstante, el filtro solo se aplica después de haber examinado
toda la tabla.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.gsg;
import java.util.Iterator;
import com.amazonaws.client.builder.AwsClientBuilder;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.ItemCollection;
import com.amazonaws.services.dynamodbv2.document.ScanOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.ScanSpec;
import com.amazonaws.services.dynamodbv2.document.utils.NameMap;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;
try {
ItemCollection<ScanOutcome> items = table.scan(scanSpec);
}
catch (Exception e) {
System.err.println("Unable to scan the table:");
System.err.println(e.getMessage());
}
}
}
Note
También puede usar la operación Scan con cualesquiera índices secundarios que haya creado
en la tabla. Para obtener más información, consulte Uso de índices secundarios para mejorar el
acceso a los datos (p. 567).
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.gsg;
import com.amazonaws.client.builder.AwsClientBuilder;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Table;
try {
System.out.println("Attempting to delete table; please wait...");
table.delete();
table.waitForDelete();
System.out.print("Success.");
}
catch (Exception e) {
System.err.println("Unable to delete table: ");
System.err.println(e.getMessage());
}
}
}
Summary
En este tutorial, ha creado elMoviesEn Amazon DynamoDB en el equipo y realizó las operaciones
básicas. La versión descargable de DynamoDB resulta útil para tareas de desarrollo y pruebas de
aplicaciones. Sin embargo, cuando la aplicación esté preparada para ejecutarla en un entorno de
producción, debe modificar el código de modo que utilice el servicio web de DynamoDB.
import com.amazonaws.client.builder.AwsClientBuilder;
AmazonDynamoDB client =
AmazonDynamoDBClientBuilder.standard().withEndpointConfiguration(
new AwsClientBuilder.EndpointConfiguration("http://localhost:8000", "us-west-2"))
.build();
3. Ahora, modifique el cliente de forma que obtenga acceso a unAWSRegión en lugar de un extremo
específico.
Por ejemplo, si desea obtener acceso a la us-west-2 region, tendría que hacer lo siguiente.
.withRegion(Regions.US_WEST_2)
.build();
En lugar de utilizar DynamoDB en el equipo, ahora el programa usará el punto de enlace del servicio web
de DynamoDB en la región de EE.UU. Oeste (Oregón).
DynamoDB está disponible enAWSRegiones en el mundo. Para ver una lista completa, consulteRegiones
y puntos de enlace deen laAWSReferencia general de. Para obtener más información sobre cómo
configurar las regiones y los puntos de enlace en el código, consulteAWSSelección de regionesen laAWS
SDK for JavaGuía para desarrolladores.
• Crear una tabla denominada Movies y cargar ejemplos de datos en formato JSON.
• Realizar operaciones de creación, lectura, actualización y eliminación en la tabla.
• Ejecutar consultas sencillas.
Mientras realiza este tutorial, puede consultar laAWS SDK for JavaScriptReferencia de la API.
En este tutorial se utiliza la versión descargable de DynamoDB. Para obtener información sobre
cómo ejecutar el mismo código en el servicio web de DynamoDB, consulte laTutorial y revisión
de JavaScript y DynamoDB (p. 124).
• Configure unAWSLa clave de accesoAWSSDK Para obtener más información, consulte Configuración
de DynamoDB (servicio web) (p. 57).
• Configure AWS SDK for JavaScript. Para ello, agregue o modifique la siguiente etiqueta de script en las
páginas de código HTML:
<script src="https://sdk.amazonaws.com/js/aws-sdk-2.7.16.min.js"></script>
Note
La versión de AWS SDK for JavaScript podría haberse actualizado. Para obtener la última
versión, consulte laAWS SDK for JavaScriptReferencia de la API.
• HabilitarCompartir recursos entre orígenes (CORS)Para que pueda existir la comunicación entre el
navegador del equipo y la versión descargable de DynamoDB.
1. Descargue la extensión ModHeader gratuita para el navegador Chrome (o cualquier otra extensión
del navegador que permita modificar los encabezados de respuesta HTTP).
2. Ejecute la extensión ModHeader para el navegador Chrome y agregue un encabezado de respuesta
HTTP con el nombre establecido en "Access-Control-Allow-Origin" y el valor "null" o "*".
Important
Esta configuración solo es necesaria si ejecuta el programa del tutorial para JavaScript
en el equipo. Una vez que haya completado el tutorial, debe deshabilitar o eliminar esta
configuración.
3. Ahora, ya puede ejecutar los archivos del programa del tutorial de JavaScript.
Si prefiere ejecutar una versión completa del programa del tutorial de JavaScript en lugar de realizar
instrucciones paso a paso, haga lo siguiente:
<!--
Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
This file is licensed under the Apache License, Version 2.0 (the "License").
You may not use this file except in compliance with the License. A copy of
the License is located at
http://aws.amazon.com/apache2.0/
<script>
AWS.config.update({
region: "us-west-2",
endpoint: 'http://localhost:8000',
// accessKeyId default can be used while using the downloadable version of DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
accessKeyId: "fakeMyKeyId",
// secretAccessKey default can be used while using the downloadable version of
DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
secretAccessKey: "fakeSecretAccessKey"
});
function createMovies() {
var params = {
TableName : "Movies",
KeySchema: [
{ AttributeName: "year", KeyType: "HASH"},
{ AttributeName: "title", KeyType: "RANGE" }
],
AttributeDefinitions: [
{ AttributeName: "year", AttributeType: "N" },
{ AttributeName: "title", AttributeType: "S" }
],
ProvisionedThroughput: {
ReadCapacityUnits: 5,
WriteCapacityUnits: 5
}
};
</script>
</head>
<body>
<input id="createTableButton" type="button" value="Create Table"
onclick="createMovies();" />
<br><br>
<textarea readonly id= "textarea" style="width:400px; height:800px"></textarea>
</body>
</html>
Note
• El punto de enlace debe configurarse de modo que indique que está creando la tabla en
Amazon DynamoDB en el equipo.
• En la función createMovies, especifique el nombre de la tabla, los atributos de clave
principal y los tipos de datos.
• LaProvisionedThroughputEl parámetro es obligatorio; sin embargo, en la versión
descargable de DynamoDB se hace caso omiso de él. El desempeño provisionado está
fuera del alcance de este tutorial.
2. Abra el archivo MoviesCreateTable.html en el navegador.
3. Seleccione Create Table (Crear tabla).
Para obtener más información sobre cómo administrar tablas, consulte Uso de tablas y datos en
DynamoDB (p. 344).
Temas
• Paso 2.1: Descargue el archivo (p. 106)
• Paso 2.2: Cargue los ejemplos de datos en la tabla Movies (p. 106)
En este escenario se utiliza un ejemplo de archivo de datos que contiene información sobre varios miles de
películas de IMDb (Internet Movie Database). Los datos de las películas se encuentran en formato JSON,
tal y como se muestra en el siguiente ejemplo. Para cada película, se indican el año, year, el título, title
y un mapa JSON denominado info.
[
{
"year" : ... ,
"title" : ... ,
"info" : { ... }
},
{
"year" : ...,
"title" : ...,
"info" : { ... }
},
...
• year y title se utilizan como valores de atributos de clave principal de la tabla Movies.
• El resto de los valores info se almacenan en un único atributo denominado info. Este programa ilustra
cómo almacenar JSON en un atributo de Amazon DynamoDB.
{
"year" : 2013,
"title" : "Turn It Down, Or Else!",
"info" : {
"directors" : [
"Alice Smith",
"Bob Jones"
],
"release_date" : "2013-01-18T00:00:00Z",
"rating" : 6.2,
"genres" : [
"Comedy",
"Drama"
],
"image_url" : "http://ia.media-imdb.com/images/N/
O9ERWAU7FS797AJ7LU8HN09AMUP908RLlo5JF90EWR7LJKQ7@@._V1_SX400_.jpg",
"plot" : "A rock band plays their music at high volumes, annoying the neighbors.",
"rank" : 11,
"running_time_secs" : 5215,
"actors" : [
"David Matthewman",
"Ann Thomas",
"Jonathan G. Neff"
]
}
}
<!--
Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
This file is licensed under the Apache License, Version 2.0 (the "License").
You may not use this file except in compliance with the License. A copy of
the License is located at
http://aws.amazon.com/apache2.0/
<script type="text/javascript">
AWS.config.update({
region: "us-west-2",
endpoint: 'http://localhost:8000',
// accessKeyId default can be used while using the downloadable version of DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
accessKeyId: "fakeMyKeyId",
// secretAccessKey default can be used while using the downloadable version of
DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
secretAccessKey: "fakeSecretAccessKey"
});
function processFile(evt) {
document.getElementById('textarea').innerHTML = "";
document.getElementById('textarea').innerHTML += "Importing movies into DynamoDB.
Please wait..." + "\n";
var file = evt.target.files[0];
if (file) {
allMovies.forEach(function (movie) {
document.getElementById('textarea').innerHTML += "Processing: " +
movie.title + "\n";
var params = {
TableName: "Movies",
Item: {
"year": movie.year,
"title": movie.title,
"info": movie.info
}
};
docClient.put(params, function (err, data) {
if (err) {
document.getElementById('textarea').innerHTML += "Unable to add
movie: " + count + movie.title + "\n";
document.getElementById('textarea').innerHTML += "Error JSON: "
+ JSON.stringify(err) + "\n";
} else {
document.getElementById('textarea').innerHTML += "PutItem
succeeded: " + movie.title + "\n";
textarea.scrollTop = textarea.scrollHeight;
}
});
});
};
r.readAsText(file);
} else {
alert("Could not read movie data file");
}
}
</script>
</head>
<body>
<input type="file" id="fileinput" accept='application/json'/>
<br><br>
<textarea readonly id= "textarea" style="width:400px; height:800px"></textarea>
<script>
document.getElementById('fileinput').addEventListener('change', processFile,
false);
</script>
</body>
</html>
Para obtener más información sobre cómo leer y escribir datos, consulte Uso de elementos y
atributos (p. 410).
Temas
<!--
Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
This file is licensed under the Apache License, Version 2.0 (the "License").
You may not use this file except in compliance with the License. A copy of
the License is located at
http://aws.amazon.com/apache2.0/
<script>
AWS.config.update({
region: "us-west-2",
endpoint: 'http://localhost:8000',
// accessKeyId default can be used while using the downloadable version of DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
accessKeyId: "fakeMyKeyId",
// secretAccessKey default can be used while using the downloadable version of
DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
secretAccessKey: "fakeSecretAccessKey"
});
function createItem() {
var params = {
TableName :"Movies",
Item:{
"year": 2015,
"title": "The Big New Movie",
"info":{
"plot": "Nothing happens at all.",
"rating": 0
}
}
};
docClient.put(params, function(err, data) {
if (err) {
</script>
</head>
<body>
<input id="createItem" type="button" value="Create Item" onclick="createItem();" />
<br><br>
<textarea readonly id= "textarea" style="width:400px; height:800px"></textarea>
</body>
</html>
Note
La clave principal es obligatoria. Este código agrega un elemento que tiene la clave principal
(year, title) y atributos info. El atributo info almacena un ejemplo de código JSON que
proporciona más información sobre la película.
2. Abra el archivo MoviesItemOps01.html en el navegador.
3. Elija Create Item (Crear elemento).
{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Nothing happens at all.",
rating: 0
}
}
Puede utilizar el método get para leer el elemento en la tabla Movies. Debe especificar los valores de
clave principal para poder leer cualquier elemento de Movies si conoce los valores de year y title.
<!--
Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
This file is licensed under the Apache License, Version 2.0 (the "License").
You may not use this file except in compliance with the License. A copy of
the License is located at
http://aws.amazon.com/apache2.0/
<head>
<script src="https://sdk.amazonaws.com/js/aws-sdk-2.7.16.min.js"></script>
<script>
AWS.config.update({
region: "us-west-2",
endpoint: 'http://localhost:8000',
// accessKeyId default can be used while using the downloadable version of DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
accessKeyId: "fakeMyKeyId",
// secretAccessKey default can be used while using the downloadable version of
DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
secretAccessKey: "fakeSecretAccessKey"
});
function readItem() {
var table = "Movies";
var year = 2015;
var title = "The Big New Movie";
var params = {
TableName: table,
Key:{
"year": year,
"title": title
}
};
docClient.get(params, function(err, data) {
if (err) {
document.getElementById('textarea').innerHTML = "Unable to read item: " +
"\n" + JSON.stringify(err, undefined, 2);
} else {
document.getElementById('textarea').innerHTML = "GetItem succeeded: " +
"\n" + JSON.stringify(data, undefined, 2);
}
});
}
</script>
</head>
<body>
<input id="readItem" type="button" value="Read Item" onclick="readItem();" />
<br><br>
<textarea readonly id= "textarea" style="width:400px; height:800px"></textarea>
</body>
</html>
{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Nothing happens at all.",
rating: 0
}
}
A esto:
{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Everything happens all at once.",
rating: 5.5,
actors: ["Larry", "Moe", "Curly"]
}
}
<!--
Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
This file is licensed under the Apache License, Version 2.0 (the "License").
You may not use this file except in compliance with the License. A copy of
the License is located at
http://aws.amazon.com/apache2.0/
<script>
AWS.config.update({
region: "us-west-2",
endpoint: 'http://localhost:8000',
// accessKeyId default can be used while using the downloadable version of DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
accessKeyId: "fakeMyKeyId",
// secretAccessKey default can be used while using the downloadable version of
DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
secretAccessKey: "fakeSecretAccessKey"
});
function updateItem() {
var table = "Movies";
var year = 2015;
var title = "The Big New Movie";
var params = {
TableName:table,
Key:{
"year": year,
"title": title
},
UpdateExpression: "set info.rating = :r, info.plot=:p, info.actors=:a",
ExpressionAttributeValues:{
":r":5.5,
":p":"Everything happens all at once.",
":a":["Larry", "Moe", "Curly"]
},
ReturnValues:"UPDATED_NEW"
};
</script>
</head>
<body>
<input id="updateItem" type="button" value="Update Item" onclick="updateItem();" />
<br><br>
<textarea readonly id= "textarea" style="width:400px; height:800px"></textarea>
</body>
</html>
Note
Este programa utiliza UpdateExpression para describir todas las actualizaciones que
desee realizar con el elemento especificado.
LaReturnValuesEl parámetro indica a Amazon DynamoDB que devuelva solamente los
atributos actualizados ("UPDATED_NEW").
2. Abra el archivo MoviesItemOps03.html en el navegador.
3. Elija Update Item (Actualizar elemento).
El programa siguiente muestra cómo aumentar el valor de rating para una película. Cada vez que se
ejecuta, el programa incrementa el valor de este atributo en una unidad.
<!--
Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
This file is licensed under the Apache License, Version 2.0 (the "License").
You may not use this file except in compliance with the License. A copy of
the License is located at
http://aws.amazon.com/apache2.0/
<script>
AWS.config.update({
region: "us-west-2",
endpoint: 'http://localhost:8000',
// accessKeyId default can be used while using the downloadable version of DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
accessKeyId: "fakeMyKeyId",
// secretAccessKey default can be used while using the downloadable version of
DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
secretAccessKey: "fakeSecretAccessKey"
});
function increaseRating() {
var table = "Movies";
var year = 2015;
var title = "The Big New Movie";
var params = {
TableName:table,
Key:{
"year": year,
"title": title
},
UpdateExpression: "set info.rating = info.rating + :val",
ExpressionAttributeValues:{
":val":1
},
ReturnValues:"UPDATED_NEW"
};
</script>
</head>
<body>
<input id="increaseRating" type="button" value="Increase Rating"
onclick="increaseRating();" />
<br><br>
<textarea readonly id= "textarea" style="width:400px; height:800px"></textarea>
</body>
</html>
En este caso, el elemento se actualiza solamente si hay más de tres actores en la película.
<!--
Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
This file is licensed under the Apache License, Version 2.0 (the "License").
You may not use this file except in compliance with the License. A copy of
the License is located at
http://aws.amazon.com/apache2.0/
<script>
AWS.config.update({
region: "us-west-2",
endpoint: 'http://localhost:8000',
// accessKeyId default can be used while using the downloadable version of DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
accessKeyId: "fakeMyKeyId",
// secretAccessKey default can be used while using the downloadable version of
DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
secretAccessKey: "fakeSecretAccessKey"
});
function conditionalUpdate() {
var table = "Movies";
var year = 2015;
</script>
</head>
<body>
<input id="conditionalUpdate" type="button" value="Conditional Update"
onclick="conditionalUpdate();" />
<br><br>
<textarea readonly id= "textarea" style="width:400px; height:800px"></textarea>
</body>
</html>
Esto se debe a que la película tiene tres actores, pero la condición busca un valor mayor que tres
actores.
4. Modifique el programa para que ConditionExpression tenga el aspecto siguiente.
<!--
Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
This file is licensed under the Apache License, Version 2.0 (the "License").
You may not use this file except in compliance with the License. A copy of
the License is located at
http://aws.amazon.com/apache2.0/
<script>
AWS.config.update({
region: "us-west-2",
endpoint: 'http://localhost:8000',
// accessKeyId default can be used while using the downloadable version of DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
accessKeyId: "fakeMyKeyId",
// secretAccessKey default can be used while using the downloadable version of
DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
secretAccessKey: "fakeSecretAccessKey"
});
function conditionalDelete() {
var table = "Movies";
var year = 2015;
var title = "The Big New Movie";
var params = {
TableName:table,
Key:{
"year":year,
"title":title
},
ConditionExpression:"info.rating <= :val",
ExpressionAttributeValues: {
":val": 5.0
}
};
</script>
</head>
<body>
<input id="conditionalDelete" type="button" value="Conditional Delete"
onclick="conditionalDelete();" />
<br><br>
<textarea readonly id= "textarea" style="width:400px; height:800px"></textarea>
</body>
</html>
var params = {
TableName:table,
Key:{
"title":title,
"year":year
}
};
Para buscar todas las películas estrenadas durante un año, solo debe especificar el valor de year.
También puede proporcionar el atributo title para recuperar un subconjunto de películas que cumplan
determinada condición (según la clave de ordenación), como buscar las películas estrenadas en 2014 cuyo
título comience por la letra "A".
Además del método query, puede usar el método scan para recuperar todos los datos de la tabla.
Para obtener más información sobre cómo consultar y examinar datos, consulte Uso de consultas en
DynamoDB (p. 497) y Uso de operaciones de examen en DynamoDB (p. 516), respectivamente.
Temas
• Paso 4.1: Consulta - Todas las películas estrenadas durante un año (p. 118)
• Paso 4.2: Consulta - Todas las películas estrenadas durante un año con unos títulos (p. 119)
• Paso 4.3: Examen (p. 121)
<!--
Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
This file is licensed under the Apache License, Version 2.0 (the "License").
You may not use this file except in compliance with the License. A copy of
the License is located at
http://aws.amazon.com/apache2.0/
<script>
AWS.config.update({
region: "us-west-2",
endpoint: 'http://localhost:8000',
// accessKeyId default can be used while using the downloadable version of DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
accessKeyId: "fakeMyKeyId",
// secretAccessKey default can be used while using the downloadable version of
DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
secretAccessKey: "fakeSecretAccessKey"
});
function queryData() {
document.getElementById('textarea').innerHTML += "Querying for movies from 1985.";
var params = {
TableName : "Movies",
KeyConditionExpression: "#yr = :yyyy",
ExpressionAttributeNames:{
"#yr": "year"
},
ExpressionAttributeValues: {
":yyyy":1985
}
};
</script>
</head>
<body>
<input id="queryData" type="button" value="Query" onclick="queryData();" />
<br><br>
<textarea readonly id= "textarea" style="width:400px; height:800px"></textarea>
</body>
</html>
Note
Note
El programa anterior muestra cómo consultar una tabla según sus atributos de clave principal. En
DynamoDB, puede crear si lo desea uno o varios índices secundarios en una tabla y consultarlos
de la misma forma que se consulta una tabla. Los índices secundarios ofrecen a las aplicaciones
mayor flexibilidad, porque permiten consultar atributos sin clave. Para obtener más información,
consulte Uso de índices secundarios para mejorar el acceso a los datos (p. 567).
<!--
Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
This file is licensed under the Apache License, Version 2.0 (the "License").
You may not use this file except in compliance with the License. A copy of
http://aws.amazon.com/apache2.0/
<script>
AWS.config.update({
region: "us-west-2",
endpoint: 'http://localhost:8000',
// accessKeyId default can be used while using the downloadable version of DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
accessKeyId: "fakeMyKeyId",
// secretAccessKey default can be used while using the downloadable version of
DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
secretAccessKey: "fakeSecretAccessKey"
});
function queryData() {
document.getElementById('textarea').innerHTML += "Querying for movies from 1985.";
var params = {
TableName : "Movies",
ProjectionExpression:"#yr, title, info.genres, info.actors[0]",
KeyConditionExpression: "#yr = :yyyy and title between :letter1 and :letter2",
ExpressionAttributeNames:{
"#yr": "year"
},
ExpressionAttributeValues: {
":yyyy":1992,
":letter1": "A",
":letter2": "L"
}
};
</script>
</head>
<body>
<input id="queryData" type="button" value="Query" onclick="queryData();" />
<br><br>
<textarea readonly id= "textarea" style="width:400px; height:800px"></textarea>
</body>
</html>
<!--
Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
This file is licensed under the Apache License, Version 2.0 (the "License").
You may not use this file except in compliance with the License. A copy of
the License is located at
http://aws.amazon.com/apache2.0/
<script>
AWS.config.update({
region: "us-west-2",
endpoint: 'http://localhost:8000',
// accessKeyId default can be used while using the downloadable version of DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
accessKeyId: "fakeMyKeyId",
// secretAccessKey default can be used while using the downloadable version of
DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
secretAccessKey: "fakeSecretAccessKey"
});
function scanData() {
document.getElementById('textarea').innerHTML += "Scanning Movies table." + "\n";
var params = {
TableName: "Movies",
ProjectionExpression: "#yr, title, info.rating",
FilterExpression: "#yr between :start_yr and :end_yr",
ExpressionAttributeNames: {
"#yr": "year",
},
ExpressionAttributeValues: {
":start_yr": 1950,
":end_yr": 1959
}
};
docClient.scan(params, onScan);
</script>
</head>
<body>
<input id="scanData" type="button" value="Scan" onclick="scanData();" />
<br><br>
<textarea readonly id= "textarea" style="width:400px; height:800px"></textarea>
</body>
</html>
Note
También puede usar la operación Scan con cualesquiera índices secundarios que haya creado
en la tabla. Para obtener más información, consulte Uso de índices secundarios para mejorar el
acceso a los datos (p. 567).
<!--
Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
This file is licensed under the Apache License, Version 2.0 (the "License").
You may not use this file except in compliance with the License. A copy of
the License is located at
http://aws.amazon.com/apache2.0/
<script>
AWS.config.update({
region: "us-west-2",
endpoint: 'http://localhost:8000',
// accessKeyId default can be used while using the downloadable version of DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
accessKeyId: "fakeMyKeyId",
// secretAccessKey default can be used while using the downloadable version of
DynamoDB.
// For security reasons, do not store AWS Credentials in your files. Use Amazon
Cognito instead.
secretAccessKey: "fakeSecretAccessKey"
});
function deleteMovies() {
var params = {
TableName : "Movies"
};
</script>
</head>
<body>
<input id="deleteTableButton" type="button" value="Delete Table"
onclick="deleteMovies();" />
<br><br>
<textarea readonly id= "textarea" style="width:400px; height:800px"></textarea>
</body>
</html>
AWS.config.update({region: "aws-region"});
AWS.config.update({region: "us-west-2"});
El programa ahora utiliza el servicio web de Amazon DynamoDB en la región EE. UU. Oeste (Oregón).
DynamoDB está disponible enAWSRegiones en todo el mundo Para obtener una lista completa,
consulteRegiones y puntos de enlace deen laAWSReferencia general de. Para obtener más información
sobre cómo configurar las regiones y los puntos de enlace en el código, consulteEstablecimiento de la
regiónen laAWS SDK for JavaScriptGuía de introducción.
• Crear una tabla denominada Movies y cargar ejemplos de datos en formato JSON.
• Realizar operaciones de creación, lectura, actualización y eliminación en la tabla.
• Ejecutar consultas sencillas.
Mientras realiza este tutorial, puede consultar laAWS SDK for JavaScriptReferencia de la API.
Para obtener más información, consulte la Guía de introducción a AWS SDK for JavaScript.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
var AWS = require("aws-sdk");
AWS.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
});
var params = {
TableName : "Movies",
KeySchema: [
{ AttributeName: "year", KeyType: "HASH"}, //Partition key
Note
• El punto de enlace debe configurarse de modo que indique que está creando la tabla en
Amazon DynamoDB en el equipo.
• En la llamada createTable, especifique el nombre de la tabla, los atributos de clave
principal y los tipos de datos.
• LaProvisionedThroughputes obligatorio; sin embargo, en la versión descargable de
DynamoDB se hace caso omiso de él. El desempeño provisionado está fuera del alcance
de este tutorial.
2. Para ejecutar el programa, introduzca el siguiente comando.
node MoviesCreateTable.js
Para obtener más información sobre cómo administrar tablas, consulte Uso de tablas y datos en
DynamoDB (p. 344).
Temas
• Paso 2.1: Descargue el ejemplo de datos (p. 127)
• Paso 2.2: Cargue los ejemplos de datos en la tabla Movies (p. 127)
Usará un ejemplo de archivo de datos que contiene información sobre varios miles de películas de IMDb
(Internet Movie Database). Los datos de las películas se encuentran en formato JSON, tal y como se
muestra en el siguiente ejemplo. Para cada película, se indican el año, year, el título, title y un mapa
JSON denominado info.
[
{
"year" : ... ,
"title" : ... ,
"info" : { ... }
},
{
"year" : ...,
"title" : ...,
"info" : { ... }
},
...
• year y title se utilizan como valores de atributos de clave principal de la tabla Movies.
• El resto de los valores info se almacenan en un único atributo denominado info. Este programa ilustra
cómo almacenar JSON en un atributo de Amazon DynamoDB.
{
"year" : 2013,
"title" : "Turn It Down, Or Else!",
"info" : {
"directors" : [
"Alice Smith",
"Bob Jones"
],
"release_date" : "2013-01-18T00:00:00Z",
"rating" : 6.2,
"genres" : [
"Comedy",
"Drama"
],
"image_url" : "http://ia.media-imdb.com/images/N/
O9ERWAU7FS797AJ7LU8HN09AMUP908RLlo5JF90EWR7LJKQ7@@._V1_SX400_.jpg",
"plot" : "A rock band plays their music at high volumes, annoying the neighbors.",
"rank" : 11,
"running_time_secs" : 5215,
"actors" : [
"David Matthewman",
"Ann Thomas",
"Jonathan G. Neff"
]
}
}
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
var AWS = require("aws-sdk");
var fs = require('fs');
AWS.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
});
node MoviesLoadData.js
Para obtener más información sobre cómo leer y escribir datos, consulte Uso de elementos y
atributos (p. 410).
Temas
• Paso 3.1: Creación de un elemento nuevo (p. 129)
• Paso 3.2: Lectura de un elemento (p. 130)
• Paso 3.3: Actualización de un elemento (p. 131)
• Paso 3.4: Incremento de un contador atómico (p. 133)
• Paso 3.5: Actualización de un elemento (condicionalmente) (p. 134)
• Paso 3.6: Eliminación de un elemento (p. 135)
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
var AWS = require("aws-sdk");
AWS.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
});
var params = {
TableName:table,
Item:{
"year": year,
"title": title,
"info":{
"plot": "Nothing happens at all.",
"rating": 0
}
}
};
}
});
Note
La clave principal es obligatoria. Este código agrega un elemento que tiene la clave principal
(year, title) y atributos info. El atributo info almacena un ejemplo de código JSON que
proporciona más información sobre la película.
2. Para ejecutar el programa, introduzca el siguiente comando.
node MoviesItemOps01.js
{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Nothing happens at all.",
rating: 0
}
}
Puede utilizar el método get para leer el elemento en la tabla Movies. Debe especificar los valores de
clave principal para poder leer cualquier elemento de Movies si conoce los valores de year y title.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
var AWS = require("aws-sdk");
AWS.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
});
var params = {
TableName: table,
Key:{
"year": year,
"title": title
}
};
node MoviesItemOps02.js
{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Nothing happens at all.",
rating: 0
}
}
{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Everything happens all at once.",
rating: 5.5,
actors: ["Larry", "Moe", "Curly"]
}
}
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
var AWS = require("aws-sdk");
AWS.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
});
var params = {
TableName:table,
Key:{
"year": year,
"title": title
},
UpdateExpression: "set info.rating = :r, info.plot=:p, info.actors=:a",
ExpressionAttributeValues:{
":r":5.5,
":p":"Everything happens all at once.",
":a":["Larry", "Moe", "Curly"]
},
ReturnValues:"UPDATED_NEW"
};
Note
Este programa utiliza UpdateExpression para describir todas las actualizaciones que
desee realizar con el elemento especificado.
LaReturnValuesindica a DynamoDB que devuelva solamente los atributos actualizados
("UPDATED_NEW").
2. Para ejecutar el programa, introduzca el siguiente comando.
node MoviesItemOps03.js
El programa siguiente muestra cómo aumentar el valor de rating para una película. Cada vez que se
ejecuta el programa, incrementa el valor de este atributo en una unidad.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
var AWS = require("aws-sdk");
AWS.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
});
var params = {
TableName:table,
Key:{
"year": year,
"title": title
},
UpdateExpression: "set info.rating = info.rating + :val",
ExpressionAttributeValues:{
":val": 1
},
ReturnValues:"UPDATED_NEW"
};
node MoviesItemOps04.js
En este caso, el elemento se actualiza solamente si hay más de tres actores en la película.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
var AWS = require("aws-sdk");
AWS.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
});
var params = {
TableName:table,
Key:{
"year": year,
"title": title
},
UpdateExpression: "remove info.actors[0]",
ConditionExpression: "size(info.actors) > :num",
ExpressionAttributeValues:{
":num": 3
},
ReturnValues:"UPDATED_NEW"
};
} else {
console.log("UpdateItem succeeded:", JSON.stringify(data, null, 2));
}
});
node MoviesItemOps05.js
Esto se debe a que la película tiene tres actores, pero la condición busca un valor mayor que tres
actores.
3. Modifique el programa para que ConditionExpression tenga el aspecto siguiente.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
var AWS = require("aws-sdk");
AWS.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
});
var params = {
TableName:table,
Key:{
"year": year,
"title": title
},
ConditionExpression:"info.rating <= :val",
ExpressionAttributeValues: {
":val": 5.0
}
};
node MoviesItemOps06.js
var params = {
TableName:table,
Key:{
"title":title,
"year":year
}
};
Para buscar todas las películas estrenadas durante un año, solo debe especificar el valor de year.
También puede indicar el valor de title si desea recuperar un subconjunto de películas basadas en una
condición determinada (la clave de ordenación). Por ejemplo, puede encontrar las películas estrenadas en
2014 cuyo título comienza por la "A".
Además del método query, puede usar también el método scan que puede recuperar todos los datos de
la tabla.
Para obtener más información sobre cómo consultar y examinar datos, consulte Uso de consultas en
DynamoDB (p. 497) y Uso de operaciones de examen en DynamoDB (p. 516), respectivamente.
Temas
• Paso 4.1: Consulta de todas las películas estrenadas durante un año (p. 137)
• Paso 4.2: Consulta de todas las películas estrenadas durante un año con unos títulos
determinados (p. 138)
• Paso 4.3: Examen (p. 139)
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
var AWS = require("aws-sdk");
AWS.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
});
var params = {
TableName : "Movies",
KeyConditionExpression: "#yr = :yyyy",
ExpressionAttributeNames:{
"#yr": "year"
},
ExpressionAttributeValues: {
":yyyy": 1985
}
};
Note
node MoviesQuery01.js
Note
El programa anterior muestra cómo consultar una tabla según sus atributos de clave principal. En
DynamoDB, puede crear si lo desea uno o varios índices secundarios en una tabla y consultarlos
de la misma forma que se consulta una tabla. Los índices secundarios ofrecen a las aplicaciones
mayor flexibilidad, porque permiten consultar atributos sin clave. Para obtener más información,
consulte Uso de índices secundarios para mejorar el acceso a los datos (p. 567).
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
var AWS = require("aws-sdk");
AWS.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
});
console.log("Querying for movies from 1992 - titles A-L, with genres and lead actor");
var params = {
TableName : "Movies",
ProjectionExpression:"#yr, title, info.genres, info.actors[0]",
KeyConditionExpression: "#yr = :yyyy and title between :letter1 and :letter2",
ExpressionAttributeNames:{
"#yr": "year"
},
ExpressionAttributeValues: {
":yyyy": 1992,
":letter1": "A",
":letter2": "L"
}
};
node MoviesQuery02.js
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
AWS.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
});
var params = {
TableName: "Movies",
ProjectionExpression: "#yr, title, info.rating",
FilterExpression: "#yr between :start_yr and :end_yr",
ExpressionAttributeNames: {
"#yr": "year",
},
ExpressionAttributeValues: {
":start_yr": 1950,
":end_yr": 1959
}
};
node MoviesScan.js
Note
También puede usar la operación Scan con cualesquiera índices secundarios que ha creado en la
tabla. Para obtener más información, consulte Uso de índices secundarios para mejorar el acceso
a los datos (p. 567).
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
var AWS = require("aws-sdk");
AWS.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
});
var params = {
TableName : "Movies"
};
node MoviesDeleteTable.js
Summary
En este tutorial, hemos creado laMoviesen Amazon DynamoDB en el equipo y realizó las operaciones
básicas. La versión descargable de DynamoDB resulta útil para tareas de desarrollo y pruebas de
aplicaciones. Sin embargo, cuando la aplicación esté preparada para ejecutarla en un entorno de
producción, debe modificar el código de modo que utilice el servicio web de DynamoDB.
AWS.config.update({endpoint: "https://dynamodb.aws-region.amazonaws.com"});
Por ejemplo, si desea utilizar la región us-west-2, establezca el punto de enlace siguiente.
AWS.config.update({endpoint: "https://dynamodb.us-west-2.amazonaws.com"});
En lugar de utilizar DynamoDB en el equipo, ahora el programa usará el punto de enlace del servicio web
de DynamoDB en la región de EE.UU. Oeste (Oregón).
DynamoDB está disponible enAWSRegiones del mundo. Para ver una lista completa, consulteRegiones
y puntos de enlace deen laAWSReferencia general de. Para obtener más información sobre cómo
configurar las regiones y los puntos de enlace en el código, consulte Setting the Region en la AWS SDK for
JavaScript Developer Guide.
• Crear una tabla denominada Movies mediante un programa de utilidad escrito en C# y cargar ejemplos
de datos en formato JSON.
• Realizar operaciones de creación, lectura, actualización y eliminación en la tabla.
• Ejecutar consultas sencillas.
El módulo de DynamoDB del AWS SDK for .NET ofrece varios modelos de programación para diferentes
casos de uso. En este ejercicio, en el código C# se utiliza el modelo de documento, que proporciona un
nivel de abstracción que suele ser práctico. También utiliza la API de bajo nivel, que administra atributos
anidados de forma más eficaz.
Para obtener información acerca de la API del modelo de documento, consulte .NET: Modelo de
documento (p. 279). Para obtener información acerca de la API de bajo nivel, consulte Uso de tablas de
DynamoDB en .NET (p. 403).
Temas
• Requisitos previos del tutorial de.NET y DynamoDB (p. 143)
• Paso 1: Creación de un cliente de DynamoDB (p. 144)
• Paso 2: Creación de una tabla de DynamoDB con la API de bajo nivel (p. 146)
• Paso 3: Carga de datos de ejemplo en la tabla de DynamoDB (p. 148)
• Paso 4: Agregar una película a la tabla de DynamoDB (p. 150)
• Paso 5: Leer y mostrar un registro de la tabla de DynamoDB (p. 151)
• Paso 6: Actualización del nuevo registro de película en la tabla de DynamoDB (p. 152)
Antes de comenzar, siga estos pasos para asegurarse de que dispone de todos los requisitos previos
necesarios para completar el aprendizaje:
• Utilice un equipo en el que se ejecute una versión reciente de Windows y una versión actual de Microsoft
Visual Studio. Si todavía no ha instalado Visual Studio, puede descargar una copia gratuita de la edición
Community en el sitio web de Microsoft Visual Studio.
• Descargue y ejecute DynamoDB (versión descargable). Para obtener más información, consulte
Configuración de DynamoDB Local (versión descargable) (p. 50).
Note
En este tutorial se utiliza la versión descargable de DynamoDB. Para obtener más información
sobre cómo ejecutar el mismo código en el servicio web de DynamoDB, consultePaso 1:
Creación de un cliente de DynamoDB (p. 144).
• Configurar unaAWSPara utilizar la claveAWSSDK. Para obtener más información, consulte
Configuración de DynamoDB (servicio web) (p. 57).
• Configure un perfil de seguridad para DynamoDB en Visual Studio. Para obtener instrucciones paso a
paso, consulte Ejemplos de código .NET (p. 340).
• Abra la solución de demostración de introducción que se utiliza en este tutorial en Visual Studio:
Note
En este tutorial se muestra cómo utilizar métodos asíncronos en lugar de métodos síncronos. Esto
se debe a que .NET Core solo admite métodos asíncronos y también porque el modelo asíncrono
es preferible en general cuando el rendimiento es fundamental. Para obtener más información,
consulteAWSAPI asincrónicas de para .NET.
Para instalar el paquete NuGet para el módulo de DynamoDB delAWS SDK for .NETversión 3 en sus
propios programas, abra elConsola del administrador de paquetes NuGeten elHerramientas deEn Visual
Studio. A continuación, escriba el siguiente comando en laPM>.
Install-Package AWSSDK.DynamoDBv2
De forma similar, puede utilizar laConsola del administrador de paquetes NuGetPara cargar
elJson.NETEn sus propios proyectos en Visual Studio. En elPM>, escriba el siguiente comando.
Install-Package Newtonsoft.Json
Paso siguiente
Paso 1: Creación de un cliente de DynamoDB (p. 144)
using System;
using System.Net;
using System.Net.NetworkInformation;
using Amazon.DynamoDBv2;
namespace DynamoDB_intro
{
public static partial class DdbIntro
{
/
*-----------------------------------------------------------------------------------
* If you are creating a client for the Amazon DynamoDB service, make sure your
credentials
* are set up first, as explained in:
* https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/
SettingUp.DynamoWebService.html,
*
* If you are creating a client for DynamoDBLocal (for testing purposes),
* DynamoDB-Local should be started first. For most simple testing, you can keep
* data in memory only, without writing anything to disk. To do this, use the
* following command line:
*
* java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -
inMemory
*
* For information about DynamoDBLocal, see:
* https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/
DynamoDBLocal.html.
*-----------------------------------------------------------------------------------*/
return isAvailable;
}
return true;
}
}
Main llama a esta función con el parámetro useDynamoDBLocal establecido en true. Por tanto, la
versión de prueba local de DynamoDB ya debe estar ejecutándose en su equipo utilizando el puerto
predeterminado (8000) o la llamada falla. Si aún no lo tiene instalado, consulte.Ejecución de DynamoDB en
el equipo (p. 50).
Paso siguiente
Paso 2: Creación de una tabla de DynamoDB con la API de bajo nivel (p. 146)
En este paso de laTutorial de Microsoft NET y DynamoDB (p. 142), se crea una tabla
denominadaMoviesEn Amazon DynamoDB. La clave principal de la tabla se compone de los siguientes
atributos:
Dado que «year» es una palabra reservada en DynamoDB, tiene que crear un alias para ella
(como, por ejemplo,)#yr) usandoExpressionAttributeNamescuando se hace referencia a
él en una expresión de bajo nivel.
• title: clave de ordenación. El valor de AttributeType es S si es de cadena.
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Amazon.DynamoDBv2.Model;
namespace DynamoDB_intro
{
public static partial class DdbIntro
{
public static async Task<bool> CheckingTableExistence_async(string tblNm)
{
var response = await DdbIntro.Client.ListTablesAsync();
return response.TableNames.Contains(tblNm);
}
try
{
var makeTbl = await DdbIntro.Client.CreateTableAsync(request);
}
catch (Exception)
{
response = false;
}
return response;
}
return result;
}
}
}
El ejemplo DynamoDB_intro utiliza métodos asíncronos en lugar de métodos síncronos siempre que
es posible. Esto se debe a que .NET Core solo admite métodos asíncronos y el modelo asíncrono
es preferible en general cuando el rendimiento es fundamental. Para obtener más información,
consulteAWSAPI asincrónicas de para .NET.
Para obtener más información sobre cómo administrar tablas, consulte Uso de tablas y datos en
DynamoDB (p. 344).
Paso siguiente
Paso 3: Carga de datos de ejemplo en la tabla de DynamoDB (p. 148)
Para cada película, moviedata.json define un par de nombre-valor year, un par de nombre-valor
title y un objeto info complejo, como se muestra en el ejemplo siguiente.
{
"year" : 2013,
"title" : "Turn It Down, Or Else!",
"info" : {
"directors" : [
"Alice Smith",
"Bob Jones"
],
"release_date" : "2013-01-18T00:00:00Z",
"rating" : 6.2,
"genres" : [
"Comedy",
"Drama"
],
"image_url" : "http://ia.media-imdb.com/images/N/
O9ERWAU7FS797AJ7LU8HN09AMUP908RLlo5JF90EWR7LJKQ7@@._V1_SX400_.jpg",
"plot" : "A rock band plays their music at high volumes, annoying the neighbors.",
"rank" : 11,
"running_time_secs" : 5215,
"actors" : [
"David Matthewman",
"Ann Thomas",
"Jonathan G. Neff"
]
}
}
using System;
using System.IO;
using System.Threading.Tasks;
using Amazon.DynamoDBv2.DocumentModel;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
namespace DynamoDB_intro
{
public static partial class DdbIntro
{
public static async Task<bool> LoadingData_async(Table table, string filePath)
{
var movieArray = await ReadJsonMovieFile_async(filePath);
if (movieArray != null)
await LoadJsonMovieData_async(table, movieArray);
return true;
try
{
sr = new StreamReader(jsonMovieFilePath);
jtr = new JsonTextReader(sr);
movieArray = (JArray)await JToken.ReadFromAsync(jtr);
}
catch (Exception ex)
{
Console.WriteLine(" ERROR: could not read the file!\n Reason:
{0}.", ex.Message);
}
finally
{
jtr?.Close();
sr?.Close();
}
return movieArray;
}
return true;
}
}
}
Paso siguiente
Paso 4: Agregar una película a la tabla de DynamoDB (p. 150)
using System;
using System.Threading.Tasks;
using Amazon.DynamoDBv2.DocumentModel;
namespace DynamoDB_intro
{
public static partial class DdbIntro
{
public static async Task<bool> CheckingForMovie_async(Document newItem)
{
int year = (int)newItem["year"];
string name = newItem["title"];
try
{
var writeNew = await MoviesTable.PutItemAsync(newItem);
Console.WriteLine(" -- Writing a new movie to the Movies table...");
return result;
}
}
}
Paso siguiente
Paso 5: Leer y mostrar un registro de la tabla de DynamoDB (p. 151)
using System;
using System.Threading.Tasks;
using Amazon.DynamoDBv2.DocumentModel;
namespace DynamoDB_intro
{
public static partial class DdbIntro
{
public static async Task<Document> ReadingMovie_async(int year, string title)
{
// Create Primitives for the HASH and RANGE portions of the primary key
Primitive hash = new Primitive(year.ToString(), true);
Primitive range = new Primitive(title, false);
try
{
var movieItem = await MoviesTable.GetItemAsync(hash, range, Token);
return movieItem;
}
catch (Exception)
{
return null;
}
}
}
}
Paso siguiente
Paso 6: Actualización del nuevo registro de película en la tabla de DynamoDB (p. 152)
Temas
• Cambiar trama y valoración y añadir actores (p. 152)
• Aumentar la valoración de la película de forma atómica (p. 153)
• Intentar actualizar utilizando una condición que falla (p. 154)
• Para obtener más información (p. 154)
• Paso siguiente (p. 154)
},
UpdateExpression = "SET info.rating = :r, info.plot = :p, info.actors = :a",
ReturnValues = "NONE"
};
using System;
using System.Threading.Tasks;
using Amazon.DynamoDBv2.Model;
namespace DynamoDB_intro
{
public static partial class DdbIntro
{
public static async Task<bool> UpdatingMovie_async(UpdateItemRequest updateRequest)
{
var result = false;
try
{
await Client.UpdateItemAsync(updateRequest);
result = true;
}
catch (Exception)
{
result = false;
}
return result;
}
}
}
Para aumentar la valoración de la película que acaba de crear, la función Main realiza los cambios
siguientes en la UpdateItemRequest que utilizó en la actualización anterior.
};
updateRequest.UpdateExpression = "SET info.rating = info.rating + :inc";
Para demostrar esto, la función Main lleva a cabo los cambios siguientes en UpdateItemRequest que
utilizó para aumentar la valoración de la película.
La actualización ahora se puede producir solo si hay más de tres actores en el registro de película que
se está actualizando. Dado que solo se enumeran tres actores, la condición falla cuando Main espera en
UpdatingMovie_async y la actualización no se produce.
Paso siguiente
Paso 7: Eliminar condicionalmente (p. 154)
La función Main en DynamoDB_intro comienza creando una condición del siguiente modo.
using System;
using System.Threading.Tasks;
using Amazon.DynamoDBv2.DocumentModel;
namespace DynamoDB_intro
{
Console.WriteLine( " -- Trying to delete the {0} movie \"{1}\"...", year, title );
try
{
var delItem = table.DeleteItemAsync( hash, range, deleteConfig );
deletedItem = await delItem;
}
catch( Exception ex )
{
Console.WriteLine( " FAILED to delete the movie item, for this reason:\n
{0}\n", ex.Message );
return false;
}
Console.WriteLine( " -- SUCCEEDED in deleting the movie record that looks like
this:\n" +
deletedItem.ToJsonPretty( ) );
return true;
}
}
}
Dado que la valoración de la película es 6,5, que es mayor que 5,0, la condición no se cumple y la
eliminación no se lleva a cabo.
A continuación, cuando la función Main cambia el umbral de valoración en la condición a 7,0 en lugar de
5,0, la eliminación se realiza correctamente.
Paso siguiente
Paso 8: Consultar una tabla de DynamoDB con .NET (p. 155)
Temas
• Utilice una búsqueda de modelo de documento sencilla para consultar películas de 1985 (p. 156)
• Utilizar una QueryOperationConfig para crear una búsqueda de consulta más compleja (p. 156)
• Utilizar una consulta de bajo nivel para buscar películas de 1992 con títulos entre "M..." y
"Tzz..." (p. 157)
• Paso siguiente (p. 157)
using System;
using System.Threading.Tasks;
using Amazon.DynamoDBv2.Model;
using Amazon.DynamoDBv2.DocumentModel;
using System.Collections.Generic;
namespace DynamoDB_intro
{
public static partial class DdbIntro
{
public static async Task<List<List<Document>>> SearchListing_async(Search search)
{
List<List<Document>> docsList = new List<List<Document>>();
do
{
try
{
var getNextBatch = search.GetNextSetAsync();
var docList = await getNextBatch;
docsList.Add(docList);
}
catch (Exception)
{
return null;
}
} while (!search.IsDone);
return docsList;
}
Nuevamente, crea un objeto Search llamando a la API Table.Query, esta vez con el objeto
QueryOperationConfig como único parámetro.
Dado que «year» es una palabra reservada en DynamoDB, tiene que crear un alias para ella
(aquí#yr) usandoExpressionAttributeNamespara usarlo en una expresión de bajo nivel.
Paso siguiente
Paso 9: Analizar la tabla Movies con .NET (p. 157)
Temas
• Utilice una búsqueda de modelo de documento para analizar películas de los años 50 (p. 158)
• Utilizar un análisis de bajo nivel para recuperar películas de los años 60 (p. 158)
Para obtener un objeto Search para el análisis, pasa el objeto ScanOperationConfig a Table.Scan.
Utilizando el objeto Search, espera a continuación en SearchListing_async (implementado en
08_Querying.cs) para recuperar y mostrar los resultados del análisis.
Dado que «year» es una palabra reservada en DynamoDB, tiene que crear un alias para ella
(aquí#yr) usandoExpressionAttributeNamespara usarlo en una expresión de bajo nivel.
Paso siguiente
Paso 10: Eliminación de la tabla Movies con .NET (p. 159)
using System;
using System.Threading.Tasks;
namespace DynamoDB_intro
{
public static partial class DdbIntro
{
public static async Task<bool> DeletingTable_async(string tableName)
{
var tblDelete = await Client.DeleteTableAsync(tableName);
return true;
}
}
}
PHP y DynamoDB
En este tutorial, utilizaremos elAWS SDK for PHPPara escribir programas sencillos que lleven a cabo las
operaciones de Amazon DynamoDB siguientes:
• Crear una tabla denominada Movies y cargar ejemplos de datos en formato JSON.
• Realizar operaciones de creación, lectura, actualización y eliminación en la tabla.
• Ejecutar consultas sencillas.
Mientras realiza este tutorial, puede consultar laAWS SDK for PHPGuía para desarrolladores. LaSección
Amazon DynamoDBen laAWS SDK for PHPReferencia de la APIdescribe los parámetros y resultados de
las operaciones de DynamoDB.
Note
En este tutorial se utiliza la versión descargable de DynamoDB. Para obtener información sobre
cómo ejecutar el mismo código en el servicio de DynamoDB, consulte elSummary (p. 179).
• Configure unaAWSpara utilizar la clave de acceso de laAWSSDK. Para obtener más información,
consulte Configuración de DynamoDB (servicio web) (p. 57).
• Configurar la AWS SDK for PHP:
• Instalar PHP PHP.
• Instale el SDK for PHP..
Para obtener más información, consulteIntroducciónen laAWS SDK for PHPGuía de introducción.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
require 'vendor/autoload.php';
date_default_timezone_set('UTC');
use Aws\DynamoDb\Exception\DynamoDbException;
$dynamodb = $sdk->createDynamoDb();
$params = [
'TableName' => 'Movies',
'KeySchema' => [
[
'AttributeName' => 'year',
'KeyType' => 'HASH' //Partition key
],
[
'AttributeName' => 'title',
'KeyType' => 'RANGE' //Sort key
]
],
'AttributeDefinitions' => [
[
'AttributeName' => 'year',
'AttributeType' => 'N'
],
[
'AttributeName' => 'title',
'AttributeType' => 'S'
],
],
'ProvisionedThroughput' => [
'ReadCapacityUnits' => 10,
'WriteCapacityUnits' => 10
]
];
try {
$result = $dynamodb->createTable($params);
echo 'Created table. Status: ' .
$result['TableDescription']['TableStatus'] ."\n";
Note
• El punto de enlace debe configurarse de modo que indique que está creando la tabla en
Amazon DynamoDB en el equipo.
• En la llamada createTable, especifique el nombre de la tabla, los atributos de clave
principal y los tipos de datos.
• LaProvisionedThroughputEl parámetro es obligatorio; sin embargo, en la versión
descargable de DynamoDB se hace caso omiso de él. El desempeño provisionado está
fuera del alcance de este ejercicio.
2. Para ejecutar el programa, introduzca el siguiente comando.
php MoviesCreateTable.php
Para obtener más información sobre cómo administrar tablas, consulte Uso de tablas y datos en
DynamoDB (p. 344).
Temas
• Paso 2.1: Descargue el archivo de datos de ejemplo (p. 162)
• Paso 2.2: Cargue los ejemplos de datos en la tabla Movies (p. 163)
En este escenario se utiliza un ejemplo de archivo de datos que contiene información sobre varios miles de
películas de IMDb (Internet Movie Database). Los datos de las películas se encuentran en formato JSON,
tal y como se muestra en el siguiente ejemplo. Para cada película, se indican el año, year, el título, title
y un mapa JSON denominado info.
[
{
"year" : ... ,
"title" : ... ,
"info" : { ... }
},
{
"year" : ...,
"title" : ...,
"info" : { ... }
},
...
• year y title se utilizan como valores de atributos de clave principal de la tabla Movies.
• El resto de los valores info se almacenan en un único atributo denominado info. Este programa ilustra
cómo almacenar JSON en un atributo de Amazon DynamoDB.
{
"year" : 2013,
"title" : "Turn It Down, Or Else!",
"info" : {
"directors" : [
"Alice Smith",
"Bob Jones"
],
"release_date" : "2013-01-18T00:00:00Z",
"rating" : 6.2,
"genres" : [
"Comedy",
"Drama"
],
"image_url" : "http://ia.media-imdb.com/images/N/
O9ERWAU7FS797AJ7LU8HN09AMUP908RLlo5JF90EWR7LJKQ7@@._V1_SX400_.jpg",
"plot" : "A rock band plays their music at high volumes, annoying the neighbors.",
"rank" : 11,
"running_time_secs" : 5215,
"actors" : [
"David Matthewman",
"Ann Thomas",
"Jonathan G. Neff"
]
}
}
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
require 'vendor/autoload.php';
date_default_timezone_set('UTC');
use Aws\DynamoDb\Exception\DynamoDbException;
use Aws\DynamoDb\Marshaler;
$dynamodb = $sdk->createDynamoDb();
$marshaler = new Marshaler();
$tableName = 'Movies';
$year = $movie['year'];
$title = $movie['title'];
$info = $movie['info'];
$json = json_encode([
'year' => $year,
'title' => $title,
'info' => $info
]);
$params = [
'TableName' => $tableName,
'Item' => $marshaler->marshalJson($json)
];
try {
$result = $dynamodb->putItem($params);
echo "Added movie: " . $movie['year'] . " " . $movie['title'] . "\n";
} catch (DynamoDbException $e) {
echo "Unable to add movie:\n";
echo $e->getMessage() . "\n";
break;
}
Note
php MoviesLoadData.php
Para obtener más información sobre cómo leer y escribir datos, consulte Uso de elementos y
atributos (p. 410).
Temas
• Paso 3.1: Crear un elemento nuevo (p. 164)
• Paso 3.2: Lea un elemento (p. 166)
• Paso 3.3: Actualización de un elemento (p. 167)
• Paso 3.4: Incremento de un contador atómico (p. 169)
• Paso 3.5: Actualización de un elemento (condicionalmente) (p. 170)
• Paso 3.6: Eliminación de un elemento (p. 172)
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
require 'vendor/autoload.php';
date_default_timezone_set('UTC');
use Aws\DynamoDb\Exception\DynamoDbException;
use Aws\DynamoDb\Marshaler;
$dynamodb = $sdk->createDynamoDb();
$marshaler = new Marshaler();
$tableName = 'Movies';
$year = 2015;
$title = 'The Big New Movie';
$item = $marshaler->marshalJson('
{
"year": ' . $year . ',
"title": "' . $title . '",
"info": {
"plot": "Nothing happens at all.",
"rating": 0
}
}
');
$params = [
'TableName' => 'Movies',
'Item' => $item
];
try {
$result = $dynamodb->putItem($params);
echo "Added item: $year - $title\n";
Note
La clave principal es obligatoria. Este código agrega un elemento que tiene la clave principal
(year, title) y atributos info. El atributo info almacena un mapa que proporciona más
información sobre la película.
2. Para ejecutar el programa, introduzca el siguiente comando.
php MoviesItemOps01.php
{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Nothing happens at all.",
rating: 0
}
}
Puede utilizar el método getItem para leer el elemento en la tabla Movies. Debe especificar los valores
de clave principal para poder leer cualquier elemento de Movies si conoce los valores de year y title.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
require 'vendor/autoload.php';
date_default_timezone_set('UTC');
use Aws\DynamoDb\Exception\DynamoDbException;
use Aws\DynamoDb\Marshaler;
$dynamodb = $sdk->createDynamoDb();
$marshaler = new Marshaler();
$tableName = 'Movies';
$year = 2015;
$title = 'The Big New Movie';
$key = $marshaler->marshalJson('
{
"year": ' . $year . ',
"title": "' . $title . '"
}
');
$params = [
'TableName' => $tableName,
try {
$result = $dynamodb->getItem($params);
print_r($result["Item"]);
php MoviesItemOps02.php
{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Nothing happens at all.",
rating: 0
}
}
{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Everything happens all at once.",
rating: 5.5,
actors: ["Larry", "Moe", "Curly"]
}
}
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
require 'vendor/autoload.php';
date_default_timezone_set('UTC');
use Aws\DynamoDb\Exception\DynamoDbException;
use Aws\DynamoDb\Marshaler;
$dynamodb = $sdk->createDynamoDb();
$marshaler = new Marshaler();
$tableName = 'Movies';
$year = 2015;
$title = 'The Big New Movie';
$key = $marshaler->marshalJson('
{
"year": ' . $year . ',
"title": "' . $title . '"
}
');
$eav = $marshaler->marshalJson('
{
":r": 5.5 ,
":p": "Everything happens all at once.",
":a": [ "Larry", "Moe", "Curly" ]
}
');
$params = [
'TableName' => $tableName,
'Key' => $key,
'UpdateExpression' =>
'set info.rating = :r, info.plot=:p, info.actors=:a',
'ExpressionAttributeValues'=> $eav,
'ReturnValues' => 'UPDATED_NEW'
];
try {
$result = $dynamodb->updateItem($params);
echo "Updated item.\n";
print_r($result['Attributes']);
Note
Este programa utiliza UpdateExpression para describir todas las actualizaciones que
desee realizar con el elemento especificado.
LaReturnValuesEl parámetro indica a Amazon DynamoDB que devuelva únicamente los
atributos actualizados (UPDATED_NEW).
2. Para ejecutar el programa, introduzca el siguiente comando.
php MoviesItemOps03.php
El programa siguiente muestra cómo aumentar el valor de rating para una película. Cada vez que se
ejecuta el programa, incrementa el valor de este atributo en una unidad.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
require 'vendor/autoload.php';
date_default_timezone_set('UTC');
use Aws\DynamoDb\Exception\DynamoDbException;
use Aws\DynamoDb\Marshaler;
$dynamodb = $sdk->createDynamoDb();
$marshaler = new Marshaler();
$tableName = 'Movies';
$year = 2015;
$title = 'The Big New Movie';
$key = $marshaler->marshalJson('
{
"year": ' . $year . ',
"title": "' . $title . '"
}
');
$eav = $marshaler->marshalJson('
{
":val": 1
}
');
$params = [
'TableName' => $tableName,
'Key' => $key,
'UpdateExpression' => 'set info.rating = info.rating + :val',
'ExpressionAttributeValues'=> $eav,
'ReturnValues' => 'UPDATED_NEW'
];
try {
$result = $dynamodb->updateItem($params);
echo "Updated item. ReturnValues are:\n";
print_r($result['Attributes']);
php MoviesItemOps04.php
En este caso, el elemento se actualiza solamente si hay más de tres actores en la película.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
require 'vendor/autoload.php';
date_default_timezone_set('UTC');
use Aws\DynamoDb\Exception\DynamoDbException;
use Aws\DynamoDb\Marshaler;
$dynamodb = $sdk->createDynamoDb();
$marshaler = new Marshaler();
$tableName = 'Movies';
$year = 2015;
$title = 'The Big New Movie';
$key = $marshaler->marshalJson('
{
"year": ' . $year . ',
"title": "' . $title . '"
}
');
$eav = $marshaler->marshalJson('
{
":num": 3
}
');
$params = [
'TableName' => $tableName,
'Key' => $key,
'UpdateExpression' => 'remove info.actors[0]',
'ConditionExpression' => 'size(info.actors) > :num',
'ExpressionAttributeValues'=> $eav,
'ReturnValues' => 'UPDATED_NEW'
];
try {
$result = $dynamodb->updateItem($params);
echo "Updated item. ReturnValues are:\n";
print_r($result['Attributes']);
php MoviesItemOps05.php
El progama falla porque la película tiene tres actores, pero la condición busca un valor mayor que tres
actores.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
require 'vendor/autoload.php';
date_default_timezone_set('UTC');
use Aws\DynamoDb\Exception\DynamoDbException;
use Aws\DynamoDb\Marshaler;
$dynamodb = $sdk->createDynamoDb();
$marshaler = new Marshaler();
$tableName = 'Movies';
$year = 2015;
$title = 'The Big New Movie';
$key = $marshaler->marshalJson('
{
"year": ' . $year . ',
"title": "' . $title . '"
}
');
$eav = $marshaler->marshalJson('
{
":val": 5
}
');
$params = [
'TableName' => $tableName,
'Key' => $key,
'ConditionExpression' => 'info.rating <= :val',
'ExpressionAttributeValues'=> $eav
];
try {
$result = $dynamodb->deleteItem($params);
echo "Deleted item.\n";
php MoviesItemOps06.php
$params = [
'TableName' => $tableName,
'Key' => $key
];
Para buscar todas las películas estrenadas durante un año, solo debe especificar el valor de year.
También puede indicar el valor de title si desea recuperar un subconjunto de películas basadas en una
condición determinada (la clave de ordenación). Por ejemplo, para encontrar las películas estrenadas en
2014 cuyo título comienza por la "A".
Además de laquery, puede usar el método descanmétodo para recuperar todos los datos de la tabla.
Para obtener más información sobre cómo consultar y examinar datos, consulte Uso de consultas en
DynamoDB (p. 497) y Uso de operaciones de examen en DynamoDB (p. 516), respectivamente.
Temas
• Paso 4.1: Consulta - Todas las películas estrenadas durante un año (p. 174)
• Paso 4.2: Consulta - Todas las películas estrenadas durante un año con unos títulos
determinados (p. 175)
• Paso 4.3: Examen (p. 177)
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
require 'vendor/autoload.php';
date_default_timezone_set('UTC');
use Aws\DynamoDb\Exception\DynamoDbException;
use Aws\DynamoDb\Marshaler;
$dynamodb = $sdk->createDynamoDb();
$marshaler = new Marshaler();
$tableName = 'Movies';
$eav = $marshaler->marshalJson('
{
":yyyy": 1985
}
');
$params = [
'TableName' => $tableName,
'KeyConditionExpression' => '#yr = :yyyy',
'ExpressionAttributeNames'=> [ '#yr' => 'year' ],
'ExpressionAttributeValues'=> $eav
];
try {
$result = $dynamodb->query($params);
Note
php MoviesItemQuery01.php
Note
El programa anterior muestra cómo consultar una tabla según sus atributos de clave principal.
En Amazon DynamoDB, puede crear si lo desea uno o varios índices secundarios en una tabla y
consultarlos de la misma forma que se consulta una tabla. Los índices secundarios ofrecen a las
aplicaciones mayor flexibilidad, porque permiten consultar atributos sin clave. Para obtener más
información, consulte Uso de índices secundarios para mejorar el acceso a los datos (p. 567).
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
require 'vendor/autoload.php';
date_default_timezone_set('UTC');
use Aws\DynamoDb\Exception\DynamoDbException;
use Aws\DynamoDb\Marshaler;
$dynamodb = $sdk->createDynamoDb();
$marshaler = new Marshaler();
$tableName = 'Movies';
$eav = $marshaler->marshalJson('
{
":yyyy":1992,
":letter1": "A",
":letter2": "L"
}
');
$params = [
'TableName' => $tableName,
'ProjectionExpression' => '#yr, title, info.genres, info.actors[0]',
'KeyConditionExpression' =>
'#yr = :yyyy and title between :letter1 and :letter2',
'ExpressionAttributeNames'=> [ '#yr' => 'year' ],
'ExpressionAttributeValues'=> $eav
];
echo "Querying for movies from 1992 - titles A-L, with genres and lead actor\n";
try {
$result = $dynamodb->query($params);
php MoviesQuery02.php
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
require 'vendor/autoload.php';
date_default_timezone_set('UTC');
use Aws\DynamoDb\Exception\DynamoDbException;
use Aws\DynamoDb\Marshaler;
$dynamodb = $sdk->createDynamoDb();
$params = [
'TableName' => 'Movies',
'ProjectionExpression' => '#yr, title, info.rating',
try {
while (true) {
$result = $dynamodb->scan($params);
if (isset($result['LastEvaluatedKey'])) {
$params['ExclusiveStartKey'] = $result['LastEvaluatedKey'];
} else {
break;
}
}
php MoviesScan.php
Note
También puede usar la operación Scan con cualesquiera índices secundarios que ha creado en la
tabla. Para obtener más información, consulte Uso de índices secundarios para mejorar el acceso
a los datos (p. 567).
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
require 'vendor/autoload.php';
date_default_timezone_set('UTC');
use Aws\DynamoDb\Exception\DynamoDbException;
$dynamodb = $sdk->createDynamoDb();
$params = [
'TableName' => 'Movies'
];
try {
$result = $dynamodb->deleteTable($params);
echo "Deleted table.\n";
php MoviesDeleteTable.php
Summary
En este tutorial, hemos creado elMoviesEn Amazon DynamoDB en el equipo y realizó las operaciones
básicas. La versión para descargar de DynamoDB resulta útil para tareas de desarrollo y pruebas
de aplicaciones. Sin embargo, cuando la aplicación esté preparada para ejecutarla en un entorno de
producción, es importante modificar el código de modo que utilice el servicio web de DynamoDB.
Después de quitar esta línea, el código puede obtener acceso al servicio web DynamoDB en elAWSRegión
especificada por el parámetroregionvalor de configuración. Por ejemplo, en la siguiente línea se
especifica que se desea utilizar la región EE.UU. Oeste (Oregón).
En lugar de utilizar la versión descargable de DynamoDB en el equipo, ahora el programa usará el punto
de enlace del servicio de DynamoDB en la región EE.UU. Oeste (Oregón).
DynamoDB está disponible enAWSRegiones del mundo entero. Para ver una lista completa,
consulteRegiones y puntos de enlace deen laAWSReferencia general de. Para obtener más información
sobre cómo configurar las regiones y los puntos de enlace en el código, consulte laboto: Interfaz Python de
Python a Amazon Web Services.
• Crear una tabla denominada Movies y cargar ejemplos de datos en formato JSON.
• Realizar operaciones de creación, lectura, actualización y eliminación en la tabla.
• Ejecutar consultas sencillas.
Mientras realiza este tutorial, puede consultar la documentación de AWS SDK for Python (Boto). Las
siguientes secciones son específicas de DynamoDB:
• Manual de DynamoDB
• Cliente de bajo nivel de DynamoDB
import boto3
def create_movie_table(dynamodb=None):
if not dynamodb:
dynamodb = boto3.resource('dynamodb', endpoint_url="http://localhost:8000")
table = dynamodb.create_table(
TableName='Movies',
KeySchema=[
{
'AttributeName': 'year',
'KeyType': 'HASH' # Partition key
},
{
'AttributeName': 'title',
'KeyType': 'RANGE' # Sort key
}
],
AttributeDefinitions=[
{
'AttributeName': 'year',
'AttributeType': 'N'
},
{
'AttributeName': 'title',
'AttributeType': 'S'
},
],
ProvisionedThroughput={
'ReadCapacityUnits': 10,
'WriteCapacityUnits': 10
}
)
return table
if __name__ == '__main__':
movie_table = create_movie_table()
print("Table status:", movie_table.table_status)
Note
• El punto de enlace debe configurarse de modo que indique que está creando la tabla en
elversión descargable de DynamoDBen su equipo.
• En la llamada create_table, especifique el nombre de la tabla, los atributos de clave
principal y los tipos de datos.
python MoviesCreateTable.py
Para obtener más información sobre cómo administrar tablas, consulte Uso de tablas y datos en
DynamoDB (p. 344).
Temas
• Paso 2.1: Descargue el archivo de datos de ejemplo (p. 183)
• Paso 2.2: Cargue los ejemplos de datos en la tabla Movies (p. 183)
En este escenario se utiliza un ejemplo de archivo de datos que contiene información sobre varios miles de
películas de IMDb (Internet Movie Database). Los datos de las películas se encuentran en formato JSON,
tal y como se muestra en el siguiente ejemplo. Para cada película, se indican el año, year, el título, title
y un mapa JSON denominado info.
[
{
"year" : ... ,
"title" : ... ,
"info" : { ... }
},
{
"year" : ...,
"title" : ...,
"info" : { ... }
},
...
• year y title se utilizan como valores de atributos de clave principal de la tabla Movies.
• El resto de los valores info se almacenan en un único atributo denominado info. Este programa ilustra
cómo almacenar JSON en un atributo de Amazon DynamoDB.
{
"year" : 2013,
"title" : "Turn It Down, Or Else!",
"info" : {
"directors" : [
"Alice Smith",
"Bob Jones"
],
"release_date" : "2013-01-18T00:00:00Z",
"rating" : 6.2,
"genres" : [
"Comedy",
"Drama"
],
"image_url" : "http://ia.media-imdb.com/images/N/
O9ERWAU7FS797AJ7LU8HN09AMUP908RLlo5JF90EWR7LJKQ7@@._V1_SX400_.jpg",
"plot" : "A rock band plays their music at high volumes, annoying the neighbors.",
"rank" : 11,
"running_time_secs" : 5215,
"actors" : [
"David Matthewman",
"Ann Thomas",
"Jonathan G. Neff"
]
}
}
table = dynamodb.Table('Movies')
for movie in movies:
year = int(movie['year'])
title = movie['title']
print("Adding movie:", year, title)
table.put_item(Item=movie)
if __name__ == '__main__':
with open("moviedata.json") as json_file:
movie_list = json.load(json_file, parse_float=Decimal)
load_movies(movie_list)
python MoviesLoadData.py
Para obtener más información sobre cómo leer y escribir datos, consulte Uso de elementos y
atributos (p. 410).
Temas
• Paso 3.1: Creación de un elemento nuevo (p. 184)
• Paso 3.2: Lectura de un elemento (p. 185)
• Paso 3.3: Actualización de un elemento (p. 185)
• Paso 3.4: Incrementar un contador atómico (p. 187)
• Paso 3.5: Actualización de un elemento (condicionalmente) (p. 188)
• Paso 3.6: Eliminación de un elemento (p. 189)
table = dynamodb.Table('Movies')
response = table.put_item(
Item={
'year': year,
'title': title,
'info': {
'plot': plot,
'rating': rating
}
}
)
return response
if __name__ == '__main__':
movie_resp = put_movie("The Big New Movie", 2015,
"Nothing happens at all.", 0)
print("Put movie succeeded:")
pprint(movie_resp, sort_dicts=False)
Note
• La clave principal es obligatoria. Este código agrega un elemento que tiene la clave
principal (year, title) y atributos info. El atributo info almacena un ejemplo de código
JSON que proporciona más información sobre la película.
Versión de API 2012-08-10
184
Amazon DynamoDB Guía para desarrolladores
Paso 3: Operaciones de CRUD
python MoviesItemOps01.py
{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Nothing happens at all.",
rating: 0
}
}
Puede utilizar el método get_item para leer el elemento en la tabla Movies. Debe especificar los valores
de clave principal para poder leer cualquier elemento de Movies si conoce los valores de year y title.
table = dynamodb.Table('Movies')
try:
response = table.get_item(Key={'year': year, 'title': title})
except ClientError as e:
print(e.response['Error']['Message'])
else:
return response['Item']
if __name__ == '__main__':
movie = get_movie("The Big New Movie", 2015,)
if movie:
print("Get movie succeeded:")
pprint(movie, sort_dicts=False)
python MoviesItemOps02.py
{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Nothing happens at all.",
rating: 0
}
}
{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Everything happens all at once.",
rating: 5.5,
actors: ["Larry", "Moe", "Curly"]
}
}
table = dynamodb.Table('Movies')
response = table.update_item(
Key={
'year': year,
'title': title
},
UpdateExpression="set info.rating=:r, info.plot=:p, info.actors=:a",
ExpressionAttributeValues={
':r': Decimal(rating),
':p': plot,
':a': actors
},
ReturnValues="UPDATED_NEW"
)
return response
if __name__ == '__main__':
update_response = update_movie(
"The Big New Movie", 2015, 5.5, "Everything happens all at once.",
["Larry", "Moe", "Curly"])
Note
Este programa utiliza UpdateExpression para describir todas las actualizaciones que
desee realizar con el elemento especificado.
LaReturnValuesEl parámetro indica a DynamoDB que devuelva solamente los atributos
actualizados (UPDATED_NEW).
2. Para ejecutar el programa, introduzca el siguiente comando.
python MoviesItemOps03.py
El programa siguiente muestra cómo aumentar el valor de rating para una película. Cada vez que se
ejecuta el programa, incrementa el valor de este atributo en una unidad.
table = dynamodb.Table('Movies')
response = table.update_item(
Key={
'year': year,
'title': title
},
UpdateExpression="set info.rating = info.rating + :val",
ExpressionAttributeValues={
':val': Decimal(rating_increase)
},
ReturnValues="UPDATED_NEW"
)
return response
if __name__ == '__main__':
update_response = increase_rating("The Big New Movie", 2015, 1)
print("Update movie succeeded:")
pprint(update_response, sort_dicts=False)
python MoviesItemOps04.py
table = dynamodb.Table('Movies')
try:
response = table.update_item(
Key={
'year': year,
'title': title
},
UpdateExpression="remove info.actors[0]",
ConditionExpression="size(info.actors) > :num",
ExpressionAttributeValues={':num': actor_count},
ReturnValues="UPDATED_NEW"
)
except ClientError as e:
if e.response['Error']['Code'] == "ConditionalCheckFailedException":
print(e.response['Error']['Message'])
else:
raise
else:
return response
if __name__ == '__main__':
print("Attempting conditional update (expecting failure)...")
update_response = remove_actors("The Big New Movie", 2015, 3)
if update_response:
print("Update movie succeeded:")
pprint(update_response, sort_dicts=False)
python MoviesItemOps05.py
El progama falla porque la película tiene tres actores, pero la condición busca un valor mayor que tres
actores.
3. Modifique el programa para que ConditionExpression tenga el aspecto siguiente.
table = dynamodb.Table('Movies')
try:
response = table.delete_item(
Key={
'year': year,
'title': title
},
ConditionExpression="info.rating <= :val",
ExpressionAttributeValues={
":val": Decimal(rating)
}
)
except ClientError as e:
if e.response['Error']['Code'] == "ConditionalCheckFailedException":
print(e.response['Error']['Message'])
else:
raise
else:
return response
if __name__ == '__main__':
print("Attempting a conditional delete...")
delete_response = delete_underrated_movie("The Big New Movie", 2015, 5)
if delete_response:
print("Delete movie succeeded:")
pprint(delete_response, sort_dicts=False)
python MoviesItemOps06.py
response = table.delete_item(
Key={
'year': year,
'title': title
}
)
Para buscar todas las películas estrenadas durante un año, solo debe especificar el valor de year.
También puede indicar el valor de title si desea recuperar un subconjunto de películas basadas en una
condición determinada (la clave de ordenación). Por ejemplo, puede encontrar las películas estrenadas en
2014 cuyo título comienza por la "A".
Además del método query, puede usar el método scan para recuperar todos los datos de la tabla.
Para obtener más información sobre cómo consultar y examinar datos, consulte Uso de consultas en
DynamoDB (p. 497) y Uso de operaciones de examen en DynamoDB (p. 516), respectivamente.
Temas
• Paso 4.1: Consulta de todas las películas estrenadas durante un año (p. 190)
• Paso 4.2: Consulta de todas las películas estrenadas durante un año con unos títulos
determinados (p. 191)
• Paso 4.3: Examen (p. 192)
import boto3
from boto3.dynamodb.conditions import Key
table = dynamodb.Table('Movies')
response = table.query(
KeyConditionExpression=Key('year').eq(year)
)
return response['Items']
if __name__ == '__main__':
query_year = 1985
print(f"Movies from {query_year}")
movies = query_movies(query_year)
for movie in movies:
print(movie['year'], ":", movie['title'])
Note
python MoviesQuery01.py
Note
El programa anterior muestra cómo consultar una tabla según sus atributos de clave principal. En
DynamoDB, puede crear si lo desea uno o varios índices secundarios en una tabla y consultarlos
de la misma forma que se consulta una tabla. Los índices secundarios ofrecen a las aplicaciones
mayor flexibilidad, porque permiten consultar atributos sin clave. Para obtener más información,
consulte Uso de índices secundarios para mejorar el acceso a los datos (p. 567).
table = dynamodb.Table('Movies')
print(f"Get year, title, genres, and lead actor")
# Expression attribute names can only reference items in the projection expression.
response = table.query(
ProjectionExpression="#yr, title, info.genres, info.actors[0]",
ExpressionAttributeNames={"#yr": "year"},
KeyConditionExpression=
Key('year').eq(year) & Key('title').between(title_range[0], title_range[1])
)
return response['Items']
if __name__ == '__main__':
query_year = 1992
query_range = ('A', 'L')
print(f"Get movies from {query_year} with titles from "
f"{query_range[0]} to {query_range[1]}")
movies = query_and_project_movies(query_year, query_range)
for movie in movies:
print(f"\n{movie['year']} : {movie['title']}")
pprint(movie['info'])
python MoviesQuery02.py
table = dynamodb.Table('Movies')
scan_kwargs = {
'FilterExpression': Key('year').between(*year_range),
'ProjectionExpression': "#yr, title, info.rating",
'ExpressionAttributeNames': {"#yr": "year"}
}
done = False
start_key = None
while not done:
if start_key:
scan_kwargs['ExclusiveStartKey'] = start_key
response = table.scan(**scan_kwargs)
display_movies(response.get('Items', []))
start_key = response.get('LastEvaluatedKey', None)
done = start_key is None
if __name__ == '__main__':
def print_movies(movies):
for movie in movies:
print(f"\n{movie['year']} : {movie['title']}")
pprint(movie['info'])
Note
python MoviesScan.py
Note
También puede usar la operación Scan con cualesquiera índices secundarios que haya creado
en la tabla. Para obtener más información, consulte Uso de índices secundarios para mejorar el
acceso a los datos (p. 567).
import boto3
def delete_movie_table(dynamodb=None):
if not dynamodb:
dynamodb = boto3.resource('dynamodb', endpoint_url="http://localhost:8000")
table = dynamodb.Table('Movies')
table.delete()
if __name__ == '__main__':
Versión de API 2012-08-10
193
Amazon DynamoDB Guía para desarrolladores
Summary
delete_movie_table()
print("Movies table deleted.")
python MoviesDeleteTable.py
Summary
En este tutorial, ha creado elMoviesEn la versión descargable de Amazon DynamoDB en el equipo y
hemos realizado algunas operaciones básicas. La versión para descargar de DynamoDB resulta útil para
tareas de desarrollo y pruebas de aplicaciones. Sin embargo, cuando la aplicación esté preparada para
ejecutarla en un entorno de producción, debe modificar el código de modo que utilice el servicio web de
DynamoDB.
dynamodb = boto3.resource('dynamodb',endpoint_url="http://localhost:8000")
dynamodb = boto3.resource('dynamodb',region_name='us-west-2')
En lugar de utilizar la versión descargable de DynamoDB en el equipo, ahora el programa usará el servicio
web de DynamoDB en la región de EE.UU. Oeste (Oregón).
DynamoDB está disponible enAWSRegiones de todo el mundo Para ver la lista completa,
consulteRegiones y puntos de enlace deen laAWSReferencia general de. Para obtener más información
sobre cómo configurar las regiones y los puntos de enlace en el código, consulteAWSSelección de
regionesen laAWS SDK for JavaGuía para desarrolladores.
Ruby y DynamoDB
En este tutorial, se utiliza elAWS SDK for RubyPara escribir programas sencillos que lleven a cabo las
operaciones de Amazon DynamoDB siguientes:
• Crear una tabla denominada Movies y cargar ejemplos de datos en formato JSON.
• Realizar operaciones de creación, lectura, actualización y eliminación en la tabla.
• Ejecutar consultas sencillas.
Mientras realiza este tutorial, puede consultar laAWS SDK for RubyReferencia de la API. LaSección de
DynamoDBEn él se describen los parámetros y resultados de las operaciones de DynamoDB.
Note
Para obtener más información, consulteInstalación deen laAWS SDK for RubyReferencia de la API.
require 'aws-sdk-dynamodb'
def run_me
region = 'us-west-2'
dynamodb_client = Aws::DynamoDB::Client.new
table_definition = {
table_name: 'Movies',
key_schema: [
{
attribute_name: 'year',
key_type: 'HASH' # Partition key.
},
{
attribute_name: 'title',
key_type: 'RANGE' # Sort key.
}
],
attribute_definitions: [
{
attribute_name: 'year',
attribute_type: 'N'
},
{
attribute_name: 'title',
attribute_type: 'S'
}
],
provisioned_throughput: {
read_capacity_units: 10,
write_capacity_units: 10
}
}
if create_table_result == 'Error'
puts 'Table not created.'
else
puts "Table created with status '#{create_table_result}'."
end
end
Note
• El punto de enlace debe configurarse de modo que indique que está creando la tabla en la
versión descargable de Amazon DynamoDB en el equipo.
• En la llamada create_table, especifique el nombre de la tabla, los atributos de clave
principal y los tipos de datos.
• El parámetro provisioned_throughput es obligatorio. Sin embargo, la versión
descargable de DynamoDB no lo tiene en cuenta. El desempeño provisionado está fuera
del alcance de este ejercicio.
2. Para ejecutar el programa, introduzca el siguiente comando.
ruby MoviesCreateTable.rb
Para obtener más información sobre cómo administrar tablas, consulte Uso de tablas y datos en
DynamoDB (p. 344).
Temas
• Paso 2.1: Descargue el archivo de datos de ejemplo (p. 197)
• Paso 2.2: Cargue los ejemplos de datos en la tabla Movies (p. 198)
Usará un ejemplo de archivo de datos que contiene información sobre varios miles de películas de IMDb
(Internet Movie Database). Los datos de las películas se encuentran en formato JSON, tal y como se
muestra en el siguiente ejemplo. Para cada película, se indican el año, year, el título, title y un mapa
JSON denominado info.
{
"year" : ... ,
"title" : ... ,
"info" : { ... }
},
{
"year" : ...,
"title" : ...,
"info" : { ... }
},
...
• year y title se utilizan como valores de atributos de clave principal de la tabla Movies.
• El resto de los valores info se almacenan en un único atributo denominado info. Este programa ilustra
cómo almacenar JSON en un atributo de DynamoDB.
{
"year" : 2013,
"title" : "Turn It Down, Or Else!",
"info" : {
"directors" : [
"Alice Smith",
"Bob Jones"
],
"release_date" : "2013-01-18T00:00:00Z",
"rating" : 6.2,
"genres" : [
"Comedy",
"Drama"
],
"image_url" : "http://ia.media-imdb.com/images/N/
O9ERWAU7FS797AJ7LU8HN09AMUP908RLlo5JF90EWR7LJKQ7@@._V1_SX400_.jpg",
"plot" : "A rock band plays their music at high volumes, annoying the neighbors.",
"rank" : 11,
"running_time_secs" : 5215,
"actors" : [
"David Matthewman",
"Ann Thomas",
"Jonathan G. Neff"
]
}
}
require 'aws-sdk-dynamodb'
require 'json'
$movie_counter = 0
$total_movies = 0
def run_me
region = 'us-west-2'
table_name = 'Movies'
data_file = 'moviedata.json'
dynamodb_client = Aws::DynamoDB::Client.new
file = File.read(data_file)
movies = JSON.parse(file)
$total_movies = movies.count
movies.each do |movie|
table_item = {
table_name: table_name,
item: movie
}
add_item_to_table(dynamodb_client, table_item)
end
puts 'Done.'
end
ruby MoviesLoadData.rb
Para obtener más información sobre cómo leer y escribir datos, consulte Uso de elementos y
atributos (p. 410).
Temas
• Paso 3.1: Creación de un elemento nuevo (p. 199)
• Paso 3.2: Lea un elemento (p. 200)
• Paso 3.3: Actualización de un elemento (p. 201)
• Paso 3.4: Incremento de un contador atómico (p. 203)
• Paso 3.5: Actualización de un elemento (condicionalmente) (p. 204)
• Paso 3.6: Eliminación de un elemento (p. 205)
require 'aws-sdk-dynamodb'
def run_me
region = 'us-west-2'
table_name = 'Movies'
title = 'The Big New Movie'
year = 2015
dynamodb_client = Aws::DynamoDB::Client.new
item = {
year: year,
title: title,
info: {
plot: 'Nothing happens at all.',
rating: 0
}
}
table_item = {
table_name: table_name,
item: item
}
Note
La clave principal es obligatoria. Este código agrega un elemento que tiene la clave principal
(year, title) y atributos info. El atributo info almacena un mapa que proporciona más
información sobre la película.
2. Para ejecutar el programa, introduzca el siguiente comando.
ruby MoviesItemOps01.rb
{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Nothing happens at all.",
rating: 0
}
}
Puede utilizar el método get_item para leer el elemento en la tabla Movies. Debe especificar los valores
de clave principal para poder leer cualquier elemento de Movies si conoce los valores de year y title.
require 'aws-sdk-dynamodb'
def run_me
region = 'us-west-2'
table_name = 'Movies'
title = 'The Big New Movie'
year = 2015
# endpoint: 'http://localhost:8000',
region: region
)
dynamodb_client = Aws::DynamoDB::Client.new
table_item = {
table_name: table_name,
key: {
year: year,
title: title
}
}
ruby MoviesItemOps02.rb
{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Nothing happens at all.",
rating: 0
}
}
{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Everything happens all at once.",
rating: 5.5,
actors: ["Larry", "Moe", "Curly"]
}
}
require 'aws-sdk-dynamodb'
def run_me
region = 'us-west-2'
table_name = 'Movies'
title = 'The Big New Movie'
year = 2015
dynamodb_client = Aws::DynamoDB::Client.new
table_item = {
table_name: table_name,
key: {
year: year,
title: title
},
update_expression: 'SET info.rating = :r, info.plot = :p, info.actors = :a',
expression_attribute_values: {
':r': 5.5,
':p': 'Everything happens all at once.',
':a': [ 'Larry', 'Moe', 'Curly' ]
},
return_values: 'UPDATED_NEW'
}
if table_item_updated?(dynamodb_client, table_item)
puts 'Table updated.'
else
puts 'Table not updated.'
end
end
Note
Este programa utiliza update_expression para describir todas las actualizaciones que
desee realizar con el elemento especificado.
Lareturn_valuesEl parámetro indica a Amazon DynamoDB que devuelva solamente los
atributos actualizados (UPDATED_NEW).
2. Para ejecutar el programa, introduzca el siguiente comando.
ruby MoviesItemOps03.rb
El programa siguiente muestra cómo aumentar el valor de rating para una película. Cada vez que se
ejecuta el programa, incrementa el valor de este atributo en una unidad.
require 'aws-sdk-dynamodb'
def run_me
region = 'us-west-2'
table_name = 'Movies'
title = 'The Big New Movie'
year = 2015
dynamodb_client = Aws::DynamoDB::Client.new
table_item = {
table_name: table_name,
key: {
year: year,
title: title
},
update_expression: 'SET info.rating = info.rating + :val',
expression_attribute_values: {
':val': 1
},
return_values: 'UPDATED_NEW'
}
if table_item_updated?(dynamodb_client, table_item)
puts 'Table updated.'
else
puts 'Table not updated.'
end
end
ruby MoviesItemOps04.rb
En este caso, el elemento se actualiza solamente si el número de actores es mayor que tres.
require 'aws-sdk-dynamodb'
def run_me
region = 'us-west-2'
table_name = 'Movies'
title = 'The Big New Movie'
year = 2015
dynamodb_client = Aws::DynamoDB::Client.new
table_item = {
table_name: table_name,
key: {
year: year,
title: title
},
update_expression: 'REMOVE info.actors[0]',
condition_expression: 'size(info.actors) > :num',
expression_attribute_values: {
':num': 3
},
return_values: 'UPDATED_NEW'
}
if table_item_updated?(dynamodb_client, table_item)
puts 'Table updated.'
else
puts 'Table not updated.'
end
end
ruby MoviesItemOps05.rb
El progama falla porque la película tiene tres actores, pero la condición busca un valor mayor que tres
actores.
3. Modifique el programa para que ConditionExpression tenga el aspecto siguiente.
require 'aws-sdk-dynamodb'
true
rescue StandardError => e
puts "Error deleting item: #{e.message}"
false
end
def run_me
region = 'us-west-2'
table_name = 'Movies'
title = 'The Big New Movie'
year = 2015
dynamodb_client = Aws::DynamoDB::Client.new
table_item = {
table_name: table_name,
key: {
year: year,
title: title
},
condition_expression: 'info.rating <= :val',
expression_attribute_values: {
':val' => 5
}
}
if table_item_deleted?(dynamodb_client, table_item)
puts 'Item deleted.'
else
puts 'Item not deleted.'
end
end
ruby MoviesItemOps06.rb
params = {
table_name: "Movies",
key: {
year: year,
title: title
}
}
Para buscar todas las películas estrenadas durante un año, solo debe especificar el valor de year.
También puede indicar el valor de title si desea recuperar un subconjunto de películas basadas en una
condición determinada (la clave de ordenación). Por ejemplo, puede encontrar las películas estrenadas en
2014 cuyo título comienza por la "A".
Además de laquery, puede usar elscanPara recuperar todos los datos de la tabla.
Para obtener más información sobre cómo consultar y examinar datos, consulte Uso de consultas en
DynamoDB (p. 497) y Uso de operaciones de examen en DynamoDB (p. 516), respectivamente.
Temas
• Paso 4.1: Consulta de todas las películas estrenadas durante un año (p. 207)
• Paso 4.2: Consulta de todas las películas estrenadas durante un año con unos títulos
determinados (p. 209)
• Paso 4.3: Examen (p. 210)
require 'aws-sdk-dynamodb'
end
def run_me
region = 'us-west-2'
table_name = 'Movies'
year = 1985
dynamodb_client = Aws::DynamoDB::Client.new
query_for_items_from_table(dynamodb_client, query_condition)
end
Note
ruby MoviesItemQuery01.rb
Note
El programa anterior muestra cómo consultar una tabla según sus atributos de clave principal. En
DynamoDB, puede crear si lo desea uno o varios índices secundarios en una tabla y consultarlos
de la misma forma que se consulta una tabla. Los índices secundarios ofrecen a las aplicaciones
mayor flexibilidad, porque permiten consultar atributos sin clave. Para obtener más información,
consulte Uso de índices secundarios para mejorar el acceso a los datos (p. 567).
require 'aws-sdk-dynamodb'
def run_me
region = 'us-west-2'
table_name = 'Movies'
year = 1982
letter1 = 'A'
letter2 = 'L'
dynamodb_client = Aws::DynamoDB::Client.new
query_condition = {
table_name: table_name,
projection_expression: '#yr, title, info.genres, info.actors[0]',
key_condition_expression: '#yr = :yyyy AND title BETWEEN :letter1 AND :letter2',
expression_attribute_names: { '#yr' => 'year' },
expression_attribute_values: {
puts "Searching for items in the '#{table_name}' table from '#{year}' and " \
"titles starting with the letters '#{letter1}' through '#{letter2}'..."
query_for_items_from_table(dynamodb_client, query_condition)
end
ruby MoviesQuery02.rb
El siguiente programa escanea elMovies, que contiene aproximadamente 5 000 elementos. El examen
especifica el filtro opcional que permite recuperar solamente las películas de la década de 1950
(aproximadamente 100 elementos) y descartar todas las demás.
require 'aws-sdk-dynamodb'
if result.items.count.zero?
puts 'No matching movies found (yet)...'
else
puts "Found #{result.items.count} matching movies (so far):"
result.items.each do |movie|
puts "#{movie["title"]} (#{movie["year"].to_i}), " \
"Rating: #{movie["info"]["rating"].to_f}"
end
break if result.last_evaluated_key.nil?
def run_me
region = 'us-west-2'
table_name = 'Movies'
start_year = 1950
end_year = 1959
dynamodb_client = Aws::DynamoDB::Client.new
scan_condition = {
table_name: table_name,
projection_expression: '#yr, title, info.rating',
filter_expression: '#yr between :start_yr and :end_yr',
expression_attribute_names: { '#yr' => 'year' },
expression_attribute_values: {
':start_yr' => start_year,
':end_yr' => end_year
}
}
puts "Searching for items in the '#{table_name}' table from #{start_year} " \
"through #{end_year}..."
scan_for_items_from_table(dynamodb_client, scan_condition)
end
ruby MoviesScan.rb
Note
También puede utilizar lascanCon cualesquiera índices secundarios que haya creado en la tabla.
Para obtener más información, consulte Uso de índices secundarios para mejorar el acceso a los
datos (p. 567).
require 'aws-sdk-dynamodb'
true
rescue StandardError => e
puts "Error deleting table: #{e.message}"
false
end
def run_me
region = 'us-west-2'
table_name = 'Movies'
dynamodb_client = Aws::DynamoDB::Client.new
if table_deleted?(dynamodb_client, table_name)
puts 'Table deleted.'
else
puts 'Table not deleted.'
end
end
ruby MoviesDeleteTable.rb
Summary
En este tutorial, ha creado elMoviesEn la versión descargable de Amazon DynamoDB en el equipo y
hemos realizado algunas operaciones básicas. La versión descargable de DynamoDB resulta útil para
tareas de desarrollo y pruebas de aplicaciones. Sin embargo, cuando la aplicación esté preparada para
ejecutarla en un entorno de producción, debe modificar el código de modo que utilice el servicio web de
DynamoDB.
Aws.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
})
Aws.config.update({
region: "us-west-2"
]);
Después de quitar esta línea, el código puede obtener acceso al servicio de DynamoDB en elAWSRegión
especificada por laregionValor de configuración.
En lugar de utilizar la versión de DynamoDB en el equipo, el programa usará el punto de enlace del
servicio web de DynamoDB de la región EE.UU. Oeste (Oregón).
DynamoDB está disponible enAWSRegiones en el mundo. Para ver una lista completa, consulteRegiones
y puntos de enlace deen laAWSReferencia general de. Para obtener más información, consulte la Guía de
introducción a AWS SDK for Ruby.
Temas
• Información general deAWSSupport del SDK de con DynamoDB (p. 214)
• Interfaces de programación (p. 216)
• API de bajo nivel de DynamoDB (p. 220)
• Control de errores con DynamoDB (p. 224)
• Interfaces de programación de nivel superior para DynamoDB (p. 230)
• Cómo ejecutar los ejemplos de código de esta guía para desarrolladores (p. 332)
Cada una de lasAWSLos SDK proporcionan servicios importantes a la aplicación, tales como los
siguientes:
• Reenviar las solicitudes a un punto de enlace de DynamoDB y recibir las respuestas de DynamoDB.
• Extraer los resultados de esas respuestas.
• Implementar la lógica de reintento básica en caso de errores.
Interfaces de programación
En la siguiente sección se destacan algunas de las interfaces disponibles utilizando elAWS SDK for
JavaPor ejemplo. (No todas las interfaces están disponibles en todos losAWSSDK de.)
Temas
• Interfaces de bajo nivel (p. 217)
• Interfaces de documentos (p. 218)
• Interfaz de persistencia de objetos (p. 218)
En algunos casos, es preciso identificar los tipos de datos de los atributos utilizando Descriptores de tipos
de datos (p. 223); por ejemplo, S si es una cadena o N si es un número.
Note
Hay interfaz de bajo nivel disponible en cada idioma específicoAWSSDK DE.
En el siguiente programa de Java se utiliza la interfaz de bajo nivel del AWS SDK for Java. El programa
emite unGetItemsolicitud de una canción en elMusice imprime el año en que se lanzó la canción.
package com.amazonaws.codesamples;
import java.util.HashMap;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import com.amazonaws.services.dynamodbv2.model.GetItemRequest;
import com.amazonaws.services.dynamodbv2.model.GetItemResult;
try {
GetItemResult result = client.getItem(request);
if (result && result.getItem() != null) {
AttributeValue year = result.getItem().get("Year");
System.out.println("The song was released in " + year.getN());
} else {
System.out.println("No matching song was found");
}
} catch (Exception e) {
System.err.println("Unable to retrieve data: ");
System.err.println(e.getMessage());
}
}
}
Interfaces de documentos
MuchosAWSLos SDK proporcionan una interfaz de documentos, lo que permite realizar operaciones
del plano de datos (crear, leer, actualizar, eliminar) en tablas e índices. Con una interfaz de documento,
no tiene que especificarDescriptores de tipos de datos (p. 223). Los tipos de datos quedan implícitos
en la propia semántica de los datos. EstosAWSLos SDK también proporcionan métodos para convertir
fácilmente documentos JSON a los tipos de datos nativos de Amazon DynamoDB y viceversa.
Note
En el siguiente programa de Java se utiliza la interfaz de documentos del AWS SDK for Java. El programa
crea unTableObjeto que representa laMusicy, a continuación, le pide a ese objeto que useGetItempara
recuperar una canción. Después, el programa imprime el año en que se lanzó la canción.
package com.amazonaws.codesamples.gsg;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.GetItemOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;
}
}
Las interfaces de persistencia de objetos están disponibles en laAWSSDK para Java y .NET.
Para obtener más información, consulte Interfaces de programación de nivel superior para
DynamoDB (p. 230).
package com.amazonaws.codesamples;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBAttribute;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBHashKey;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBRangeKey;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBTable;
@DynamoDBTable(tableName="Music")
public class MusicItem {
private String artist;
private String songTitle;
private String albumTitle;
private int year;
@DynamoDBHashKey(attributeName="Artist")
public String getArtist() { return artist;}
public void setArtist(String artist) {this.artist = artist;}
@DynamoDBRangeKey(attributeName="SongTitle")
public String getSongTitle() { return songTitle;}
public void setSongTitle(String songTitle) {this.songTitle = songTitle;}
@DynamoDBAttribute(attributeName = "AlbumTitle")
public String getAlbumTitle() { return albumTitle;}
public void setAlbumTitle(String albumTitle) {this.albumTitle = albumTitle;}
@DynamoDBAttribute(attributeName = "Year")
public int getYear() { return year; }
public void setYear(int year) { this.year = year; }
}
A continuación, puede crear una instancia de unMusicItemy recupere una canción utilizando
laload()Método deDynamoDBMapper. Después, el programa imprime el año en que se lanzó la canción.
package com.amazonaws.codesamples;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMapper;
try {
MusicItem result = mapper.load(keySchema);
if (result != null) {
System.out.println(
"The song was released in "+ result.getYear());
} else {
System.out.println("No matching song was found");
}
} catch (Exception e) {
System.err.println("Unable to retrieve data: ");
System.err.println(e.getMessage());
}
Amazon DynamoDBAPI de bajo niveles la interfaz de nivel de protocolo de DynamoDB. En este nivel, cada
solicitud HTTP(S) debe tener el formato correcto y llevar una firma digital válida.
LaAWSLos SDK construyen las solicitudes al API de bajo nivel de DynamoDB automáticamente y
procesan las respuestas de DynamoDB. Esto le permite centrarse en la lógica de la aplicación, en lugar
de en los detalles de bajo nivel. Sin embargo, le resultará útil conocer algunos conceptos básicos del
funcionamiento del API de bajo nivel de DynamoDB.
Para obtener más información acerca de la API de bajo nivel de DynamoDB, consulteReferencia de la API
de Amazon DynamoDB.
Note
DynamoDB Streams tiene su propio API de bajo nivel, que es independiente de la de DynamoDB
y totalmente compatible con elAWSSDK de.
Para obtener más información, consulte Captura de datos de cambio para DynamoDB
Streams (p. 661). Para la API de Streams de bajo nivel de DynamoDB Streams, consulte
la.Referencia de la API de Amazon DynamoDB Streams.
El API de bajo nivel de DynamoDB utiliza la notación de objetos de JavaScript (JSON) como formato de
protocolo de conexión. JSON presenta los datos de forma jerárquica para transmitir simultáneamente sus
valores y su estructura. Los pares de nombre-valor se definen con el formato name:value. La jerarquía de
datos se define mediante llaves anidadas de pares de nombre-valor.
DynamoDB usa JSON como protocolo de transporte únicamente, no como formato de almacenamiento.
LaAWSLos SDK usan JSON para enviar datos a DynamoDB, y DynamoDB responde con JSON.
DynamoDB no almacena datos de forma persistente en formato JSON.
Note
Para obtener más información acerca de JSON, consulte Introducing JSON en el sitio web
JSON.org.
Supongamos que dispone de una tabla denominada Pets, con un esquema de claves que consta de
AnimalType (clave de partición) y Name (clave de ordenación). Ambos atributos son de tipo string. Para
recuperar un elemento dePets, elAWSSDK construye la siguiente solicitud.
POST / HTTP/1.1
Host: dynamodb.<region>.<domain>;
Accept-Encoding: identity
Content-Length: <PayloadSizeBytes>
User-Agent: <UserAgentString>
Content-Type: application/x-amz-json-1.0
Authorization: AWS4-HMAC-SHA256 Credential=<Credential>, SignedHeaders=<Headers>,
Signature=<Signature>
X-Amz-Date: <Date>
X-Amz-Target: DynamoDB_20120810.GetItem
{
"TableName": "Pets",
"Key": {
"AnimalType": {"S": "Dog"},
"Name": {"S": "Fido"}
}
}
Formato de respuesta
Una vez que recibe la solicitud, DynamoDB la procesa y devuelve una respuesta. Para la solicitud
mostrada anteriormente, la carga de la respuesta HTTP(S) contiene los resultados de la operación, como
se muestra en el siguiente ejemplo.
HTTP/1.1 200 OK
x-amzn-RequestId: <RequestId>
x-amz-crc32: <Checksum>
Content-Type: application/x-amz-json-1.0
Content-Length: <PayloadSizeBytes>
Date: <Date>
{
"Item": {
"Age": {"N": "8"},
"Colors": {
"L": [
{"S": "White"},
{"S": "Brown"},
{"S": "Black"}
]
},
"Name": {"S": "Fido"},
"Vaccinations": {
"M": {
"Rabies": {
"L": [
{"S": "2009-03-17"},
{"S": "2011-09-21"},
{"S": "2014-07-08"}
]
},
"Distemper": {"S": "2015-10-13"}
}
},
"Breed": {"S": "Beagle"},
"AnimalType": {"S": "Dog"}
}
}
En este punto, elAWSEl SDK devuelve los datos de respuesta a la aplicación para continuar
procesándolos.
Note
Si DynamoDB no puede procesar una solicitud, devuelve un código de error HTTP y un mensaje.
LaAWSEl SDK los propaga a su aplicación en forma de excepciones. Para obtener más
información, consulte Control de errores con DynamoDB (p. 224).
En las secciones Formato de las solicitudes (p. 222) y Formato de respuesta (p. 222) encontrará
ejemplos de cómo se usan los descriptores de tipos de datos. En la solicitud GetItem se especifica S
para los atributos del esquema de claves de Pets (AnimalType y Name), que son de tipo string. La
respuesta GetItem contiene un elemento Pets con atributos de tipo string (S), number (N), map (M) y
list (L).
• S: String
• N: Number
• B: Binary
• BOOL: Boolean
• NULL: Null
• M: Map
• L: List
• SS: String Set
• NS: Number Set
• BS: Binary Set
Note
Datos numéricos
Los distintos lenguajes de programación ofrecen diferentes niveles de compatibilidad con JSON.
En algunos casos, es posible que prefiera usar una biblioteca de terceros para validar y analizar los
documentos JSON.
Algunas bibliotecas de terceros se basan en el tipo Number de JSON y proporcionan sus propios tipos,
tales como int, long o double. Sin embargo, el tipo de datos Number nativo de DynamoDB no se
mapea exactamente a estos otros tipos de datos, por lo que estas diferencias entre los tipos pueden
provocar conflictos. Además, muchas bibliotecas JSON no controlan los valores numéricos con una
precisión fija y deducen automáticamente que el tipo de datos de las secuencias que contienen una coma
decimal es double.
Para resolver estos problemas, DynamoDB proporciona un único tipo numérico sin pérdida de datos.
Para evitar conversiones implícitas no deseadas a un valor de tipo double, DynamoDB utiliza cadenas
para efectuar la transferencia de datos de valores numéricos. Este enfoque proporciona flexibilidad
para actualizar los valores de los atributos y, al mismo tiempo, mantener una semántica de ordenación
adecuada; por ejemplo, colocar los valores "01", "2" y "03" en la secuencia correcta.
Si la precisión del número es importante para la aplicación, debe convertir los valores numéricos en
cadenas antes de pasárselos a DynamoDB.
El esquema de codificación base64 utilizado por DynamoDB se describe enRFC 4648En el sitio web de
Internet Engineering Task Force (IETF).
Temas
• Componentes de un error (p. 225)
• Mensajes y códigos de error (p. 225)
• Control de errores en la aplicación (p. 228)
• Reintentos de error y retardo exponencial (p. 229)
• Operaciones por lotes y control de errores (p. 230)
Componentes de un error
Cuando el programa envía una solicitud, DynamoDB intenta procesarla. Si la solicitud se lleva a cabo
correctamente, DynamoDB devuelve un código de estado HTTP de operación correcta (200 OK), así como
los resultados de la operación solicitada.
Si la solicitud no se realiza correctamente, DynamoDB devuelve un error. Cada error tiene tres
componentes:
LaAWSLos SDK se encargan de transmitir los errores a la aplicación para que pueda adoptar las medidas
apropiadas. Por ejemplo, en un programa en Java, puede escribir una lógica try-catch para controlar
una excepción ResourceNotFoundException.
Si no utiliza unaAWSSDK, tiene que analizar el contenido de la respuesta de bajo nivel de DynamoDB. A
continuación se muestra un ejemplo de este tipo de respuesta.
{"__type":"com.amazonaws.dynamodb.v20120810#ResourceNotFoundException",
"message":"Requested resource not found: Table: tablename not found"}
AccessDeniedException
¿Reintentar? No
ConditionalCheckFailedException
Ha especificado una condición que se ha evaluado en false. Por ejemplo, es posible que haya
intentado realizar una actualización condicional de un elemento, pero que el valor real del atributo no
coincidiese con el valor previsto en la condición.
¿Reintentar? No
IncompleteSignatureException
La firma de la solicitud no incluía todos los componentes necesarios. Si utiliza unaAWSSDK, las
solicitudes se firman automáticamente; en caso contrario, visite laProceso de firma Signature Version
4en laAWSReferencia general de.
¿Reintentar? No
ItemCollectionSizeLimitExceededException
Para una tabla con un índice secundario local, un grupo de elementos con el mismo valor de clave de
partición ha superado el límite de tamaño máximo de 10 GB. Para obtener más información sobre las
colecciones de elementos, consulte Colecciones de elementos (p. 621).
¿Reintentar? Sí
LimitExceededException
Hay demasiadas operaciones del plano de control simultáneas. El número acumulado de tablas e
índices que se encuentren en laCREATING,DELETING, o bienUPDATINGno puede exceder de 50.
¿Reintentar? Sí
MissingAuthenticationTokenException
¿Reintentar? No
ProvisionedThroughputExceededException
Mensaje: Ha superado el rendimiento aprovisionado máximo permitido para una tabla o para uno
o varios índices secundarios globales. Para ver las métricas de rendimiento aprovisionado en
comparación con el rendimiento consumido, abra elConsola de Amazon CloudWatch.
Ejemplo: Tu velocidad de solicitudes es demasiado alta. LaAWSLos SDK para DynamoDB reintentan
automáticamente las solicitudes que reciben esta excepción. La solicitud se llevará a cabo con
éxito en algún momento, salvo que la cola de reintentos sea demasiado larga para que pueda
alcanzarse el final. Reduzca la frecuencia de las solicitudes mediante Reintentos de error y retardo
exponencial (p. 229).
¿Reintentar? Sí
RequestLimitExceeded
Mensaje: El rendimiento supera el límite de rendimiento actual de la cuenta. Para solicitar un aumento
de límite, póngase en contacto conAWSSupport enhttps://aws.amazon.com/support.
¿Reintentar? Sí
ResourceInUseException
Ejemplo: Ha intentado volver a crear una tabla que ya existía o eliminar una tabla que se encuentra en
elCREATINGestado.
¿Reintentar? No
ResourceNotFoundException
¿Reintentar? No
ThrottlingException
Para las tablas que utilizan el modo bajo demanda, esta excepción es posible que se produzca para
cualquier operación de la API de plano de datos si la tarifa de solicitud es demasiado alta. Para
obtener más información sobre el escalado bajo demanda, consulte Picos de tráfico y propiedades de
escalado
¿Reintentar? Sí
UnrecognizedClientException
La firma de la solicitud es incorrecta. La causa más probable es que un no sea válidoAWSID de clave
de acceso o clave secreta.
¿Reintentar? Sí
ValidationException
Este error se produce por varias razones; por ejemplo, si se ha omitido un parámetro obligatorio, uno
de los valores está fuera del rango admitido o los tipos de datos no concuerdan. El mensaje de error
contiene información acerca de la parte concreta de la solicitud que ha provocado el error.
¿Reintentar? No
¿Reintentar? Sí
Note
Pueden producirse errores internos del servidor cuando se utilizan elementos. Cabe esperar
que esto suceda durante la vida útil de una tabla. Todas las solicitudes que producen un error
se pueden reintentar inmediatamente.
¿Reintentar? Sí
LaAWSLos SDK de llevan a cabo sus propios reintentos y comprobaciones de errores. Si se produce
algún error al utilizar uno de los métodosAWSSDK, el código de error y la descripción pueden ayudarle a
solucionar el problema.
También debería aparecer el Request ID en la respuesta. LaRequest IDpuede resultar útil si necesita
trabajar conAWSSupport para diagnosticar un problema.
En el siguiente ejemplo de código Java se intenta obtener un elemento de una tabla de DynamoDB y
se realiza un control de errores rudimentario. En este caso, se limita a informar al usuario de que se ha
producido un error en la solicitud.
try {
Item item = table.getItem("year", 1978, "title", "Superman");
if (item != null) {
System.out.println("Result: " + item);
} else {
//No such item exists in the table
System.out.println("Item not found");
}
En este ejemplo de código, la construcción try-catch controla dos tipos de excepciones diferentes:
EACHAWSSDK implementa automáticamente una lógica de reintento. Puede modificar los parámetros de
reintento de acuerdo con sus necesidades. Por ejemplo, tomemos una aplicación en Java que requiere
una estrategia de conmutación por error rápida y no permite reintentos en caso de error. Con el AWS SDK
for Java, podría usar la clase ClientConfiguration y proporcionar un valor de maxErrorRetry de
0 para desactivar los reintentos. Para obtener más información, consulte laAWSDocumentación del SDK
para el lenguaje de programación.
Si no utiliza unaAWSSDK, debe reintentar las solicitudes originales que reciban errores de servidor
(5xx). Sin embargo, los errores de cliente (4xx, salvo las excepciones ThrottlingException o
ProvisionedThroughputExceededException) indican que es preciso revisar la solicitud en sí para
corregir el problema antes de volver a intentarlo.
Además de los reintentos simples, cadaAWSSDK implementa un algoritmo de retardo exponencial para
mejorar el control de flujo. El retardo exponencial se basa en el concepto de utilizar tiempos de espera
progresivamente más largos entre reintentos para las respuestas a errores consecutivos. Por ejemplo,
las aplicaciones cliente podrían esperar 50 milisegundos antes de llevar a cabo el primer reintento,
100 milisegundos antes del segundo, hasta 200 milisegundos antes del tercero y así sucesivamente. Sin
embargo, si la solicitud no se ha llevado a cabo correctamente al cabo de un minuto, el problema podría
radicar en que el tamaño de la solicitud supera el rendimiento aprovisionado, y no en la tasa de solicitudes.
Establezca el número máximo de reintentos de modo que se detenga al cabo de un minuto. Si la solicitud
no se realiza correctamente, investigue las opciones de rendimiento aprovisionado.
Note
La mayoría los algoritmos de retardo exponencial utilizan la fluctuación (el retraso aleatorio) para evitar
conflictos sucesivos. Habida cuenta de que no está intentando evitar este tipo de conflictos en estos casos,
no es preciso utilizar este número aleatorio. Sin embargo, si utiliza clientes simultáneos, la fluctuación
puede ayudar a que las solicitudes tengan éxito con mayor rapidez. Para obtener más información,
consulte la entrada de blog sobre Exponential Backoff and Jitter.
Una operación por lotes puede tolerar que algunas solicitudes individuales del lote no se lleven a cabo.
Por ejemplo, tomemos una solicitud BatchGetItem para leer cinco elementos. Aunque algunas de
las solicitudes GetItem subyacentes no se realicen, esto no provocará un error de toda la operación
BatchGetItem. Sin embargo, si las cinco operaciones de lectura fallan, entonces el BatchGetItem
completo falla.
Las operaciones por lotes devuelven información sobre las solicitudes individuales que no se realizan,
para que pueda diagnosticar el problema y reintentar la operación. Para BatchGetItem, las tablas
y claves principales en cuestión se devuelven en el valor UnprocessedKeys de la respuesta. Para
BatchWriteItem, se devuelve información similar en UnprocessedItems.
La causa más probable de que no se realice una lectura o una escritura es la limitación controlada. Para
BatchGetItem, una o varias tablas de la solicitud por lotes no tiene suficiente capacidad de lectura
aprovisionada para admitir la operación. Para BatchWriteItem, una o varias de las tablas no tiene
suficiente capacidad de escritura aprovisionada.
Si DynamoDB devuelve elementos sin procesar, debe reintentar la operación por lotes para estos
elementos. Sin embargo, recomendamos encarecidamente utilizar un algoritmo de retardo exponencial.
Si reintenta la operación de forma inmediata, podría volver a producirse un error en las solicitudes
subyacentes de lectura o escritura a causa de la limitación controlada de las tablas individuales. Si retrasa
la operación por lotes mediante el retardo exponencial, será mucho más probable que las solicitudes
individuales del lote se lleven a cabo correctamente.
Para simplificar el desarrollo, elAWSLos SDK para Java y .NET proporcionan interfaces adicionales con
niveles superiores de abstracción. Las interfaces de nivel superior para DynamoDB permiten definir las
relaciones entre los objetos del programa del desarrollador y las tablas de base de datos en las que se
almacenan esos datos de objetos. Una vez que se ha definido este mapeo, basta con llamar a métodos
de objetos simples, comosave,load, o biendelete, y las operaciones de bajo nivel de DynamoDB
subyacentes se invocan automáticamente si su intervención. Esto le permite escribir código orientado a
objetos, en lugar de código orientado a bases de datos.
Las interfaces de programación de nivel superior para DynamoDB están disponibles en laAWSSDK para
Java y .NET.
Java
.NET
Java: DynamoDBMapper
Temas
• Tipos de datos admitidos (p. 233)
• Anotaciones de Java para DynamoDB (p. 234)
• Clase DynamoDBMapper (p. 239)
• Ajustes de configuración opcionales para DynamoDBMapper (p. 247)
• Ejemplo: Operaciones de CRUD (p. 248)
• Ejemplo: Operaciones de escritura por lotes (p. 250)
• Ejemplo: Consulta y examen (p. 257)
• Ejemplo: Operaciones de Transacción (p. 266)
• Bloqueo optimista con el número de versión (p. 273)
• Mapeo de datos arbitrarios (p. 276)
LaAWS SDK for Javaproporciona unDynamoDBMapperLa clase le permite mapear las clases del lado del
cliente a las tablas de Amazon DynamoDB. Para utilizarDynamoDBMapperPara definir la relación entre
los elementos de una tabla de DynamoDB y sus instancias de objetos correspondientes en el código.
LaDynamoDBMapperLa clase permite obtener acceso a tablas, realizar varias operaciones de creación,
lectura, actualización y eliminación (CRUD, Create, Read, Update y Delete) y ejecutar consultas.
Note
El SDK for Java proporciona un conjunto de tipos de anotación para que pueda mapear las clases de
tablas. Por ejemplo, tomemos una tabla ProductCatalog cuya clave de partición es Id.
ProductCatalog(Id, ...)
Puede mapear una clase de la aplicación cliente a la tabla ProductCatalog tal y como se
muestra en el siguiente código Java. En este código se define un objeto Java estándar (POJO)
denominadoCatalogItem, que utiliza anotaciones para mapear campos de objetos a nombres de
atributos de DynamoDB.
Example
package com.amazonaws.codesamples;
import java.util.Set;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBAttribute;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBHashKey;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBIgnore;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBTable;
@DynamoDBTable(tableName="ProductCatalog")
public class CatalogItem {
@DynamoDBHashKey(attributeName="Id")
public Integer getId() { return id; }
public void setId(Integer id) {this.id = id; }
@DynamoDBAttribute(attributeName="Title")
public String getTitle() {return title; }
public void setTitle(String title) { this.title = title; }
@DynamoDBAttribute(attributeName="ISBN")
public String getISBN() { return ISBN; }
public void setISBN(String ISBN) { this.ISBN = ISBN; }
@DynamoDBAttribute(attributeName="Authors")
public Set<String> getBookAuthors() { return bookAuthors; }
public void setBookAuthors(Set<String> bookAuthors) { this.bookAuthors = bookAuthors; }
@DynamoDBIgnore
public String getSomeProp() { return someProp; }
public void setSomeProp(String someProp) { this.someProp = someProp; }
}
De forma predeterminada, las propiedades de la clase se mapean a los atributos de la tabla que tienen el
mismo nombre. Las propiedades Title e ISBN se mapean a los atributos de la tabla que tienen el mismo
nombre.
La definición de clase puede tener propiedades que no se mapeen a ningún atributo de la tabla. Estas
propiedades se identifican agregándoles la anotación @DynamoDBIgnore. En el ejemplo anterior, la
propiedad SomeProp se ha marcado con la anotación @DynamoDBIgnore. Al cargar una instancia de
CatalogItem en la tabla, la instancia de DynamoDBMapper no incluye la propiedad SomeProp. Tampoco
el mapeador devuelve este atributo cuando se recupera un elemento de la tabla.
Después de haber definido la clase de mapeo, puede usar métodos DynamoDBMapper para escribir una
instancia de esa clase en un elemento correspondiente de la tabla Catalog. En el siguiente ejemplo de
código se muestra esta técnica.
mapper.save(item);
En el siguiente ejemplo de código se muestra cómo recuperar el elemento y obtener acceso a algunos de
sus atributos.
partitionKey.setId(102);
DynamoDBQueryExpression<CatalogItem> queryExpression = new
DynamoDBQueryExpression<CatalogItem>()
.withHashKeyValues(partitionKey);
DynamoDBMapperofrece una forma natural e intuitiva de usar los datos de DynamoDB en Java. También
ofrece varias características integradas, tales como el bloqueo optimista, las transacciones ACID, la
generación automática de valores de claves de partición y de orden y el control de versiones de objetos.
Amazon DynamoDB admite los siguientes tipos de datos y clases encapsuladoras Java primitivos.
• String
• Boolean, boolean
• Byte, byte
• Date (como una cadena ISO_8601 con precisión de milisegundos, convertida a UTC)
• Calendar (como una cadena ISO_8601 con precisión de milisegundos, convertida a UTC)
• Long, long
• Integer, int
• Double, double
• Float, float
• BigDecimal
• BigInteger
Note
• Para obtener más información sobre las reglas de asignación de DynamoDB y los distintos tipos
de datos admitidos, consulteReglas de nomenclatura y tipos de datos (p. 13).
• DynamoDBMapper admite valores binarios vacíos.
• Los valores de cadena vacíos son compatibles conAWS SDK for Java 2.x.
EnAWSEn SDK for Java 1.x, DynamoDBMapper admite leer valores de atributo de cadena
vacíos; sin embargo, no escribirá valores de atributo de cadena vacíos, ya que estos atributos
se eliminan de la solicitud.
Tipos de colección Set SS (tipo String Set), NS (tipo Number Set) o BS (tipo
Binary Set)
LaDynamoDBTypeConverterLa interfaz permite mapear sus propios tipos de datos arbitrarios a un tipo
de datos que sea compatible de forma nativa con DynamoDB. Para obtener más información, consulte
Mapeo de datos arbitrarios (p. 276).
Temas
• DynamoDBAttribute (p. 235)
• DynamoDBAutoGeneratedKey (p. 235)
• DynamoDBDocument (p. 235)
• DynamoDBHashKey (p. 236)
• DynamoDBIgnore (p. 237)
• DynamoDBIndexHashKey (p. 237)
• DynamoDBIndexRangeKey (p. 237)
• DynamoDBRangeKey (p. 237)
• DynamoDBTable (p. 238)
• DynamoDBTypeConverted (p. 238)
• DynamoDBTyped (p. 238)
• DynamoDBVersionAttribute (p. 239)
DynamoDBAttribute
Mapea una propiedad a un atributo de tabla. De forma predeterminada, cada propiedad de clase se
mapea a un atributo de elemento con el mismo nombre. Sin embargo, si los nombres no son iguales,
puede utilizar esta anotación para mapear una propiedad al atributo. En el siguiente fragmento de Java,
DynamoDBAttribute mapea la propiedad BookAuthors al nombre de atributo Authors de la tabla.
@DynamoDBAttribute(attributeName = "Authors")
public List<String> getBookAuthors() { return BookAuthors; }
public void setBookAuthors(List<String> BookAuthors) { this.BookAuthors = BookAuthors; }
DynamoDBAutoGeneratedKey
Marca una propiedad de clave de partición o de clave de ordenación como generada automáticamente.
DynamoDBMapper genera un UUID aleatorio al guardar estos atributos. Solo se pueden marcar
propiedades de tipo String como claves generadas automáticamente.
@DynamoDBTable(tableName="AutoGeneratedKeysExample")
public class AutoGeneratedKeys {
private String id;
private String payload;
@DynamoDBHashKey(attributeName = "Id")
@DynamoDBAutoGeneratedKey
public String getId() { return id; }
public void setId(String id) { this.id = id; }
@DynamoDBAttribute(attributeName="payload")
public String getPayload() { return this.payload; }
public void setPayload(String payload) { this.payload = payload; }
DynamoDBDocument
Indica que una clase se puede serializar como un documento de Amazon DynamoDB.
Por ejemplo, supongamos que desea mapear un documento JSON a un atributo DynamoDB de tipo Map
(M). En el siguiente ejemplo de código se define un elemento que contiene un atributo anidado (Pictures)
de tipo Map.
@DynamoDBHashKey(attributeName="Id")
public Integer getId() { return id;}
public void setId(Integer id) {this.id = id;}
@DynamoDBAttribute(attributeName="Pictures")
public Pictures getPictures() { return pictures;}
public void setPictures(Pictures pictures) {this.pictures = pictures;}
@DynamoDBDocument
public static class Pictures {
private String frontView;
private String rearView;
private String sideView;
@DynamoDBAttribute(attributeName = "FrontView")
public String getFrontView() { return frontView; }
public void setFrontView(String frontView) { this.frontView = frontView; }
@DynamoDBAttribute(attributeName = "RearView")
public String getRearView() { return rearView; }
public void setRearView(String rearView) { this.rearView = rearView; }
@DynamoDBAttribute(attributeName = "SideView")
public String getSideView() { return sideView; }
public void setSideView(String sideView) { this.sideView = sideView; }
}
}
A continuación, podría guardar un nuevo elemento ProductCatalog, con Pictures, tal como se
muestra en el siguiente ejemplo.
item.setId(123);
mapper.save(item);
{
"Id" : 123
"Pictures" : {
"SideView" : "http://example.com/products/123_left_side.jpg",
"RearView" : "http://example.com/products/123_rear.jpg",
"FrontView" : "http://example.com/products/123_front.jpg"
}
}
DynamoDBHashKey
Mapea una propiedad de clase a la clave de partición de la tabla. La propiedad debe ser un escalar de tipo
String, Number o Binary. La propiedad no puede ser un tipo de colección.
Supongamos que tenemos una tabla, ProductCatalog, cuya clave principal es Id. En el siguiente
código Java se define una clase CatalogItem y se mapea su propiedad Id a la clave principal de la tabla
ProductCatalog utilizando la etiqueta @DynamoDBHashKey.
@DynamoDBTable(tableName="ProductCatalog")
public class CatalogItem {
private Integer Id;
@DynamoDBHashKey(attributeName="Id")
public Integer getId() {
return Id;
}
public void setId(Integer Id) {
this.Id = Id;
}
// Additional properties go here.
}
DynamoDBIgnore
Indica a la instancia DynamoDBMapper que la propiedad asociada debe pasarse por alto. Al guardar datos
en la tabla, DynamoDBMapper no guarda esta propiedad en la tabla.
Se aplica al método getter o al campo de clase de una propiedad sin modelar. Si la anotación se aplica
directamente al campo de clase, los métodos getter y setter correspondientes deben declararse en la
misma clase.
DynamoDBIndexHashKey
Mapea una propiedad de clase a la clave de partición de un índice secundario global. La propiedad debe
ser un escalar de tipo String, Number o Binary. La propiedad no puede ser un tipo de colección.
Use esta anotación para utilizar una operación en unQueryíndices secundario mundial. Debe especificar
el nombre de índice (globalSecondaryIndexName). Si el nombre de la propiedad de clase es distinto
de la clave de partición del índice, también deberá especificar el nombre de ese atributo de índice
(attributeName).
DynamoDBIndexRangeKey
Asigna una propiedad de clase a la clave de ordenación de un índice secundario global o un índice
secundario local. La propiedad debe ser un escalar de tipo String, Number o Binary. La propiedad no
puede ser un tipo de colección.
Use esta anotación para utilizar una operación en unQueryUn índice secundario local o global y desea
refinar los resultados mediante la clave de ordenación del índice. Debe especificar el nombre de índice
(globalSecondaryIndexName o localSecondaryIndexName). Si el nombre de la propiedad de clase
es distinto de la clave de ordenación del índice, también deberá especificar el nombre de ese atributo de
índice (attributeName).
DynamoDBRangeKey
Mapea una propiedad de clase a la clave de ordenación de la tabla. La propiedad debe ser un escalar de
tipo String, Number o Binary. No puede ser un tipo de colección.
Si la clave principal es compuesta (clave de partición y clave de ordenación), puede utilizar esta etiqueta
para mapear el campo de clase a la clave de ordenación. Por ejemplo, supongamos que tenemos una
tabla Reply en la que se almacenan las respuestas de las conversaciones de un foro. Cada conversación
puede tener muchas respuestas. La clave principal de esta tabla consta de ThreadId y ReplyDateTime.
ThreadId es la clave de partición y ReplyDateTime es la de orden.
En el siguiente código Java se define una clase Reply y se mapea a la tabla Reply. Se utilizan las
etiquetas @DynamoDBHashKey y @DynamoDBRangeKey para identificar las propiedades de clase
mapeadas a la clave principal.
@DynamoDBTable(tableName="Reply")
public class Reply {
private Integer id;
private String replyDateTime;
@DynamoDBHashKey(attributeName="Id")
public Integer getId() { return id; }
public void setId(Integer id) { this.id = id; }
@DynamoDBRangeKey(attributeName="ReplyDateTime")
public String getReplyDateTime() { return replyDateTime; }
public void setReplyDateTime(String replyDateTime) { this.replyDateTime =
replyDateTime; }
DynamoDBTable
Identifica la tabla de destino de DynamoDB. Por ejemplo, el código Java siguiente define una
claseDevelopery lo asigna a laPeopleen DynamoDB.
@DynamoDBTable(tableName="People")
public class Developer { ...}
La anotación @DynamoDBTable se puede heredar. Cualquier nueva clase que herede de la clase
Developer también se mapea a la tabla People. Por ejemplo, supongamos que hemos creado una clase
Lead que hereda de la clase Developer. Dado que ha mapeado la clase Developer a la tabla People,
los objetos de la clase Lead también se almacenan en la misma tabla.
La anotación @DynamoDBTable también se puede anular. Cualquier nueva clase que herede de la clase
Developer de forma predeterminada se mapea a la misma tabla People. Sin embargo, puede anular
este mapeo predeterminado. Por ejemplo, si crea una clase que hereda de la clase Developer, puede
mapearla explícitamente a otra tabla agregando la anotación @DynamoDBTable, como se muestra en el
siguiente ejemplo de código Java.
@DynamoDBTable(tableName="Managers")
public class Manager extends Developer { ...}
DynamoDBTypeConverted
Anotación para marcar que una propiedad usa un convertidor de tipos personalizado. Se puede
usar una anotación definida por el usuario para pasar propiedades adicionales al convertidor
DynamoDBTypeConverter.
LaDynamoDBTypeConverterLa interfaz permite mapear sus propios tipos de datos arbitrarios a un tipo
de datos que sea compatible de forma nativa con DynamoDB. Para obtener más información, consulte
Mapeo de datos arbitrarios (p. 276).
DynamoDBTyped
Anotación para anular el vínculo de tipo de atributo estándar. Los tipos estándar no requieren la anotación
si se les aplica el vínculo de atributo predeterminado para ese tipo.
DynamoDBVersionAttribute
Identifica una propiedad de clase para almacenar un número de versión de bloqueo optimista.
DynamoDBMapper asigna un número de versión a esta propiedad cuando guarda un elemento nuevo e
incrementa su valor cada vez que se actualiza el elemento. Solo se admiten escalares de tipo Number.
Para obtener más información sobre los tipos de datos, consulte Tipos de datos (p. 14). Para obtener más
información sobre el control de versiones, consulte Bloqueo optimista con el número de versión (p. 273).
Clase DynamoDBMapper
Temas
• save (p. 239)
• carga (p. 240)
• delete (p. 240)
• query (p. 240)
• queryPage (p. 242)
• scan (p. 242)
• scanPage (p. 243)
• parallelScan (p. 243)
• batchSave (p. 243)
• batchLoad (p. 244)
• batchDelete (p. 244)
• batchWrite (p. 244)
• transactionWrite (p. 245)
• transactionLoad (p. 245)
• count (p. 246)
• generateCreateTableRequest (p. 246)
• createS3Link (p. 246)
• getS3ClientCache (p. 247)
save
Guarda el objeto especificado en la tabla. El objeto que se desea guardar es el único parámetro obligatorio
para este método. Puede usar el objeto DynamoDBMapperConfig para proporcionar parámetros de
configuración opcionales.
Si no hay un elemento que tenga la misma clave principal, este método crea un nuevo elemento en la
tabla. Si hay un elemento que tiene la misma clave principal, lo actualiza. Si las claves de partición y orden
son de tipo String y se han anotado con @DynamoDBAutoGeneratedKey, se les asigna un identificador
universal único (UUID) aleatorio si se deja sin inicializar. Los campos de versión que se anotan con
@DynamoDBVersionAttribute se incrementan en una unidad. Además, si se actualiza un campo
de versión o se genera una clave, el objeto que se ha pasado se actualiza como consecuencia de la
operación.
Si el control de versiones está habilitado, las versiones del elemento del lado del cliente y del lado del
servidor deben coincidir. Sin embargo, no es preciso que coincidan las versiones si se utiliza la opción
SaveBehavior.CLOBBER. Para obtener más información sobre el control de versiones, consulte Bloqueo
optimista con el número de versión (p. 273).
carga
Recupera un elemento de una tabla. Es preciso proporcionar la clave principal del elemento que se desea
recuperar. Puede usar el objeto DynamoDBMapperConfig para proporcionar parámetros de configuración
opcionales. Por ejemplo, si lo desea puede solicitar lecturas de consistencia alta para asegurarse de que
este método recupere solamente los valores más recientes de los elementos, como se muestra en la
siguiente instrucción de Java.
De forma predeterminada, DynamoDB devuelve el elemento cuyos valores presentan consistencia final.
Para obtener más información sobre el modelo de consistencia final de DynamoDB, consulte.Consistencia
de lectura (p. 17).
delete
Elimina un elemento de la tabla. Debe pasar una instancia de objeto de la clase mapeada.
Si el control de versiones está habilitado, las versiones del elemento del lado del cliente y del lado del
servidor deben coincidir. Sin embargo, no es preciso que coincidan las versiones si se utiliza la opción
SaveBehavior.CLOBBER. Para obtener más información sobre el control de versiones, consulte Bloqueo
optimista con el número de versión (p. 273).
query
Consulta una tabla o un índice secundario. Solo se puede consultar una tabla o un índice si cuenta con una
clave principal compuesta (una clave de partición y una clave de ordenación). Este método requiere que
se proporcione un valor de clave de partición y un filtro de consulta que se aplica a la clave de ordenación.
Una expresión de filtro incluye una condición y un valor.
Supongamos que tenemos una tabla Reply en la que se almacenan respuestas de conversaciones. Para
cada tema de conversación puede haber cero o más respuestas. La clave principal de la tabla Reply
consta de los campos Id y ReplyDateTime, donde Id es la clave de partición y ReplyDateTime es la
clave de orden de la clave principal.
Supongamos que creamos una asignación entre unReplyy la clase correspondienteReplyen DynamoDB.
En el siguiente código Java se usa DynamoDBMapper para buscar todas las respuestas de las últimas dos
semanas para un tema de conversación concreto.
Example
De forma predeterminada, el método query devuelve una colección de "carga diferida". Inicialmente
devuelve una sola página de resultados y, a continuación, realiza una llamada de servicio para obtener la
página siguiente si es necesario. Para obtener todos los elementos coincidentes, recorra en iteración la
colección latestReplies.
Tenga en cuenta que llamar al método size() en la colección cargará todos los resultados para
proporcionar un recuento preciso. Esto puede provocar que se consuma una gran cantidad de rendimiento
aprovisionado y en una tabla muy grande incluso podría agotar toda la memoria en su JVM.
Para consultar un índice, antes es preciso modelarlo como clase de mapeador. Supongamos que
elReplyLa tabla tiene un índice secundario global denominadoPostedBy-Message-Index. La clave de
partición de este índice es PostedBy y la de orden, Message. La definición de clase de un elemento del
índice tendría el siguiente aspecto:
@DynamoDBTable(tableName="Reply")
public class PostedByMessage {
private String postedBy;
private String message;
@DynamoDBIndexHashKey(globalSecondaryIndexName = "PostedBy-Message-Index",
attributeName = "PostedBy")
public String getPostedBy() { return postedBy; }
public void setPostedBy(String postedBy) { this.postedBy = postedBy; }
@DynamoDBIndexRangeKey(globalSecondaryIndexName = "PostedBy-Message-Index",
attributeName = "Message")
public String getMessage() { return message; }
public void setMessage(String message) { this.message = message; }
La anotación @DynamoDBTable indica que este índice está asociado a la tabla Reply. La anotación
@DynamoDBIndexHashKey se refiere a la clave de partición (PostedBy) del índice y la anotación
@DynamoDBIndexRangeKey, a su clave de ordenación (Message).
Ahora, puede usar DynamoDBMapper para consultar el índice y recuperar un subconjunto de los mensajes
publicados por un usuario determinado. Debe especificar withIndexName para que DynamoDB sepa qué
índice hay que consultar. En el siguiente código se consulta un índice secundario global. Es imprescindible
especificar withConsistentRead(false), ya que los índices secundarios globales admiten las lecturas
consistentes finales, pero no las de consistencia alta.
queryPage
Consulta una tabla o un índice secundario y devuelve una sola página de resultados coincidentes. Al igual
que con el método query, es preciso especificar un valor de clave de partición y un filtro de consulta que
se aplica al atributo de clave de ordenación. Sin embargo,queryPageDevuelve solamente la primera
«página» de datos, es decir, la cantidad de datos que caben en
scan
Examina una tabla o un índice secundario completos. Si lo desea, puede especificar una expresión
FilterExpression para filtrar el conjunto de resultados.
Supongamos que tenemos una tabla Reply en la que se almacenan respuestas de conversaciones. Para
cada tema de conversación puede haber cero o más respuestas. La clave principal de la tabla Reply
consta de los campos Id y ReplyDateTime, donde Id es la clave de partición y ReplyDateTime es la
clave de orden de la clave principal.
Si ha mapeado una clase de Java a la tabla Reply, puede usar DynamoDBMapper para examinar la tabla.
Por ejemplo, en el siguiente código Java se examina toda la tabla Reply y únicamente se devuelven las
respuestas de un año determinado.
Example
De forma predeterminada, el método scan devuelve una colección de "carga diferida". Inicialmente
devuelve una sola página de resultados y, a continuación, realiza una llamada de servicio para obtener la
página siguiente si es necesario. Para obtener todos los elementos coincidentes, recorra en iteración la
colección replies.
Tenga en cuenta que llamar al método size() en la colección cargará todos los resultados para
proporcionar un recuento preciso. Esto puede provocar que se consuma una gran cantidad de rendimiento
aprovisionado y en una tabla muy grande incluso podría agotar toda la memoria en su JVM.
Para examinar un índice, antes es preciso modelarlo como clase de mapeador. Supongamos que
elReplyLa tabla tiene un índice secundario global denominadoPostedBy-Message-Index. La clave
de partición de este índice es PostedBy y la de orden, Message. En la sección query (p. 240) se
muestra una clase de mapeador para este índice. Usa las anotaciones @DynamoDBIndexHashKey y
@DynamoDBIndexRangeKey para especificar la clave de ordenación y la de partición del índice.
scanPage
Examina una tabla o un índice secundario y devuelve una sola página de resultados coincidentes. Al igual
que sucede con el método scan, si lo desea, puede especificar una expresión FilterExpression para
filtrar el conjunto de resultados. Sin embargo,scanPageSolo devuelve la primera «página» de datos; es
decir, la cantidad de datos que se ajusta a 1 MB.
parallelScan
Realiza un examen en paralelo de una tabla o un índice secundario completos. Se especifica un
número de segmentos lógicos de la tabla, junto con una expresión de examen para filtrar los resultados.
parallelScan divide la tarea de examen entre varios procesos de trabajo, uno para cada segmento
lógico. Los procesos de trabajo examinan los datos en paralelo y devuelven los resultados.
int numberOfThreads = 4;
Para obtener un ejemplo de código Java que ilustra el uso de parallelScan, consulte Ejemplo: Consulta
y examen (p. 257).
batchSave
Guarda objetos en una o varias tablas mediante una o varias llamadas al método
AmazonDynamoDB.batchWriteItem. Este método no proporciona garantías de transacción.
book1.id = 901;
book1.productCategory = "Book";
book1.title = "Book 901 Title";
mapper.batchSave(Arrays.asList(book1, book2));
batchLoad
Recupera varios elementos de una o varias tablas mediante sus claves principales.
batchDelete
Elimina objetos de una o varias tablas mediante una o varias llamadas al método
AmazonDynamoDB.batchWriteItem. Este método no proporciona garantías de transacción.
batchWrite
Guarda o elimina objetos en una o varias tablas mediante una o varias llamadas al método
AmazonDynamoDB.batchWriteItem. Este método no proporciona garantías de transacción ni admite el
control de versiones (colocaciones o eliminaciones condicionales).
En el siguiente código Java se escribe un nuevo elemento en la tabla Forum, se escribe un nuevo
elemento en la tabla Thread y se elimina un elemento de la tabla ProductCatalog.
mapper.batchWrite(objectsToWrite, objectsToDelete);
transactionWrite
Guarda o elimina objetos en una o varias tablas mediante una llamada al método
AmazonDynamoDB.transactWriteItems.
Para ver una lista de excepciones específicas de la transacción, consulte Errores de TransactWriteItems.
Para obtener más información sobre las transacciones de DynamoDB y las garantías proporcionadas de
atomicidad, uniformidad, aislamiento y durabilidad (ACID), consulteTransacciones de Amazon DynamoDB.
Note
• DynamoDBMapperConfig.SaveBehavior.
El siguiente código Java escribe un nuevo elemento en cada una de las tablas Forum y Thread de un
modo transaccional.
transactionLoad
Carga objetos de una o varias tablas mediante una llamada al método
AmazonDynamoDB.transactGetItems.
Para ver una lista de excepciones específicas de transacciones, consulte Errores de TransactGetItems.
Para obtener más información sobre las transacciones de DynamoDB y las garantías proporcionadas de
atomicidad, uniformidad, aislamiento y durabilidad (ACID), consulteTransacciones de Amazon DynamoDB.
El siguiente código Java carga un elemento en cada una de las tablas Forum y Thread de un modo
transaccional.
count
Evalúa la expresión de examen especificada y devuelve el recuento de elementos coincidentes. No se
devuelven datos de elementos.
generateCreateTableRequest
Analiza una clase POJO que representa una tabla DynamoDB y devuelve unCreateTableRequestPara
esa tabla.
createS3Link
Crea un enlace a un objeto en Amazon S3. Debe especificar un nombre de bucket y un nombre de clave
para identificar el objeto en el bucket de forma exclusiva.
Para usar createS3Link, la clase de mapeador debe definir métodos getter y setter. Esto se ilustra en
el siguiente ejemplo de código con la adición de un nuevo atributo y de métodos getter/setter a la clase
CatalogItem.
@DynamoDBTable(tableName="ProductCatalog")
public class CatalogItem {
...
....
@DynamoDBAttribute(attributeName = "ProductImage")
public S3Link getProductImage() {
return productImage;
}
...
}
En el siguiente código Java se define un nuevo elemento para escribirlo en la tabla Product. El artículo
incluye un enlace a la imagen de un producto; los datos de la imagen se cargan en Amazon S3.
item.id = 150;
item.title = "Book 150 Title";
item.getProductImage().uploadFrom(new File("/file/path/book_150_cover.jpg"));
mapper.save(item);
LaS3LinkLa clase proporciona muchos métodos más para manipular objetos en Amazon S3. Para
obtener más información, consulte los javadocs en Class S3Link.
getS3ClientCache
Devuelve el objeto subyacenteS3ClientCachepara acceder a Amazon S3. Un objeto S3ClientCache
es un mapa inteligente para objetos AmazonS3Client. Si tiene varios clientes, unS3ClientCachepuede
ayudarle a mantener los clientes organizados porAWS, y puede crear nuevos clientes de Amazon S3 a
petición.
En el siguiente fragmento de código se crea una clase DynamoDBMapper con ajustes personalizados:
.withPaginationLoadingStrategy(DynamoDBMapperConfig.PaginationLoadingStrategy.EAGER_LOADING)
.build();
En este ejemplo de código se supone que ya ha cargado datos en DynamoDB para su cuenta
siguiendo las instrucciones delCreación de tablas y carga de datos para ejemplos de código en
DynamoDB (p. 333)sección.
Para obtener instrucciones paso a paso acerca de cómo ejecutar el siguiente ejemplo, consulte
Ejemplos de código Java (p. 338).
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.datamodeling;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBAttribute;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBHashKey;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMapper;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMapperConfig;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBTable;
@DynamoDBTable(tableName = "ProductCatalog")
public static class CatalogItem {
private Integer id;
private String title;
private String ISBN;
private Set<String> bookAuthors;
// Partition key
@DynamoDBHashKey(attributeName = "Id")
public Integer getId() {
return id;
}
@DynamoDBAttribute(attributeName = "Title")
public String getTitle() {
return title;
}
@DynamoDBAttribute(attributeName = "ISBN")
public String getISBN() {
return ISBN;
}
@DynamoDBAttribute(attributeName = "Authors")
public Set<String> getBookAuthors() {
return bookAuthors;
}
@Override
public String toString() {
return "Book [ISBN=" + ISBN + ", bookAuthors=" + bookAuthors + ", id=" + id +
", title=" + title + "]";
}
}
Para obtener más información sobre las tablas que se utilizan en este ejemplo, consulte.Creación de tablas
y carga de datos para ejemplos de código en DynamoDB (p. 333). Para obtener instrucciones paso a
paso para probar el siguiente ejemplo, consulte Ejemplos de código Java (p. 338).
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.datamodeling;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBAttribute;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBHashKey;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMapper;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMapperConfig;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBRangeKey;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBTable;
testBatchSave(mapper);
testBatchDelete(mapper);
testBatchWrite(mapper);
System.out.println("Example complete!");
}
catch (Throwable t) {
System.err.println("Error running the DynamoDBMapperBatchWriteExample: " + t);
t.printStackTrace();
}
}
.build();
@DynamoDBTable(tableName = "ProductCatalog")
public static class Book {
private int id;
private String title;
private String ISBN;
private int price;
private int pageCount;
private String productCategory;
private boolean inPublication;
// Partition key
@DynamoDBHashKey(attributeName = "Id")
public int getId() {
return id;
}
@DynamoDBAttribute(attributeName = "Title")
public String getTitle() {
return title;
}
@DynamoDBAttribute(attributeName = "ISBN")
public String getISBN() {
return ISBN;
}
@DynamoDBAttribute(attributeName = "Price")
public int getPrice() {
return price;
}
@DynamoDBAttribute(attributeName = "PageCount")
public int getPageCount() {
return pageCount;
}
@DynamoDBAttribute(attributeName = "ProductCategory")
public String getProductCategory() {
return productCategory;
}
@DynamoDBAttribute(attributeName = "InPublication")
public boolean getInPublication() {
return inPublication;
}
@Override
public String toString() {
return "Book [ISBN=" + ISBN + ", price=" + price + ", product category=" +
productCategory + ", id=" + id
+ ", title=" + title + "]";
}
@DynamoDBTable(tableName = "Reply")
public static class Reply {
private String id;
private String replyDateTime;
private String message;
private String postedBy;
// Partition key
@DynamoDBHashKey(attributeName = "Id")
public String getId() {
return id;
}
// Sort key
@DynamoDBRangeKey(attributeName = "ReplyDateTime")
public String getReplyDateTime() {
return replyDateTime;
}
@DynamoDBAttribute(attributeName = "Message")
public String getMessage() {
return message;
}
@DynamoDBAttribute(attributeName = "PostedBy")
public String getPostedBy() {
return postedBy;
}
@DynamoDBTable(tableName = "Thread")
public static class Thread {
private String forumName;
private String subject;
private String message;
private String lastPostedDateTime;
private String lastPostedBy;
private Set<String> tags;
private int answered;
private int views;
private int replies;
// Partition key
@DynamoDBHashKey(attributeName = "ForumName")
public String getForumName() {
return forumName;
}
// Sort key
@DynamoDBRangeKey(attributeName = "Subject")
public String getSubject() {
return subject;
}
@DynamoDBAttribute(attributeName = "Message")
public String getMessage() {
return message;
}
@DynamoDBAttribute(attributeName = "LastPostedDateTime")
public String getLastPostedDateTime() {
return lastPostedDateTime;
}
@DynamoDBAttribute(attributeName = "LastPostedBy")
public String getLastPostedBy() {
return lastPostedBy;
}
@DynamoDBAttribute(attributeName = "Tags")
public Set<String> getTags() {
return tags;
}
@DynamoDBAttribute(attributeName = "Answered")
public int getAnswered() {
return answered;
}
@DynamoDBAttribute(attributeName = "Views")
public int getViews() {
return views;
}
@DynamoDBAttribute(attributeName = "Replies")
public int getReplies() {
return replies;
}
@DynamoDBTable(tableName = "Forum")
public static class Forum {
private String name;
private String category;
private int threads;
// Partition key
@DynamoDBHashKey(attributeName = "Name")
public String getName() {
return name;
}
@DynamoDBAttribute(attributeName = "Category")
public String getCategory() {
return category;
}
@DynamoDBAttribute(attributeName = "Threads")
public int getThreads() {
return threads;
}
}
}
En el ejemplo de Java de esta sección se definen las clases siguientes y se mapean a las tablas de
Amazon DynamoDB. Para obtener más información sobre cómo crear ejemplos de tablas, consulte
Creación de tablas y carga de datos para ejemplos de código en DynamoDB (p. 333).
La tabla ProductCatalog tiene Id como clave principal. No tiene una clave de ordenación que forme
parte de la clave principal. Por lo tanto, no puede consultar la tabla. Puede usar el valor de Id para
obtener un elemento.
• Ejecute las siguientes consultas en laReplyTabla de.
Por motivos de rendimiento, debe usar la operación de consulta y no una operación de examen. Sin
embargo, a veces puede que necesite examinar una tabla. Supongamos que se ha cometido un
error al especificar los datos y que el precio de uno de los libros se ha establecido en un valor menor
que 0. En este ejemplo se examina la tabla ProductCategory para buscar los elementos de libro
(ProductCategory es el libro) cuyo precio sea menor que 0.
• Realice un examen en paralelo de la tabla ProductCatalog para encontrar las bicicletas de un tipo
específico.
Note
En este ejemplo de código se supone que ya ha cargado datos en DynamoDB para su cuenta
siguiendo las instrucciones delCreación de tablas y carga de datos para ejemplos de código en
DynamoDB (p. 333)sección.
Para obtener instrucciones paso a paso acerca de cómo ejecutar el siguiente ejemplo, consulte
Ejemplos de código Java (p. 338).
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.datamodeling;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TimeZone;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBAttribute;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBHashKey;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMapper;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBQueryExpression;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBRangeKey;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBScanExpression;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBTable;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
// Scan a table and find book items priced less than specified
// value.
FindBooksPricedLessThanSpecifiedValue(mapper, "20");
// Scan a table with multiple threads and find bicycle items with a
// specified bicycle type
int numberOfThreads = 16;
FindBicyclesOfSpecificTypeWithMultipleThreads(mapper, numberOfThreads, "Road");
System.out.println("Example complete!");
}
catch (Throwable t) {
System.err.println("Error running the DynamoDBMapperQueryScanExample: " + t);
t.printStackTrace();
}
}
System.out.println(
"FindRepliesPostedWithinTimePeriod: Find replies for thread Message = 'DynamoDB
Thread 2' posted within a period.");
long startDateMilli = (new Date()).getTime() - (14L * 24L * 60L * 60L * 1000L); //
Two
//
weeks
//
ago.
long endDateMilli = (new Date()).getTime() - (7L * 24L * 60L * 60L * 1000L); // One
//
week
//
ago.
SimpleDateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-
dd'T'HH:mm:ss.SSS'Z'");
dateFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));
String startDate = dateFormatter.format(startDateMilli);
String endDate = dateFormatter.format(endDateMilli);
System.out.println("FindBicyclesOfSpecificTypeWithMultipleThreads: Scan
ProductCatalog With Multiple Threads.");
Map<String, AttributeValue> eav = new HashMap<String, AttributeValue>();
eav.put(":val1", new AttributeValue().withS("Bicycle"));
eav.put(":val2", new AttributeValue().withS(bicycleType));
@DynamoDBTable(tableName = "ProductCatalog")
public static class Book {
private int id;
private String title;
private String ISBN;
private int price;
private int pageCount;
private String productCategory;
private boolean inPublication;
@DynamoDBHashKey(attributeName = "Id")
public int getId() {
return id;
}
@DynamoDBAttribute(attributeName = "Title")
public String getTitle() {
return title;
}
@DynamoDBAttribute(attributeName = "ISBN")
public String getISBN() {
return ISBN;
}
@DynamoDBAttribute(attributeName = "Price")
public int getPrice() {
return price;
}
@DynamoDBAttribute(attributeName = "PageCount")
public int getPageCount() {
return pageCount;
}
@DynamoDBAttribute(attributeName = "ProductCategory")
public String getProductCategory() {
return productCategory;
}
@DynamoDBAttribute(attributeName = "InPublication")
public boolean getInPublication() {
return inPublication;
}
@Override
public String toString() {
return "Book [ISBN=" + ISBN + ", price=" + price + ", product category=" +
productCategory + ", id=" + id
+ ", title=" + title + "]";
}
@DynamoDBTable(tableName = "ProductCatalog")
public static class Bicycle {
private int id;
private String title;
private String description;
private String bicycleType;
private String brand;
private int price;
private List<String> color;
private String productCategory;
@DynamoDBHashKey(attributeName = "Id")
public int getId() {
return id;
}
@DynamoDBAttribute(attributeName = "Title")
public String getTitle() {
return title;
}
@DynamoDBAttribute(attributeName = "Description")
public String getDescription() {
return description;
}
@DynamoDBAttribute(attributeName = "BicycleType")
public String getBicycleType() {
return bicycleType;
}
@DynamoDBAttribute(attributeName = "Brand")
public String getBrand() {
return brand;
@DynamoDBAttribute(attributeName = "Price")
public int getPrice() {
return price;
}
@DynamoDBAttribute(attributeName = "Color")
public List<String> getColor() {
return color;
}
@DynamoDBAttribute(attributeName = "ProductCategory")
public String getProductCategory() {
return productCategory;
}
@Override
public String toString() {
return "Bicycle [Type=" + bicycleType + ", color=" + color + ", price=" + price
+ ", product category="
+ productCategory + ", id=" + id + ", title=" + title + "]";
}
@DynamoDBTable(tableName = "Reply")
public static class Reply {
private String id;
private String replyDateTime;
private String message;
private String postedBy;
// Partition key
@DynamoDBHashKey(attributeName = "Id")
public String getId() {
return id;
}
// Range key
@DynamoDBRangeKey(attributeName = "ReplyDateTime")
public String getReplyDateTime() {
return replyDateTime;
}
this.replyDateTime = replyDateTime;
}
@DynamoDBAttribute(attributeName = "Message")
public String getMessage() {
return message;
}
@DynamoDBAttribute(attributeName = "PostedBy")
public String getPostedBy() {
return postedBy;
}
@DynamoDBTable(tableName = "Thread")
public static class Thread {
private String forumName;
private String subject;
private String message;
private String lastPostedDateTime;
private String lastPostedBy;
private Set<String> tags;
private int answered;
private int views;
private int replies;
// Partition key
@DynamoDBHashKey(attributeName = "ForumName")
public String getForumName() {
return forumName;
}
// Range key
@DynamoDBRangeKey(attributeName = "Subject")
public String getSubject() {
return subject;
}
@DynamoDBAttribute(attributeName = "Message")
public String getMessage() {
return message;
}
@DynamoDBAttribute(attributeName = "LastPostedDateTime")
public String getLastPostedDateTime() {
return lastPostedDateTime;
@DynamoDBAttribute(attributeName = "LastPostedBy")
public String getLastPostedBy() {
return lastPostedBy;
}
@DynamoDBAttribute(attributeName = "Tags")
public Set<String> getTags() {
return tags;
}
@DynamoDBAttribute(attributeName = "Answered")
public int getAnswered() {
return answered;
}
@DynamoDBAttribute(attributeName = "Views")
public int getViews() {
return views;
}
@DynamoDBAttribute(attributeName = "Replies")
public int getReplies() {
return replies;
}
@DynamoDBTable(tableName = "Forum")
public static class Forum {
private String name;
private String category;
private int threads;
@DynamoDBHashKey(attributeName = "Name")
public String getName() {
return name;
}
@DynamoDBAttribute(attributeName = "Category")
public String getCategory() {
return category;
}
@DynamoDBAttribute(attributeName = "Threads")
public int getThreads() {
return threads;
}
• transactionWrite para añadir, actualizar y eliminar varios elementos de una o varias tablas en una
transacción.
• transactionLoad para recuperar varios elementos de una o varias tablas en una transacción.
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBAttribute;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBHashKey;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMapper;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMapperConfig;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBTable;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBRangeKey;
import com.amazonaws.services.dynamodbv2.datamodeling.TransactionWriteRequest;
import com.amazonaws.services.dynamodbv2.datamodeling.TransactionLoadRequest;
import com.amazonaws.services.dynamodbv2.model.TransactionCanceledException;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBTransactionWriteExpression;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBTransactionLoadExpression;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMappingException;
import com.amazonaws.services.dynamodbv2.model.ResourceNotFoundException;
import com.amazonaws.services.dynamodbv2.model.InternalServerErrorException;
testPutAndUpdateInTransactionWrite();
testPutWithConditionalUpdateInTransactionWrite();
testPutWithConditionCheckInTransactionWrite();
testMixedOperationsInTransactionWrite();
testTransactionLoadWithSave();
testTransactionLoadWithTransactionWrite();
System.out.println("Example complete");
}
catch (Throwable t) {
System.err.println("Error running the DynamoDBMapperTransactionWriteExample: "
+ t);
t.printStackTrace();
}
}
// Read DynamoDB Forum item and Thread item at the same time in a serializable
manner
TransactionLoadRequest transactionLoadRequest = new TransactionLoadRequest();
.withProjectionExpression("Subject, Message");
transactionLoadRequest.addLoad(dynamodbForumThread, loadExpressionForThread);
// Loaded objects are guaranteed to be in same order as the order in which they are
// added to TransactionLoadRequest
List<Object> loadedObjects = executeTransactionLoad(transactionLoadRequest);
Forum loadedDynamoDBForum = (Forum) loadedObjects.get(0);
System.out.println("Forum: " + loadedDynamoDBForum.name);
System.out.println("Threads: " + loadedDynamoDBForum.threads);
Thread loadedDynamodbForumThread = (Thread) loadedObjects.get(1);
System.out.println("Subject: " + loadedDynamodbForumThread.subject);
System.out.println("Message: " + loadedDynamodbForumThread.message);
}
// Update Forum item for DynamoDB and add a thread to DynamoDB Forum, in
// an ACID manner using transactionWrite
dynamodbForum.threads = 1;
Thread dynamodbForumThread = new Thread();
dynamodbForumThread.forumName = "DynamoDB New Forum";
dynamodbForumThread.subject = "Sample Subject 2";
dynamodbForumThread.message = "Sample Question 2";
TransactionWriteRequest transactionWriteRequest = new TransactionWriteRequest();
transactionWriteRequest.addPut(dynamodbForumThread);
transactionWriteRequest.addUpdate(dynamodbForum);
executeTransactionWrite(transactionWriteRequest);
// Read DynamoDB Forum item and Thread item at the same time in a serializable
manner
TransactionLoadRequest transactionLoadRequest = new TransactionLoadRequest();
.withProjectionExpression("Subject, Message");
transactionLoadRequest.addLoad(dynamodbForumThread, loadExpressionForThread);
// Loaded objects are guaranteed to be in same order as the order in which they are
// added to TransactionLoadRequest
List<Object> loadedObjects = executeTransactionLoad(transactionLoadRequest);
Forum loadedDynamoDBForum = (Forum) loadedObjects.get(0);
System.out.println("Forum: " + loadedDynamoDBForum.name);
System.out.println("Threads: " + loadedDynamoDBForum.threads);
Thread loadedDynamodbForumThread = (Thread) loadedObjects.get(1);
System.out.println("Subject: " + loadedDynamodbForumThread.subject);
System.out.println("Message: " + loadedDynamodbForumThread.message);
}
// Update Forum item for S3 and Create new Forum item for DynamoDB using
transactionWrite
s3Forum.category = "Amazon Web Services";
Forum dynamodbForum = new Forum();
dynamodbForum.name = "DynamoDB Forum";
dynamodbForum.category = "Amazon Web Services";
dynamodbForum.threads = 0;
TransactionWriteRequest transactionWriteRequest = new TransactionWriteRequest();
transactionWriteRequest.addUpdate(s3Forum);
transactionWriteRequest.addPut(dynamodbForum);
executeTransactionWrite(transactionWriteRequest);
}
.withConditionExpression("attribute_exists(Category)");
.withConditionExpression("attribute_exists(Subject)");
.withConditionExpression("attribute_exists(Subject)");
@DynamoDBTable(tableName = "Thread")
public static class Thread {
private String forumName;
private String subject;
private String message;
private String lastPostedDateTime;
private String lastPostedBy;
private Set<String> tags;
private int answered;
private int views;
private int replies;
// Partition key
@DynamoDBHashKey(attributeName = "ForumName")
public String getForumName() {
return forumName;
}
// Sort key
@DynamoDBRangeKey(attributeName = "Subject")
public String getSubject() {
return subject;
}
@DynamoDBAttribute(attributeName = "Message")
public String getMessage() {
return message;
}
@DynamoDBAttribute(attributeName = "LastPostedDateTime")
public String getLastPostedDateTime() {
return lastPostedDateTime;
}
@DynamoDBAttribute(attributeName = "LastPostedBy")
public String getLastPostedBy() {
return lastPostedBy;
}
@DynamoDBAttribute(attributeName = "Tags")
public Set<String> getTags() {
return tags;
}
@DynamoDBAttribute(attributeName = "Answered")
public int getAnswered() {
return answered;
}
@DynamoDBAttribute(attributeName = "Views")
public int getViews() {
return views;
}
@DynamoDBAttribute(attributeName = "Replies")
public int getReplies() {
return replies;
}
@DynamoDBTable(tableName = "Forum")
public static class Forum {
private String name;
private String category;
private int threads;
// Partition key
@DynamoDBHashKey(attributeName = "Name")
public String getName() {
return name;
}
@DynamoDBAttribute(attributeName = "Category")
public String getCategory() {
return category;
}
@DynamoDBAttribute(attributeName = "Threads")
public int getThreads() {
return threads;
}
Con el bloqueo optimista, cada elemento tiene un atributo que actúa como número de versión. Si
recupera un elemento de una tabla, la aplicación registra el número de versión de ese elemento. Puede
actualizar el elemento, pero solo si el número de versión del lado del servidor no ha cambiado. Si no hay
una coincidencia de versión, significa que alguien más ha modificado el elemento antes que usted. El
intento de actualización falla porque tiene una versión obsoleta del elemento. Si esto ocurre, solo hay
que volver a intentar recuperar el elemento y actualizarlo. El bloqueo optimista impide que sobrescriba
accidentalmente los cambios realizados por otras personas. También impide que otras personas
sobrescriban accidentalmente sus cambios.
Para admitir el bloqueo optimista, el AWS SDK for Java proporciona la anotación
@DynamoDBVersionAttribute. En la clase de mapeo de la tabla, debe designar una propiedad en
la que se almacenará el número de versión y marcarla con esta anotación. Al guardar un objeto, el
elemento correspondiente de la tabla de DynamoDB tendrá un atributo en el que se almacenará el número
de versión. DynamoDBMapper asigna un número de versión la primera vez que se guarda el objeto y
aumenta automáticamente este número de versión cada vez que se actualiza el elemento. Las solicitudes
de actualización o eliminación solamente se llevan a cabo si la versión del objeto en el lado del cliente
coincide con el número de versión del elemento correspondiente en la tabla de DynamoDB.
Note
• Las tablas globales de DynamoDB usan una reconciliación del tipo "prevalece el último escritor"
entre las actualizaciones simultáneas. Si usa tablas globales, prevalecerá la política del último
escritor. Por tanto, en este caso, la estrategia de bloqueo no funciona según lo previsto.
• Las operaciones de escritura transaccionales DynamoDBMapper no admiten las expresiones
de anotación y condición @DynamoDBVersionAttribute en la misma llamada a la API. Si un
objeto en una escritura transacciones se anota con @DynamoDBVersionAttribute y también
tiene una expresión de condición, se producirá una SdkClientException.
Por ejemplo, en el siguiente código Java se define una clase CatalogItem que tiene varias propiedades.
La propiedad Version está etiquetada con la anotación @DynamoDBVersionAttribute.
Example
@DynamoDBTable(tableName="ProductCatalog")
public class CatalogItem {
@DynamoDBHashKey(attributeName="Id")
public Integer getId() { return id; }
public void setId(Integer Id) { this.id = Id; }
@DynamoDBAttribute(attributeName="Title")
public String getTitle() { return title; }
public void setTitle(String title) { this.title = title; }
@DynamoDBAttribute(attributeName="ISBN")
public String getISBN() { return ISBN; }
public void setISBN(String ISBN) { this.ISBN = ISBN;}
@DynamoDBAttribute(attributeName = "Authors")
public Set<String> getBookAuthors() { return bookAuthors; }
public void setBookAuthors(Set<String> bookAuthors) { this.bookAuthors = bookAuthors; }
@DynamoDBIgnore
public String getSomeProp() { return someProp;}
public void setSomeProp(String someProp) {this.someProp = someProp;}
@DynamoDBVersionAttribute
public Long getVersion() { return version; }
public void setVersion(Long version) { this.version = version;}
}
Puede aplicar la anotación @DynamoDBVersionAttribute a los tipos que admiten valores null; estos
están disponibles en las clases encapsuladoras primitivas que proporcionan un tipo que admite valores
null, tales como Long e Integer.
El bloqueo optimista afecta a los siguientes métodos de DynamoDBMapper como se indica a continuación:
También puede establecer el comportamiento de bloqueo para una operación específica. Por ejemplo,
en el siguiente fragmento de código Java se usa DynamoDBMapper para guardar un elemento de
catálogo. Se agrega el parámetro opcional DynamoDBMapperConfig.SaveBehavior al método
DynamoDBMapperConfig para especificar save.
Note
Example
Por ejemplo, tomemos la siguiente clase CatalogItem que define una propiedad, Dimension, del tipo
DimensionType. Esta propiedad almacena las dimensiones del elemento, tales como altura, anchura
o espesor. Supongamos que decide almacenar estas dimensiones del elemento en una cadena (por
ejemplo, 8.5x11x.05) en DynamoDB. En el ejemplo siguiente se proporciona el código convertidor que
convierte el objeto DimensionType en una cadena y una cadena al tipo DimensionType.
Note
En este ejemplo de código se supone que ya ha cargado datos en DynamoDB para su cuenta
siguiendo las instrucciones delCreación de tablas y carga de datos para ejemplos de código en
DynamoDB (p. 333)sección.
Para obtener instrucciones paso a paso acerca de cómo ejecutar el siguiente ejemplo, consulte
Ejemplos de código Java (p. 338).
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.datamodeling;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBAttribute;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBHashKey;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMapper;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBTypeConverted;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBTypeConverter;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBTable;
bookRetrieved.getDimensions().setHeight("9.0");
bookRetrieved.getDimensions().setLength("12.0");
bookRetrieved.getDimensions().setThickness("2.0");
mapper.save(bookRetrieved);
@DynamoDBTable(tableName = "ProductCatalog")
public static class Book {
private int id;
private String title;
private String ISBN;
private Set<String> bookAuthors;
private DimensionType dimensionType;
// Partition key
@DynamoDBHashKey(attributeName = "Id")
public int getId() {
return id;
}
@DynamoDBAttribute(attributeName = "Title")
public String getTitle() {
return title;
}
@DynamoDBAttribute(attributeName = "ISBN")
public String getISBN() {
return ISBN;
}
@DynamoDBAttribute(attributeName = "Authors")
public Set<String> getBookAuthors() {
return bookAuthors;
}
@DynamoDBTypeConverted(converter = DimensionTypeConverter.class)
@DynamoDBAttribute(attributeName = "Dimensions")
public DimensionType getDimensions() {
return dimensionType;
}
@DynamoDBAttribute(attributeName = "Dimensions")
public void setDimensions(DimensionType dimensionType) {
this.dimensionType = dimensionType;
}
@Override
public String toString() {
return "Book [ISBN=" + ISBN + ", bookAuthors=" + bookAuthors + ",
dimensionType= "
+ dimensionType.getHeight() + " X " + dimensionType.getLength() + " X " +
dimensionType.getThickness()
+ ", Id=" + id + ", Title=" + title + "]";
}
}
@Override
public String convert(DimensionType object) {
DimensionType itemDimensions = (DimensionType) object;
String dimension = null;
try {
if (itemDimensions != null) {
dimension = String.format("%s x %s x %s", itemDimensions.getLength(),
itemDimensions.getHeight(),
itemDimensions.getThickness());
}
}
catch (Exception e) {
e.printStackTrace();
}
return dimension;
}
@Override
public DimensionType unconvert(String s) {
return itemDimension;
}
}
}
LaAWS SDK for .NETProporciona clases de modelo de documento que encapsulan algunas de las
operaciones de bajo nivel de Amazon DynamoDB y así le ayudan a simplificar la codificación. En el modelo
de documento, las clases principales son Table y Document. La clase Table proporciona métodos
de operaciones de datos, como PutItem, GetItem y DeleteItem. Además, proporciona los métodos
Query y Scan. La clase Document representa un solo elemento de una tabla.
Las clases del modelo de documento citadas están disponibles en el espacio de nombres
Amazon.DynamoDBv2.DocumentModel.
• bool
• byte
• char
• DateTime
• decimal
• double
• float
• Guid
• Int16
• Int32
• Int64
• SByte
• string
• UInt16
• UInt32
• UInt64
En la tabla siguiente se resume el mapeo de los tipos de .NET anteriores a los tipos de DynamoDB.
Tipos de recopilación (List, HashSet y array) BS (tipo Binary Set), SS (tipo String Set) y NS (tipo
Number Set)
AWS SDK for .NETEl define tipos para mapear tipos booleanos, nulos, listas y mapas de DynamoDB a la
API del modelo de documento de .NET:
Note
• Se admiten valores binarios vacíos.
• Se admite la lectura de valores de cadena vacíos. Los valores de atributo de cadena vacíos se
admiten dentro de los valores de atributo del tipo de conjunto de cadenas mientras se escribe
en DynamoDB. Los valores de atributo de cadena vacíos del tipo de cadena y los valores de
cadena vacíos contenidos en el tipo lista o mapa se eliminan de las solicitudes de escritura
Para llevar a cabo operaciones de datos con el modelo de documento, previamente debe llamar al método
Table.LoadTable, que crea una instancia de la clase Table que representa una tabla específica.
En el siguiente ejemplo de C# se crea unTableObjeto que representaProductCatalogen Amazon
DynamoDB.
Example
Note
En general, se utiliza elLoadTableUna vez al principio de la aplicación porque crea
unDescribeTableque se suma al viaje de ida y vuelta a DynamoDB.
A continuación, puede utilizar el objeto Table para realizar diversas operaciones de datos. Cada
operación de datos tiene dos tipos de sobrecargas: Uno acepta los parámetros mínimos imprescindibles
y el otro acepta información de configuración opcional específica de la operación. Por ejemplo, para
recuperar un elemento, debe proporcionar el valor de clave principal de la tabla, en cuyo caso puede
utilizar la siguiente sobrecarga de GetItem.
Example
// Get the item from a table that has a primary key that is composed of only a partition
key.
Table.GetItem(Primitive partitionKey);
// Get the item from a table whose primary key is composed of both a partition key and sort
key.
Table.GetItem(Primitive partitionKey, Primitive sortKey);
También puede pasar parámetros opcionales a estos métodos. Por ejemplo, la operación GetItem
anterior devuelve el elemento completo, incluidos todos sus atributos. Si lo desea, puede especificar una
lista de atributos que se van a recuperar. En este caso, se utiliza la siguiente sobrecarga de GetItem, que
acepta el parámetro del objeto de configuración específico de la operación.
Example
Puede utilizar el objeto de configuración para especificar varios parámetros opcionales como, por ejemplo,
solicitar una lista de atributos concretos o especificar el tamaño de página (número de elementos por
página). Cada método de operación de datos tiene su propia clase de configuración. Por ejemplo, puede
usar la clase GetItemOperationConfig para proporcionar opciones para la operación GetItem. Puede
usar la clase PutItemOperationConfig para proporcionar parámetros opcionales para la operación
PutItem.
En las siguientes secciones se explican las distintas operaciones de datos que la clase Table admite.
A continuación se indican los pasos que debe seguir para colocar un nuevo elemento en una tabla con el
modelo de documento de AWS SDK for .NET.
En el siguiente ejemplo de código C# se ponen en práctica las tareas anteriores. En el ejemplo se carga un
elemento en la tabla ProductCatalog.
Example
table.PutItem(book);
En el ejemplo anterior, la instancia de Document crea un elemento que tiene los atributos Number,
String, String Set, Boolean y Null (Null se usa para indicar que el valor de QuantityOnHand
de este producto es desconocido). Para los tipos Boolean y Null, use los métodos de constructor
DynamoDBBool y DynamoDBNull.
En DynamoDB, elListyMapLos tipos de datos pueden contener elementos compuestos de otros tipos de
datos. A continuación se muestra cómo mapear estos tipos de datos a la API del modelo de documento:
Puede modificar el ejemplo anterior para agregar un atributo de tipo List al elemento. Para ello, se usa un
constructor DynamoDBList, como se muestra en el ejemplo de código siguiente.
Example
table.PutItem(book);
Para agregar un atributo Map al libro, se define otro objeto Document. En el siguiente ejemplo de código
se ilustra cómo hacerlo.
Example
book.Add("Pictures", pictures);
table.PutItem(book);
• El parámetro ConditionalExpression para hacer que esta sea una solicitud de colocación
condicional. En el ejemplo se crea una expresión que especifica que el atributo ISBN debe tener un valor
específico que ha de estar presente en el elemento que se va a sustituir.
Example
table.PutItem(book, config);
Example
La operación GetItem devuelve todos los atributos del elemento y, de forma predeterminada, utiliza la
lectura consistente final (consulte Consistencia de lectura (p. 17)).
Example
Al recuperar un elemento usando la API de modelo de documento, puede obtener acceso a los elementos
individuales en el objeto Document devuelto, como se muestra en el siguiente ejemplo.
Example
int id = doc["Id"].AsInt();
string title = doc["Title"].AsString();
List<string> authors = doc["Authors"].AsListOfString();
bool inStock = doc["InStock"].AsBoolean();
DynamoDBNull quantityOnHand = doc["QuantityOnHand"].AsDynamoDBNull();
Para los atributos de tipo List o Map, a continuación se muestra cómo mapearlos a la API de modelo de
documento:
En el siguiente ejemplo de código se muestra cómo recuperar un elemento de tipo List (RelatedItems) y
otro de tipo Map (Pictures) del objeto Document:
Example
Example
• El parámetro ConditionalExpression para garantizar que el atributo ISBN del elemento de libro que
se va a eliminar tenga un valor específico.
• El parámetro ReturnValues para solicitar que el método Delete devuelva el elemento que ha
eliminado.
Example
Puede usar la operación UpdateItem para actualizar los valores de atributos presentes y agregar
atributos nuevos a la colección existente o eliminarlos de ella. Para proporcionar estas actualizaciones, se
crea una instancia de Document que describe las actualizaciones que se desea llevar a cabo.
Note
A continuación se indican los pasos que hay que seguir para actualizar un elemento mediante el modelo
de documento de AWS SDK for .NET:
1. Ejecute laTable.LoadTableEl método proporciona el nombre de la tabla en la que desea llevar a cabo
la operación de actualización.
2. Cree una instancia de Document proporcionando todas las actualizaciones que desee realizar.
Debe proporcionar la clave principal, bien en la instancia de Document, o bien explícitamente como
parámetro.
En el siguiente ejemplo de código C# se ponen en práctica las tareas anteriores. En el ejemplo de código
se actualiza un elemento de la tabla Book. La operación UpdateItem actualiza el atributo Authors,
elimina el atributo PageCount y agrega el atributo nuevo XYZ. La instancia de Document incluye la clave
principal del libro que se va a actualizar.
Example
table.Update(book);
Example
Cuando se utiliza la API del modelo de documento, se puede especificar cualquier cantidad de
operaciones en un lote. Sin embargo, DynamoDB limita el número de operaciones de un lote y el
tamaño total del lote para una operación por lotes. Para obtener más información acerca de los límites
específicos, consulte, consulteBatchWriteItem. Si la API del modelo de documento detecta que la
solicitud de escritura por lotes ha superado el número permitido de solicitudes de escritura o la carga de
HTTP de un lote ha superado el límite permitido por BatchWriteItem, divide el lote en varios lotes de
menor tamaño. Además, si una respuesta a una escritura por lotes devuelve elementos sin procesar,
la API del modelo de documento envía automáticamente otra solicitud de escritura por lotes con esos
elementos que no se han procesado.
En el siguiente ejemplo de código C# se ponen en práctica los pasos anteriores. En el ejemplo se utiliza
una operación de escritura por lotes para realizar dos escrituras: cargar un elemento de libro y eliminar
otro.
batchWrite.AddDocumentToPut(book1);
// specify delete item using overload that takes PK.
batchWrite.AddKeyToDelete(12345);
batchWrite.Execute();
Para ver un ejemplo práctico, consulte Ejemplo: Operaciones Batch utilizandoAWS SDK for .NETAPI de
modelo de documento (p. 293).
Puede utilizar la operación batchWrite para realizar operaciones de colocación y eliminación en varias
tablas. A continuación se indican los pasos que debe seguir para colocar o eliminar varios elementos en
varias tablas con el modelo de documento de AWS SDK for .NET.
1. Se crea una instancia de DocumentBatchWrite por cada tabla en la que se desea colocar o eliminar
varios elementos, como se describe en el procedimiento anterior.
2. Cree una instancia de MultiTableDocumentBatchWrite y agregue a ella los objetos
DocumentBatchWrite individuales.
3. Ejecute el método MultiTableDocumentBatchWrite.Execute.
En el siguiente ejemplo de código C# se ponen en práctica los pasos anteriores. En el ejemplo se utiliza la
operación de escritura por lotes para llevar a cabo las siguientes operaciones de escritura:
superBatch.Execute();
Para obtener instrucciones paso a paso sobre cómo realizar las pruebas del ejemplo siguiente, consulte
Ejemplos de código .NET (p. 340).
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using System;
using System.Collections.Generic;
using System.Linq;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DocumentModel;
using Amazon.Runtime;
namespace com.amazonaws.codesamples
{
class MidlevelItemCRUD
{
// Delete.
DeleteBook(productCatalog);
Console.WriteLine("To continue, press Enter");
Console.ReadLine();
}
catch (AmazonDynamoDBException e) { Console.WriteLine(e.Message); }
catch (AmazonServiceException e) { Console.WriteLine(e.Message); }
catch (Exception e) { Console.WriteLine(e.Message); }
}
productCatalog.PutItem(book);
}
// Optional parameters.
UpdateItemOperationConfig config = new UpdateItemOperationConfig
{
// Get updated item in response.
ReturnValues = ReturnValues.AllNewAttributes
};
Document updatedBook = productCatalog.UpdateItem(book, config);
Console.WriteLine("UpdateMultipleAttributes: Printing item after updates ...");
PrintDocument(updatedBook);
}
// Optional parameters.
UpdateItemOperationConfig config = new UpdateItemOperationConfig
{
ConditionalExpression = expr,
ReturnValues = ReturnValues.AllNewAttributes
};
Document updatedBook = productCatalog.UpdateItem(book, config);
Console.WriteLine("UpdateBookPriceConditionally: Printing item whose price was
conditionally updated");
PrintDocument(updatedBook);
}
if (value is Primitive)
stringValue = value.AsPrimitive().Value.ToString();
else if (value is PrimitiveList)
stringValue = string.Join(",", (from primitive
in value.AsPrimitiveList().Entries
select primitive.Value).ToArray());
Console.WriteLine("{0} - {1}", attribute, stringValue);
}
}
}
}
• Ilustra una escritura por lotes en una única tabla. Agrega dos elementos a la tabla ProductCatalog.
• Ilustra una escritura por lotes en varias tablas. Agrega un elemento a las tablas Forum y Thread y
elimina un elemento de la tabla Thread.
Si ha seguido los pasos de Creación de tablas y carga de datos para ejemplos de código en
DynamoDB (p. 333), habrá creado ya las tablas ProductCatalog, Forum y Thread. También
puede crear estos ejemplos de tablas mediante programación. Para obtener más información, consulte
Creación de ejemplos de tablas y carga de datos mediante la.AWS SDK for .NET (p. 1097). Para obtener
instrucciones paso a paso para probar el siguiente ejemplo, consulte Ejemplos de código .NET (p. 340).
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using System;
using System.Collections.Generic;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DocumentModel;
using Amazon.Runtime;
namespace com.amazonaws.codesamples
{
class MidLevelBatchWriteItem
{
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
static void Main(string[] args)
{
try
{
SingleTableBatchWrite();
MultiTableBatchWrite();
}
catch (AmazonDynamoDBException e) { Console.WriteLine(e.Message); }
catch (AmazonServiceException e) { Console.WriteLine(e.Message); }
catch (Exception e) { Console.WriteLine(e.Message); }
batchWrite.AddDocumentToPut(book1);
// Specify delete item using overload that takes PK.
batchWrite.AddKeyToDelete(12345);
Console.WriteLine("Performing batch write in SingleTableBatchWrite()");
batchWrite.Execute();
}
El método Query proporciona dos sobrecargas. Los parámetros mínimos que requiere el método Query
son un valor de clave de partición y un filtro de clave de orden. Puede utilizar la siguiente sobrecarga para
proporcionar estos parámetros mínimos necesarios.
Example
Por ejemplo, en el siguiente código C# se realiza una consulta para obtener todas las respuestas del foro
publicadas en los últimos 15 días.
Example
Con ello se crea un objeto Search. Ahora, puede llamar al método Search.GetNextSet de manera
iterativa para recuperar una página de resultados a la vez, como se muestra en el siguiente ejemplo de
código C#. El código imprime los valores de los atributos de elemento que la consulta devuelve.
Example
documentSet = search.GetNextSet();
foreach (var document in documentSet)
PrintDocument(document);
} while (!search.IsDone);
Example
Query(QueryOperationConfig config);
Supongamos que desea ejecutar la consulta del ejemplo anterior (recuperar las respuestas del foro
publicadas en los últimos 15 días). Sin embargo, supongamos que desea proporcionar parámetros
de consulta opcionales para recuperar solo determinados atributos y, además, solicitar la lectura
de consistencia alta. En el siguiente ejemplo de código C# se construye la solicitud con el objeto
QueryOperationConfig.
Example
• Buscar las respuestas a una conversación del foro publicadas en los últimos 15 días.
En esta consulta se utiliza el operador de consulta Between para buscar las respuestas publicadas
entre dos fechas.
• Obtenga un producto de la tabla ProductCatalog.
Dado que la tabla ProductCatalog tiene una clave principal que consta únicamente de una clave de
partición, solo se pueden obtener elementos; no se puede consultar la tabla. En el ejemplo se recupera
un elemento de producto específico mediante su Id.
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using System;
using System.Collections.Generic;
using System.Linq;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DocumentModel;
using Amazon.Runtime;
using Amazon.SecurityToken;
namespace com.amazonaws.codesamples
{
class MidLevelQueryAndScan
{
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Get Example.
Table productCatalogTable = Table.LoadTable(client, "ProductCatalog");
int productId = 101;
GetProduct(productCatalogTable, productId);
// Use Query overloads that takes the minimum required query parameters.
Search search = table.Query(filter);
Filter = filter
};
do
{
documentList = search.GetNextSet();
Console.WriteLine("\nFindRepliesPostedWithinTimePeriod: printing replies
posted within dates: {0} and {1} ............", startDate, endDate);
foreach (var document in documentList)
{
PrintDocument(document);
}
} while (!search.IsDone);
}
}
}
}
}
Example
Scan(ScanFilter filter);
Por ejemplo, supongamos que tenemos una tabla de conversaciones del foro para registrar información
como el asunto de la conversación (clave principal), el mensaje correspondiente, el Id del foro al que
pertenece la conversación, las Tags y otros datos. Supongamos que el asunto es la clave principal.
Example
Esta es una versión simplificada de foros e hilos que se ven enAWSforos (consulteForos de debate de). En
el siguiente ejemplo de código C# se consultan todas las conversaciones de un foro determinado (ForumId
= 101) que tiene la etiqueta "sortkey". Dado que la ForumId no es una clave principal, en el ejemplo se
examina la tabla. ScanFilter incluye dos condiciones. La consulta devuelve todas las conversaciones
que cumplen ambas condiciones.
Example
También puede especificar parámetros opcionales en Scan, tales como una lista de atributos concretos
que recuperar o si se llevará a cabo una lectura de consistencia alta. Para especificar parámetros
opcionales, debe crear un objeto ScanOperationConfig que incluya tanto los parámetros requeridos
como los opcionales y usar la sobrecarga siguiente.
Example
Scan(ScanOperationConfig config);
En el siguiente ejemplo de código C# se ejecuta la misma consulta anterior (buscar las conversaciones del
foro cuyoForumIdes101y laTagatributo contiene la palabra clave «sortkey»). Supongamos que deseamos
agregar un parámetro opcional para recuperar solo una lista de atributos específicos. En este caso, es
preciso crear un objeto ScanOperationConfig proporcionando todos los parámetros, requeridos y
opcionales, como se muestra en el ejemplo de código siguiente.
Example
La operación Scan lleva a cabo un examen de toda la tabla, por lo que existe la posibilidad de que resulte
costosa. Es preferible usar consultas en su lugar. Sin embargo, hay ocasiones en que podría ser necesario
ejecutar un examen en una tabla. Por ejemplo, si se ha producido un error al especificar los datos de
precios de los productos, habrá que examinar la tabla como se muestra en el siguiente ejemplo de código
C#. En el ejemplo se examina la tabla ProductCatalog para hallar los productos cuyo valor de precio es
inferior a 0. En el ejemplo se ilustra el uso de dos sobrecargas de Table.Scan.
Puede pasar el parámetro ScanFilter cuando solamente se deban pasar los parámetros requeridos.
• Table.Scan, que acepta el objeto ScanOperationConfig como parámetro.
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using System;
using System.Collections.Generic;
using System.Linq;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DocumentModel;
namespace com.amazonaws.codesamples
{
class MidLevelScanOnly
{
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
if (value is Primitive)
stringValue = value.AsPrimitive().Value.ToString();
else if (value is PrimitiveList)
stringValue = string.Join(",", (from primitive
in value.AsPrimitiveList().Entries
select primitive.Value).ToArray());
Console.WriteLine("{0} - {1}", attribute, stringValue);
}
}
}
}
LaAWS SDK for .NETEl proporciona un modelo de persistencia de objetos que permite mapear las clases
del lado del cliente a tablas de Amazon DynamoDB. A continuación, cada instancia de objeto se mapea a
un elemento en las tablas correspondientes. Para guardar los objetos del lado del cliente en las tablas, el
modelo de persistencia de objetos proporciona elDynamoDBContext, un punto de entrada a DynamoDB.
Esta clase le ofrece una conexión a DynamoDB y le permite obtener acceso a tablas, realizar diversas
operaciones CRUD y ejecutar consultas.
El modelo de persistencia de objetos proporciona un conjunto de atributos para mapear las clases del lado
del cliente a tablas, y las propiedades/campos a atributos de tabla.
Note
En el siguiente ejemplo se muestra cómo funciona el modelo de persistencia de objetos. Comienza con
elProductCatalogTabla de. TieneIdcomo clave principal.
ProductCatalog(Id, ...)
Example
[DynamoDBTable("ProductCatalog")]
public class Book
{
[DynamoDBHashKey]
public int Id { get; set; }
[DynamoDBProperty("Authors")]
public List<string> BookAuthors { get; set; }
[DynamoDBIgnore]
public string CoverPage { get; set; }
}
El modelo de persistencia de objetos admite el mapeo tanto explícito como predeterminado entre las
propiedades de clase y los atributos de tabla.
• Asignación explícita:Para mapear una propiedad a una clave principal, debe usar
laDynamoDBHashKeyyDynamoDBRangeKeyatributos del modelo de persistencia de objetos. Además,
en el caso de los atributos de clave no principal, si un nombre de propiedad de la clase y el atributo
de tabla correspondiente al que desea mapearlo no son iguales, debe definir el mapeo agregando
explícitamente el atributoDynamoDBPropertyAtributo.
No tiene que mapear cada propiedad de clase. Puede identificar estas propiedades agregando
laDynamoDBIgnoreAtributo. Cuando guarde unBooka la tabla, la instanciaDynamoDBContextno
incluyeCoverPagePropiedad. Tampoco se devolverá esta propiedad cuando se recupere la instancia del
libro.
Puede mapear propiedades de tipos primitivos de .NET, como int o string. También puede mapear
cualquier tipo de datos arbitrarios, siempre y cuando proporcione un convertidor adecuado para mapear los
datos arbitrarios a uno de los tipos de DynamoDB. Para obtener más información sobre cómo mapear tipos
arbitrarios, consulte Asignación de datos arbitrarios con DynamoDB mediante elAWS SDK for .NETModelo
de persistencia de objetos (p. 315).
El modelo de persistencia de objetos admite el bloqueo optimista. Durante una operación de actualización,
esto garantiza que se disponga de la última copia del elemento que se va a actualizar. Para obtener más
información, consulte Bloqueo optimista mediante un número de versión con DynamoDB mediante elAWS
SDK for .NETModelo de persistencia de objetos (p. 313).
Atributos de DynamoDB
En esta sección se describen los atributos que ofrece el modelo de persistencia de objetos para que pueda
mapear clases y propiedades a tablas y atributos de DynamoDB.
Note
DynamoDBGlobalSecondaryIndexHashKey
Mapea una propiedad de clase a la clave de partición de un índice secundario global. Use este atributo
para utilizarQueryíndices secundario mundial.
DynamoDBGlobalSecondaryIndexRangeKey
Mapea una propiedad de clase a la clave de ordenación de un índice secundario global. Use este atributo
para utilizar una operación en unQueryUn índice secundario global y desea refinar los resultados mediante
la clave de ordenación del índice.
DynamoDBHashKey
Mapea una propiedad de clase a la clave de partición de la clave principal de la tabla. Los atributos de
clave principal no pueden ser un tipo de colección.
[DynamoDBTable("ProductCatalog")]
public class Book {
[DynamoDBHashKey]
public int Id { get; set; }
DynamoDBIgnore
Indica que la propiedad asociada debe pasarse por alto. Si no desea guardar ninguna de las propiedades
de clase, puede agregar este atributo para indicar aDynamoDBContextno incluir esta propiedad al guardar
objetos en la tabla.
DynamoDBLocalSecondaryIndexRangeKey
Mapea una propiedad de clase a la clave de ordenación de un índice secundario local. Use este atributo
para utilizar una operación en unQueryUn índice secundario local y desea refinar los resultados mediante
la clave de ordenación del índice.
DynamoDBProperty
Mapea una propiedad de clase a un atributo de tabla. Si la propiedad de clase se mapea a un atributo de
tabla con el mismo nombre, no es preciso especificarlo. Sin embargo, si los nombres no son iguales, puede
utilizar esta etiqueta para realizar el mapeo. En la siguiente instrucción C #, elDynamoDBPropertymapea
laBookAuthorsa la propiedadAuthorsen la tabla.
[DynamoDBProperty("Authors")]
public List<string> BookAuthors { get; set; }
DynamoDBRenamable
Especifica un nombre alternativo para una propiedad de clase. Esto resulta útil si va a escribir un
convertidor personalizado para mapear datos arbitrarios a una tabla de DynamoDB cuando el nombre de
una propiedad de clase sea distinto del nombre del atributo de tabla.
DynamoDBRangeKey
Mapea una propiedad de clase a la clave de ordenación de la clave principal de la tabla. Si la tabla
tiene una clave principal compuesta (clave de partición y clave de ordenación), debe especificar ambos
elementosDynamoDBHashKeyyDynamoDBRangeKeyen su asignación de clases.
Por ejemplo, la tabla de ejemploReplytiene una clave principal hecha de laIdclave de partición
yReplenishment: clave de ordenación. En el siguiente ejemplo de código C# se asigna elReplyLa
claseReplyTabla de. La definición de clase también indica que dos de sus propiedades se mapean a la
clave principal.
Para obtener más información acerca de ejemplos de tablas, consulte Creación de tablas y carga de datos
para ejemplos de código en DynamoDB (p. 333).
[DynamoDBTable("Reply")]
public class Reply {
[DynamoDBHashKey]
public int ThreadId { get; set; }
[DynamoDBRangeKey]
public string Replenishment { get; set; }
// Additional properties go here.
}
DynamoDBTable
Identifica la tabla de destino de DynamoDB a la que se mapea la clase. Por ejemplo, en el siguiente
ejemplo de código C# se mapea laDeveloperLa clasePeopleen DynamoDB.
[DynamoDBTable("People")]
public class Developer { ...}
[DynamoDBTable("Managers")]
public class Manager : Developer { ...}
[DynamoDBTable("People", LowerCamelCaseProperties=true)]
public class Developer {
string DeveloperName;
...}
DynamoDBVersion
Identifica una propiedad de clase para almacenar el número de versión del elemento. Para obtener más
información sobre el control de versiones, consulte Bloqueo optimista mediante un número de versión con
DynamoDB mediante elAWS SDK for .NETModelo de persistencia de objetos (p. 313).
Clase DynamoDBContext
LaDynamoDBContextLa clase es el punto de entrada a la base de datos de Amazon DynamoDB.
Proporciona conexión con DynamoDB y permite obtener acceso a los datos de diversas tablas, realizar
distintas operaciones CRUD y ejecutar consultas. LaDynamoDBContextLa clase proporciona los
siguientes métodos.
CreateMultitableBatchGet
Crea un valorMultiTableBatchGetObjeto, que consta de varios elementos
individualesBatchGetobjects. Cada uno de estosBatchGetLos objetos se pueden usar para recuperar
elementos de una sola tabla de DynamoDB.
CreateMultiTableBatchWrite
Crea un valorMultiTableBatchWriteObjeto, que consta de varios elementos
individualesBatchWriteobjects. Cada uno de estosBatchWriteLos objetos se pueden usar para escribir
o eliminar elementos de una sola tabla de DynamoDB.
CreateBatchGet
Crea unBatchGetUn objeto que se puede usar para recuperar varios elementos de una tabla. Para
obtener más información, consulte Obtención Batch: Obtención de varios elementos (p. 320).
CreateBatchWrite
Crea unBatchWriteEl objeto que se puede utilizar para colocar o eliminar varios elementos en una tabla.
Para obtener más información, consulte Escritura Batch: Colocación y eliminación de varios elementos
(p. 318).
Delete
Elimina un elemento de la tabla. El método requiere la clave principal del elemento que se desea eliminar.
Como parámetro de este método, puede proporcionar el valor de la clave principal o un objeto del lado del
cliente que contenga un valor de clave .
• Si especifica un objeto del lado del cliente como parámetro y ha habilitado el bloqueo optimista, la
eliminación se llevará a cabo correctamente solo si las versiones del lado del cliente y del lado del
servidor del objeto coinciden.
• Si especifica únicamente el valor de clave principal como parámetro, la eliminación se llevará a cabo
correctamente tanto si ha habilitado bloqueo optimista como si no.
Note
Para ejecutar esta operación en segundo plano, use el método DeleteAsync en su lugar.
Dispose
Elimina todos los recursos administrados y no administrados.
ExecuteBatchGet
Lee datos en una o varias tablas y procesa todos los objetos BatchGet de un objeto
MultiTableBatchGet.
Note
ExecuteBatchWrite
Escribe o elimina datos en una o varias tablas y procesa todos los objetos BatchWrite de un objeto
MultiTableBatchWrite.
Note
FromDocument
Dada una instancia de un objeto Document, el método FromDocument devuelve una instancia de una
clase del lado del cliente.
Esto resulta útil si desea utilizar las clases del modelo de documento junto con el modelo de persistencia
de objetos para realizar operaciones con datos. Para obtener más información sobre las clases
del modelo de documento que se proporcionan en laAWS SDK for .NET, consulte.NET: Modelo de
documento (p. 279).
Example
forum101 = context.FromDocument<Forum>(101);
Note
FromQuery
Ejecuciones de unQueryCon los parámetros de la consulta definidos en unaQueryOperationConfigun
objeto.
Note
Para ejecutar esta operación en segundo plano, use el método FromQueryAsync en su lugar.
FromScan
Ejecuciones de unScanCon los parámetros del examen definidos en unaScanOperationConfigun
objeto.
Note
Para ejecutar esta operación en segundo plano, use el método FromScanAsync en su lugar.
GetTargetTable
Recupera la tabla de destino del tipo especificado. Esto resulta útil si va a escribir un convertidor
personalizado para mapear datos arbitrarios a una tabla de DynamoDB y tiene que determinar qué tabla
está asociada con un tipo de datos personalizado.
Load
Recupera un elemento de una tabla. El método requiere solo la clave principal del elemento que se desea
recuperar.
De forma predeterminada, DynamoDB devuelve el elemento con valores que presentan consistencia
final. Para obtener más información sobre el modelo de consistencia final, consulteConsistencia de
lectura (p. 17).
Note
Para ejecutar esta operación en segundo plano, use el método LoadAsync en su lugar.
Query
Consulta una tabla basándose en los parámetros de consulta que haya proporcionado.
Solo se puede consultar una tabla si cuenta con una clave principal compuesta (una clave de partición y
una clave de ordenación). Al realizar la consulta, debe especificar una clave de partición y una condición
que se aplica a la clave de ordenación.
Example
Si la tabla tiene una clave principal simple (clave de partición), no puede usar elQueryMétodo de. En su
lugar, puede usar el método Load y proporcionar la clave de partición para recuperar el elemento.
Note
Para ejecutar esta operación en segundo plano, use el método QueryAsync en su lugar.
Save (Guardar)
Guarda el objeto especificado en la tabla. Si la clave principal especificada en el objeto de entrada no
existe en la tabla, el método agrega un nuevo elemento a la tabla. Si la clave principal sí está presente, el
método actualiza el elemento.
Para ejecutar esta operación en segundo plano, use el método SaveAsync en su lugar.
Scan
Realiza un examen de toda la tabla.
Puede filtrar los resultados del examen especificando una condición de examen. La condición se
puede evaluar según cualesquiera atributos de la tabla. Supongamos que tiene una clase del lado del
clienteBookAsignado a la claseProductCatalogen DynamoDB. En el siguiente ejemplo de C# se
examina la tabla y se devuelven solamente aquellos elementos del libro cuyo precio es menor que 0.
Example
Note
Para ejecutar esta operación en segundo plano, use el método ScanAsync en su lugar.
ToDocument
Devuelve una instancia de la clase Document del modelo de documento de la instancia de clase.
Esto resulta útil si desea utilizar las clases del modelo de documento junto con el modelo de persistencia
de objetos para realizar operaciones con datos. Para obtener más información sobre las clases
del modelo de documento que se proporcionan en laAWS SDK for .NET, consulte.NET: Modelo de
documento (p. 279).
Supongamos que tenemos una clase del lado del cliente mapeada a la muestraForumTabla de.
A continuación, puede usar unDynamoDBContextpara obtener un elemento comoDocumentdel
objetoForumComo se muestra en el siguiente ejemplo de código C#.
Example
Example
DynamoDBContextincluye estos parámetros opcionales con cada solicitud que se envía utilizando este
contexto.
ejemplo de código C#. En el ejemplo se carga un elemento de libro concreto. El método Load de
DynamoDBContext especifica los parámetros opcionales anteriores.
Example
• bool
• byte
• char
• DateTime
• decimal
• double
• float
• Int16
• Int32
• Int64
• SByte
• string
• UInt16
• UInt32
• UInt64
En la tabla siguiente se resume el mapeo de los tipos de .NET anteriores a los tipos de DynamoDB.
El modelo de persistencia de objetos también admite los tipos de datos arbitrarios. Sin embargo, debe
proporcionar el código de convertidor para mapear los tipos complejos a los tipos de DynamoDB.
Note
Su solicitud de actualización o eliminación solamente se llevará a cabo si la versión del objeto en el lado
del cliente coincide con el número de versión del elemento correspondiente en el lado del servidor. Si su
aplicación contiene una copia anticuada, debe obtener la versión más reciente del servidor para poder
actualizar o eliminar el elemento en cuestión.
Example
[DynamoDBTable("ProductCatalog")]
public class Book
{
[DynamoDBHashKey] //Partition key
public int Id { get; set; }
[DynamoDBProperty]
public string Title { get; set; }
[DynamoDBProperty]
public string ISBN { get; set; }
[DynamoDBProperty("Authors")]
public List<string> BookAuthors { get; set; }
[DynamoDBVersion]
public int? VersionNumber { get; set; }
}
Note
Puede aplicar el atributo DynamoDBVersion solamente a un tipo numérico primitivo que pueda
contener valores null (por ejemplo, int?).
Example
Si proporciona un objeto como parámetro, la eliminación solamente se llevará a cabo si la versión del
objeto coincide con la versión del elemento correspondiente en el lado del servidor. Sin embargo, si
proporciona un valor de clave principal como parámetro,DynamoDBContextNo conoce los números de
versión, y elimina el elemento sin comprobar la versión.
Tenga en cuenta que la implementación interna del bloqueo optimista en el código del modelo de
persistencia de objetos utiliza las acciones de actualización condicional y eliminación condicional del API
de DynamoDB.
En lugar de establecer la propiedad para todo el contexto, puede deshabilitar el bloqueo optimista
para una operación específica, tal y como se muestra en el siguiente ejemplo de código C#. En el
ejemplo se utiliza el contexto para eliminar un elemento de libro. LaDeleteestablece el método
opcionalSkipVersionCheckPropiedad en true, con lo que deshabilita la comprobación de versiones.
Example
Puede crear cualquier tipo en el lado del cliente. Sin embargo, los datos almacenados en las tablas serán
de uno de los tipos de DynamoDB. Además, durante las consultas y los exámenes, las comparaciones se
harán respecto a los datos almacenados en DynamoDB.
Para obtener instrucciones paso a paso para probar el siguiente ejemplo, consulte Ejemplos de
código .NET (p. 340).
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using System;
using System.Collections.Generic;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;
using Amazon.DynamoDBv2.DocumentModel;
using Amazon.Runtime;
using Amazon.SecurityToken;
namespace com.amazonaws.codesamples
{
class HighLevelMappingArbitraryData
{
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// 1. Create a book.
DimensionType myBookDimensions = new DimensionType()
{
Length = 8M,
Height = 11M,
Thickness = 0.5M
};
context.Save(myBook);
[DynamoDBProperty("Authors")]
public List<string> BookAuthors
{
get; set;
}
// Arbitrary type, with a converter to map it to DynamoDB type.
[DynamoDBProperty(typeof(DimensionTypeConverter))]
public DimensionType Dimensions
{
get; set;
}
}
}
}
}
Note
Example
bookBatch.Execute();
• Cree una instancia de la clase BatchWrite para cada tipo y especifique los elementos que desee
colocar o eliminar, como se describe en la sección anterior.
• Utilice uno de los métodos siguientes para crear una instancia de MultiTableBatchWrite:
• Ejecute laCombineen uno de los métodosBatchWriteLos objetos que ha creado en el paso anterior.
• Proporcione una lista de objetos MultiTableBatchWrite para crear una instancia del tipo
BatchWrite.
• Ejecute laCreateMultiTableBatchWriteMétodo deDynamoDBContexty pase la lista
deBatchWriteobjects.
• Llame al método Execute de MultiTableBatchWrite, que lleva a cabo las operaciones
especificadas de colocación y eliminación en varias tablas.
Example
threadBatch.AddPutItem(newThread);
Para ver un ejemplo práctico, consulte Ejemplo: Operación de escritura por lotes mediante elAWS SDK
for .NETModelo de persistencia de objetos (p. 323).
Note
El API de procesamiento por lotes de DynamoDB limita el número de escrituras de un lote, así
como el tamaño del lote. Para obtener más información, consulteBatchWriteItem. Cuando se
utiliza el API del modelo de persistencia de objetos de .NET, se puede especificar cualquier
cantidad de operaciones. Sin embargo, si el número de operaciones de un lote o el tamaño
superan el límite, el API de .NET dividirá la solicitud de escritura por lotes en lotes de menor
tamaño y enviará varias solicitudes de escritura por lotes a DynamoDB.
Example
• Para cada tipo, cree una instancia del tipo CreateBatchGet y proporcione los valores de clave
principal que desee recuperar de cada tabla.
• Utilice uno de los métodos siguientes para crear una instancia de la clase MultiTableBatchGet:
• Ejecute laCombineen uno de los métodosBatchGetLos objetos que creamos en el paso anterior.
• Proporcione una lista de objetos MultiBatchGet para crear una instancia del tipo BatchGet.
• Ejecute laCreateMultiTableBatchGetMétodo deDynamoDBContexty pase la lista
deBatchGetobjects.
• Llame a laExecuteMétodo deMultiTableBatchGet, que devuelve los resultados con tipos en
elBatchGetobjects.
Example
Console.WriteLine(orderBatch.Results.Count);
Console.WriteLine(orderDetailBatch.Results.Count);
El siguiente ejemplo no funciona con .NET Core, ya que no es compatible con los métodos
sincrónicos. Para obtener más información, consulteAWSAPI asincrónicas de para .NET.
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using System;
using System.Collections.Generic;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;
using Amazon.Runtime;
namespace com.amazonaws.codesamples
{
class HighLevelItemCRUD
{
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Retrieve the updated book. This time add the optional ConsistentRead
parameter using DynamoDBContextConfig object.
Book updatedBook = context.Load<Book>(bookID, new DynamoDBContextConfig
{
ConsistentRead = true
});
[DynamoDBTable("ProductCatalog")]
public class Book
{
[DynamoDBHashKey] //Partition key
public int Id
{
get; set;
}
[DynamoDBProperty]
public string Title
{
get; set;
}
[DynamoDBProperty]
public string ISBN
{
get; set;
}
[DynamoDBProperty("Authors")] //String Set datatype
public List<string> BookAuthors
{
get; set;
}
}
}
Para obtener más información sobre las tablas que se utilizan en este ejemplo, consulte.Creación de tablas
y carga de datos para ejemplos de código en DynamoDB (p. 333). Para obtener instrucciones paso a
paso sobre cómo realizar las pruebas del ejemplo siguiente, consulte Ejemplos de código .NET (p. 340).
Note
El siguiente ejemplo no funciona con .NET Core, ya que no es compatible con los métodos
sincrónicos. Para obtener más información, consulteAWSAPI asincrónicas de para .NET.
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
namespace com.amazonaws.codesamples
{
class HighLevelBatchWriteItem
{
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
{
Name = "Test BatchWrite Forum",
Threads = 0
};
var forumBatch = context.CreateBatchWrite<Forum>();
forumBatch.AddPutItem(newForum);
[DynamoDBTable("Reply")]
public class Reply
{
[DynamoDBHashKey] //Partition key
public string Id
{
get; set;
}
[DynamoDBTable("Thread")]
public class Thread
{
// PK mapping.
[DynamoDBTable("Forum")]
public class Forum
{
[DynamoDBHashKey] //Partition key
public string Name
{
get; set;
}
// All the following properties are explicitly mapped,
// only to show how to provide mapping.
[DynamoDBProperty]
public int Threads
{
get; set;
}
[DynamoDBProperty]
public int Views
{
get; set;
}
[DynamoDBProperty]
public string LastPostBy
{
get; set;
}
[DynamoDBProperty]
public DateTime LastPostDateTime
{
get; set;
}
[DynamoDBProperty]
public int Messages
{
get; set;
}
}
[DynamoDBTable("ProductCatalog")]
public class Book
{
[DynamoDBHashKey] //Partition key
public int Id
{
get; set;
}
public string Title
{
get; set;
}
public string ISBN
{
get; set;
}
public int Price
{
get; set;
}
public string PageCount
{
get; set;
}
public string ProductCategory
{
get; set;
}
public bool InPublication
{
get; set;
}
}
}
• Las clases Forum, Thread y Reply se mapean a las tablas del mismo nombre.
La tabla ProductCatalog tiene Id como clave principal. No tiene una clave de ordenación que forme
parte de la clave principal. Por lo tanto, no puede consultar la tabla. Puede usar el valor de Id para
obtener un elemento.
• Ejecute las siguientes consultas en laReplyTabla de. (ElReplyLa clave principal de la tabla consta
deIdyReplyDateTimeAtributos. LaReplyDateTimees una clave de ordenación. Por lo tanto, puede
consultar esta tabla.
• Buscar las respuestas a una conversación del foro publicadas en los últimos 15 días.
• Buscar las respuestas a una conversación del foro publicadas en un intervalo de tiempo determinado.
• Escanee laProductCatalogPara buscar los libros cuyo precio sea menor que cero.
Por motivos de desempeño, debe usar una operación de consulta y no una operación de examen.
Sin embargo, a veces puede que necesite examinar una tabla. Supongamos que se ha cometido
un error al especificar los datos y que el precio de uno de los libros se ha establecido en un valor
menor que 0. En este ejemplo se escanea elProductCategorypara buscar elementos de libro (la
tablaProductCategoryEs el libro) cuyo precio es menor que 0.
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using System;
using System.Collections.Generic;
using System.Configuration;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;
using Amazon.DynamoDBv2.DocumentModel;
using Amazon.Runtime;
namespace com.amazonaws.codesamples
{
class HighLevelQueryAndScan
{
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Scan table.
FindProductsPricedLessThanZero(context);
Console.WriteLine("To continue, press Enter");
Console.ReadLine();
}
catch (AmazonDynamoDBException e) { Console.WriteLine(e.Message); }
catch (AmazonServiceException e) { Console.WriteLine(e.Message); }
catch (Exception e) { Console.WriteLine(e.Message); }
}
[DynamoDBTable("Reply")]
public class Reply
{
[DynamoDBHashKey] //Partition key
public string Id
{
get; set;
}
[DynamoDBTable("Thread")]
public class Thread
{
// Partition key mapping.
[DynamoDBHashKey] //Partition key
public string ForumName
{
get; set;
}
[DynamoDBRangeKey] //Sort key
public DateTime Subject
{
get; set;
}
// Implicit mapping.
public string Message
{
get; set;
}
[DynamoDBTable("Forum")]
public class Forum
{
[DynamoDBHashKey]
public string Name
{
get; set;
}
// All the following properties are explicitly mapped
// to show how to provide mapping.
[DynamoDBProperty]
public int Threads
{
get; set;
}
[DynamoDBProperty]
public int Views
{
get; set;
}
[DynamoDBProperty]
public string LastPostBy
{
get; set;
}
[DynamoDBProperty]
public DateTime LastPostDateTime
{
get; set;
}
[DynamoDBProperty]
public int Messages
{
get; set;
}
}
[DynamoDBTable("ProductCatalog")]
public class Book
{
[DynamoDBHashKey] //Partition key
public int Id
{
get; set;
}
public string Title
{
get; set;
}
public string ISBN
{
get; set;
}
public int Price
{
get; set;
}
public string PageCount
{
get; set;
}
public string ProductCategory
{
get; set;
}
public bool InPublication
{
get; set;
}
}
}
• Java
• JavaScript en el navegador
• .NET
• Node.js
• PHP
• Python
• Ruby
• C++
• Go
• Android
• iOS
Para comenzar rápidamente a trabajar con estos lenguajes, consulte Introducción a DynamoDB yAWSSDK
de (p. 82).
Los ejemplos de código de esta Guía para desarrolladores ofrecen una cobertura más exhaustiva de las
operaciones de DynamoDB en los siguientes lenguajes de programación:
Para poder comenzar con este ejercicio, primero debe crear unAWS, obtenga su clave de acceso y
clave secreta, y configure elAWS Command Line Interface(AWS CLI) en su equipo. Para obtener más
información, consulte Configuración de DynamoDB (servicio web) (p. 57).
Note
Si utiliza la versión descargable de DynamoDB, debe usar laAWS CLIpara crear las tablas y los
datos de muestra. Asimismo, debe especificar el parámetro --endpoint-url en cada comando
de la AWS CLI. Para obtener más información, consulte Configuración del punto de enlace
local (p. 56).
Estas tablas y sus datos se utilizan como ejemplos en esta guía para desarrolladores.
Note
Temas
• Paso 1: Crear ejemplos de tablas (p. 333)
• Paso 2: Cargar los datos en las tablas (p. 336)
• Paso 3: Consulta de los datos (p. 337)
• Paso 4: (Opcional) Limpieza (p. 338)
• Summary (p. 338)
Puede crear una tabla ProductCatalog en la que cada elemento se identifique de forma exclusiva
mediante un único atributo numérico: Id.
Puede modelar esta aplicación creando tres tablas: Forum, Thread y Reply.
• En el campo Partition key (Clave de partición), escriba ForumName. Establezca el tipo de datos
en String (Cadena).
• Elija Add sort key (Añadir clave de ordenación).
• En el cuadro Sort key (Clave de ordenación), introduzca Subject. Establezca el tipo de datos
en String (Cadena).
4. Cuando esté conforme con los ajustes, elija Create (Crear).
• En el campo Partition key (Clave de partición), escriba Id. Establezca el tipo de datos en String
(Cadena).
• Elija Add sort key (Añadir clave de ordenación).
• En el cuadro Sort key (Clave de ordenación), introduzca ReplyDateTime. Establezca el tipo
de datos en String (Cadena).
c. En la sección Table settings (Configuración de la tabla), desactive Use default settings (Usar
configuración predeterminada).
d. En la sección Secondary indexes (Índices secundarios), elija Add index (Añadir índice).
e. En la ventana Add index (Añadir índice), haga lo siguiente:
Si todavía no ha configurado la AWS CLI, consulte Mediante AWS CLI (p. 62) para obtener
instrucciones.
Vamos a descargar un archivo comprimido .zip que contiene archivos JSON con ejemplos de datos para
cada tabla. Para cada archivo, utilizará la propiedadAWS CLIpara cargar los datos en DynamoDB. Cada
vez que una carga de datos se lleve a cabo correctamente, se generará el resultado siguiente.
{
"UnprocessedItems": {}
}
• sampledata.zip
2. Extraiga los archivos de datos .json del archivo comprimido.
3. Copie los archivos .json en el directorio actual.
4. Elija la pestaña Items (Elementos) para ver los datos que ha cargado en la tabla.
5. Para ver un elemento de la tabla, elija su Id. Si lo desea, también puede editar el elemento.
6. Para volver a la lista de tablas, elija Cancel (Cancelar).
Repita este procedimiento para cada una de las demás tablas que ha creado:
• Forum
• Thread
• Reply
A lo siguiente:
• ProductCatalog
• Forum
• Thread
Repita este procedimiento para cada una de las demás tablas que ha creado:
• Forum
• Thread
• Responder
Summary
En este ejercicio, hemos utilizado la consola de DynamoDB para crear varias tablas en DynamoDB.
A continuación, hemos usado la AWS CLI para cargar datos en las tablas y hemos realizado algunas
operaciones básicas con los datos desde la consola.
La consola y la AWS CLI son útiles para comenzar a usar este servicio con rapidez. No obstante, es
probable que desee conocer mejor cómo funciona DynamoDB y cómo escribir programas de aplicación
con DynamoDB. En el resto de esta guía para desarrolladores se abordan estos temas.
Esta Guía para desarrolladores contiene fragmentos de código Java y programas listos para ejecutarlos.
Encontrará estos ejemplos de código en las secciones siguientes:
Puede comenzar rápidamente a trabajar con Eclipse y AWS Toolkit for Eclipse. Además de un IDE
completo, obtendrá elAWS SDK for Javacon actualizaciones automáticas y plantillas preconfiguradas para
crearAWSaplicaciones.
SDK de para Java proporciona clientes seguros para subprocesos con el fin de trabajar con DynamoDB.
Como práctica recomendada, sus aplicaciones deben crear un cliente y reutilizar el cliente entre
subprocesos.
Los ejemplos de código de esta guía se han diseñado para utilizarlos con la última versión del
AWS SDK for Java.
Si está utilizando la propiedadAWS Toolkit for Eclipse, puede configurar las actualizaciones
automáticas para el SDK for Java. Para hacer esto en Eclipse, vaya aPreferenciasy elija AWS
Toolkit ,AWS SDK for Java,Descargar nuevos SDK automáticamente.
[default]
aws_access_key_id = AWS access key ID goes here
aws_secret_access_key = Secret key goes here
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.regions.Regions;
...
// This client will default to US West (Oregon)
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.build();
Si desea ejecutar los ejemplos de código en DynamoDB localmente en su equipo, configure el punto de
enlace como se indica a continuación.
AWSSDK V1
AWSSDK V2
Esta guía contiene fragmentos de código .NET y programas listos para ejecutarlos. Encontrará estos
ejemplos de código en las secciones siguientes:
Puede comenzar rápidamente a trabajar con elAWS SDK for .NETCon el Toolkit for Visual Studio.
Si es la primera vez que usa Toolkit for Visual Studio, elijaUsar un nuevo perfilPara configurar
suAWSCredenciales de .
6. En el proyecto de Visual Studio, elija la pestaña correspondiente al código fuente del programa
(Program.cs). Copie el ejemplo de código de la página de documentación en el editor de Visual
Studio sustituyendo cualquier otro código que aparezca en el editor.
7. Si ve mensajes de error del formularioNo se pudo encontrar el tipo o el nombre del espacio de
nombres..., es preciso instalar la propiedadAWSSDK para DynamoDB de la siguiente manera:
a. En el Explorador de soluciones, abra el menú contextual (haga clic con el botón derecho) del
proyecto y elija Administrar paquetes NuGet.
b. En Administrador de paquetes NuGet, elija Examinar.
c. En el cuadro de búsqueda, introduzca AWSSDK.DynamoDBv2 y espere a que se lleve a cabo la
búsqueda.
d. Elija AWSSDK.DynamoDBv2 y después elija Install (Instalar).
e. Cuando se haya completado la instalación, elija la pestaña Program.cs para volver al programa.
8. Para ejecutar el código, elija Iniciar en la barra de herramientas de Visual Studio.
LaAWS SDK for .NETcuenta con clientes seguros para subprocesos que ofrecen trabajo con DynamoDB.
Como práctica recomendada, sus aplicaciones deben crear un cliente y reutilizar el cliente entre
subprocesos.
Los ejemplos de código de esta guía se han diseñado para utilizarlos con la última versión del
AWS SDK for .NET.
El Toolkit for Visual Studio admite varios conjuntos de credenciales de cualquier número de cuentas. Cada
conjunto se conoce como perfil. Visual Studio agrega entradas al archivoApp.configDe este modo, su
aplicación puede buscar elAWSCredenciales en tiempo de ejecución.
Para obtener una lista completa de las regiones, consulteAWSRegiones y puntos de enlace deen
laReferencia general de Amazon Web Services.
Si desea ejecutar los ejemplos de código en DynamoDB localmente en su equipo, configure el punto de
enlace como se indica a continuación.
Temas
• Uso de tablas y datos en DynamoDB (p. 344)
• Uso de elementos y atributos (p. 410)
• Uso de consultas en DynamoDB (p. 497)
• Uso de operaciones de examen en DynamoDB (p. 516)
• PartiQL: un lenguaje de consulta compatible con SQL para Amazon DynamoDB (p. 537)
• Uso de índices secundarios para mejorar el acceso a los datos (p. 567)
• Captura de datos de cambio con Amazon DynamoDB (p. 650)
• Administración de flujos de trabajo complejos con transacciones de DynamoDB (p. 689)
• Backups de DynamoDB (p. 701)
También puede llevar a cabo las mismas tareas utilizando la AWS Management Console. Para
obtener más información, consulte Mediante la consola (p. 60).
En esta sección también se ofrece más información sobre la capacidad de desempeño, el uso del escalado
automático de DynamoDB de o la configuración manual del desempeño provisionado.
Temas
• Operaciones básicas en tablas de DynamoDB (p. 344)
• Consideraciones sobre el cambio del modo de capacidad de lectura/escritura (p. 349)
• Administración de la configuración en tablas de capacidad provisionadas de DynamoDB (p. 350)
• Tamaños y formatos de elementos de DynamoDB (p. 354)
• Administración automática de la capacidad de desempeño con la función Auto Scaling de
DynamoDB (p. 355)
• Tablas globales: Replicación en varias regiones con DynamoDB (p. 370)
• Agregar etiquetas a los recursos (p. 394)
• Uso de tablas de DynamoDB en Java (p. 398)
• Uso de tablas de DynamoDB en .NET (p. 403)
Temas
• Creación de una tabla (p. 345)
• Descripción de una tabla (p. 347)
• Actualización de una tabla (p. 348)
• Eliminación de una tabla (p. 348)
• Enumeración de nombres de tablas (p. 348)
• Descripción de las cuotas de rendimiento aprovisionado (p. 349)
• Nombre de la tabla. El nombre debe cumplir las reglas de nomenclatura de DynamoDB y debe ser único
para laAWSCuenta y región. Por ejemplo, puede crear unaPeopleEn EE. UU. Este (Norte de Virginia) y
otroPeopleEn Europa (Irlanda). Sin embargo, estas dos tablas serían totalmente distintas entre sí. Para
obtener más información, consulte Reglas de nomenclatura y tipos de datos (p. 13).
• Clave principal. La clave principal puede constar de un atributo (clave de partición) o dos (clave
de partición y clave de ordenación). Debe proporcionar el nombre, el tipo de datos y el rol de cada
atributo: HASH (para una clave de partición) y RANGE (para una clave de ordenación). Para obtener más
información, consulte Clave principal (p. 6).
• Ajustes de rendimiento (de las tablas aprovisionadas). Si utiliza el modo aprovisionado, debe especificar
los ajustes iniciales de rendimiento de lectura y escritura de la tabla. Puede cambiar estos ajustes en
otro momento o habilitar la función Auto Scaling de DynamoDB para administrarlos automáticamente.
Para obtener más información, consulte Administración de la configuración en tablas de capacidad
provisionadas de DynamoDB (p. 350) y Administración automática de la capacidad de desempeño con
la función Auto Scaling de DynamoDB (p. 355).
{
"TableDescription": {
"TableArn": "arn:aws:dynamodb:us-east-1:123456789012:table/Music",
"AttributeDefinitions": [
{
"AttributeName": "Artist",
"AttributeType": "S"
},
{
"AttributeName": "SongTitle",
"AttributeType": "S"
}
],
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"WriteCapacityUnits": 5,
"ReadCapacityUnits": 10
},
"TableSizeBytes": 0,
"TableName": "Music",
"TableStatus": "CREATING",
"TableId": "12345678-0123-4567-a123-abcdefghijkl",
"KeySchema": [
{
"KeyType": "HASH",
"AttributeName": "Artist"
},
{
"KeyType": "RANGE",
"AttributeName": "SongTitle"
}
],
"ItemCount": 0,
"CreationDateTime": 1542397215.37
}
}
El componente TableStatus indica el estado actual de la tabla (CREATING). Puede que la tabla tarde un
tiempo en crearse, según los valores especificados para ReadCapacityUnits y WriteCapacityUnits.
Cuanto mayores sean estos valores, más recursos tendrá que asignar DynamoDB a la tabla.
{
"TableDescription": {
"TableArn": "arn:aws:dynamodb:us-east-1:123456789012:table/Music",
"AttributeDefinitions": [
{
"AttributeName": "Artist",
"AttributeType": "S"
},
{
"AttributeName": "SongTitle",
"AttributeType": "S"
}
],
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"WriteCapacityUnits": 0,
"ReadCapacityUnits": 0
},
"TableSizeBytes": 0,
"TableName": "Music",
"BillingModeSummary": {
"BillingMode": "PAY_PER_REQUEST"
},
"TableStatus": "CREATING",
"TableId": "12345678-0123-4567-a123-abcdefghijkl",
"KeySchema": [
{
"KeyType": "HASH",
"AttributeName": "Artist"
},
{
"KeyType": "RANGE",
"AttributeName": "SongTitle"
}
],
"ItemCount": 0,
"CreationDateTime": 1542397468.348
}
}
Important
Al llamar a DescribeTable en una tabla bajo demanda, las unidades de capacidad de lectura y
de escritura se establecen en 0.
Al llamar a DescribeTable en una tabla bajo demanda, las unidades de capacidad de lectura y
de escritura se establecen en 0.
Example
La tabla está lista para usarla cuando el valor de TableStatus cambia de CREATING a ACTIVE.
Note
• Modificar los ajustes de rendimiento aprovisionado de una tabla (para las tablas en modo
aprovisionado).
• Cambiar el modo de capacidad de lectura/escritura de la tabla.
• Manipular los índices secundarios globales de la tabla (consulte Uso de índices secundarios en
DynamoDB (p. 570)).
• Habilite o deshabilite los DynamoDB Streams en la tabla (consulteCaptura de datos de cambio para
DynamoDB Streams (p. 661)).
Example
En el siguiente ejemplo de la AWS CLI se muestra cómo modificar los ajustes de desempeño provisionado
de una tabla:
Note
Example
En el siguiente ejemplo de la AWS CLI se muestra cómo modificar el modo de capacidad de lectura/
escritura de una tabla al modo bajo demanda:
Example
En el ejemplo siguiente de AWS CLI, se muestra cómo se elimina una tabla.
Cuando se emite una solicitud DeleteTable, el estado de la tabla cambia de ACTIVE a DELETING.
Puede que la tabla tarde un tiempo en eliminarse, según los recursos que utilice; por ejemplo, los datos
almacenados en la tabla y las secuencias o índices que contenga.
Example
Los siguientes ejemplos deAWS CLImuestra cómo enumerar los nombres de las tablas de DynamoDB.
Example
En el siguiente ejemplo de la AWS CLI se muestra cómo describir las cuotas de rendimiento aprovisionado
actuales.
Para obtener más información acerca de estas cuotas y cómo solicitar un aumento de cuotas, consulte
Cuotas de rendimiento predeterminadas (p. 1067).
Administración de la capacidad
Al actualizar una tabla en modo aprovisionado al modo bajo demanda, no necesita especificar el
rendimiento de lectura y escritura que espera de su aplicación.
Tenga en cuenta lo siguiente al actualizar una tabla del modo bajo demanda al modo aprovisionado:
• Si utiliza la AWS Management Console, esta calcula los valores iniciales de capacidad aprovisionada
en función de la capacidad de lectura y escritura consumida de su tabla y de los índices secundarios
globales durante los últimos 30 minutos. Para anular estos valores recomendados, elija Override
recommended values.
• Si utiliza laAWS CLIorAWSCon Amazon CloudWatch, elija los ajustes de capacidad aprovisionada
correctos de su tabla y de los índices secundarios globales tras haber examinado su consumo histórico
(ConsumedWriteCapacityUnitsyConsumedReadCapacityUnits) para determinar la nueva
configuración de rendimiento.
Note
Si va a cambiar una tabla global al modo aprovisionado, fíjese en el consumo máximo en todas
las réplicas regionales de las tablas base y en los índices secundarios globales para determinar
los nuevos ajustes de rendimiento.
• Si utiliza la consola, se eliminarán todos los ajustes de escalado automático (si los hay).
• Si utiliza laAWS CLIorAWSSe conservarán todos los ajustes de Auto Scaling de. Estos ajustes se
pueden aplicar al actualizar la tabla de nuevo al modo aprovisionado de facturación.
• Si utiliza la consola, DynamoDB recomienda habilitar la función Auto Scaling de con los valores
predeterminados siguientes:
• Objetivo de utilización: 70 %
• Capacidad aprovisionada mínima: 5 unidades
• Capacidad aprovisionada máxima: La región máxima
• Si utiliza la AWS CLI o el SDK, se conservan los ajustes anteriores de escalado automático (si los hay).
En su lugar, puede crear una tabla en modo bajo demanda para no tener que administrar ningún
ajuste de capacidad para servidores, almacenamiento o desempeño. DynamoDB se adapta de
forma instantánea a sus cargas de trabajo a medida que aumentan o disminuyen a cualquier
nivel de tráfico alcanzado previamente. Si el nivel de tráfico de una carga de trabajo alcanza un
nuevo nivel máximo, DynamoDB se adapta rápidamente para acomodar la carga de trabajo. Para
obtener más información, consulte Modo bajo demanda (p. 18).
Si lo prefiere, puede permitir que la función Auto Scaling de DynamoDB administre la capacidad de
desempeño de la tabla. Sin embargo, en cualquier caso deberá proporcionar los ajustes iniciales de
capacidad de lectura y escritura al crear la tabla. La función Auto Scaling de DynamoDB utiliza estos
ajustes iniciales como punto de partida y, a continuación, los ajusta dinámicamente en respuesta a los
requisitos de la aplicación. Para obtener más información, consulte Administración automática de la
capacidad de desempeño con la función Auto Scaling de DynamoDB (p. 355).
A medida que cambian los requisitos de datos y acceso de la aplicación, puede que tenga que ajustar
los ajustes de desempeño de la tabla. Si utiliza la función Auto Scaling de DynamoDB, los ajustes de
desempeño se modificarán automáticamente en respuesta a las cargas de trabajo reales. También puede
usar la operación UpdateTable para ajustar manualmente la capacidad de desempeño de la tabla. Es
posible que prefiera hacerlo de ese modo para cargar datos masivamente de un almacén de datos en
la nueva tabla de DynamoDB. Podría crear la tabla con un ajuste de desempeño de escritura mayor y, a
continuación, reducir este ajuste una vez finalizada la carga masiva de datos.
Temas
• Unidades de capacidad de lectura (p. 351)
• Unidades de capacidad de escritura (p. 352)
• Limitación controlada de solicitudes y capacidad de ráfaga (p. 353)
Para obtener más información sobre los modelos de consistencia de lectura de DynamoDB,
consulteConsistencia de lectura (p. 17).
Por ejemplo, supongamos que ha creado una tabla con 10 unidades de capacidad de lectura
provisionadas. Esto le permite realizar 10 lecturas de consistencia alta por segundo o 20 lecturas
consistentes finales por segundo, para elementos de hasta 4 KB.
Al leer un elemento de más de 4 KB se consumen más unidades de capacidad de lectura. Por ejemplo,
una lectura de consistencia alta de un elemento de 8 KB (4 KB × 2) consume 2 unidades de capacidad de
lectura. Una lectura consistente final del mismo elemento consume solo 1 unidad de capacidad de lectura.
A efectos de las lecturas, los tamaños del elemento se redondean al siguiente múltiplo de 4 KB. Por
ejemplo, leer un elemento de 3500 bytes consume el mismo desempeño que leer un elemento de 4 KB.
• GetItem: lee un solo elemento de una tabla. Para determinar el número de unidades de capacidad
queGetItemAprenda a consumir, tome el tamaño del elemento y redondéela al múltiplo de 4 KB. Si ha
especificado una lectura de consistencia alta, este es el número de unidades de capacidad necesarias.
Si se trata de una lectura consistente final (el valor predeterminado), divida este número por dos.
Por ejemplo, si lee un elemento de 3,5 KB, DynamoDB redondea su tamaño a 4 KB. Si lee un elemento
de 10 KB, DynamoDB redondea su tamaño a 12 KB.
• BatchGetItem: permite leer hasta 100 elementos de una o varias tablas. DynamoDB procesa cada
elemento del lote como un elemento individualGetItem, de este modo, DynamoDB redondea primero
el tamaño de cada elemento al múltiplo de inmediatamente superior y, a continuación, calcula el tamaño
total. El resultado no es necesariamente igual que el tamaño total de todos los elementos. Por ejemplo,
siBatchGetItemLee un elemento de 1,5 KB y un elemento de 6,5 KB; DynamoDB calcula sus tamaños
en 12 KB (4 KB + 8 KB) y no en 8 KB (1,5 KB + 6,5 KB).
• Query: lee varios elementos que tienen el mismo valor de clave de partición. Todos los elementos
devueltos se tratan como una sola operación de lectura, de tal forma que DynamoDB calcula el tamaño
total de todos los elementos y, a continuación, redondea al múltiplo de 4 KB inmediatamente superior.
Por ejemplo, supongamos que la consulta devuelve 10 elementos cuyo tamaño combinado es de
40,8 KB. DynamoDB redondea el tamaño del elemento de la operación a 44 KB. Si una consulta
devuelve 1500 elementos de 64 bytes cada uno, el tamaño acumulado es de 96 KB.
• Scan: lee todos los elementos de una tabla. DynamoDB considera el tamaño de los elementos que se
evalúan, no el tamaño de los elementos que el examen devuelve.
Si realiza una operación de lectura en un elemento que no existe, DynamoDB sigue consumiendo el
rendimiento de lectura aprovisionado: Una solicitud de lectura de consistencia alta consumirá una unidad
de capacidad de lectura, mientras que una lectura consistente final consumirá 0,5 unidades de capacidad
de lectura.
Para cualquier operación que devuelve elementos, puede solicitar un subconjunto de atributos para
recuperarlos. Sin embargo, esto no afecta al cálculo del tamaño de los elementos. Por otra parte, Query y
Scan pueden devolver recuentos de elementos en lugar de valores de atributos. Para obtener el recuento
de los elementos, se consume la misma cantidad de unidades de capacidad de lectura y se llevan a cabo
los mismos cálculos de tamaño de los elementos. Esto se debe a que DynamoDB tiene que leer cada
elemento para poder incrementar el recuento.
Por ejemplo, supongamos que ha creado una tabla con 10 unidades de capacidad de escritura
provisionadas. Esto le permite realizar 10 escrituras por segundo, para elementos con un tamaño de hasta
1 KB por segundo.
A efectos de las escrituras, los tamaños de los elementos se redondean al siguiente múltiplo de 1 KB Por
ejemplo, escribir un elemento de 500 bytes consume el mismo desempeño que leer un elemento de 1 KB.
• PutItem: escribe un solo elemento en una tabla. Si ya existe un elemento con la misma clave principal
en la tabla, la operación lo sustituye. Para calcular el consumo de desempeño provisionado, el tamaño
de elemento que se tiene en cuenta es el mayor de los dos.
• UpdateItem: modifica un solo elemento de la tabla. DynamoDB considera el tamaño del elemento tal
y como aparece antes y después de la actualización. El desempeño provisionado consumido refleja
el mayor de estos tamaños de elemento. Aunque se actualice tan solo un subconjunto de atributos
del elemento, UpdateItem consumirá la cantidad total de desempeño provisionado (el mayor de los
tamaños de elemento de "antes" y "después").
• DeleteItem: elimina un solo elemento de una tabla. El consumo de desempeño provisionado se basa
en el tamaño del elemento eliminado.
• BatchWriteItem: escribe hasta 25 elementos en una o varias tablas. DynamoDB procesa cada
elemento del lote como un elemento individualPutItemorDeleteItem(las actualizaciones no son
compatibles). Por este motivo, DynamoDB redondea primero el tamaño de cada elemento al múltiplo de
inmediatamente superior y, a continuación, calcula el tamaño total. El resultado no es necesariamente
igual que el tamaño total de todos los elementos. Por ejemplo, siBatchWriteItemescribe un elemento
de 500 bytes y un elemento de 3,5 KB; DynamoDB calcula sus tamaños en 5 KB (1 KB + 8 KB) y no en 5
KB (500 bytes + 3,5 KB).
PutItem, UpdateItem y DeleteItem permiten las escrituras condicionales, en las que se especifica una
expresión que debe evaluarse en true para que la operación se lleve a cabo correctamente. Si la expresión
se evalúa en false, DynamoDB consume unidades de capacidad de escritura de la tabla:
• El número de unidades de capacidad de escritura consumidas por un elemento que ya existe dependerá
del tamaño del elemento nuevo. Por ejemplo, una escritura condicional de un elemento de 1 KB de que
no se lleva a cabo consume una unidad de capacidad de escritura. Si el tamaño del nuevo elemento es
el doble, la escritura condicional que no se ha llevado a cabo consumiría dos unidades de capacidad de
escritura.
• Para un nuevo elemento, DynamoDB consume una unidad de capacidad de escritura.
La consola de DynamoDB muestra métricas de Amazon CloudWatch de las tablas, para que pueda
monitorizar las solicitudes de lectura y escritura que han sido objeto de una limitación controlada. Si se le
aplica la limitación controlada en demasiadas ocasiones, puede ser conveniente aumentar los ajustes de
desempeño provisionado de la tabla.
En algunos casos, DynamoDB utilizaCapacidad de ráfagasPara atender las lecturas o escrituras que
superan los ajustes de desempeño configurados para la tabla. Con la capacidad de ráfaga, pueden
realizarse correctamente solicitudes de lectura o escritura inesperadas que, de otro modo, habrían sido
objeto de una limitación controlada. Para obtener más información, consulte Uso eficaz de la capacidad de
ráfagas (p. 996).
• Tamaño de los elementos. Algunos elementos son lo bastante pequeños para leerlos o escribirlos con
una sola unidad de capacidad. Los elementos mayores requieren varias unidades de capacidad. Si
calcula el tamaño de los elementos que la tabla contendrá, podrá especificar ajustes más precisos de
desempeño provisionado para la tabla.
• Tasas previstas de solicitudes de lectura y escritura. Además del tamaño de elemento, debe calcular el
número de lecturas y escrituras que debe llevar a cabo por segundo.
• Requisitos de consistencia de lectura. Las unidades de capacidad de lectura se basan en operaciones
de lectura de consistencia alta, que consumen el doble de recursos de la base de datos que las lecturas
coherentes finales. Es importante determinar si la aplicación necesita las lecturas de consistencia alta
o si es posible adoptar un enfoque más flexible que realice en su lugar lecturas consistentes finales. De
forma predeterminada, las operaciones de lectura de DynamoDB son consistentes finales. Si es preciso,
puede solicitar lecturas de consistencia alta para estas operaciones.
Por ejemplo, supongamos que desea leer 80 elementos por segundo en una tabla. Los elementos tienen
un tamaño de 3 KB y desea realizar lecturas de consistencia alta. En este caso, cada lectura requiere
una unidad de capacidad de lectura provisionada. Para determinar esta cifra, hay que dividir el tamaño de
elemento de la operación por 4 KB y, a continuación, redondearlo al número entero más próximo, como en
este ejemplo:
• 1 unidad de capacidad de lectura por elemento × 80 lecturas por segundo = 80 unidades de capacidad
de lectura
Ahora, suponga que desea escribir 100 elementos por segundo en la tabla y que los elementos tienen
un tamaño de 512 bytes. En este caso, cada escritura requiere una unidad de capacidad de escritura
provisionada. Para determinar esta cifra, hay que dividir el tamaño de elemento de la operación por 1 KB y,
a continuación, redondearlo al número entero más próximo:
Note
Puede modificar los ajustes de desempeño provisionado de la tabla en la AWS Management Console
o mediante la operación UpdateTable. Para obtener más información sobre las reducciones y
los incrementos de rendimiento diarios, consulte Cuotas de servicio, cuenta y tabla en Amazon
DynamoDB (p. 1066).
El tamaño total de un elemento es la suma de las longitudes de los nombres y los valores de sus atributos.
Puede utilizar las siguientes directrices para calcular el tamaño de los atributos:
• Los valores de tipo String son Unicode con codificación binaria UTF-8. El tamaño de un atributo de tipo
String es (longitud del nombre de atributo) + (número de bytes con codificación UTF-8).
• Los números son de longitud variable, con un máximo de 38 dígitos significativos. Los ceros iniciales
y finales se recortan. El tamaño aproximado de un atributo de tipo Number es (longitud del nombre de
atributo) + (1 byte por cada dos dígitos significativos) + (1 byte).
• Un valor binario se debe codificar previamente en formato base64 para poder enviarlo a DynamoDB. Sin
embargo, para calcular su tamaño se utiliza la longitud en bytes sin procesar del valor. El tamaño de un
atributo de tipo Binary es (longitud del nombre de atributo) + (número de bytes sin procesar).
• El tamaño de un atributo de tipo Null o Boolean es (longitud del nombre de atributo) + (1 byte).
• Un atributo de tipo List o Map requiere 3 bytes adicionales, independientemente de su contenido. El
tamaño de un atributo de tipo List o Map es (longitud del nombre de atributo) + suma (tamaño de los
componentes anidados) + (3 bytes). El tamaño de un atributo de tipo List o Map vacío es (longitud del
nombre de atributo) + (3 bytes).
Note
Recomendamos elegir nombres de atributos cortos en lugar de largos. Esto le ayuda a reducir la
cantidad de almacenamiento necesario, así como la cantidad de RCU/WCU que utiliza.
El escalado automático de Amazon DynamoDB utiliza elAWSServicio Auto Scaling de aplicación para
ajustar de forma dinámica y automática la capacidad de desempeño provisionada en respuesta a los
patrones de tráfico reales. Esto permite que una tabla o índice secundario global aumenten su capacidad
de lectura y escritura aprovisionada para hacer frente a los aumentos repentinos de tráfico sin que se
aplique la limitación controlada. Cuando la carga de trabajo disminuye, la Application Auto Scaling reduce
el desempeño para evitar que tenga que pagar por una capacidad provisionada que no se utiliza.
Note
Si utiliza laAWS Management ConsolePara crear una tabla o un índice secundario global, la
función Auto Scaling de DynamoDB se habilita de forma predeterminada. Puede modificar los
ajustes de Auto Scaling en cualquier momento. Para obtener más información, consulte Mediante
laAWS Management ConsoleAuto Scaling de DynamoDB (p. 358).
Con Application Auto Scaling, puede crear unpolítica de escaladoPara una tabla o un índice secundario
global. La política de escalado especifica si desea escalar la capacidad de lectura o de escritura (o ambas),
así como los ajustes de unidades de capacidad provisionada mínimas y máximas para la tabla o el índice.
Puede establecer los valores de objetivo de utilización de escalado automático entre un 20 y un 90 por
ciento de la capacidad de lectura y escritura.
Note
Además de con las tablas, el escalado automático de DynamoDB es compatible con los índices
secundarios globales. Cada índice secundario global tiene su propia capacidad de desempeño
provisionada que es independiente de la de su tabla base. Al crear una política de escalado
para un índice secundario global, Application Auto Scaling ajusta los ajustes de desempeño
provisionado del índice para asegurarse de que el uso real se mantenga en valores iguales o
parecidos al porcentaje de utilización deseado.
En el siguiente diagrama se ofrece información general sobre cómo Auto Scaling administra la capacidad
de desempeño de una tabla en DynamoDB.
En los pasos siguientes se resume el proceso de Auto Scaling mostrado en el diagrama anterior:
Para comprender cómo funciona la función Auto Scaling de DynamoDB, supongamos que tenemos una
tabla denominadaProductCatalog. Es infrecuente que se realicen cargas masivas de datos en la tabla,
de modo que presenta poca actividad de escritura. Sin embargo, sí experimenta una intensa actividad
de lectura, que varía en cada momento. Mediante la supervisión de las métricas de Amazon CloudWatch
paraProductCatalog, determina que la tabla requiere 1200 unidades de capacidad de lectura (para
evitar que DynamoDB aplique una limitación controlada a las solicitudes de lectura durante los picos
de actividad). También ha determinado que ProductCatalog requiere como mínimo 150 unidades de
capacidad de lectura, cuando el tráfico de lectura se encuentra en el punto más bajo.
Dentro del rango de 150 a 1200 unidades de capacidad de lectura, decide que un objetivo de utilización
del 70 por ciento sería apropiado para la tabla ProductCatalog. Objetivo de utilizaciónes la proporción
de unidades de capacidad consumidas respecto de las unidades de capacidad provisionadas y se expresa
como un porcentaje. Application Auto Scaling de utiliza el algoritmo de seguimiento del objetivo para
asegurarse de que la capacidad de lectura provisionada deProductCatalogSe ajusta de acuerdo con las
necesidades, de tal forma que la utilización permanezca próxima al 70%.
Note
La función Auto Scaling de DynamoDB modifica los ajustes de desempeño provisionado solo
cuando la carga de trabajo real se mantiene elevada (o reducida) durante un periodo sostenido
de varios minutos. El algoritmo de seguimiento de objetivo de Auto Scaling de aplicación intenta
mantener el objetivo de utilización en el valor elegido o en valores próximos a él a largo plazo.
Los picos de actividad repentinos y breves se atienden gracias a la capacidad de ráfaga
incorporada de la tabla. Para obtener más información, consulte Uso eficaz de la capacidad de
ráfagas (p. 996).
Para habilitar el escalado automático de DynamoDB para elProductCatalogPara ello, debe crear una
política de escalado. La política especifica los elementos siguientes:
Al crear una política de escalado, Application Auto Scaling crea automáticamente un par de alarmas de
Amazon CloudWatch. Cada par representa los límites superior e inferior de los ajustes de desempeño
provisionado. Estas alarmas de CloudWatch alarmas se activan cuando la utilización real de la tabla se
desvía del objetivo de utilización durante un periodo de tiempo prolongado.
Cuando se activa una de las alarmas de CloudWatch, Amazon SNS envía una notificación (si se ha
habilitado). A continuación, la alarma de CloudWatch invoca Application Auto Scaling, que a su vez notifica
DynamoDB para ajustar elProductCatalogLa capacidad provisionada de la tabla al alza o a la baja,
según corresponda.
Notas de uso
Antes de comenzar a usar la función Auto Scaling de DynamoDB, debe tener en cuenta lo siguiente:
Temas
• Antes de comenzar: Concesión de permisos de usuario para DynamoDB Auto Scaling (p. 358)
• Creación de una nueva tabla con la función Auto Scaling habilitada (p. 359)
• Habilitación del Auto Scaling DynamoDB en tablas existentes (p. 359)
• Visualización de las actividades de Auto Scaling en la consola (p. 360)
• Modificación o deshabilitación de los ajustes de Auto Scaling de DynamoDB (p. 360)
Para configurar un usuario de IAM que pueda obtener acceso a la consola de DynamoDB y a la función
Auto Scaling de DynamoDB, agregue la siguiente política.
Para crear una nueva tabla con la función Auto Scaling habilitada
• Capacidad aprovisionada máxima: escriba el límite superior del rango de Auto Scaling.
• Aplicar la misma configuración a índices secundarios globales: mantenga esta opción en su
valor predeterminado (habilitada).
Note
Para ver estas actividades de Auto Scaling en la consola de DynamoDB, seleccione la tabla que desee
utilizar. SeleccionarCapacidady, a continuación, expanda laActividades de escaladosección. Cuando se
modifiquen los ajustes de desempeño de la tabla, aparecerán aquí los mensajes informativos.
• Cree una tabla de DynamoDB denominadaTestTable. Los ajustes de desempeño iniciales son
5 unidades de capacidad de lectura y 5 unidades de capacidad de escritura.
• Creación de una política de Auto Scaling de aplicaciones paraTestTable. La política está dirigida a
mantener una proporción objetivo del 50 % entre la capacidad de escritura consumida y la capacidad de
escritura provisionada. El rango de esta métrica está comprendido entre 5 y 10 unidades de capacidad
de escritura. El Application Auto Scaling no puede ajustar el desempeño fuera de este rango.
• Ejecute un programa de Python para dirigir tráfico de escritura aTestTable. Cuando la proporción
objetivo supere el 50% durante un periodo prolongado, la Application Auto Scaling de notificará a
DynamoDB para que ajuste el desempeño deTestTablepara mantener el 50 por ciento de utilización
objetivo.
• Compruebe que DynamoDB haya ajustado correctamente la capacidad de escritura provisionada
paraTestTable.
Temas
• Antes de empezar (p. 361)
• Paso 1: Creación de una tabla de DynamoDB (p. 361)
• Paso 2: Registrar un destino escalable (p. 362)
• Paso 3: Creación de una política de escalado (p. 362)
• Paso 4: Tráfico de escritura de unidades en TestTable (p. 364)
• Paso 5: Acciones Application Auto Scaling (p. 364)
• (Opcional) Paso 6: Eliminación (p. 365)
Antes de empezar
Complete las siguientes tareas antes de comenzar el tutorial.
Si aún no lo ha hecho, debe instalar y configurar la AWS CLI. Para ello, siga estas instrucciones en la.AWS
Command Line InterfaceGuía del usuario:
Instalación de Python
Una parte de este tutorial requiere que se ejecute un programa de Python (consultePaso 4: Tráfico de
escritura de unidades en TestTable (p. 364)). Si aún no lo ha hecho, puededescargar Python.
--query "Table.[TableName,TableStatus,ProvisionedThroughput]"
Note
También puede registrar un destino escalable en un índice secundario global. Por ejemplo,
para un índice secundario global («test-index»), el ID de recurso y los argumentos de
dimensión escalable se actualizan adecuadamente.
• DynamoDBReadCapacityUtilization
• DynamoDBWriteCapacityUtilization
• ScaleOutCooldown: cantidad mínima de tiempo (en segundos) entre cada evento de Application Auto
Scaling que aumenta el desempeño provisionado. Este parámetro permite que Application Auto Scaling
aumente de forma continua, pero no drática, el desempeño en respuesta a las cargas de trabajo reales.
El ajuste predeterminado de ScaleOutCooldown es 0.
• ScaleInCooldown: cantidad mínima de tiempo (en segundos) entre cada evento de Application
Auto Scaling que reduce el desempeño provisionado. Este parámetro permite que Application Auto
Scaling disminuya el desempeño de manera gradual y predecible. El ajuste predeterminado de
ScaleInCooldown es 0.
• TargetValue: Auto Scaling de aplicación garantiza que la proporción entre capacidad consumida y
capacidad provisionada se mantenga en este valor o en un valor próximo. TargetValue se define
como un porcentaje.
Note
Para entender aún más cómoTargetValuefunciona, imagine que tiene una tabla con un ajuste
de desempeño provisionado de 200 unidades de capacidad de escritura. Decide crear una política
de escalado para esta tabla, con un valor de TargetValue del 70 %.
Ahora, supongamos que comienza a dirigir el tráfico de escritura a la tabla, de tal forma que el
desempeño de escritura real es de 150 unidades de capacidad. La proporción entre capacidad
consumida y provisionada es ahora de (150/200), es decir, del 75 %. Esta proporción supera su
objetivo, de modo que Application Auto Scaling aumenta la capacidad de escritura provisionada a
215 para que la proporción sea de (150/215), es decir, del 69,77%; de esta forma se mantiene lo
más próxima posible al valor deTargetValuecomo sea posible, pero sin exceder de ella.
{
"PredefinedMetricSpecification": {
"PredefinedMetricType": "DynamoDBWriteCapacityUtilization"
},
"ScaleOutCooldown": 60,
"ScaleInCooldown": 60,
"TargetValue": 50.0
}
3. En el resultado, observe que Application Auto Scaling de ha creado dos alarmas de Amazon
CloudWatch para cada límite (superior e inferior) del rango de escalado objetivo.
4. Utilice el siguienteAWS CLIPara ver más detalles sobre la política de escalado.
5. En el resultado, compruebe que los ajustes de la política coincidan con las especificaciones
de Paso 2: Registrar un destino escalable (p. 362) y Paso 3: Creación de una política de
escalado (p. 362).
import boto3
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table("TestTable")
i = 0
while (i < 10):
j = 0
while (j < 10):
print (i, j)
table.put_item(
Item={
'pk':i,
'sk':j,
'filler':{"S":filler}
}
)
j += 1
i += 1
python bulk-load-test-table.py
1. Escriba el comando siguiente para ver las acciones Application Auto Scaling.
--service-namespace dynamodb
Vuelva a ejecutar este comando cada cierto tiempo mientras el programa en Python siga en ejecución.
Se tardarán varios minutos hasta que se invoque la política de escalado. En algún momento, debería
aparecer el resultado siguiente.
...
{
"ScalableDimension": "dynamodb:table:WriteCapacityUnits",
"Description": "Setting write capacity units to 10.",
"ResourceId": "table/TestTable",
"ActivityId": "0cc6fb03-2a7c-4b51-b67f-217224c6b656",
"StartTime": 1489088210.175,
"ServiceNamespace": "dynamodb",
"EndTime": 1489088246.85,
"Cause": "monitor alarm AutoScaling-table/TestTable-AlarmHigh-1bb3c8db-1b97-4353-
baf1-4def76f4e1b9 in state ALARM triggered policy MyScalingPolicy",
"StatusMessage": "Successfully set write capacity units to 10. Change successfully
fulfilled by dynamodb.",
"StatusCode": "Successful"
},
...
• EnableDynamoDBAutoscaling.java
• DisableDynamoDBAutoscaling.java
• El programa registra las unidades de capacidad de escritura como objetivo escalable de TestTable. El
rango de esta métrica está comprendido entre 5 y 10 unidades de capacidad de escritura.
• Después de crear el objetivo escalable, el programa crea una configuración de seguimiento del objetivo.
La política está dirigida a mantener una proporción objetivo del 50 % entre la capacidad de escritura
consumida y la capacidad de escritura provisionada.
• Después, el programa crea la política de escalado basada en la configuración de seguimiento del
objetivo.
El programa requiere que se suministre el nombre de recurso de Amazon (ARN) de un rol vinculado
al servicio de Auto Scaling de aplicación. (Por ejemplo: arn:aws:iam::122517410325:role/
AWSServiceRoleForApplicationAutoScaling_DynamoDBTable.) En el siguiente programa,
sustituya SERVICE_ROLE_ARN_GOES_HERE por el ARN real.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.autoscaling;
import com.amazonaws.services.applicationautoscaling.AWSApplicationAutoScalingClient;
import
com.amazonaws.services.applicationautoscaling.AWSApplicationAutoScalingClientBuilder;
import com.amazonaws.services.applicationautoscaling.model.DescribeScalableTargetsRequest;
import com.amazonaws.services.applicationautoscaling.model.DescribeScalableTargetsResult;
import com.amazonaws.services.applicationautoscaling.model.DescribeScalingPoliciesRequest;
import com.amazonaws.services.applicationautoscaling.model.DescribeScalingPoliciesResult;
import com.amazonaws.services.applicationautoscaling.model.MetricType;
import com.amazonaws.services.applicationautoscaling.model.PolicyType;
import com.amazonaws.services.applicationautoscaling.model.PredefinedMetricSpecification;
import com.amazonaws.services.applicationautoscaling.model.PutScalingPolicyRequest;
import com.amazonaws.services.applicationautoscaling.model.RegisterScalableTargetRequest;
import com.amazonaws.services.applicationautoscaling.model.ScalableDimension;
import com.amazonaws.services.applicationautoscaling.model.ServiceNamespace;
import
com.amazonaws.services.applicationautoscaling.model.TargetTrackingScalingPolicyConfiguration;
ServiceNamespace ns = ServiceNamespace.Dynamodb;
ScalableDimension tableWCUs = ScalableDimension.DynamodbTableWriteCapacityUnits;
String resourceID = "table/TestTable";
try {
aaClient.registerScalableTarget(rstRequest);
} catch (Exception e) {
System.err.println("Unable to register scalable target: ");
System.err.println(e.getMessage());
}
System.out.println();
try {
aaClient.putScalingPolicy(pspRequest);
} catch (Exception e) {
System.err.println("Unable to put scaling policy: ");
System.err.println(e.getMessage());
}
try {
DescribeScalingPoliciesResult dspResult =
aaClient.describeScalingPolicies(dspRequest);
System.out.println("DescribeScalingPolicies result: ");
System.out.println(dspResult);
} catch (Exception e) {
e.printStackTrace();
System.err.println("Unable to describe scaling policy: ");
System.err.println(e.getMessage());
}
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.autoscaling;
import com.amazonaws.services.applicationautoscaling.AWSApplicationAutoScalingClient;
import com.amazonaws.services.applicationautoscaling.model.DeleteScalingPolicyRequest;
import com.amazonaws.services.applicationautoscaling.model.DeregisterScalableTargetRequest;
import com.amazonaws.services.applicationautoscaling.model.DescribeScalableTargetsRequest;
import com.amazonaws.services.applicationautoscaling.model.DescribeScalableTargetsResult;
import com.amazonaws.services.applicationautoscaling.model.DescribeScalingPoliciesRequest;
import com.amazonaws.services.applicationautoscaling.model.DescribeScalingPoliciesResult;
import com.amazonaws.services.applicationautoscaling.model.ScalableDimension;
import com.amazonaws.services.applicationautoscaling.model.ServiceNamespace;
ServiceNamespace ns = ServiceNamespace.Dynamodb;
ScalableDimension tableWCUs = ScalableDimension.DynamodbTableWriteCapacityUnits;
String resourceID = "table/TestTable";
try {
aaClient.deleteScalingPolicy(delSPRequest);
} catch (Exception e) {
System.err.println("Unable to delete scaling policy: ");
System.err.println(e.getMessage());
}
try {
DescribeScalingPoliciesResult dspResult =
aaClient.describeScalingPolicies(descSPRequest);
System.out.println("DescribeScalingPolicies result: ");
System.out.println(dspResult);
} catch (Exception e) {
e.printStackTrace();
System.err.println("Unable to describe scaling policy: ");
System.err.println(e.getMessage());
}
System.out.println();
try {
aaClient.deregisterScalableTarget(delSTRequest);
} catch (Exception e) {
System.err.println("Unable to deregister scalable target: ");
System.err.println(e.getMessage());
}
try {
DescribeScalableTargetsResult dsaResult =
aaClient.describeScalableTargets(dscRequest);
System.out.println("DescribeScalableTargets result: ");
System.out.println(dsaResult);
System.out.println();
} catch (Exception e) {
Hay dos versiones de las tablas globales de DynamoDB disponibles: Versión 2019.11.21
(actual) (p. 372) y Versión 2017.11.29 (p. 385). Para saber qué versión utiliza, consulteDeterminación
de la versión (p. 371).
Las tablas globales de Amazon DynamoDB proporcionan una solución completamente administrada para
implementar una base de datos de varias regiones y versiones activas sin tener que crear y mantener su
propia solución de replicación. Con las tablas globales puede especificar la propiedadAWSLas regiones
en las que desea que la tabla esté disponible. DynamoDB realiza todas las tareas necesarias para crear
tablas idénticas en estas regiones y propagar los cambios en los datos en curso a todas y cada una de
ellas.
Por ejemplo, imagine que tiene una gran cartera de clientes repartidos en tres áreas geográficas: la costa
este de Estados Unidos, la costa oeste de Estados Unidos y Europa occidental. Los clientes tienen que
actualizar su información de perfil usando la aplicación. Para satisfacer este caso de uso, es preciso crear
tres tablas de DynamoDB idénticas denominadasCustomerProfiles, en tresAWSRegiones en las que
se encuentran los clientes. Estas tres tablas son completamente independientes. Los cambios realizados
en los datos de una tabla no se reflejan en el resto. Sin una solución de replicación administrada, puede
escribir código para replicar cambios de datos entre estas tablas. Sin embargo, esto le llevaría mucho
tiempo y requeriría un esfuerzo enorme.
En lugar de escribir su propio código, puede crear una tabla global que se componga de tres regiones
específicasCustomerProfilesTablas de. A continuación, DynamoDB replica automáticamente los
cambios realizados en los datos en esas tablas, para queCustomerProfileslos datos de una región se
propagarían sin problemas a las demás regiones. Además, si uno de losAWSLas regiones no disponibles
durante un tiempo, sus clientes todavía pueden obtener acceso al mismoCustomerProfilesdatos en las
demás regiones.
Las tablas globales de DynamoDB son ideales para aplicaciones con escalabilidad horizontal masiva
que cuenten con usuarios de todo el mundo. En esta situación, los usuarios esperan conseguir un
rendimiento óptimo de la aplicación. Las tablas globales proporcionan replicación multiactiva automática
aAWSRegiones en el mundo. Le permiten ofrecer a los usuarios acceso a los datos de baja latencia,
independientemente de dónde se encuentren.
Note
• Hay dos versiones de las tablas globales de DynamoDB disponibles: Versión 2019.11.21
(actual) (p. 372) y Versión 2017.11.29 (p. 385). Recomendamos usar Versión 2019.11.21
(actual) (p. 372) de las tablas globales, que permite agregar dinámicamente nuevas tablas de
réplica a partir de una tabla que contiene datos. Versión 2019.11.21 (actual) (p. 372) es más
eficiente y consume menos capacidad de escritura que Versión 2017.11.29 (p. 385).
• La compatibilidad de regiones para tablas globales Versión 2017.11.29 (p. 385) se limita a:
EE. UU. Este (Norte de Virginia), EE. UU. Este (Ohio), EE. UU. Oeste (Norte de California),
EE. UU. Oeste (Oregón), Europa (Irlanda), Europa (Londres), Europa (Fráncfort), Asia-Pacífico
(Singapur), Asia-Pacífico (Sídney), Asia-Pacífico (Tokio) y Asia-Pacífico (Seúl).
• Si usa Versión 2019.11.21 (actual) (p. 372) de tablas globales y también usa la función Time
to Live (Tiempo de vida), DynamoDB replicará las eliminaciones de TTL en todas las tablas de
réplica. La eliminación de TTL inicial no consume capacidad de escritura en la región donde se
produce el vencimiento de TTL. Sin embargo, la eliminación de TTL replicada en las tablas de
réplica consume una unidad de capacidad de escritura replicada cuando se usa la capacidad
aprovisionada, o una escritura replicada cuando se usa el modo de capacidad bajo demanda,
en cada una de las regiones de réplica. En estos casos, se aplicarán los cargos pertinentes.
• Las operaciones transaccionales proporcionan garantías de atomicidad, uniformidad,
aislamiento y durabilidad (ACID) solo en la región en la que se crea la escritura originalmente.
No se admiten las transacciones entre regiones en las tablas globales. Por ejemplo, si tiene
una tabla global con réplicas en las regiones de EE. UU. Este (Ohio) y EE. UU. Oeste (Oregón)
y realiza una operación TransactWriteItems en la región de EE. UU. Este (Norte de Virginia),
puede observar transacciones completadas parcialmente en la región EE. UU. (Oregón) a
medida que los cambios se replican. Solo se replicarán los cambios en otras regiones cuando
se hayan confirmado en la región de origen.
• Si el CMK administrado por el cliente utilizado para cifrar una réplica es inaccesible, DynamoDB
quitará esta réplica del grupo de replicación. La réplica no se eliminará y la replicación se
detendrá desde y hacia esta región, 20 horas después de detectarAWS KMScomo inaccesible.
• Sideshabilitar unaAWSRegión, DynamoDB eliminará esta réplica del grupo de replicación, 20
horas después de detectar elAWSRegión como inaccesible. La réplica no se eliminará y la
replicación se detendrá desde y hacia esta región.
• Si desea deshabilitar suCMK administrada por el clienteque se utiliza para cifrar una tabla de
réplicas, sólo debe hacerlo si la clave ya no se utiliza para cifrar una tabla de réplicas. Después
de ejecutar un comando para eliminar una tabla de réplica, debe esperar a que se complete la
operación de eliminación y a que la tabla global se convierta enActiveantes de deshabilitar la
clave. Si no lo hace, podría producirse una replicación parcial de datos desde y hacia la tabla de
réplicas.
• Si desea modificar o eliminar la directiva de rol de IAM para la tabla de réplicas, debe hacerlo
cuando la tabla de réplicas se encuentre en elActiveEl estado. Si no lo hace, puede
producirse un error al crear, actualizar o eliminar la tabla de réplica.
• Las tablas globales pueden realizarAWS KMSmediante el uso de la
herramientaAWSServiceRoleForDynamoDBReplicationRol vinculado a un servicioCMK
administrada por el clienteo elAWSCMK administrada porutilizado para cifrar la réplica.
Para obtener información sobre laAWSConsulte la disponibilidad y los precios de las regiones.Precios de
Amazon DynamoDB.
Temas
• Determinación de la versión de las tablas globales utilizadas (p. 371)
• Versión 2019.11.21 (actual) (p. 372)
• Versión 2017.11.29 (p. 385)
5. Aparecerá Global table version (Versión de tabla global), que muestra la versión de las tablas globales
en uso.
Hay dos versiones de las tablas globales de DynamoDB disponibles: Versión 2019.11.21
(actual) (p. 372) y Versión 2017.11.29 (p. 385). Para saber qué versión utiliza, consulteDeterminación
de la versión (p. 371).
Temas
• Tablas globales: Cómo funciona (p. 372)
• Prácticas recomendadas y requisitos para la administración de tablas globales (p. 373)
• Tutorial: Crear una tabla global (p. 374)
• Monitoreo de tablas globales (p. 379)
• Usar IAM con tablas globales (p. 379)
• Actualización de tablas globales a la versión 2019.11.21 (actual) (p. 382)
Hay dos versiones de las tablas globales de DynamoDB disponibles: Versión 2019.11.21
(actual) (p. 372) y Versión 2017.11.29 (p. 385). Para saber qué versión utiliza, consulteDeterminación
de la versión (p. 371).
Las secciones siguientes le ayudarán a comprender los conceptos y el comportamiento de las tablas
globales en Amazon DynamoDB.
ATabla globales una colección de una o más tablas de réplica, propiedad de una únicaAWSaccount.
Atabla de réplica(oRéplica) es una única tabla de DynamoDB que funciona como una parte de una tabla
global. Cada réplica almacena el mismo conjunto de elementos de datos. Cualquier tabla global solo puede
tener una réplica porAWSRegión . Para obtener más información sobre cómo empezar a usar las tablas
globales, consulteTutorial: Crear una tabla global (p. 374).
Al crear una tabla global de DynamoDB, se compone de varias tablas de réplica (una por región) que
DynamoDB considera como una única unidad. Cada réplica tiene el mismo nombre de tabla y el mismo
esquema de clave primaria. Cuando una aplicación escribe datos en una tabla de réplica de una región,
Puede agregar tablas de réplica a la tabla global para que esté disponible en otras regiones.
Cualquier cambio en cualquier elemento de cualquier tabla de réplica se replicará en el resto de réplicas
en la misma tabla global. En una tabla global, un elemento que se acaba de escribir se propagará
normalmente a todas las tablas de réplica en un segundo.
Con una tabla global, cada tabla de réplica almacena el mismo conjunto de elementos de datos.
DynamoDB no admite la replicación parcial de solo algunos de los elementos.
Una aplicación puede leer y escribir datos en cualquier tabla de réplica. Si la aplicación solo utiliza
operaciones de lectura consistente final y solo realiza operaciones de lectura en unaAWSRegión,
funcionará sin ninguna modificación. Sin embargo, si la aplicación requiere operaciones de lectura
consistente alta, debe realizar todas las operaciones de escritura y lectura consistente alta en la misma
región. DynamoDB no admite lecturas muy coherentes en todas las regiones. Por lo tanto, si realiza
una escritura en una región y una lectura en otra, es posible que la respuesta de la lectura incluya datos
anticuados que no reflejen los resultados de las operaciones de escritura completadas recientemente en la
otra región.
Disponibilidad y durabilidad
Si una solaAWSLa región se encuentra aislada o degradada, la aplicación puede redirigir a otra región y
realizar las operaciones de lectura y escritura en una tabla de réplica diferente. Puede aplicar una lógica de
negocio personalizada para determinar cuándo deben redirigirse solicitudes a otras regiones.
Si una región se encuentra aislada o degradada, DynamoDB lleva un seguimiento de las operaciones
de escritura que se han realizado pero que todavía no se han propagado a todas las tablas de réplica.
Cuando la región vuelva a estar online, DynamoDB reanuda la propagación de cualquier operación de
escritura pendiente desde esa región a las tablas de réplica en otras regiones. Asimismo, reanuda la
propagación de las operaciones de escritura de otras tablas de réplica a la región que ahora está online.
Hay dos versiones de las tablas globales de DynamoDB disponibles: Versión 2019.11.21
(actual) (p. 372) y Versión 2017.11.29 (p. 385). Para saber qué versión utiliza, consulteDeterminación
de la versión (p. 371).
Mediante las tablas globales de Amazon DynamoDB, puede replicar los datos de la tabla enAWSRegiones
de. Es importante que las tablas de réplica y los índices secundarios de la tabla global tengan una
configuración de capacidad de escritura idéntica para garantizar la replicación adecuada de los datos.
Cuando utilice la versión más reciente de las tablas globales, debe utilizar la capacidad bajo demanda o
habilitar el escalado automático en la tabla. El uso de escalado automático o capacidad bajo demanda
garantiza que siempre tenga capacidad suficiente para realizar escrituras replicadas en todas las regiones
de la tabla global. El número de unidades de capacidad de escritura replicada (RWCU) o unidades
de solicitud de escritura replicada será igual en todas las regiones de la tabla global. Por ejemplo,
supongamos que espera 5 escrituras por segundo en la tabla de réplicas en Ohio y 5 escrituras por
segundo en la tabla de réplicas en Virginia del Norte. En este caso, debe esperar consumir 10 RWCU (o
10 unidades de solicitud de escritura replicada, si utiliza capacidad bajo demanda) en cada región, Ohio
y Norte de Virginia. En otras palabras, debería esperar consumir 20 RWCU en total tanto en Ohio como
en el norte de Virginia. Cuando se utiliza el modo de capacidad aprovisionada, se administra la política de
escalado automático con UpdateTableReplicaAutoScaling. El rendimiento mínimo y máximo y la utilización
de destino se establecen globalmente para la tabla y se pasan a todas las réplicas de la tabla.
Hay dos versiones de las tablas globales de DynamoDB disponibles: Versión 2019.11.21
(actual) (p. 372) y Versión 2017.11.29 (p. 385). Para saber qué versión utiliza, consulteDeterminación
de la versión (p. 371).
En esta sección se indica cómo crear una tabla global mediante la consola de Amazon DynamoDB o
laAWS Command Line Interface(AWS CLI).
Temas
• Crear una tabla global (consola) (p. 374)
• Creación de una tabla global (AWS CLI) (p. 376)
• Creación de una tabla global (Java) (p. 377)
Siga estos pasos para crear una tabla global mediante la consola. En el siguiente ejemplo se crea una
tabla global con tablas de réplica en los Estados Unidos y Europa.
En Primary key (Clave principal) introduzca Artist. Elija Add sort key (Añadir clave de ordenación) e
introduzca SongTitle. (Tanto Artist como SongTitle deben ser cadenas).
Para crear la tabla, seleccione Create (Crear). Esta tabla le servirá a modo de primera tabla de réplica
en una nueva tabla global. Será el prototipo para crear otras tablas de réplica que quiera añadir más
tarde.
4. Seleccione la pestaña Global Tables (Tablas globales) y Enable streams (Habilitar transmisiones).
Deje el valor del View type (Tipo de vista) en su valor predeterminado (imágenes nuevas y viejas).
La consola comprueba el proceso para asegurarse de que no haya ninguna tabla con el mismo
nombre en la región seleccionada. Si ya existe una tabla con el mismo nombre, debe eliminar la tabla
existente antes de crear una nueva tabla de réplica en esa región.
La pestaña Global Table (Tabla global) de la tabla seleccionada (y de cualquier otra tabla de réplica)
indica que la tabla se ha replicado en varias regiones.
7. Ahora puede añadir otra región para que la tabla global se replique y sincronice en los Estados Unidos
y Europa. Para ello, repita el paso 5, pero esta vez especifiqueUE (Fráncfort)en lugar deEE.UU. Oeste
(Oregón).
8. Debe seguir usando la AWS Management Console en la región us-east-2 (EE. UU. Este [Ohio]). En la
tabla Music (Música), seleccione la pestaña Items (Elementos) y, a continuación, Create Item (Crear
Después de un breve periodo de tiempo, el elemento se replica en las tres regiones de la tabla global.
Para comprobar esto, en la consola, vaya al selector de regiones que se encuentra en la esquina
superior derecha y elijaEuropa (Fráncfort). LaMusicLa tabla de Europa (Frankfurt) debe contener el
nuevo elemento.
Siga estos pasos para crear una tabla global Music mediante la AWS CLI. En el siguiente ejemplo se crea
una tabla global con tablas de réplica en los Estados Unidos y en Europa.
1. Cree una nueva tabla (Music) en EE. UU. Este (Ohio), con DynamoDB Streams habilitada
(NEW_AND_OLD_IMAGES).
5. Para comprobar que la replicación funciona, añada un nuevo elemento alMusicEn EE. UU. Este
(Ohio).
En el siguiente ejemplo de código Java, se crea unMusicEn la región Europa (Irlanda), se crea una réplica
en la región Asia Pacífico (Seúl).
package com.amazonaws.codesamples.gtv2
import java.util.logging.Logger;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AmazonDynamoDBException;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.BillingMode;
import com.amazonaws.services.dynamodbv2.model.CreateReplicationGroupMemberAction;
import com.amazonaws.services.dynamodbv2.model.CreateTableRequest;
import com.amazonaws.services.dynamodbv2.model.DescribeTableRequest;
import com.amazonaws.services.dynamodbv2.model.GlobalSecondaryIndex;
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.Projection;
import com.amazonaws.services.dynamodbv2.model.ProjectionType;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughputOverride;
import com.amazonaws.services.dynamodbv2.model.ReplicaGlobalSecondaryIndex;
import com.amazonaws.services.dynamodbv2.model.ReplicationGroupUpdate;
import com.amazonaws.services.dynamodbv2.model.ScalarAttributeType;
import com.amazonaws.services.dynamodbv2.model.StreamSpecification;
import com.amazonaws.services.dynamodbv2.model.StreamViewType;
import com.amazonaws.services.dynamodbv2.model.UpdateTableRequest;
import com.amazonaws.waiters.WaiterParameters;
.withAttributeName("Artist").withAttributeType(ScalarAttributeType.S),
new AttributeDefinition()
.withAttributeName("SongTitle").withAttributeType(ScalarAttributeType.S))
.withKeySchema(
new
KeySchemaElement().withAttributeName("Artist").withKeyType(KeyType.HASH),
new
KeySchemaElement().withAttributeName("SongTitle").withKeyType(KeyType.RANGE))
.withBillingMode(BillingMode.PAY_PER_REQUEST)
.withGlobalSecondaryIndexes(new GlobalSecondaryIndex()
.withIndexName(indexName)
.withKeySchema(new KeySchemaElement()
.withAttributeName("SongTitle")
.withKeyType(KeyType.HASH))
.withProjection(new
Projection().withProjectionType(ProjectionType.ALL)))
.withStreamSpecification(new StreamSpecification()
.withStreamEnabled(true)
.withStreamViewType(StreamViewType.NEW_AND_OLD_IMAGES)));
ddbClient.updateTable(new UpdateTableRequest()
.withTableName(tableName)
.withReplicaUpdates(new ReplicationGroupUpdate()
.withCreate(createReplicaAction.withKMSMasterKeyId(null))));
}
}
Hay dos versiones de las tablas globales de DynamoDB disponibles: Versión 2019.11.21
(actual) (p. 372) y Versión 2017.11.29 (p. 385). Para saber qué versión utiliza, consulteDeterminación
de la versión (p. 371).
Puede utilizar Amazon CloudWatch para monitorear el comportamiento y el desempeño de una tabla
global. Amazon DynamoDB publicaReplicationLatencypara cada réplica en la tabla global.
Durante el uso normal, el valor de ReplicationLatency debería ser bastante constante. Un valor
alto de ReplicationLatency podría indicar que las actualizaciones de una réplica no se están
propagando hacia otras tablas de réplica de manera puntual. Con el tiempo, esto podría dar lugar a
que otras tablas de réplica se quedaran rezagadas, ya que dejarían de recibir actualizaciones de forma
consistente. En este caso, debería verificar que las unidades de capacidad de lectura (RCU) y de
escritura (WCU) son idénticas para cada una de las tablas de réplica. Además, al elegir la configuración
de WCU, debe seguir las recomendaciones de Prácticas recomendadas y requisitos para administrar la
capacidad (p. 373).
Para obtener más información, consulte Dimensiones y métricas de DynamoDB (p. 940).
Hay dos versiones de las tablas globales de DynamoDB disponibles: Versión 2019.11.21
(actual) (p. 372) y Versión 2017.11.29 (p. 385). Para saber qué versión utiliza, consulteDeterminación
de la versión (p. 371).
Cuando se crea una tabla global por primera vez, Amazon DynamoDB crea
automáticamente unAWS Identity and Access Management(IAM) para usted. Este rol se
denominaAWSServiceRoleForDynamoDBReplicationy permite que DynamoDB administre la
replicación entre regiones de las tablas globales. No elimine este rol vinculado a un servicio. Si lo hace, las
tablas globales dejarán de funcionar.
Para obtener más información acerca roles vinculados a servicios, consulte Uso de roles vinculados a
servicios en la Guía del usuario de IAM.
Para crear tablas de réplica en DynamoDB, debe tener los siguientes permisos en la región de origen.
• dynamodb:UpdateTable
Para crear tablas de réplica en DynamoDB, debe tener los siguientes permisos en las regiones de destino.
• dynamodb:CreateTable
• dynamodb:CreateTableReplica
• dynamodb:Scan
• dynamodb:Query
• dynamodb:UpdateItem
• dynamodb:PutItem
• dynamodb:GetItem
• dynamodb:DeleteItem
• dynamodb:BatchWriteItem
Para eliminar tablas de réplica en DynamoDB, debe tener los siguientes permisos en las regiones de
destino.
• dynamodb:DeleteTable
• dynamodb:DeleteTableReplica
• application-autoscaling:DeleteScalingPolicy
• application-autoscaling:DeleteScheduledAction
• application-autoscaling:DeregisterScalableTarget
• application-autoscaling:DescribeScalableTargets
• application-autoscaling:DescribeScalingActivities
• application-autoscaling:DescribeScalingPolicies
• application-autoscaling:DescribeScheduledActions
• application-autoscaling:PutScalingPolicy
• application-autoscaling:PutScheduledAction
• application-autoscaling:RegisterScalableTarget
Para usar UpdateTimeToLive, debe tener permisos para dynamodb:UpdateTimeToLive en todas las
regiones donde haya réplicas.
La siguiente política de IAM concede permisos para permitirle añadir réplicas a una tabla global.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"dynamodb:CreateTable",
"dynamodb:DescribeTable",
"dynamodb:UpdateTable",
"dynamodb:CreateTableReplica",
"iam:CreateServiceLinkedRole"
],
"Resource": "*"
}
]
}
La siguiente política de IAM concede permisos para permitirle actualizar la política de auto-scaling.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"application-autoscaling:RegisterScalableTarget",
"application-autoscaling:DeleteScheduledAction",
"application-autoscaling:DescribeScalableTargets",
"application-autoscaling:DescribeScalingActivities",
"application-autoscaling:DescribeScalingPolicies",
"application-autoscaling:PutScalingPolicy",
"application-autoscaling:DescribeScheduledActions",
"application-autoscaling:DeleteScalingPolicy",
"application-autoscaling:PutScheduledAction",
"application-autoscaling:DeregisterScalableTarget"
],
"Resource": "*"
}
]
}
La siguiente política de IAM concede permisos para permitir la creación de tablas y réplicas para la tabla
Customers con réplicas en tres regiones.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"dynamodb:CreateTable",
"dynamodb:DescribeTable",
"dynamodb:UpdateTable"
],
"Resource": [
"arn:aws:dynamodb:us-east-1:123456789012:table/Customers",
"arn:aws:dynamodb:us-west-1:123456789012:table/Customers",
"arn:aws:dynamodb:eu-east-2:123456789012:table/Customers"
]
}
]
}
Hay dos versiones de las tablas globales de DynamoDB disponibles: Versión 2019.11.21
(actual) (p. 372) y Versión 2017.11.29 (p. 385). Para saber qué versión utiliza, consulteDeterminación
de la versión (p. 371).
En esta sección se describe cómo actualizar las tablas globales a la versión 2019.11.21 (actual).
Temas
• Antes de empezar (p. 382)
• Actualización a la versión 2019.11.21 (actual) (p. 384)
Antes de empezar
Las tablas globales de DynamoDB versión 2019.11.21 (actual) presentan los siguientes requisitos:
• Los índices secundarios globales de las tablas de réplica deben ser coherentes en las distintas regiones.
• La configuración del cifrado de las tablas de réplica debe ser coherente en la distintas regiones.
• La configuración de Tiempo de vida (TTL) de las tablas de réplica debe ser coherente en las distintas
regiones. Si TTL está habilitado en una tabla de réplica, las eliminaciones de TTL se replican.
• Escalado automático de DynamoDBBajo demandadebe estar habilitada para unidades de capacidad de
escritura en todas las tablas de réplicas.
• Las operaciones de la API del plano de control de las tablas globales (crear, eliminar, actualizar y
describir) son diferentes. Para obtener más información, consulteTablas globales: Replicación en varias
regiones con DynamoDB.
Las tablas globales de DynamoDB versión 2019.11.21 (actual) presentan los siguientes cambios de
comportamiento:
• DynamoDB Streams publica solo un registro (en lugar de dos) para cada operación de escritura.
• Para las inserciones nuevas, no se agregan atributos aws:rep:* al registro de elementos.
• Para las actualizaciones de elementos que contienen atributos aws:rep:*, esos atributos no se
actualizan.
• El mapeador de DynamoDB no debe requerir elaws:rep:*para esta tabla.
• Al actualizar desde la versión 2017.11.29 a la versión 2019.11.21, es posible que vea un aumento
de laReplicationLatencyMétrica de. Esto se espera porque la versión 2019.11.21 (actual)
captura la medición completa del retraso de replicación entre las regiones de las tablas globales. Para
obtener más información, consulte laReplicationLatencydocumentación para la versiónVersión
2017.11.29yVersión 2019.11.21 (actual).
Permisos necesarios
La siguiente política de IAM concede permisos para actualizar cualquier tabla global a la versión
2019.11.21 (actual).
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "dynamodb:UpdateGlobalTableVersion",
"Resource": "*"
}
]
}
La siguiente política de IAM concede permisos para actualizar solo elMusicCon réplicas en dos regiones,
a la versión 2019.11.21 (actual).
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "dynamodb:UpdateGlobalTableVersion",
"Resource": [
"arn:aws:dynamodb::123456789012:global-table/Music",
"arn:aws:dynamodb:ap-southeast-1:123456789012:table/Music",
"arn:aws:dynamodb:us-east-2:123456789012:table/Music"
]
}
]
}
El proceso tarda varios minutos, pero debe terminar en menos de una hora. Durante el proceso de
actualización, la tabla permanece disponible para el tráfico de lectura y escritura. Sin embargo, el escalado
automático no modifica la capacidad aprovisionada de la tabla durante la actualización. Por consiguiente,
antes de comenzar la actualización, le recomendamos que cambie la tabla a la capacidad bajo demanda.
Si decide utilizar capacidad aprovisionada con el escalado automático durante la actualización, debe
aumentar la velocidad mínima de lectura y escritura en las políticas para contemplar el aumento esperado
de tráfico durante la actualización.
Cuando finaliza el proceso de actualización, el estado de la tabla vuelve a ser ACTIVE. Puede comprobar
el estado de la tabla medianteDescribeTable, o verifíquelo usando elTablasEn la consola de
DynamoDB.
Important
Siga estos pasos para actualizar la versión de las tablas globales de DynamoDB mediante laAWS
Management Console.
6. Una vez completado el proceso de actualización, la versión de tablas globales que aparece en la
consola cambia a 2019.11.21.
Versión 2017.11.29
Hay dos versiones de las tablas globales de DynamoDB disponibles: Versión 2019.11.21
(actual) (p. 372) y Versión 2017.11.29 (p. 385). Para saber qué versión utiliza, consulteDeterminación
de la versión (p. 371).
Temas
• Tablas globales: Cómo funciona (p. 385)
• Prácticas recomendadas y requisitos para la administración de tablas globales (p. 386)
• Crear una tabla global (p. 389)
• Monitoreo de tablas globales (p. 391)
• Usar IAM con tablas globales (p. 392)
Hay dos versiones de las tablas globales de DynamoDB disponibles: Versión 2019.11.21
(actual) (p. 372) y Versión 2017.11.29 (p. 385). Para saber qué versión utiliza, consulteDeterminación
de la versión (p. 371).
Las secciones siguientes le ayudarán a comprender los conceptos y el comportamiento de las tablas
globales en Amazon DynamoDB.
ATabla globales una colección de una o más tablas de réplica, propiedad de una únicaAWSaccount.
Atabla de réplica(oRéplica) es una única tabla de DynamoDB que funciona como una parte de una tabla
global. Cada réplica almacena el mismo conjunto de elementos de datos. Cualquier tabla global solo puede
tener una réplica porAWSRegión .
A continuación se muestra información general de carácter conceptual acerca de cómo se crea una tabla
global.
1. Cree una tabla normal de DynamoDB con las DynamoDB Streams habilitada en unaAWSRegión .
2. Repita el paso 1 para cada región en la que desea replicar los datos.
3. Defina una tabla global de DynamoDB en función de las tablas que haya creado.
LaAWS Management Consoleautomatiza estas tareas para que pueda crear una tabla global de forma más
rápida y sencilla. Para obtener más información, consulte Crear una tabla global (p. 389).
La tabla global de DynamoDB resultante se compone de varias tablas de réplica, una por región, que
DynamoDB considera como una única unidad. Cada réplica tiene el mismo nombre de tabla y el mismo
esquema de clave primaria. Cuando una aplicación escribe datos en una tabla de réplica de una región,
DynamoDB propaga automáticamente la operación de escritura en el resto de las tablas de réplica de la
otra regiónAWSRegiones de.
Important
Para mantener los datos de la tabla sincronizados, las tablas globales crean automáticamente los
siguientes atributos para cada elemento:
• aws:rep:deleting
• aws:rep:updatetime
• aws:rep:updateregion
Puede agregar tablas de réplica a la tabla global para que esté disponible en otras regiones. (Para ello, la
tabla global debe estar vacía. En otras palabras, ninguna de las tablas de réplica puede contener ningún
dato).
También puede eliminar una tabla de réplica de una tabla global. En tal caso, la tabla se desasocia
completamente de la tabla global. Esta nueva tabla independiente ya no interactúa con la tabla global y los
datos ya no se propagarán hacia o desde allí.
Cualquier cambio en cualquier elemento de cualquier tabla de réplica se replicará en el resto de réplicas
en la misma tabla global. En una tabla global, un elemento que se acaba de escribir se propagará
normalmente a todas las tablas de réplica en cuestión de segundos.
Con una tabla global, cada tabla de réplica almacena el mismo conjunto de elementos de datos.
DynamoDB no admite la replicación parcial de solo algunos de los elementos.
Una aplicación puede leer y escribir datos en cualquier tabla de réplica. Si la aplicación solo utiliza
operaciones de lectura consistente final y solo realiza operaciones de lectura en unaAWSRegión,
funcionará sin ninguna modificación. Sin embargo, si la aplicación requiere operaciones de lectura
consistente alta, debe realizar todas las operaciones de escritura y lectura consistente alta en la misma
región. DynamoDB no admite lecturas muy coherentes en todas las regiones. Por lo tanto, si realiza
una escritura en una región y una lectura en otra, es posible que la respuesta de la lectura incluya datos
anticuados que no reflejen los resultados de las operaciones de escritura completadas recientemente en la
otra región.
Pueden surgir conflictos si las aplicaciones actualizan el mismo elemento en diferentes regiones
aproximadamente al mismo momento. Para ayudar a garantizar la consistencia eventual, las tablas
globales de DynamoDB utilizan unel último escritor ganaLa reconciliación entre las actualizaciones
simultáneas. DynamoDB realiza todo lo posible para determinar quién realizó la última escritura. Con este
mecanismo de resolución de conflictos, todas las réplicas estarán de acuerdo con la última actualización y
convergerán en un estado en el cual todas tienen datos idénticos.
Disponibilidad y durabilidad
Si una solaAWSLa región se encuentra aislada o degradada, la aplicación puede redirigir a otra región y
realizar las operaciones de lectura y escritura en una tabla de réplica diferente. Puede aplicar una lógica de
negocio personalizada para determinar cuándo deben redirigirse solicitudes a otras regiones.
Si una región se encuentra aislada o degradada, DynamoDB lleva un seguimiento de las operaciones
de escritura que se han realizado pero que todavía no se han propagado a todas las tablas de réplica.
Cuando la región vuelva a estar online, DynamoDB reanuda la propagación de cualquier operación de
escritura pendiente desde esa región a las tablas de réplica en otras regiones. Asimismo, reanuda la
propagación de las operaciones de escritura de otras tablas de réplica a la región que ahora está online.
Hay dos versiones de las tablas globales de DynamoDB disponibles: Versión 2019.11.21
(actual) (p. 372) y Versión 2017.11.29 (p. 385). Para saber qué versión utiliza, consulteDeterminación
de la versión (p. 371).
Mediante las tablas globales de Amazon DynamoDB, puede replicar los datos de la tabla enAWSRegiones
de. Es importante que las tablas de réplica y los índices secundarios de la tabla global tengan una
configuración de capacidad de escritura idéntica para garantizar la replicación adecuada de los datos.
Temas
• Requisitos para agregar una tabla de réplica nueva (p. 387)
• Prácticas recomendadas y requisitos para administrar la capacidad (p. 387)
Si quiere agregar un tabla de réplica nueva a una tabla global, debe cumplirse cada una de las condiciones
siguientes:
• La tabla debe tener la misma clave de partición que todas las demás réplicas.
• La tabla debe tener la misma configuración de administración de capacidad de escritura especificada.
• La tabla debe tener el mismo nombre que todas las demás réplicas.
• La tabla debe tener DynamoDB Streams habilitado y la secuencia debe contener las imágenes viejas y
las nuevas del elemento.
• Ninguna de las tablas de réplica nuevas o existentes en la tabla global puede contener ningún dato.
Si se especifican los índices secundarios globales, se deben cumplir las siguientes condiciones:
Important
DynamoDB ajusta automáticamente las unidades de capacidad de lectura (RCU) y las unidades de
capacidad de escritura (WCU) para cada tabla de réplica en función de la carga de trabajo de la aplicación
real. Para obtener más información, consulte Administración automática de la capacidad de desempeño
con la función Auto Scaling de DynamoDB (p. 355).
Si crea las tablas de réplica con la herramientaAWS Management ConsoleLa función Auto Scaling de
está habilitada de forma predeterminada para cada tabla de réplica con la configuración de Auto Scaling
predeterminada para la administración de las unidades de capacidad de lectura y escritura.
Las unidades de capacidad de escritura replicada (RWCU) aprovisionadas en cada tabla de réplicas deben
establecerse en el número total de RWCU necesarias para las escrituras de aplicaciones en todas las
regiones multiplicadas por dos. Esto acomoda las escrituras de aplicaciones que se producen en la región
local y las escrituras de aplicaciones replicadas procedentes de otras regiones. Por ejemplo, supongamos
que espera 5 escrituras por segundo en la tabla de réplicas en Ohio y 5 escrituras por segundo en la tabla
de réplicas en Virginia del Norte. En este caso, debe aprovisionar 20 WCU a cada tabla de réplicas (5 + 5 =
10; 10 x 2 = 20).
tenerdynamodb:UpdateGlobalTable,dynamodb:DescribeLimits,application-
autoscaling:DeleteScalingPolicy, yapplication-
autoscaling:DeregisterScalableTargetPermisos. Para obtener más información,
consulte Usar IAM con tablas globales (p. 392).
Hay dos versiones de las tablas globales de DynamoDB disponibles: Versión 2019.11.21
(actual) (p. 372) y Versión 2017.11.29 (p. 385). Para saber qué versión utiliza, consulteDeterminación
de la versión (p. 371).
En esta sección se indica cómo crear una tabla global mediante la consola de Amazon DynamoDB o
laAWS Command Line Interface(AWS CLI).
Temas
• Crear una tabla global (consola) (p. 389)
• Creación de una tabla global (AWS CLI) (p. 390)
Siga estos pasos para crear una tabla global mediante la consola. En el siguiente ejemplo se crea una
tabla global con tablas de réplica en los Estados Unidos y Europa.
En Primary key (Clave principal) introduzca Artist. Elija Add sort key (Añadir clave de ordenación) e
introduzca SongTitle. (Tanto Artist como SongTitle deben ser cadenas).
Para crear la tabla, seleccione Create (Crear). Esta tabla le servirá a modo de primera tabla de réplica
en una nueva tabla global. Será el prototipo para crear otras tablas de réplica que quiera añadir más
tarde.
4. Seleccione la pestaña Global Tables (Tablas globales) y Enable streams (Habilitar transmisiones).
Deje el valor del View type (Tipo de vista) en su valor predeterminado (imágenes nuevas y viejas).
5. SeleccionarAgregar región, y elijaModo de tabla global 2017.11.29. Ahora puede elegir otra región en
la que desee implementar otra tabla de réplica. En este caso, elijaEE.UU. Oeste (Oregón)Haga clic en
y luego enContinuar. Esto inicia el proceso de creación de la tabla en EE.UU. Oeste (Oregón).
La consola comprueba el proceso para asegurarse de que no haya ninguna tabla con el mismo
nombre en la región seleccionada. (Si ya existe una tabla con el mismo nombre, debe eliminar la tabla
existente antes de crear una nueva tabla de réplica en esa región).
LaTabla globalPara la tabla seleccionada (y para cualquier otra tabla de réplica) indicará que la tabla
se replicó en varias regiones.
6. Ahora puede añadir otra región para que la tabla global se replique y sincronice en los Estados Unidos
y Europa. Para ello, repita el paso 5, pero esta vez especifiqueUE (Fráncfort)en lugar deEE.UU. Oeste
(Oregón).
7. Debe seguir usando la AWS Management Console en la región us-east-2 (EE. UU. Este [Ohio]). En la
tabla Music (Música), seleccione la pestaña Items (Elementos) y, a continuación, Create Item (Crear
elemento). En Artist (Artista), escriba item_1. En SongTitle, escriba Song Value 1. Para escribir el
elemento, seleccione Save (Guardar).
Después de un breve periodo de tiempo, el elemento se replica en las tres regiones de la tabla global.
Para comprobar esto, en la consola, vaya al selector de regiones que se encuentra en la esquina
superior derecha y elijaEuropa (Fráncfort). LaMusicLa tabla de Europa (Frankfurt) debe contener el
nuevo elemento.
Siga estos pasos para crear una tabla global Music mediante la AWS CLI. En el siguiente ejemplo se crea
una tabla global con tablas de réplica en los Estados Unidos y en Europa.
1. Cree una nueva tabla (Music) en EE. UU. Este (Ohio), con DynamoDB Streams habilitada
(NEW_AND_OLD_IMAGES).
3. Cree una tabla global (Music) que consiste en tablas de réplicas en elus-east-2yus-
east-1Regiones de.
Note
El nombre de la tabla global (Music) debe coincidir con el nombre de cada una de las tablas
de réplica (Music). Para obtener más información, consulte Prácticas recomendadas y
requisitos para la administración de tablas globales (p. 386).
Versión de API 2012-08-10
390
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales
4. Cree otra tabla en Europa (Irlanda), con la misma configuración que usó en los pasos 1 y 2.
5. Para comprobar que la replicación funciona, añada un nuevo elemento alMusicEn EE. UU. Este
(Ohio).
Hay dos versiones de las tablas globales de DynamoDB disponibles: Versión 2019.11.21
(actual) (p. 372) y Versión 2017.11.29 (p. 385). Para saber qué versión utiliza, consulteDeterminación
de la versión (p. 371).
Puede utilizar Amazon CloudWatch para monitorear el comportamiento y el desempeño de una tabla
global. Amazon DynamoDB publicaReplicationLatencyyPendingReplicationCountpara cada
réplica en la tabla global.
Durante el uso normal, el valor de ReplicationLatency debería ser bastante constante. Un valor
alto de ReplicationLatency podría indicar que las actualizaciones de una réplica no se están
propagando hacia otras tablas de réplica de manera puntual. Con el tiempo, esto podría dar lugar a
que otras tablas de réplica se quedaran rezagadas, ya que dejarían de recibir actualizaciones de forma
consistente. En este caso, debería verificar que las unidades de capacidad de lectura (RCU) y de
escritura (WCU) son idénticas para cada una de las tablas de réplica. Además, al elegir la configuración
de WCU, debe seguir las recomendaciones de Prácticas recomendadas y requisitos para administrar la
capacidad (p. 387).
Para obtener más información, consulte Dimensiones y métricas de DynamoDB (p. 940).
Hay dos versiones de las tablas globales de DynamoDB disponibles: Versión 2019.11.21
(actual) (p. 372) y Versión 2017.11.29 (p. 385). Para saber qué versión utiliza, consulteDeterminación
de la versión (p. 371).
Cuando se crea una tabla global por primera vez, Amazon DynamoDB crea
automáticamente unAWS Identity and Access Management(IAM) para usted. Este rol se
denominaAWSServiceRoleForDynamoDBReplicationy permite que DynamoDB administre la
replicación entre regiones de las tablas globales. No elimine este rol vinculado a un servicio. Si lo hace, las
tablas globales no funcionarán.
Para obtener más información acerca roles vinculados a servicios, consulte Uso de roles vinculados a
servicios en la Guía del usuario de IAM.
Para crear y mantener las tablas globales en DynamoDB, debe contar con
ladynamodb:CreateGlobalTablepara acceder a cada una de las siguientes opciones:
Laapplication-autoscaling:DeleteScalingPolicyyapplication-
autoscaling:DeregisterScalableTargetcuando se actualiza una directiva de escalado existente.
Esto es para que el servicio de tablas globales pueda quitar la directiva de escala anterior antes de
adjuntar la nueva directiva a la tabla o al índice secundario.
Si utiliza una política de IAM para administrar el acceso a una tabla de réplica, debe aplicar una política
idéntica al resto de réplicas de dicha tabla global. De este modo, podrá mantener un modelo de permisos
coherente en todas las tablas de réplica.
Al usar políticas de IAM idénticas en todas las réplicas de una tabla global, puede evitar que se conceda
inintencionadamente acceso de lectura y escritura a la tabla global de datos. Pongamos como ejemplo
a un usuario que obtenga acceso a una única réplica de una tabla global. Si ese usuario puede escribir
en esa réplica, DynamoDB propagará lo que haya escrito al resto de las tablas de réplica. En efecto, el
usuario puede escribir (indirectamente) en el resto de réplicas de la tabla global. Esta situación se puede
evitar si usa políticas de IAM coherentes en todas las tablas de réplica.
Antes de agregar una réplica a una tabla global, debe contar con el permiso de
dynamodb:CreateGlobalTable de la tabla global y de cada una de sus tablas de réplica.
La siguiente política de IAM concede permisos para permitir que elCreateGlobalTableen todas las
tablas.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["dynamodb:CreateGlobalTable"],
"Resource": "*"
}
]
}
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:UpdateGlobalTable",
"dynamodb:DescribeLimits",
"application-autoscaling:DeleteScalingPolicy",
"application-autoscaling:DeregisterScalableTarget"
],
"Resource": "*"
}
]
}
Ejemplo: Permitir la acción CreateGlobalTable para un nombre de tabla global específico con
réplicas permitidas sólo en ciertas regiones
La siguiente política de IAM concede permisos para permitir que elCreateGlobalTablePara crear una
tabla global denominadaCustomerscon réplicas en dos regiones.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "dynamodb:CreateGlobalTable",
"Resource": [
"arn:aws:dynamodb::123456789012:global-table/Customers",
"arn:aws:dynamodb:us-east-1:123456789012:table/Customers",
"arn:aws:dynamodb:us-west-1:123456789012:table/Customers"
]
}
]
}
A los índices secundarios locales (LSI) y los índices secundarios globales (GSI) relacionados
con las tablas etiquetadas se les asignan automáticamente las mismas etiquetas. En la
actualidad, no se puede etiquetar el uso de DynamoDB Streams.
El etiquetado es compatible conAWSServicios como Amazon EC2, Amazon S3, DynamoDB y más. Un
etiquetado eficiente puede ofrecerle información detallada sobre los costos permitiendo crear informes
sobre los servicios que llevan una etiqueta determinada.
Por último, es conveniente seguir estrategias de etiquetado óptimas. Para obtener información,
consulteAWSEstrategias de etiquetado.
• Cada tabla puede de DynamoDB solo puede tener una etiqueta con la misma clave. Si intenta agregar
una etiqueta existente (con la misma clave), el valor de la etiqueta existente se actualiza con el valor
nuevo.
• Las claves y los valores de las etiquetas distinguen entre mayúsculas y minúsculas.
• La longitud máxima de la clave es de 128 caracteres Unicode.
• La longitud máxima del valor es de 256 caracteres Unicode.
• Los caracteres permitidos son letras, espacios en blanco y números, además de los caracteres
especiales siguientes: + - = . _ : /
• El número máximo de etiquetas por recurso es 50.
• A los nombres y valores de etiquetas asignados por AWS se les asigna automáticamente la
funciónaws:El prefijo, que no puede asignar.AWSLos nombres de etiqueta asignados no cuentan para
el límite de 50 etiquetas. Los nombres de etiquetas asignados por el usuario presentan el prefijo user:
en el informe de asignación de costos.
• No es posible antedatar la aplicación de una etiqueta.
Para la edición en bloque, también puede usar Tag Editor en la AWS Management Console. Para obtener
más información, consulte Uso de Tag Editor.
Para usar la API de DynamoDB, consulte las siguientes operaciones en laReferencia de la API de Amazon
DynamoDB:
• TagResource
• UntagResource
• ListTagsOfResource
Temas
• Establecer permisos para filtrar por etiquetas (p. 395)
• Agregar etiquetas a tablas nuevas o existentes (AWS Management Console) (p. 396)
• Agregar etiquetas a tablas nuevas o existentes (AWS CLI) (p. 397)
• tag:GetTagKeys
• tag:GetTagValues
Puede acceder a estas operaciones adjuntando una nueva política de IAM a su usuario de IAM siguiendo
los pasos que se indican a continuación.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"tag:GetTagKeys",
"tag:GetTagValues"
],
"Resource": "*"
}
]
}
Para obtener más información sobre la estructura de las etiquetas, consulte Restricciones de
etiquetado en DynamoDB (p. 395).
Para obtener más información sobre cómo crear tablas, consulte Operaciones básicas en tablas de
DynamoDB (p. 344).
• En el ejemplo siguiente se crea una nueva tabla de Movies y se añade la etiqueta Owner con un valor
de blueTeam:
• En el ejemplo siguiente se añade la etiqueta Owner con un valor de blueTeam para la tabla Movies:
• En el ejemplo siguiente se muestran todas las etiquetas asociadas con la tabla Movies:
Debe activar ambos tipos de etiquetas por separado para que puedan aparecer en Cost Explorer o en un
informe de asignación de costos.
1. Inicie sesión en laAWS Management ConsoleAbra la consola de Billing and Cost Management enhttps://
console.aws.amazon.com/billing/home#/
2. En el panel de navegación, seleccione Cost Allocation Tags.
1. Inicie sesión en laAWS Management ConsoleAbra la consola de Billing and Cost Management enhttps://
console.aws.amazon.com/billing/home#/
2. En el panel de navegación, seleccione Cost Allocation Tags.
3. En User-Defined Cost Allocation Tags, elija Activate.
En la actualidad, los datos transferidos desde DynamoDB no se desglosan según las etiquetas en
los informes de asignación de costos.
Temas
• Creación de una tabla (p. 398)
• Actualización de una tabla (p. 399)
• Eliminación de una tabla (p. 400)
• Enumeración de tablas (p. 400)
• Ejemplo: Creación, actualización, eliminación y enumeración de tablas mediante elAWS SDK for
JavaDocumentación de la API (p. 401)
Para crear una tabla con la API del AWS SDK for Java
Debe proporcionar el nombre de la tabla, las definiciones de atributos, el esquema de claves y los
valores de desempeño provisionado.
3. Ejecute lacreateTableproporcionando el objeto de solicitud como parámetro.
table.waitForActive();
La tabla no está lista para usarla hasta que DynamoDB la haya creado y haya establecido su estado
enACTIVE (ACTIVA). La solicitud createTable devuelve un objeto Table que puede usar para obtener
más información sobre la tabla.
Example
TableDescription tableDescription =
dynamoDB.getTable(tableName).describe();
Puede llamar al método describe del cliente para obtener información sobre la tabla en cualquier
momento.
Example
Para obtener más información sobre las reducciones y los incrementos de rendimiento diarios,
consulte Cuotas de servicio, cuenta y tabla en Amazon DynamoDB (p. 1066).
Para actualizar una tabla con la API del AWS SDK for Java
Example
table.updateTable(provisionedThroughput);
table.waitForActive();
Example
table.delete();
table.waitForDelete();
Enumeración de tablas
Para enumerar las tablas de la cuenta, cree una instancia deDynamoDBEjecute lalistTablesMétodo de.
LaListTablesLa operación no requiere parámetros.
Example
while (iterator.hasNext()) {
Table table = iterator.next();
System.out.println(table.getTableName());
}
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.document;
import java.util.ArrayList;
import java.util.Iterator;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.TableCollection;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.CreateTableRequest;
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.ListTablesResult;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.services.dynamodbv2.model.TableDescription;
createExampleTable();
listMyTables();
getTableInformation();
updateExampleTable();
deleteExampleTable();
try {
// key
getTableInformation();
}
catch (Exception e) {
System.err.println("CreateTable request failed for " + tableName);
System.err.println(e.getMessage());
}
while (iterator.hasNext()) {
Table table = iterator.next();
System.out.println(table.getTableName());
}
}
try {
table.updateTable(new
ProvisionedThroughput().withReadCapacityUnits(6L).withWriteCapacityUnits(7L));
table.waitForActive();
}
catch (Exception e) {
System.err.println("UpdateTable request failed for " + tableName);
System.err.println(e.getMessage());
}
}
table.waitForDelete();
}
catch (Exception e) {
System.err.println("DeleteTable request failed for " + tableName);
System.err.println(e.getMessage());
}
}
A continuación se indican los pasos comunes para las operaciones con tablas de Amazon DynamoDB
mediante laAWS SDK for .NET.
Por ejemplo, cree un objeto CreateTableRequest para crear una tabla y un objeto
UpdateTableRequest para actualizar una tabla existente.
3. Ejecute el método apropiado proporcionado por el cliente que ha creado en el paso anterior.
Note
Los ejemplos que aparecen en esta sección no funcionan con .NET Core, ya que no es
compatible con los métodos síncronos. Para obtener más información, consulteAWSAPI
asincrónicas de para .NET.
Temas
• Creación de una tabla (p. 404)
• Actualización de una tabla (p. 405)
• Eliminación de una tabla (p. 406)
• Enumeración de tablas (p. 406)
• Ejemplo: Creación, actualización, eliminación y enumeración de tablas mediante elAWS SDK
for .NETAPI de bajo nivel (p. 407)
Para crear una tabla utilizando la API de bajo nivel del AWS SDK for .NET
Debe proporcionar el nombre de la tabla, su clave principal y los valores de rendimiento aprovisionado.
3. Ejecute laAmazonDynamoDBClient.CreateTableproporcionando el objeto de solicitud como
parámetro.
Debe esperar hasta que DynamoDB cree la tabla y establezca su estado enACTIVE. La respuesta de
CreateTable incluye la propiedad TableDescription que proporciona la información necesaria sobre
la tabla.
Example
También puede llamar al método DescribeTable del cliente para obtener información sobre la tabla en
cualquier momento.
Example
Puede aumentar la capacidad de rendimiento con la frecuencia que desee y reducirla con
ciertas restricciones. Para obtener más información sobre las reducciones y los incrementos de
rendimiento diarios, consulte Cuotas de servicio, cuenta y tabla en Amazon DynamoDB (p. 1066).
Para actualizar una tabla utilizando la API de bajo nivel del AWS SDK for .NET
Example
WriteCapacityUnits = 10
}
};
var response = client.UpdateTable(request);
Para eliminar una tabla utilizando la API de bajo nivel del AWS SDK for .NET
Example
Enumeración de tablas
Para enumerar las aplicaciones de su cuenta mediante la.AWS SDK for .NETAPI de bajo nivel de, cree
una instancia deAmazonDynamoDBClientEjecute laListTablesMétodo de.
LaListTablesLa operación no requiere parámetros. Sin embargo, puede especificar parámetros opcionales.
Por ejemplo, puede establecer el parámetro Limit si desea usar la paginación para limitar el número
de nombres de tablas por página. Para ello, debe crear un objeto ListTablesRequest y proporcionar
parámetros opcionales, como se muestra en el siguiente ejemplo de C#. Además del tamaño de
página, la solicitud establece el parámetro ExclusiveStartTableName. Inicialmente, el valor de
ExclusiveStartTableName es null. Sin embargo, para recuperar la siguiente página de resultados
después de obtener la primera de ellas, deberá establecer el valor de este parámetro en la propiedad
LastEvaluatedTableName del resultado actual.
Example
lastEvaluatedTableName = result.LastEvaluatedTableName;
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using System;
using System.Collections.Generic;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;
namespace com.amazonaws.codesamples
{
class LowLevelTableExample
{
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
private static string tableName = "ExampleTable";
DeleteExampleTable();
WaitUntilTableReady(tableName);
}
Console.WriteLine(name);
lastTableNameEvaluated = response.LastEvaluatedTableName;
} while (lastTableNameEvaluated != null);
}
WaitUntilTableReady(tableName);
}
{
TableName = tableName
});
DynamoDB proporciona cuatro operaciones que aportan la funcionalidad básica de creación, lectura,
actualización y eliminación (CRUD):
Cada una de estas operaciones requiere que especifique la clave principal del elemento que se va a usar.
Por ejemplo, para leer un elemento mediante GetItem, debe especificar la clave de partición y la clave de
ordenación (si procede) de ese elemento.
Además de las cuatro operaciones CRUD básicas, DynamoDB también ofrece las siguientes:
Estas operaciones por lotes combinan varias operaciones CRUD en una sola solicitud. Además, las
operaciones por lotes leen y escriben los elementos en paralelo, para minimizar las latencias de respuesta.
Esta sección se describe cómo utilizar estas operaciones y se incluyen los temas relacionados, tales como
las actualizaciones condicionales y los contadores atómicas. Además, se facilitan ejemplos de código en
los que se utilizan los métodosAWSSDK de.
Temas
• Lectura de un elemento (p. 411)
• Escritura de un elemento (p. 411)
• Valores devueltos (p. 413)
• Operaciones por lotes (p. 414)
• Contadores atómicos (p. 416)
Lectura de un elemento
Para leer un elemento de una tabla de DynamoDB, se utiliza laGetItem. Debe proporcionar el nombre de
la tabla, así como la clave principal del elemento que se desea.
Example
En el siguiente ejemplo de la AWS CLI se muestra cómo leer un elemento de la tabla ProductCatalog.
Note
Con GetItem, es preciso especificar la clave principal completa, no solo una parte de ella.
Por ejemplo, si una tabla contiene una clave principal compuesta (clave de partición y clave de
ordenación), tendrá que proporcionar un valor para la clave de partición y un valor para la clave de
ordenación.
De forma predeterminada, una solicitud GetItem lleva a cabo una lectura consistente final. Puede usar el
parámetro ConsistentRead para solicitar una lectura de consistencia alta, si lo prefiere. (Esto consume
unidades de capacidad de lectura adicionales, pero devuelve la versión más actualizada del elemento).
GetItem devuelve todos los atributos del elemento. Puede usar una expresión de proyección para
devolver solamente algunos de los atributos. Para obtener más información, consulte Expresiones de
proyección (p. 424).
Para devolver el número de unidades de capacidad de lectura consumidas por GetItem, establezca el
parámetro ReturnConsumedCapacity en TOTAL.
Example
En el siguiente ejemplo de la AWS Command Line Interface (AWS CLI) se muestran algunos de los
parámetros de GetItem opcionales.
Escritura de un elemento
Para crear, actualizar o eliminar un elemento de una tabla de DynamoDB, utilice una de las siguientes
operaciones:
• PutItem
• UpdateItem
• DeleteItem
Para cada una de estas operaciones, debe especificar la clave principal completa, no solo parte de
ella. Por ejemplo, si una tabla contiene una clave principal compuesta (clave de partición y clave de
ordenación), tendrá que proporcionar un valor para la clave de partición y un valor para la clave de
ordenación.
Para devolver el número de unidades de capacidad de escritura consumidas por cualquiera de estas
operaciones, establezca el parámetro ReturnConsumedCapacity en uno de los valores siguientes:
PutItem
PutItem crea un elemento nuevo. Si ya existe un elemento con la misma clave en la tabla, se sustituirá
por el nuevo.
Example
Escriba un nuevo elemento en la tabla Thread. La clave principal de Thread consta de ForumName
(clave de partición) y Subject (clave de ordenación).
{
"ForumName": {"S": "Amazon DynamoDB"},
"Subject": {"S": "New discussion thread"},
"Message": {"S": "First post in this thread"},
"LastPostedBy": {"S": "fred@example.com"},
"LastPostDateTime": {"S": "201603190422"}
}
UpdateItem
Si no existe un elemento con la clave especificada, UpdateItem crea uno nuevo. De lo contrario, modifica
los atributos de un elemento existente.
Se utiliza una expresión de actualización para especificar los atributos que se desea modificar y los nuevos
valores. Para obtener más información, consulte Expresiones de actualización (p. 438).
Example
Modifique varios atributos del elemento Thread. El parámetro ReturnValues opcional muestra el
elemento tal y como aparece después de la actualización. Para obtener más información, consulte Valores
devueltos (p. 413).
{
"ForumName": {"S": "Amazon DynamoDB"},
"Subject": {"S": "New discussion thread"}
}
{
":zero": {"N":"0"},
":lastpostedby": {"S":"barney@example.com"}
}
DeleteItem
DeleteItem elimina el elemento con la clave especificada.
Example
Valores devueltos
En algunos casos, es posible que desee que DynamoDB devuelva los valores de algunos atributos tal y
como aparecen antes o después de modificarlos. Las operaciones PutItem, UpdateItem y DeleteItem
tienen un parámetro ReturnValues que se puede usar para devolver los valores de los atributos antes o
después de modificarlos.
A continuación se indican los demás ajustes válidos deReturnValues, organizado por la operación de la
API de DynamoDB.
PutItem
• ReturnValues: ALL_OLD
• Si sobrescribe un elemento existente, ALL_OLD devuelve el elemento completo tal y como aparecía
antes de sobrescribirlo.
UpdateItem
Lo más frecuente es usar UpdateItem para actualizar un elemento existente. Sin embargo, UpdateItem
en realidad lleva a cabo una operación upsert (actualización/inserción). Esto quiere decir que creará el
elemento automáticamente si este no existe.
• ReturnValues: ALL_OLD
• Si actualiza un elemento existente, ALL_OLD devuelve el elemento completo tal y como aparecía
antes de actualizarlo.
• Si actualiza un elemento que no existía (upsert), ALL_OLD no surte efecto.
• ReturnValues: ALL_NEW
• Si actualiza un elemento existente, ALL_NEW devuelve el elemento completo tal y como aparece
después de actualizarlo.
• Si actualiza un elemento que no existía (upsert), ALL_NEW devuelve el elemento completo.
• ReturnValues: UPDATED_OLD
• Si actualiza un elemento existente, UPDATED_OLD devuelve solamente los atributos actualizados, tal y
como aparecían antes de la actualización.
• Si actualiza un elemento que no existía (upsert), UPDATED_OLD no surte efecto.
• ReturnValues: UPDATED_NEW
• Si actualiza un elemento existente, UPDATED_NEW devuelve solamente los atributos afectados, tal y
como aparecen después de la actualización.
• Si actualiza un elemento que no existía (upsert), UPDATED_NEW devuelve solamente los atributos
actualizados, tal y como aparecen después de la actualización.
DeleteItem
• ReturnValues: ALL_OLD
• Si elimina un elemento existente, ALL_OLD devuelve el elemento completo tal y como aparecía antes
de eliminarlo.
• Si elimina un elemento que no existía, ALL_OLD no devuelve ningún dato.
En esencia, las operaciones por lotes son encapsuladores que incluyen varias solicitudes de
lectura o escritura. Por ejemplo, si unBatchGetItemcontiene cinco elementos, DynamoDB realiza
cincoGetItemen su nombre. Del mismo modo, si unBatchWriteItemLa solicitud contiene dos
solicitudes de colocación y cuatro de eliminación, DynamoDB lleva a cabo dos solicitudes de
colocaciónPutItemy cuatroDeleteItemsolicitudes.
En general, una operación por lotes no genera un error a no ser que todas las solicitudes del lote generen
un error. Por ejemplo, suponga que lleva a cabo una operación BatchGetItem, pero que se produce un
error en una de las solicitudes GetItem individuales del lote. En este caso, BatchGetItem devolverá
Versión de API 2012-08-10
414
Amazon DynamoDB Guía para desarrolladores
Operaciones por lotes
las claves y los datos de la solicitud GetItem en la que se ha producido el error. Las demás solicitudes
GetItem del lote no se ven afectadas.
BatchGetItem
Una solaBatchGetItemLa operación puede contener hasta 100GetItemSolicite hasta 16 MB de datos.
Además, una operación BatchGetItem puede recuperar elementos de varias tablas.
Example
Recupere dos elementos de la tabla Thread usando una expresión de proyección para devolver solo
algunos de los atributos.
{
"Thread": {
"Keys": [
{
"ForumName":{"S": "Amazon DynamoDB"},
"Subject":{"S": "DynamoDB Thread 1"}
},
{
"ForumName":{"S": "Amazon S3"},
"Subject":{"S": "S3 Thread 1"}
}
],
"ProjectionExpression":"ForumName, Subject, LastPostedDateTime, Replies"
}
}
BatchWriteItem
LaBatchWriteItemLa operación puede contener hasta 25PutItemyDeleteItemSolicite y puede
escribir hasta 16 MB de datos. El tamaño máximo de un elemento individual es de 400 KB. Además, una
operación BatchWriteItem puede colocar o eliminar elementos en varias tablas.
Note
Example
{
"ProductCatalog": [
{
"PutRequest": {
"Item": {
"Id": { "N": "601" },
Contadores atómicos
Puede utilizar la herramienta deUpdateItempara implementar una operacióncontador atómicoUn atributo
numérico que se incrementa de forma incondicional y sin interferir con las demás solicitudes de escritura.
Todas las solicitudes de escritura se aplican en el orden en que se reciben. Con un contador atómico, las
actualizaciones no son idempotentes. Esto significa que el valor numérico aumenta cada vez que se llame
a UpdateItem.
Es posible utilizar un contador atómico para realizar el seguimiento del número de visitantes de un sitio
web. En este caso, la aplicación incrementaría un valor numérico, independientemente del valor actual.
En caso de error en la operación UpdateItem, la aplicación podría simplemente volver a intentar la
operación. Aunque se correría el riesgo de actualizar dos veces el contador, seguramente sería tolerable
un pequeño margen de error al alza o a la baja en el número de visitantes del sitio web.
Un contador atómico no sería adecuado en aquellos casos en que no fuese admisible un margen de error
al alza o a la baja (por ejemplo, en una aplicación bancaria). En este caso, es más seguro utilizar una
actualización condicional en lugar de un contador atómico.
Para obtener más información, consulte Aumento y reducción de atributos numéricos (p. 442).
Example
En el siguiente ejemplo de la AWS CLI se incrementa el valor de Price de un producto en 5. (Dado que
UpdateItem no es idempotente, el valor de Price se aumentará cada vez que se ejecute el ejemplo).
Escrituras condicionales
De forma predeterminada, las operaciones de escritura de DynamoDB
(PutItem,UpdateItem,DeleteItem) sonincondicional: Cada una de ellas sobrescribirá un elemento
existente que tenga la clave principal especificada.
Opcionalmente, DynamoDB admite las escrituras condicionales para estas operaciones. Una escritura
condicional solamente se lleva a cabo si los atributos del elemento cumplen una o varias de las
condiciones esperadas. En caso contrario, devuelve un error. Las escrituras condicionales resultan útiles
en muchas situaciones. Por ejemplo, puede ser conveniente que una operación PutItem solamente se
lleve a cabo si no existe ningún elemento que tenga la misma clave principal. O puede que desee impedir
que una operación UpdateItem modifique un elemento si uno de sus atributos tiene un valor determinado.
Las escrituras condicionales son útiles en aquellos casos en que varios usuarios intentan modificar el
mismo elemento. Fíjese en el siguiente diagrama, en el que dos usuarios (Alice y Bob) trabajan con el
mismo elemento de una tabla de DynamoDB.
Suponga que Alice utiliza la AWS CLI para actualizar el atributo Price a 8.
{
":newval":{"N":"8"}
}
Ahora, supongamos que Bob emite una solicitud UpdateItem parecida más adelante, pero cambia el
valor de Price a 12. Para Bob, el parámetro --expression-attribute-values tendrá el siguiente
aspecto:
{
":newval":{"N":"12"}
}
Bob la solicitud de Bob se lleva a cabo, pero se pierde la actualización previa de Alice.
Para solicitar una operación PutItem, DeleteItem o UpdateItem condicional, debe especificar una
expresión de condición. Una expresión de condición es una cadena que contiene nombres de atributos,
operadores condicionales y funciones integradas. La totalidad de expresión debe evaluarse en true. De lo
contrario, la operación no se llevará a cabo correctamente.
Ahora, fíjese en el siguiente diagrama, en el que se muestra que el uso de escrituras condicionales
impediría que la actualización de Alice se sobrescribiese.
Alice intenta actualizar el valor de Price a 8, pero solamente si el valor de Price actual es 10.
{
":newval":{"N":"8"},
":currval":{"N":"10"}
}
La actualización de Alice se lleva a cabo correctamente porque el resultado de evaluar la condición es true.
A continuación, Bob intenta actualizar el valor de Price a 12, pero solamente si el valor de Price actual
es 10. Para Bob, el parámetro --expression-attribute-values tendrá el siguiente aspecto:
{
":newval":{"N":"12"},
":currval":{"N":"10"}
}
Dado que Alice ha cambiado previamente el valor de Price a 8, la expresión de condición se evalúa en
false, de modo que la actualización de Bob no se lleva a cabo.
Por ejemplo, suponga que emite una solicitud UpdateItem para aumentar el valor de Price de un
elemento en 3, pero solamente si el valor de Price actual es 20. Después de enviar la solicitud, pero
antes de recibir su resultado, se produce un error en la red y usted no sabe si la solicitud se ha realizado
correctamente. Como esta escritura condicional es idempotente, puede reintentar el mismoUpdateItemy
DynamoDB actualiza el elemento solo si elPricees actualmente 20.
Note
Para devolver el número de unidades de capacidad de escritura consumidas durante una escritura
condicional, se usa el parámetro ReturnConsumedCapacity:
• INDEXES: devuelve el número total de unidades de capacidad de escritura consumidas, con subtotales
para la tabla y todos los índices secundarios que se hayan visto afectados por la operación.
• NONE: no devuelve ningún dato de capacidad de escritura. (Esta es la opción predeterminada.)
Note
Temas
• Especificación de atributos de elemento al utilizar expresiones (p. 421)
• Expresiones de proyección (p. 424)
• Nombres de atributos de expresión en DynamoDB (p. 425)
• Valores de los atributos de expresión (p. 428)
• Expresiones de condición (p. 428)
• Expresiones de actualización (p. 438)
Temas
• Atributos de nivel superior (p. 422)
• Atributos anidados (p. 423)
• Rutas de documento (p. 423)
{
"Id": 123,
"Title": "Bicycle 123",
• Id
• Title
• Description
• BicycleType
• Brand
• Price
• Color
• ProductCategory
• InStock
• QuantityOnHand
• RelatedItems
• Pictures
• ProductReviews
• Comment
• Safety.Warning
Todos estos atributos de nivel superior son escalares, con la salvedad de Color (lista), RelatedItems
(lista), Pictures (mapa) y ProductReviews (mapa).
Atributos anidados
Se considera que un atributo es anidado si está integrado en otro atributo. Para obtener acceso a un
atributo anidado, se utilizan los operadores de desreferenciación:
• MyList[0]
• AnotherList[12]
• ThisList[5][11]
El número contenido entre corchetes debe ser un entero no negativo. Por lo tanto, las siguientes
expresiones no son válidas:
• MyList[-1]
• MyList[0.4]
El operador de desreferenciación de una entrada de un mapa es . (un punto). Utilice el punto como
separador entre las entradas de un mapa:
• MyMap.nestedField
• MyMap.nestedField.deeplyNestedField
Rutas de documento
En una expresión, se utiliza unruta de documentopara indicar a DynamoDB dónde encontrar un atributo.
En el caso de un atributo de nivel superior, la ruta de documento es el nombre de atributo. En el caso de
un atributo anidado, se utilizan operadores de desreferenciación para construir la ruta de documento.
Description
• Atributo de lista de nivel superior. (Devuelve la lista completa, no solo algunos de los componentes).
RelatedItems
• Tercera entrada de la lista RelatedItems. Recuerde que las entradas de lista se basan en cero.
RelatedItems[2]
• Imagen frontal del producto.
Pictures.FrontView
• Todas las opiniones de cinco estrellas.
ProductReviews.FiveStar
• Primera de las opiniones de cinco estrellas.
ProductReviews.FiveStar[0]
Note
La profundidad máxima de una ruta de documento es 32. Por lo tanto, el número de operadores
de desreferenciación de una ruta no puede superar este límite.
Puede utilizar cualquier nombre de atributo en una ruta de documento, siempre y cuando el primer carácter
sea a-z o A-Z y el segundo carácter (si lo hay) sea a-z, A-Z o 0-9. Si un nombre de atributo no cumple
este requisito, tendrá que definir un nombre de atributo de expresión como marcador de posición. Para
obtener más información, consulte Nombres de atributos de expresión en DynamoDB (p. 425).
Expresiones de proyección
Para leer datos de una tabla de, se utilizan operaciones tales comoGetItem,Query, o bienScan. De forma
predeterminada, Amazon DynamoDB devuelve todos los atributos de los elementos. Si desea obtener solo
uno en lugar de todos ellos, debe usar una expresión de proyección.
Una expresión de proyección es una cadena que identifica los atributos que se desea. Para recuperar un
solo atributo, especifique su nombre. Si desea obtener varios atributos, separe sus nombres mediante
comas.
Title
• Tres atributos de nivel superior. DynamoDB recupera todo elColorSet.
Puede utilizar cualquier nombre de atributo en una expresión de proyección, siempre y cuando el primer
carácter sea a-z o A-Z y el segundo carácter (si lo hay) sea a-z, A-Z o 0-9. Si un nombre de atributo no
cumple este requisito, tendrá que definir un nombre de atributo de expresión como marcador de posición.
Para obtener más información, consulte Nombres de atributos de expresión en DynamoDB (p. 425).
En el ejemplo de la AWS CLI siguiente se muestra cómo usar una expresión de proyección con
una operación GetItem. La expresión de proyección recupera un atributo escalar de nivel superior
(Description), la primera entrada de una lista (RelatedItems[0]) y una lista anidada en un mapa
(ProductReviews.FiveStar).
{
"Id": { "N": "123" }
}
Para obtener ejemplos de código específicos de los lenguajes de programación, consulte Introducción a
DynamoDB yAWSSDK de (p. 82).
En esta sección se describen varias situaciones en las que debe utilizar nombres de atributos de
expresión.
Note
En los ejemplos de esta sección se utiliza la AWS Command Line Interface (AWS CLI). Para
obtener ejemplos de código específicos de los lenguajes de programación, consulte Introducción a
DynamoDB yAWSSDK de (p. 82).
Temas
• Palabras reservadas (p. 425)
• Nombres de atributo que contienen puntos (p. 426)
• Atributos anidados (p. 426)
• Repetición de nombres de atributos (p. 427)
Palabras reservadas
En algunas ocasiones, es posible que necesite escribir una expresión que contenga un nombre de atributo
que entre en conflicto con una palabra reservada de DynamoDB. Para obtener una lista completa de
palabras reservadas, consulte Palabras reservadas en DynamoDB (p. 1135).
Por ejemplo, el siguiente ejemplo de la AWS CLI no funcionaría correctamente porque COMMENT es una
palabra reservada,
--key '{"Id":{"N":"123"}}' \
--projection-expression "Comment"
Para solucionar este problema, puede sustituir Comment por un nombre de atributo de expresión; por
ejemplo, #c. El símbolo de almohadilla (#) es obligatorio e indica que se trata de un marcador de posición
del nombre de un atributo. Ahora, el ejemplo de la AWS CLI tendría el siguiente aspecto.
Note
Supongamos que desea obtener acceso a Safety.Warning mediante una expresión de proyección.
DynamoDB podría devolver un resultado vacío, en lugar de la cadena prevista (»Always wear a
helmet«). Esto se debe a que DynamoDB interpreta el punto en una expresión como un separador de
ruta de documento. En este caso, tiene que definir un nombre de atributo de expresión (por ejemplo, #sw)
como sustituto de Safety.Warning. A continuación, podría utilizar la siguiente expresión de proyección.
Atributos anidados
Supongamos que desea obtener acceso al atributo anidado ProductReviews.OneStar, utilizando la
siguiente expresión de proyección.
El resultado podría contener todas las opiniones sobre productos de una sola estrella, que es lo previsto.
Pero ¿qué sucedería si utiliza en su lugar un nombre de atributo de expresión? Por ejemplo, ¿qué ocurriría
si definiese #pr1star como sustituto de ProductReviews.OneStar?
DynamoDB podría devolver un resultado vacío, en lugar del mapa previsto de opiniones de una sola
estrella. Esto se debe a que DynamoDB interpreta el punto en el nombre de un atributo de expresión
como un carácter del nombre del atributo. Cuando DynamoDB evalúa el nombre del atributo de
expresión#pr1star, determina queProductReviews.OneStarSe refiere a un atributo escalar, que no
es lo que estaba previsto.
El enfoque correcto consiste en definir un nombre de atributo de expresión para cada componente de la
ruta del documento:
• #pr — ProductReviews
• #1star — OneStar
Para que resulte más concisa, puede sustituir ProductReviews por un nombre de atributo de expresión,
como #pr. Ahora, la expresión revisada tendría el siguiente aspecto.
Si define un nombre de atributo de expresión, debe usarlo de forma coherente en toda la expresión.
Además, es importante no omitir el signo #.
Por ejemplo, supongamos que desea devolver todos los elementos de ProductCatalogque estén
disponibles en el color Black y tengan un precio de 500 o menos. Podría utilizar una operación Scan con
una expresión de filtro, como en este ejemplo de la AWS Command Line Interface (AWS CLI).
{
":c": { "S": "Black" },
":p": { "N": "500" }
}
Note
Una operación de Scan lee todos los elementos de una tabla. Debe evitar utilizar Scan con tablas
grandes.
La expresión de filtro se aplica a los resultados de Scan y los elementos que no coinciden con la
expresión de filtro se descartan.
Si define un valor de atributo de expresión, debe usarlo de forma coherente en toda la expresión. Además,
es importante no omitir el signo :.
Los valores de atributos de expresión se usan con expresiones de condición clave, expresiones de
condición, expresiones de actualización y expresiones de filtro.
Note
Para obtener ejemplos de código específicos de los lenguajes de programación, consulte
Introducción a DynamoDB yAWSSDK de (p. 82).
Expresiones de condición
Para manipular datos en una tabla de Amazon DynamoDB, utilice elPutItem,UpdateItem,
yDeleteItemoperaciones. También puede utilizar BatchWriteItem para realizar varias operaciones
PutItem o DeleteItem en una sola llamada.
Para estas operaciones de manipulación de datos, puede especificar una expresión de condición con el fin
de determinar qué elementos deben modificarse. Si la expresión de condición se evalúa en true, entonces
la operación se realiza correctamente; de lo contrario, se produce un error.
--item file://item.json
Los argumentos de --item se almacenan en el archivo item.json. Para simplificar, se utilizan tan solo
algunos de los atributos de elementos.
{
"Id": {"N": "456" },
"ProductCategory": {"S": "Sporting Goods" },
"Price": {"N": "650" }
}
Temas
• PUT condicional (p. 429)
• Eliminaciones condicionales (p. 429)
• Actualizaciones condicionales (p. 430)
• Ejemplos de expresiones condicionales (p. 431)
• Operador de comparación y referencia de funciones (p. 433)
PUT condicional
La operación PutItem sobrescribe un elemento que tenga la misma clave (si existe). Si desea evitar que
esto suceda, utilice una expresión de condición. Esto permite que la escritura se lleve a cabo únicamente si
el elemento en cuestión no tiene la misma clave.
Si la expresión de condición se evalúa en false, DynamoDB devuelve el siguiente mensaje de error: The
conditional request failed (Error en la solicitud condicional).
Note
Para obtener más información sobre attribute_not_exists y otras funciones, consulte
Operador de comparación y referencia de funciones (p. 433).
Eliminaciones condicionales
Para realizar una eliminación condicional, se usa una operación DeleteItem con una expresión de
condición. La expresión de condición debe evaluarse en true para que la operación se lleve a cabo
correctamente; de lo contrario, se produce un error.
{
"Id": {
"N": "456"
},
"Price": {
"N": "650"
},
"ProductCategory": {
"S": "Sporting Goods"
}
}
Suponga que desea eliminar el elemento, pero solo en las siguientes condiciones:
{
":cat1": {"S": "Sporting Goods"},
":cat2": {"S": "Gardening Supplies"},
":lo": {"N": "500"},
":hi": {"N": "600"}
}
Note
En la expresión de condición, el:(carácter de dos puntos) indica unExpresión de valor de atributo:
un marcador de posición para un valor real. Para obtener más información, consulte Valores de
los atributos de expresión (p. 428).
Para obtener más información sobre IN, AND y otras palabras clave, consulte Operador de
comparación y referencia de funciones (p. 433).
Actualizaciones condicionales
Para realizar una actualización condicional, se usa una operación UpdateItem con una expresión de
condición. La expresión de condición debe evaluarse en true para que la operación se lleve a cabo
correctamente; de lo contrario, se produce un error.
Note
UpdateItem también admite las expresiones de actualización, donde especifica las
modificaciones que se desea aplicar a un elemento. Para obtener más información, consulte
Expresiones de actualización (p. 438).
Supongamos que ha comenzado por el elemento mostrado en Expresiones de condición (p. 428).
{
"Id": { "N": "456"},
"Price": {"N": "650"},
"ProductCategory": {"S": "Sporting Goods"}
}
En el ejemplo siguiente se realiza una operación UpdateItem. Intenta reducir elPriceDe un producto por
75, pero la expresión de condición impide la actualización si el valor dePricees inferior o igual a 500.
{
":discount": { "N": "75"},
":limit": {"N": "500"}
}
Si el valor inicial de Price es 650, la operación UpdateItem reduce el Price a 575. Si ejecuta la
operación UpdateItem de nuevo, el valor de Price se reduce a 500. Si se ejecuta una tercera vez, la
expresión de condición se evalúa en false y la actualización no se lleva a cabo.
Note
En el ejemplo siguiente se utiliza attribute_type para eliminar un producto sólo si tiene un atributo
Color de tipo String Set.
{
":v_sub":{"S":"SS"}
}
Puede comprobar si un valor de atributo String comienza con una subcadena determinada mediante la
función begins_with. Si la expresión de condición se evalúa en true, entonces la operación se realiza
correctamente; de lo contrario, produce un error.
En el ejemplo siguiente se utiliza begins_with para eliminar un producto solo si el elemento FrontView
del mapa Pictures comienza con un valor específico.
{
":v_sub":{"S":"http://"}
}
Puede buscar un elemento en un conjunto o buscar una subcadena dentro de una cadena mediante el uso
de la función contains. Si la expresión de condición se evalúa en true, entonces la operación se realiza
correctamente; de lo contrario, produce un error.
En el ejemplo siguiente se utiliza contains para eliminar un producto sólo si el conjunto de cadenas
Color tiene un elemento con un valor específico.
{
":v_sub":{"S":"Red"}
}
En el ejemplo siguiente se utiliza size para eliminar un producto sólo si el tamaño del atributo Binary
VideoClip es mayor de 64000 bytes.
{
":v_sub":{"N":"64000"}
}
Temas
• Sintaxis de las expresiones de condición (p. 433)
• Realización de comparaciones (p. 434)
• Functions (p. 434)
• Evaluaciones lógicas (p. 438)
• Parentheses (p. 438)
• Precedencia en las condiciones (p. 438)
• Un nombre de atributo de nivel superior, como por ejemplo Id, Title, Description o
ProductCategory
• Una ruta de documento que hace referencia a un atributo anidado
condition-expression ::=
operand comparator operand
| operand BETWEEN operand AND operand
| operand IN ( operand (',' operand (, ...) ))
| function
| condition AND condition
| condition OR condition
| NOT condition
| ( condition )
comparator ::=
=
| <>
| <
| <=
| >
| >=
function ::=
attribute_exists (path)
| attribute_not_exists (path)
| attribute_type (path, type)
| begins_with (path, substr)
| contains (path, operand)
| size (path)
Realización de comparaciones
Utilice estos comparadores para comparar un operando con un rango o una lista de valores:
Use las palabras clave BETWEEN e IN para comparar un operando con un rango o una lista de valores:
Functions
Utilice las siguientes funciones para determinar si un atributo existe en un elemento o evaluar el valor de
un atributo. Los nombres de estas funciones distinguen entre mayúsculas y minúsculas. En el caso de los
atributos anidados, debe proporcionar su ruta de documento completa.
Función Descripción
• attribute_exists (Pictures.SideView)
• attribute_not_exists (Manufacturer)
• S — Cadena
Función Descripción
• SS: String Set
• N: Number
• NS: Number Set
• B: Binary
• BS: Binary Set
• BOOL — Booleano
• NULL — Null
• L — List
• M: Map
• attribute_type
(ProductReviews.FiveStar, :v_sub)
• begins_with
(Pictures.FrontView, :v_sub)
Función Descripción
Función Descripción
• size(ProductReviews.OneStar)
> :v_sub
Evaluaciones lógicas
Utilice las palabras clave AND, OR y NOT para llevar a cabo evaluaciones lógicas. En la lista siguiente, a y b
representan las condiciones que se van a evaluar.
Parentheses
Los paréntesis se utilizan para cambiar la preferencia de una evaluación lógica. Por ejemplo, supongamos
que las condiciones a y b son true y que la condición c es false. La siguiente expresión se evalúa en true:
• a OR b AND c
Sin embargo, si se incluye una condición entre paréntesis, esta se evalúa antes. Por ejemplo, lo siguiente
se evalúa en false:
• (a OR b) AND c
Note
En una expresión se pueden utilizar paréntesis anidados. En este caso, se evalúan primero los
más internos.
Expresiones de actualización
Para actualizar un elemento existente de una tabla de Amazon DynamoDB, utilice elUpdateItem. Es
preciso proporcionar la clave del elemento que se desea actualizar. Asimismo, debe proporcionar una
expresión de actualización que indique los atributos que se van a modificar y los valores que se les
asignarán.
update-expression ::=
[ SET action [, action] ... ]
[ REMOVE action [, action] ...]
Una expresión de actualización consta de una o varias cláusulas. Cada cláusula comienza con una palabra
clave SET, REMOVE, ADD o DELETE. Puede incluir cualquiera de estas cláusulas en una expresión de
actualización, en cualquier orden. Sin embargo, cada palabra clave de acción solo puede aparecer una
vez.
Cada cláusula contiene una o más acciones, separadas por comas. Cada acción representa una
modificación de datos.
Los ejemplos que aparecen en esta sección se basan en el elemento ProductCatalog que se muestra
en Expresiones de proyección (p. 424).
Temas
• SET: modificación o adición de atributos de elementos (p. 439)
• REMOVE: eliminación de atributos de un elemento (p. 443)
• ADD: actualización de números y conjuntos (p. 444)
• DELETE: eliminación de componentes de un conjunto (p. 445)
También puede utilizar SET para sumar o restar un valor de un atributo de tipo Number. Para llevar a cabo
varias acciones SET, debe separarlas por comas.
set-action ::=
path = value
value ::=
operand
| operand '+' operand
| operand '-' operand
operand ::=
path | function
La siguiente operación PutItem crea un elemento de muestra al que se refieren los ejemplos.
Los argumentos de --item se almacenan en el archivo item.json. Para simplificar, se utilizan tan solo
algunos de los atributos de elementos.
{
"Id": {"N": "789"},
"ProductCategory": {"S": "Home Improvement"},
Temas
• Modificación de atributos (p. 440)
• Adición de listas y mapas (p. 440)
• Adición de componentes a una lista (p. 441)
• Adición de atributos de mapa anidados (p. 441)
• Aumento y reducción de atributos numéricos (p. 442)
• Adición de componentes a una lista (p. 442)
• Cómo evitar sobrescribir un atributo existente (p. 443)
Modificación de atributos
Example
Actualice los atributos ProductCategory y Price.
{
":c": { "S": "Hardware" },
":p": { "N": "60" }
}
Note
En el navegadorUpdateItemfuncionamiento,--return-values ALL_NEWHace que
DynamoDB devuelva el elemento tal y como aparece después de la actualización.
Example
Agregue una lista y un mapa nuevos.
{
":ri": {
"L": [
{ "S": "Hammer" }
]
},
":pr": {
"M": {
"FiveStar": {
"L": [
{ "S": "Best product ever!" }
]
}
}
}
}
Example
Agregue un nuevo atributo a la lista RelatedItems. Recuerde que las entradas de lista están basadas en
cero; es decir, [0] representa la primera entrada de la lista, [1] representa la segunda, y así sucesivamente.
{
":ri": { "S": "Nails" }
}
Note
Cuando se utiliza SET para actualizar una entrada de lista, el contenido de esa entrada se
sustituye por los nuevos datos que ha especificado. Si el componente no existe, SET adjunta el
nuevo componente al final de la lista.
Si agrega varias entradas en una misma operación SET, las entradas se ordenan según su
número.
Example
Agregue algunos atributos de mapa anidados.
{
"#pr": "ProductReviews",
"#5star": "FiveStar",
"#3star": "ThreeStar"
}
{
":r5": { "S": "Very happy with my purchase" },
":r3": {
"L": [
{ "S": "Just OK - not that great" }
]
}
}
Example
Reduzca el Price de un elemento.
La función toma dos listas como entrada y anexa todos los elementos de list2 a list1.
Example
En Adición de componentes a una lista (p. 441), ha creado la lista RelatedItems y ha incluido
en ella dos componentes: Hammer y Nails. Ahora, va a agregar dos componentes más al final de
RelatedItems.
{
":vals": {
"L": [
{ "S": "Screwdriver" },
{"S": "Hacksaw" }
]
}
}
Por último, vamos a agregar un componente más al principio de RelatedItems. Para ello, invierta
el orden de los componentes de list_append. (Recuerde que list_append toma dos listas como
información de entrada y agrega la segunda lista a la primera).
Ahora, el atributo RelatedItems resultante contiene cinco entradas, el siguiente orden: Chisel, Hammer,
Nails, Screwdriver y Hacksaw.
Example
Establezca el valor de Price de un elemento, pero solo si este no tiene ya un atributo Price. (Si Price
ya existe, no sucede nada).
remove-action ::=
path
Example
Elimine algunos atributos de un elemento. (Si el atributo no existe, no sucede nada).
Example
En Adición de componentes a una lista (p. 442), ha modificado un atributo de lista (RelatedItems) para
que contenga cinco componentes:
• [0]—Chisel
• [1]—Hammer
• [2]—Nails
• [3]—Screwdriver
• [4]—Hacksaw
En el siguiente ejemplo de la AWS Command Line Interface (AWS CLI) se eliminan Hammer y Nails de la
lista.
Después de eliminar Hammer y Nails, los componentes restantes se reordenan. Ahora, la lista contiene lo
siguiente:
• [0]—Chisel
• [1]—Screwdriver
• [2]—Hacksaw
Utilice la acción ADD en una expresión de actualización para agregar un nuevo atributo y sus valores a un
elemento.
Si el atributo ya existe, el comportamiento de ADD depende del tipo de datos del atributo:
• Si el atributo es un número y el valor que se agrega también es un número, entonces el valor se suma
matemáticamente al atributo existente. (Si el valor es un número negativo, entonces se resta del atributo
existente).
• Si el atributo es un conjunto y el valor que se agrega también es un conjunto, entonces el valor se
agrega al conjunto existente.
Note
La acción ADD solo es compatible con los tipos de datos Number y Set.
Para llevar a cabo varias acciones ADD, debe separarlas por comas.
• El componente path es la ruta de documento de un atributo. El tipo de datos del atributo debe ser
Number o Set.
• El componente value es un número que se desea agregar al atributo (si el tipo de datos es Number) o
un conjunto que se desea agregar al atributo (si el tipo de datos es Set).
add-action ::=
path value
Adición de un número
Ahora que QuantityOnHand ya existe, puede volver a ejecutar el ejemplo para incrementar
QuantityOnHand en 5 cada vez.
Supongamos que el atributo Color no existe. En el siguiente ejemplo de la AWS CLI, Color se establece
en un conjunto de cadenas que contiene dos componentes.
Utilice la acción DELETE en una expresión de actualización para eliminar una o varias entradas de un
conjunto. Para llevar a cabo varias acciones DELETE, debe separarlas por comas.
• El componente path es la ruta de documento de un atributo. El tipo de datos del atributo debe ser Set.
• Subset representa uno o varios componentes que se van a eliminar de path. Para subset debe
especificar un tipo de datos Set.
delete-action ::=
path value
Example
En Adición de componentes a un conjunto (p. 445), crea el conjunto de cadenas Color. En este ejemplo
se eliminan algunos de los componentes de ese conjunto.
TTL es útil si almacena elementos que pierden relevancia después de un tiempo específico. A
continuación, se muestran casos de uso de TTL de ejemplo:
• Elimine datos del usuario o del sensor después de un año de inactividad en una aplicación.
• Archive los elementos caducados en un lago de datos de Amazon S3 a través de Amazon DynamoDB
Streams yAWS Lambda.
• Retenga la información confidencial durante un periodo determinado de tiempo de acuerdo con las
obligaciones contractuales o reglamentarias.
habilitar TTL en una tabla, un proceso en segundo plano del escáner por partición evalúa de forma
automática y continua el estado de vencimiento de los elementos de la tabla.
El proceso en segundo plano del escáner compara la hora actual, en formato de tiempo Unix en segundos,
con el valor almacenado en el atributo definido por el usuario de un elemento. Si el atributo es unNumber,
el valor del atributo es una marca de tiempo enFormato de tiempo de época Unixinsegundos, y el valor
de marca temporal es anterior a la hora actual, pero no cinco años más o más (para evitar una posible
eliminación accidental debido a un valor de TTL mal formado), entonces el elemento se establece en
vencido. Para obtener información detallada sobre dar formato a atributos de TTL, consulteDar formato
al atributo de TTL de un elemento (p. 449). Un segundo proceso en segundo plano busca elementos
vencidos y los elimina. Los dos procesos tienen lugar automáticamente en segundo plano, no afectan al
tráfico de lectura ni de escritura en la tabla y no tienen un costo monetario.
A medida que los elementos se eliminan de la tabla, se producen dos operaciones en segundo plano
simultáneamente:
• Los elementos se eliminan de cualquier índice secundario local e índice secundario global del mismo
modo que una operación DeleteItem.
• Una operación de eliminación para cada elemento escribe DynamoDB Stream, pero se etiqueta como
una eliminación del sistema y no como una eliminación regular. Para obtener más información acerca de
cómo utilizar esta eliminación de sistema, consulte DynamoDB Streams y Tiempo de vida.
Important
• En función del tamaño y el nivel de actividad de una tabla, la operación de eliminación real
de un elemento vencido puede variar. Debido a que TTL está destinado a ser un proceso en
segundo plano, la naturaleza de la capacidad utilizada para el vencimiento y la eliminación
de elementos a través de TTL es variable (pero gratuita). TTL suele eliminar los elementos
vencidos en el plazo de 48 horas desde su vencimiento.
• Los elementos que han vencido, pero TTL todavía no ha eliminado, siguen apareciendo en
lecturas, consultas y análisis. Si no desea elementos vencidos en el conjunto de resultados,
debe filtrarlos. Para ello, utilice una expresión de filtro que devuelva solo los elementos en
los que el valor de vencimiento de Tiempo de vida sea posterior a la fecha y hora actuales en
formato de tiempo Unix. Para obtener más información, consulte Expresiones de filtro para
Scan (p. 516).
• Los elementos que hayan pasado su fecha de vencimiento pero que aún no se hayan eliminado
pueden actualizarse y se respetarán las actualizaciones correctas para cambiar o quitar el
atributo de vencimiento.
Puede monitorear las tasas de TTL en la pestaña de métricas de CloudWatch para una tabla y consultar
cuándo se eliminan los elementos y a qué velocidad.
SessionData
En este ejemplo, cada elemento tiene un valor del atributo ExpirationTime que se establece al crearlo.
Considere el siguiente elemento de la tabla.
SessionData
Temas
• Dar formato al atributo de TTL de un elemento (p. 449)
• Notas de uso (p. 449)
• Solución de problemas de TTL (p. 450)
• El elemento debe contener el atributo especificado cuando se habilitó TTL en la tabla. Por ejemplo, si
especifica que una tabla utilice el nombre del atributo expdate como atributo de TTL, pero un elemento
no tiene un atributo con ese nombre, el proceso de TTL ignora el elemento.
• El valor del atributo de TTL debe ser un tipo de datos Number. Por ejemplo, si especifica que una tabla
utilice el nombre del atributo expdate como atributo de TTL, pero el atributo de un elemento es un tipo
de datos String, los procesos de TTL ignoran el elemento.
• El valor del atributo de TTL debe ser una marca temporal en formato de tiempo Unix en segundos.
Si utiliza cualquier otro formato, los procesos de TTL ignoran el elemento. Por ejemplo, si establece
el valor del atributo en 1645119622, es decir, jueves 17 de febrero de 2022 17:40:22 h (GMT), el
elemento vencerá después de ese momento. Para obtener un formulario web visual para probar valores
y consultar ejemplos de código para diferentes lenguajes para el formato de tiempo Unix, consulte Epoch
Converter.
• El valor del atributo de TTL debe ser una fecha y hora con un vencimiento de no más de cinco años en
el pasado. Por ejemplo, si establece el valor del atributo en 1171734022, es decir, 17 de febrero de 2007
17:40:22 h (GMT) y más de cinco años. Como resultado, los procesos TTL no caducarán ese elemento.
Notas de uso
Al usar TTL, tenga en cuenta lo siguiente:
• Habilitar, desactivar o cambiar la configuración de TTL en una tabla puede tardar aproximadamente una
hora en propagarse la configuración y permitir la ejecución de cualquier otra acción relacionada con TTL.
• No se puede volver a configurar TTL para buscar un atributo diferente. Debe desactivar TTL y, a
continuación, volver a habilitar TTL con el nuevo atributo en el futuro.
• Cuando usaAWS CloudFormation, puede habilitar TL al crear una tabla de DynamoDB. Para obtener
más información, consulte la Guía del usuario de AWS CloudFormation.
• Puede usarAWS Identity and Access ManagementPara impedir actualizaciones no autorizadas
del atributo TTL en un elemento o la configuración de TTL. Si permite el acceso solo a acciones
especificadas en las políticas de IAM existentes, asegúrese de que las políticas se actualizan para
permitir dynamodb:UpdateTimeToLive para roles que necesitan habilitar o desactivar TTL en tablas.
Para obtener más información, consulte Uso de políticas basadas en identidad (Políticas de IAM) para
Amazon DynamoDB.
• Considere si necesita realizar cualquier procesamiento posterior de elementos eliminados a través
de Amazon DynamoDB Streams, como archivar elementos en un lago de datos de Amazon S3.
Los registros de secuencias de eliminaciones de TTL se marcan como eliminaciones del sistema
y como eliminaciones normales, y puede filtrar por eliminaciones del sistema mediante unAWS
Lambdafunción. Para obtener más información acerca de las incorporaciones a los registros de
secuencias, consulteStreams de Amazon DynamoDB y tiempo de vida.
• Si la recuperación de datos es un problema, le recomendamos que realice una copia de seguridad de las
tablas.
• Para copias de seguridad de tablas totalmente administradas, utilice DynamoDBcopias de seguridad
bajo demandaorBackups continuos con recuperación a un momento dado.
• Si solo necesita recuperar los datos de las últimas 24 horas, puede usar Amazon DynamoDB Streams.
Para obtener más información, consulteStreams de Amazon DynamoDB y tiempo de vida.
• Confirme que ha habilitado TTL en la tabla y que el nombre del atributo seleccionado para TTL está
configurado en lo que el código está escribiendo en los elementos. Puede confirmar esta información en
la pestaña de la tabla Información general en la consola de DynamoDB.
• Consulte las métricas de Amazon CloudWatch en laMétricasEn la consola de DynamoDB para confirmar
que TL elimina elementos como espera que se eliminen.
• Confirme que el valor del atributo de TTL tenga el formato adecuado. Para obtener más información,
consulte Dar formato al atributo de TTL de un elemento (p. 449).
Temas
• Habilitación del tiempo de vida (consola) (p. 450)
• Habilitación del tiempo de vida (AWS CLI) (p. 452)
4. En el cuadro de diálogo Manage TTL (Administrar TTL), elija Enable TTL (Habilitar TTL) y después
introduzca un nombre para TTL attribute (Atributo TTL).
• Habilitar TTL: elija esta opción para habilitar o deshabilitar TTL en la tabla. Puede que el cambio
tarde hasta una hora en procesarse completamente.
• Atributo TTL: nombre del atributo de DynamoDB en el que se almacenará la marca temporal de TL
para los elementos.
• Streams de backup de 24 horas: elija esta configuración para habilitar Amazon DynamoDB Streams
en la tabla. Para obtener más información sobre cómo puede utilizar DynamoDB Streams para
realizar copias de seguridad, consulteDynamoDB Streams y tiempo de vida (p. 665).
5. (Opcional) Para obtener una vista previa de algunos de los elementos que se eliminarán cuando se
habilite TTL, elija Run preview (Ejecutar vista previa).
Warning
De este modo, se le proporcionará un ejemplo de lista de elementos. No se trata de una lista
completa de todos los elementos que TTL eliminará.
6. Elija Continue (Continuar) para guardar la configuración y habilitar TTL.
Ahora que TL está habilitado, el atributo TL lleva la marcaTTTLcuando vea elementos en la consola de
DynamoDB.
Para ver la fecha y la hora de vencimiento de un elemento, mantenga el cursor del ratón sobre el atributo.
Este ejemplo comienza con la fecha actual y añade cinco días para crear una fecha de vencimiento.
A continuación, convierte la fecha de vencimiento al formato de tiempo Unix y, por último, agrega un
elemento a la tabla "TTLExample".
Note
Una forma de establecer valores de vencimiento para Tiempo de vida consiste en calcular el
número de segundos que se sumarán al momento del vencimiento. Por ejemplo, 5 días son
432 000 segundos. Sin embargo, a menudo es preferible comenzar por una fecha y tomarla como
punto de partida.
Es bastante sencillo obtener el tiempo actual en formato de tiempo Unix, como en los siguientes ejemplos.
Además, el SDK for Java proporciona un modelo de persistencia de objetos, que permite
mapear las clases del lado del cliente a las tablas de DynamoDB. Este enfoque puede reducir
la cantidad de código que hay que escribir. Para obtener más información, consulte Java:
DynamoDBMapper (p. 231).
Esta sección contiene ejemplos de Java que permiten realizar diversas acciones con elementos de la API
de documentos de Java y varios ejemplos de trabajo completos.
Temas
• Colocación de un elemento (p. 453)
• Obtención de un elemento (p. 456)
• Escritura Batch: Colocación y eliminación de varios elementos (p. 458)
• Obtención Batch: Obtención de varios elementos (p. 459)
• Actualización de un elemento (p. 460)
• Eliminación de un elemento (p. 462)
• Ejemplo: Operaciones CRUD mediante elAWS SDK for JavaDocumentación de la API (p. 463)
• Ejemplo: Uso de operaciones por lotes medianteAWS SDK for JavaDocumentación de la API (p. 466)
• Ejemplo: Control de atributos de tipo Binary mediante elAWS SDK for JavaDocumentación de la
API (p. 471)
Colocación de un elemento
El método putItem almacena un elemento en una tabla. Si el elemento existe, sustituye el elemento
completo. En lugar de ello, si prefiere actualizar solamente algunos atributos concretos, puede usar el
método updateItem. Para obtener más información, consulte Actualización de un elemento (p. 460).
4. Llame al método putItem del objeto Table utilizando el Item que creó en el paso anterior.
En el siguiente ejemplo de código Java se muestran las tareas anteriores. El código escribe un nuevo
elemento en la tabla ProductCatalog.
Example
En el ejemplo anterior, el elemento tiene atributos que son escalares (String, Number, Boolean, Null),
conjuntos (String Set) y tipos de documentos (List, Map).
especificar una condición para cargar el elemento. Si la condición especificada no se cumple, AWS SDK
for Java genera una excepción ConditionalCheckFailedException. En el ejemplo de código se
especifican los parámetros opcionales siguientes en el método putItem:
• Una expresión ConditionExpression que define las condiciones de la solicitud. El código define la
condición siguiente: si el elemento existente tiene la misma clave principal, solo se sustituirá si tiene
también un atributo ISBN igual a un valor específico.
• Un mapa de ExpressionAttributeValues que se usa en la condición. En este caso, solo se
requiere una sustitución: Marcador de posición:valEn la expresión de condición se sustituye en tiempo
de ejecución por el valor de ISBN real que se va a comprobar.
En el siguiente ejemplo se agrega un nuevo elemento de libro utilizando estos parámetros opcionales.
Example
Suponga que desea almacenar el siguiente documento JSON, que contiene los proveedores que pueden
servir pedidos de un producto determinado.
Example
{
"V01": {
"Name": "Acme Books",
"Offices": [ "Seattle" ]
},
"V02": {
"Name": "New Publishers, Inc.",
"Offices": ["London", "New York"
]
},
"V03": {
"Name": "Better Buy Books",
"Offices": [ "Tokyo", "Los Angeles", "Sydney"
]
}
}
Puede utilizar el método withJSON para almacenar esta información en la tabla ProductCatalog en un
atributo de tipo Map denominado VendorInfo. En el siguiente ejemplo de código Java se muestra cómo
hacerlo.
Obtención de un elemento
Para recuperar un solo elemento, utilice el método getItem de un objeto Table. Sigue estos pasos:
En el siguiente ejemplo de código Java se muestran los pasos anteriores. El código obtiene el elemento
que tiene la clave de partición especificada.
Puede usar una expresión ProjectionExpression para recuperar solamente algunos atributos o
componentes concretos, en lugar de un elemento completo. Una expresión ProjectionExpression
permite especificar atributos de nivel superior o anidados mediante rutas de documentos. Para obtener
más información, consulte Expresiones de proyección (p. 424).
Los parámetros del método getItem no permiten especificar la consistencia de .lectura Sin embargo,
puede crear una especificación GetItemSpec, que proporciona acceso pleno a toda la información
de entrada de la operación de bajo nivel GetItem. En el ejemplo de código siguiente se crea una
especificación GetItemSpec y se utiliza como información de entrada para el método getItem.
Example
System.out.println(item.toJSONPretty());
Para imprimir un Item en formato fácil de leer, utilice el método toJSONPretty. El resultado del ejemplo
anterior tiene este aspecto.
{
"RelatedItems" : [ 341 ],
"Reviews" : {
"FiveStar" : [ "Excellent! Can't recommend it highly enough! Buy it!", "Do yourself a
favor and buy this" ]
},
"Id" : 123,
"Title" : "20-Bicycle 123"
}
Note
Puede usar el método toJSON para convertir cualquier elemento (o sus atributos) en una cadena
con formato JSON. En el siguiente ejemplo de código se recuperan varios atributos de nivel
superior y anidados y se imprimen los resultados como JSON.
{"VendorInfo":{"V01":{"Name":"Acme Books","Offices":
["Seattle"]}},"Price":30,"Title":"Book 210 Title"}
En el siguiente ejemplo de código Java se muestran los pasos anteriores. El ejemplo lleva a cabo
una operación batchWriteItem en dos tablas: Forum y Thread. Los objetos TableWriteItems
correspondientes definen las siguientes acciones:
Para ver un ejemplo práctico, consulte Ejemplo: Operación de escritura por lotes mediante elAWS SDK for
JavaDocumentación de la API (p. 467).
En el siguiente ejemplo de código Java se muestran los pasos anteriores. El ejemplo recupera dos
elementos de la tabla Forum y tres de la tabla Thread.
Example
forumTableKeysAndAttributes.addHashOnlyPrimaryKeys("Name",
"Amazon S3",
"Amazon DynamoDB");
Actualización de un elemento
El método updateItem de un objeto Table permite actualizar los valores de atributos presentes, agregar
atributos nuevos o eliminarlos de un elemento existente.
• Si un elemento no existe (no hay ningún elemento en la tabla con la clave principal especificada),
updateItem agrega un elemento nuevo a la tabla.
• Si un elemento ya existe, updateItem lleva a cabo la actualización según lo especificado en el
parámetro UpdateExpression.
Note
También es posible actualizar un elemento mediante putItem. Por ejemplo, si llama a putItem
para agregar un elemento a la tabla pero ya existe uno con la clave principal especificada,
putItem sustituye el elemento completo. Si hay atributos en el elemento existente que no se
especifican en la información de entrada, putItem los elimina del elemento.
En general, recomendamos usar updateItem siempre que desee modificar atributos de
elementos. El método updateItem solo modifica los atributos del elemento que especifique en la
información de entrada, pero deja los demás atributos del elemento tal cual estaban.
1. Cree una instancia de la clase Table para representar la tabla que desea usar.
2. Llame al método updateTable de la instancia de Table. Debe especificar la clave principal del
elemento que desea recuperar, junto con una expresión UpdateExpression que describa los
atributos que hay que cambiar y cómo modificarlos.
En el siguiente ejemplo de código Java se muestran las tareas anteriores. El código actualiza un elemento
de libro en la tabla ProductCatalog. Se agrega un nuevo autor al conjunto Authors y se elimina el
atributo ISBN existente. También se reduce el precio en una unidad.
Example
Contador atómico
Puede usar updateItem para implementar un contador atómico y aumentar o reducir el valor de un
atributo existente sin interferir con las demás solicitudes de escritura. Para incrementar un contador
atómico, use una expresión UpdateExpression con la acción set para sumar un valor numérico a una
atributo existente de tipo Number.
Eliminación de un elemento
El método deleteItem elimina un elemento de una tabla. Es preciso proporcionar la clave principal del
elemento que se desea eliminar.
Example
Example
Además, el SDK for Java proporciona un modelo de persistencia de objetos, que permite
mapear las clases del lado del cliente a las tablas de DynamoDB. Este enfoque puede reducir
la cantidad de código que hay que escribir. Para obtener más información, consulte Java:
DynamoDBMapper (p. 231).
Note
En este ejemplo de código se supone que ya ha cargado datos en DynamoDB para su cuenta
siguiendo las instrucciones delCreación de tablas y carga de datos para ejemplos de código en
DynamoDB (p. 333)sección.
Para obtener instrucciones paso a paso acerca de cómo ejecutar el siguiente ejemplo, consulte
Ejemplos de código Java (p. 338).
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.document;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DeleteItemOutcome;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.UpdateItemOutcome;
import com.amazonaws.services.dynamodbv2.document.spec.DeleteItemSpec;
import com.amazonaws.services.dynamodbv2.document.spec.UpdateItemSpec;
import com.amazonaws.services.dynamodbv2.document.utils.NameMap;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;
import com.amazonaws.services.dynamodbv2.model.ReturnValue;
createItems();
retrieveItem();
}
catch (Exception e) {
System.err.println("Create items failed.");
System.err.println(e.getMessage());
}
}
try {
}
catch (Exception e) {
System.err.println("GetItem failed.");
System.err.println(e.getMessage());
}
try {
}
catch (Exception e) {
System.err.println("Failed to add new attribute in " + tableName);
System.err.println(e.getMessage());
}
}
try {
}
catch (Exception e) {
System.err.println("Failed to update multiple attributes in " + tableName);
System.err.println(e.getMessage());
}
}
try {
// Specify the desired price (25.00) and also the condition (price =
// 20.00)
}
catch (Exception e) {
System.err.println("Error updating item in " + tableName);
System.err.println(e.getMessage());
}
}
try {
}
catch (Exception e) {
System.err.println("Error deleting item in " + tableName);
System.err.println(e.getMessage());
}
}
}
Además, el SDK for Java proporciona un modelo de persistencia de objetos, que permite
mapear las clases del lado del cliente a las tablas de DynamoDB. Este enfoque puede reducir
la cantidad de código que hay que escribir. Para obtener más información, consulte Java:
DynamoDBMapper (p. 231).
Temas
• Ejemplo: Operación de escritura por lotes mediante elAWS SDK for JavaDocumentación de la
API (p. 467)
• Ejemplo: Operación de obtención por lotes mediante elAWS SDK for JavaDocumentación de la
API (p. 469)
Al crear la solicitud de escritura por lotes, puede especificar cualquier cantidad de solicitudes de colocación
y eliminación en una o varias tablas. Sin embargo, batchWriteItem limita el tamaño de una solicitud de
escritura por lotes y el número de operaciones de colocación y eliminación que se pueden llevar a cabo
en una misma operación de escritura por lotes. Si la solicitud supera estos límites, se rechaza la solicitud.
Si la tabla no cuenta con suficiente desempeño provisionado para atender esta solicitud, los elementos de
solicitud sin procesar se devuelven en la respuesta.
En el siguiente ejemplo se comprueba la respuesta para saber si contiene elementos de solicitud sin
transformar. En caso afirmativo, entra en bucle y vuelve a enviar la solicitud batchWriteItem con
elementos sin procesar. Si ha seguido la sección Creación de tablas y carga de datos para ejemplos de
código en DynamoDB (p. 333), seguramente habrá creado ya las tablas Forum y Thread. También puede
crear estas tablas y cargar los ejemplos de datos mediante programación. Para obtener más información,
consulte Creación de ejemplos de tablas y carga de datos mediante la.AWS SDK for Java (p. 1090).
Para obtener instrucciones paso a paso para probar el siguiente ejemplo, consulte Ejemplos de código
Java (p. 338).
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.document;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.BatchWriteItemOutcome;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.TableWriteItems;
import com.amazonaws.services.dynamodbv2.model.WriteRequest;
writeMultipleItemsBatchWrite();
do {
if (outcome.getUnprocessedItems().size() == 0) {
System.out.println("No unprocessed items found");
}
else {
System.out.println("Retrieving the unprocessed items");
outcome = dynamoDB.batchWriteItemUnprocessed(unprocessedItems);
}
}
catch (Exception e) {
System.err.println("Failed to retrieve items: ");
e.printStackTrace(System.err);
}
En este ejemplo de código se supone que ya ha cargado datos en DynamoDB para su cuenta
siguiendo las instrucciones delCreación de tablas y carga de datos para ejemplos de código en
DynamoDB (p. 333)sección.
Para obtener instrucciones paso a paso acerca de cómo ejecutar el siguiente ejemplo, consulte
Ejemplos de código Java (p. 338).
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.document;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.BatchGetItemOutcome;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.TableKeysAndAttributes;
import com.amazonaws.services.dynamodbv2.model.KeysAndAttributes;
try {
BatchGetItemOutcome outcome =
dynamoDB.batchGetItem(forumTableKeysAndAttributes,
threadTableKeysAndAttributes);
do {
for (String tableName : outcome.getTableItems().keySet()) {
System.out.println("Items in table " + tableName);
List<Item> items = outcome.getTableItems().get(tableName);
for (Item item : items) {
System.out.println(item.toJSONPretty());
}
}
if (unprocessed.isEmpty()) {
System.out.println("No unprocessed keys found");
}
else {
System.out.println("Retrieving the unprocessed keys");
outcome = dynamoDB.batchGetItemUnprocessed(unprocessed);
}
} while (!unprocessed.isEmpty());
}
catch (Exception e) {
System.err.println("Failed to retrieve items.");
System.err.println(e.getMessage());
}
Además, el SDK for Java proporciona un modelo de persistencia de objetos, que permite
mapear las clases del lado del cliente a las tablas de DynamoDB. Este enfoque puede reducir
la cantidad de código que hay que escribir. Para obtener más información, consulte Java:
DynamoDBMapper (p. 231).
Para obtener instrucciones paso a paso para probar el siguiente ejemplo, consulte Ejemplos de código
Java (p. 338).
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.document;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.GetItemSpec;
dateFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));
String replyDateTime = dateFormatter.format(new Date());
is.close();
baos.close();
bais.close();
return result;
}
}
Por ejemplo, use el objeto de solicitud PutItemRequest para cargar un elemento y el objeto de
solicitud GetItemRequest para recuperar un elemento existente.
Puede usar el objeto de solicitud para proporcionar los parámetros necesarios y opcionales.
3. Ejecute el método apropiado proporcionado por el cliente pasándolo en el objeto de solicitud que ha
creado en el paso anterior.
Temas
• Colocación de un elemento (p. 474)
• Obtención de un elemento (p. 476)
• Actualización de un elemento (p. 477)
• Contador atómico (p. 479)
• Eliminación de un elemento (p. 479)
• Escritura Batch: Colocación y eliminación de varios elementos (p. 481)
• Obtención Batch: Obtención de varios elementos (p. 482)
• Ejemplo: Operaciones CRUD mediante elAWS SDK for .NETAPI de bajo nivel (p. 484)
• Ejemplo: Operaciones Batch mediante elAWS SDK for .NETAPI de bajo nivel (p. 489)
• Ejemplo: Control de atributos de tipo Binary mediante elAWS SDK for .NETAPI de bajo nivel (p. 495)
Colocación de un elemento
LaPutItemEl método carga un elemento en una tabla. Si el elemento existe, sustituye el elemento
completo.
Note
En lugar de ello, si prefiere actualizar solamente algunos atributos concretos, puede usar
el método UpdateItem. Para obtener más información, consulte Actualización de un
elemento (p. 477).
A continuación se indican los pasos que hay que seguir para cargar un elemento mediante el API de bajo
nivel del SDK para .NET:
Example
En el ejemplo anterior, puede cargar un elemento de libro que tenga el valor deId,Title,ISBN,
yAuthorsAtributos. Tenga en cuenta queIdEs un atributo de tipo numérico, y todos los demás son de
cadena. Autores es unStringSet.
Example
{"#I", "ISBN"}
},
ExpressionAttributeValues = new Dictionary<string, AttributeValue>()
{
{":isbn",new AttributeValue {S = "444-4444444444"}}
},
ConditionExpression = "#I = :isbn"
};
var response = client.PutItem(request);
Obtención de un elemento
El método GetItem recupera un elemento.
Note
Para recuperar varios elementos, puede usar elBatchGetItemMétodo de. Para obtener más
información, consulte Obtención Batch: Obtención de varios elementos (p. 482).
A continuación se indican los pasos que hay que seguir para recuperar un elemento existente mediante
elAWS SDK for .NETAPI.
Para obtener un elemento, debe proporcionar el nombre de la tabla y la clave principal del elemento.
3. Ejecute laGetItemal proporcionar el métodoGetItemRequestObjeto que creó en el paso anterior.
Example
Actualización de un elemento
LaUpdateItemEl método actualiza un elemento si existe. Puede utilizar la herramienta
deUpdateItemPara actualizar los valores de atributos presentes, agregar atributos nuevos o eliminarlos
de la colección existente. Si el elemento que tiene clave principal especificada no se encuentra, se agrega
un nuevo elemento.
Note
LaPutItemLa operación también puede llevar a cabo una actualización. Para obtener más
información, consulte Colocación de un elemento (p. 474). Por ejemplo, si llama aPutItemPara
cargar un elemento y la clave principal ya existe, elPutItemLa operación sustituye todo el
elemento. Si hay atributos en el elemento existente que no se especifican en la información de
entrada, elPutItemLa operación elimina dichos atributos. Sin embargo,UpdateItemActualiza
solo los atributos de entrada especificados. Todos los demás atributos existentes de ese elemento
permanecen inalterados.
A continuación se indican los pasos que hay que seguir para actualizar un elemento existente mediante el
API de bajo nivel del SDK para .NET:
2. Cree una instancia de la clase UpdateItemRequest para proporcionar los parámetros requeridos.
Se trata del objeto de solicitud en el que se describen todas las actualizaciones, tales como agregar
atributos o actualizar o eliminar atributos existentes. Para eliminar un atributo, especifique su nombre
con el valor null.
3. Ejecute laUpdateItemal proporcionar el métodoUpdateItemRequestObjeto que creó en el paso
anterior.
En el siguiente ejemplo de código C# se ponen en práctica los pasos anteriores. En el ejemplo se actualiza
un elemento de libro en elProductCatalogTabla INTO Se agrega un nuevo autor alAuthorsy elimina la
colecciónISBNatributo. También se reduce el precio en una unidad.
Example
Contador atómico
Puede usar updateItem para implementar un contador atómico y aumentar o reducir el valor de un
atributo existente sin interferir con las demás solicitudes de escritura. Para actualizar un contador atómico,
useupdateItemcon un atributo de tipoNumberen laUpdateExpressionParámetro de, yADDcomo
elAction.
Eliminación de un elemento
El método DeleteItem elimina un elemento de una tabla.
A continuación se indican los pasos que hay que seguir para eliminar un elemento mediante el API de bajo
nivel del SDK para .NET.
Para eliminar un elemento, se requieren el nombre de la tabla y la clave principal del elemento.
3. Ejecute laDeleteItemal proporcionar el métodoDeleteItemRequestObjeto que creó en el paso
anterior.
Example
Example
// Optional parameters.
ReturnValues = "ALL_OLD",
ExpressionAttributeNames = new Dictionary<string, string>()
{
{"#IP", "InPublication"}
},
ExpressionAttributeValues = new Dictionary<string, AttributeValue>()
{
{":inpub",new AttributeValue {BOOL = false}}
},
ConditionExpression = "#IP = :inpub"
};
En el siguiente ejemplo de código C# se ponen en práctica los pasos anteriores. En el siguiente ejemplo se
crea una solicitud BatchWriteItemRequest para realizar las siguientes operaciones de escritura:
{
{ "ForumName", new AttributeValue { S = "Amazon S3 forum" } },
{ "Subject", new AttributeValue { S = "My sample question" } },
{ "Message", new AttributeValue { S = "Message Text." } },
{ "KeywordTags", new AttributeValue { SS = new List<string> { "Amazon S3",
"Bucket" } } }
}
}
},
new WriteRequest
{
DeleteRequest = new DeleteRequest
{
Key = new Dictionary<string,AttributeValue>()
{
{ "ForumName", new AttributeValue { S = "Some forum name" } },
{ "Subject", new AttributeValue { S = "Some subject" } }
}
}
}
}
}
}
};
response = client.BatchWriteItem(request);
Para ver un ejemplo práctico, consulte Ejemplo: Operaciones Batch mediante elAWS SDK for .NETAPI de
bajo nivel (p. 489).
A continuación se indican los pasos que hay que seguir para recuperar varios elementos mediante elAWS
SDK for .NETAPI.
Para recuperar varios elementos, es obligatorio indicar el nombre de la tabla y una lista de valores de
clave principal.
3. Ejecute laBatchGetItemal proporcionar el métodoBatchGetItemRequestObjeto que creó en el
paso anterior.
4. Procese la respuesta. Debe comprobar si han quedado claves sin procesar, lo que podría ocurrir si se
alcanza la cuota de rendimiento aprovisionada o se produce cualquier otro error transitorio.
}
// Any unprocessed keys? could happen if you exceed ProvisionedThroughput or some other
error.
Dictionary<string, KeysAndAttributes> unprocessedKeys = result.UnprocessedKeys;
foreach (KeyValuePair<string, KeysAndAttributes> pair in unprocessedKeys)
{
Console.WriteLine(pair.Key, pair.Value);
}
Example
estos ejemplos de tablas mediante programación. Para obtener más información, consulte Creación de
ejemplos de tablas y carga de datos mediante la.AWS SDK for .NET (p. 1097).
Para obtener instrucciones paso a paso para probar el siguiente ejemplo, consulte Ejemplos de
código .NET (p. 340).
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using System;
using System.Collections.Generic;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;
using Amazon.SecurityToken;
namespace com.amazonaws.codesamples
{
class LowLevelItemCRUDExample
{
private static string tableName = "ProductCatalog";
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Delete item.
DeleteItem();
Console.WriteLine("To continue, press Enter");
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine("To continue, press Enter");
Console.ReadLine();
}
}
{"#A","Authors"},
{"#NA","NewAttribute"},
{"#I","ISBN"}
},
ExpressionAttributeValues = new Dictionary<string, AttributeValue>()
{
{":auth",new AttributeValue {
SS = {"Author YY", "Author ZZ"}
}},
{":new",new AttributeValue {
S = "New Value"
}}
},
TableName = tableName,
ReturnValues = "ALL_NEW" // Give me all attributes of the updated item.
};
var response = client.UpdateItem(request);
TableName = tableName,
ReturnValues = "ALL_NEW" // Give me all attributes of the updated item.
};
var response = client.UpdateItem(request);
Console.WriteLine(
attributeName + " " +
(value.S == null ? "" : "S=[" + value.S + "]") +
(value.N == null ? "" : "N=[" + value.N + "]") +
(value.SS == null ? "" : "SS=[" + string.Join(",", value.SS.ToArray())
+ "]") +
(value.NS == null ? "" : "NS=[" + string.Join(",", value.NS.ToArray())
+ "]")
);
}
Console.WriteLine("************************************************");
}
}
}
En esta sección se proporcionan ejemplos de operaciones por lotes,Escritura por lotesyObtener por lotes,
que admite Amazon DynamoDB.
Ejemplo: Operación de escritura por lotes mediante elAWS SDK for .NETAPI de
bajo nivel
En el siguiente ejemplo de código C# se usa el método BatchWriteItem para llevar a cabo las siguientes
operaciones de colocación y eliminación:
Al crear la solicitud de escritura por lotes, puede especificar cualquier cantidad de solicitudes de colocación
y eliminación en una o varias tablas. Sin embargo, DynamoDBBatchWriteItemlimita el tamaño de
una solicitud de escritura por lotes y el número de operaciones de colocación y eliminación que se
pueden llevar a cabo en una misma operación de escritura por lotes. Para obtener más información,
consulteBatchWriteItem. Si la solicitud supera estos límites, se rechaza la solicitud. Si la tabla no cuenta
con suficiente desempeño provisionado para atender esta solicitud, los elementos de solicitud sin procesar
se devuelven en la respuesta.
En el siguiente ejemplo se comprueba la respuesta para saber si contiene elementos de solicitud sin
transformar. En caso afirmativo, entra en bucle y vuelve a enviar la solicitud BatchWriteItem con
elementos sin procesar. Si ha seguido los pasos deCreación de tablas y carga de datos para ejemplos de
código en DynamoDB (p. 333), ya tiene elForumyThreadCreadas. También puede crear estos ejemplos
de tablas y cargar los ejemplos de datos mediante programación. Para obtener más información, consulte
Creación de ejemplos de tablas y carga de datos mediante la.AWS SDK for .NET (p. 1097).
Para obtener instrucciones paso a paso para probar el siguiente ejemplo, consulte Ejemplos de
código .NET (p. 340).
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using System;
using System.Collections.Generic;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;
namespace com.amazonaws.codesamples
{
class LowLevelBatchWrite
{
private static string table1Name = "Forum";
private static string table2Name = "Thread";
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
S = "Message Text."
} },
{ "KeywordTags", new AttributeValue {
SS = new List<string> { "S3", "Bucket" }
} }
}
}
},
new WriteRequest
{
// For the operation to delete an item, if you provide a
primary key value
// that does not exist in the table, there is no error, it is
just a no-op.
DeleteRequest = new DeleteRequest
{
Key = new Dictionary<string, AttributeValue>()
{
{ "ForumName", new AttributeValue {
S = "Some partition key value"
} },
{ "Subject", new AttributeValue {
S = "Some sort key value"
} }
}
}
}
}
}
}
};
CallBatchWriteTillCompletion(request);
}
int callCount = 0;
do
{
Console.WriteLine("Making request");
response = client.BatchWriteItem(request);
callCount++;
Console.WriteLine("Unprocessed");
foreach (var unp in unprocessed)
{
Console.WriteLine("{0} - {1}", unp.Key, unp.Value.Count);
}
Console.WriteLine();
// For the next iteration, the request will have unprocessed items.
request.RequestItems = unprocessed;
} while (response.UnprocessedItems.Count > 0);
Ejemplo: Operación de obtención por lotes mediante elAWS SDK for .NETAPI de
bajo nivel
En el siguiente ejemplo de código C# se utiliza elBatchGetItempara recuperar varios elementos del
métodoForumy laThreaden Amazon DynamoDB. LaBatchGetItemRequestEspecifica los nombres de
las tablas y una lista de claves principales para cada tabla. En el ejemplo se procesa la respuesta y se
imprimen los elementos recuperados.
Si ha seguido los pasos deCreación de tablas y carga de datos para ejemplos de código en
DynamoDB (p. 333)Ya tiene estas tablas creadas con datos de ejemplo. También puede crear estos
ejemplos de tablas y cargar los ejemplos de datos mediante programación. Para obtener más información,
consulte Creación de ejemplos de tablas y carga de datos mediante la.AWS SDK for .NET (p. 1097).
Para obtener instrucciones paso a paso para probar el siguiente ejemplo, consulte Ejemplos de
código .NET (p. 340).
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using System;
using System.Collections.Generic;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;
namespace com.amazonaws.codesamples
{
class LowLevelBatchGet
{
private static string table1Name = "Forum";
private static string table2Name = "Thread";
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
};
BatchGetItemResponse response;
do
{
Console.WriteLine("Making request");
response = client.BatchGetItem(request);
request.RequestItems = unprocessedKeys;
} while (response.UnprocessedKeys.Count > 0);
}
Console.WriteLine(
attributeName + " " +
(value.S == null ? "" : "S=[" + value.S + "]") +
(value.N == null ? "" : "N=[" + value.N + "]") +
(value.SS == null ? "" : "SS=[" + string.Join(",", value.SS.ToArray())
+ "]") +
(value.NS == null ? "" : "NS=[" + string.Join(",", value.NS.ToArray())
+ "]")
);
}
Console.WriteLine("************************************************");
}
}
}
Si ha seguido los pasos deCreación de tablas y carga de datos para ejemplos de código en
DynamoDB (p. 333), ya tiene elReplyCreada. También puede crear estos ejemplos de tablas mediante
programación. Para obtener más información, consulte Creación de ejemplos de tablas y carga de datos
mediante la.AWS SDK for .NET (p. 1097).
Para obtener instrucciones paso a paso para probar el siguiente ejemplo, consulte Ejemplos de
código .NET (p. 340).
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;
namespace com.amazonaws.codesamples
{
class LowLevelItemBinaryExample
{
private static string tableName = "Reply";
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
try
{
CreateItem(replyIdPartitionKey, replyDateTimeSortKey);
RetrieveItem(replyIdPartitionKey, replyDateTimeSortKey);
// Delete item.
DeleteItem(replyIdPartitionKey, replyDateTimeSortKey);
PrintItem(attributeList);
}
TableName = tableName,
Key = new Dictionary<string, AttributeValue>()
{
{ "Id", new AttributeValue {
S = partitionKey
} },
{ "ReplyDateTime", new AttributeValue {
S = sortKey
} }
}
};
var response = client.DeleteItem(request);
}
Console.WriteLine(
attributeName + " " +
(value.S == null ? "" : "S=[" + value.S + "]") +
(value.N == null ? "" : "N=[" + value.N + "]") +
(value.SS == null ? "" : "SS=[" + string.Join(",", value.SS.ToArray())
+ "]") +
(value.NS == null ? "" : "NS=[" + string.Join(",", value.NS.ToArray())
+ "]") +
(value.B == null ? "" : "B=[" + FromGzipMemoryStream(value.B) + "]")
);
}
Console.WriteLine("************************************************");
}
Debe proporcionar el nombre del atributo de clave de partición y un único valor para dicho atributo.
Query devuelve todos los elementos que contengan ese valor de clave de partición. Si lo desea, puede
proporcionar un atributo de clave de ordenación y utilizar un operador de comparación para limitar los
resultados de búsqueda.
Temas
• Expresiones de condición de clave (p. 498)
• Expresiones de filtro para Query (p. 500)
• Limitación del número de elementos del conjunto de resultados (p. 501)
• Paginación de resultados de la consulta de tabla (p. 501)
• Recuento de los elementos de los resultados (p. 502)
• Unidades de capacidad que Query consume (p. 503)
• Consistencia de lectura de Query (p. 503)
• Consulta de tablas e índices: Java (p. 503)
• Consulta de tablas e índices: .NET (p. 509)
Debe especificar el nombre y valor de la clave de partición como una condición de igualdad.
Si lo desea, puede proporcionar una segunda condición para la clave de ordenación (en caso de incluirse).
En la condición de clave de ordenación se debe utilizar uno de los siguientes operadores de comparación:
• begins_with (a, substr): es true si el valor del atributo a comienza por una subcadena
determinada.
En los siguientes ejemplos de la AWS Command Line Interface (AWS CLI) se muestra el uso de
expresiones de condición de clave. Estas expresiones utilizan marcadores de posición (como :name y
:sub) en lugar de los valores reales. Para obtener más información, consulte Nombres de atributos de
expresión en DynamoDB (p. 425) y Valores de los atributos de expresión (p. 428).
Example
Consulta la tabla Thread para buscar un valor concreto de ForumName (clave de partición). La consulta
leerá todos los elementos que tengan ese valor de ForumName, porque la clave de ordenación (Subject)
no se incluye en KeyConditionExpression.
Example
Consulta la tabla Thread para buscar un valor concreto de ForumName (clave de partición), pero esta vez
devuelve solo los elementos que tienen un valor determinado de Subject (clave de ordenación).
{
":name":{"S":"Amazon DynamoDB"},
":sub":{"S":"DynamoDB Thread 1"}
}
Example
Consulta la tabla Reply para buscar un valor concreto de Id (clave de partición), pero solo devuelve los
elementos cuyo valor de ReplyDateTime (clave de ordenación) comienza por determinados caracteres.
{
":id":{"S":"Amazon DynamoDB#DynamoDB Thread 1"},
":dt":{"S":"2015-09"}
}
Puede utilizar cualquier nombre de atributo en una expresión de condición de clave, siempre y cuando el
primer carácter sea a-z o A-Z y el segundo carácter (si lo hay) sea a-z, A-Z o 0-9. Además, el nombre
de atributo no debe ser una palabra reservada de DynamoDB. Para obtener una lista completa de estas
palabras, consulte Palabras reservadas en DynamoDB (p. 1135). Si un nombre de atributo no cumple
estos requisitos, debe definir un nombre de atributo de expresión como marcador de posición. Para
obtener más información, consulte Nombres de atributos de expresión en DynamoDB (p. 425).
DynamoDB almacena cerca unos de otros y ordenados según su clave de ordenación aquellos
elementos que tienen un valor de clave de partición determinado. En unQuery, DynamoDB recupera los
elementos de forma ordenada y, a continuación, los procesa medianteKeyConditionExpressiony
cualquierFilterExpressionque podría estar presente. Solo entonces devuelve los resultados de Query
al cliente.
Los resultados de Query siempre se ordenan según el valor de la clave de ordenación. Si el tipo de datos
de la clave de ordenación es Number, los resultados se devuelven en orden numérico. De lo contrario,
los resultados se devuelven según el orden de los bytes UTF-8. De forma predeterminada, el orden es
ascendente. Para invertirlo, establezca el parámetro ScanIndexForward en false.
Una sola operaciónQueryLa operación puede recuperar un máximo de 1 MB de datos. Este límite se
aplica antes de aplicar cualquier expresión FilterExpression a los resultados. Si LastEvaluatedKey
está presente en la respuesta y su valor no es null, debe paginar el conjunto de resultados (consulte
Paginación de resultados de la consulta de tabla (p. 501)).
Una expresión de filtro se aplica después de que la operación Query haya finalizado, pero antes de
devolver los resultados. Por consiguiente, Query consume la misma cantidad de capacidad de lectura
aunque se especifique una expresión de filtro.
AQueryLa operación puede recuperar un máximo de 1 MB de datos. Este límite se aplica antes de evaluar
la expresión de filtro.
Una expresión de filtro no puede contener atributos de clave de partición ni de clave de ordenación. Esos
atributos se deben especificar en la expresión de condición de clave, no en la expresión de filtro.
La sintaxis de una expresión de filtro es la misma que la de una expresión de condición de clave. Las
expresiones de filtro pueden utilizar los comparadores, funciones y operadores lógicos que las expresiones
de condición clave, con la adición del operador no es igual (<>). Para obtener más información, consulte
Expresiones de condición de clave (p. 498).
Example
En el siguiente ejemplo de la AWS CLI, se consulta la tabla Thread para buscar un valor concreto de
ForumName (clave de partición) y Subject (clave de ordenación). De los elementos encontrados, solo se
devuelven los hilos de discusión más populares; es decir, solo aquellos que tienen un valor deViews.
{
":fn":{"S":"Amazon DynamoDB"},
":sub":{"S":"DynamoDB Thread 1"},
":num":{"N":"3"}
}
Note
Una expresión de filtro elimina los elementos del conjunto de resultados de Query. Si es posible,
evite usar Query cuando prevea que va a recuperar gran cantidad de elementos, pero que tendrá
que descartar la mayoría de ellos.
Por ejemplo, suponga que utiliza Query en una tabla con un valor de Limit de 6 y sin expresión de filtro.
El resultado de Query contendrá los seis primeros elementos de la tabla que coincidan con la expresión de
condición de clave de la solicitud.
Ahora, suponga que agrega una expresión de filtro a Query. En este caso, DynamoDB lee hasta
seis elementos y, a continuación, devuelve solo aquellos que coinciden con la expresión de filtro. La
finalQueryEste resultado contiene seis elementos o menos, aunque más elementos hubieran coincidido
con la expresión de filtro si DynamoDB hubiera seguido leyendo más elementos.
Una sola operaciónQuerySolo devuelve un conjunto de resultados que se ajuste al límite de tamaño de
1 MB. Para determinar si hay más resultados y para recuperarlos de página en página, las aplicaciones
deben hacer lo siguiente:
Puede utilizar la AWS CLI para ver este comportamiento. LaAWS CLIenvía un bajo nivel
deQuerysolicitudes a DynamoDB repetidamente, hastaLastEvaluatedKeyya no está presente en
los resultados. Considere el siguiente ejemplo de la AWS CLI que recupera títulos de películas de un
determinado año:
El elemento LastEvaluatedKey de la respuesta indica que no se han recuperado todos los elementos.
LaAWS CLIA continuación, emite otroQuerysolicitud a DynamoDB. Este patrón de solicitud y respuesta
continúa hasta la respuesta final.
LaAWSLos SDK se encargan también de las respuestas de DynamoDB de bajo nivel (incluida
la presencia o ausencia deLastEvaluatedKey) y proporcionar varias abstracciones
para paginarQueryResultados. Por ejemplo, la interfaz de documentos SDK for Java
proporcionajava.util.Iteratorsoporte para que pueda examinar los resultados de uno en
uno.
Para obtener ejemplos de código en varios lenguajes de programación, consulte laGuía de
introducción a Amazon DynamoDBy laAWSDocumentación del SDK para su idioma.
Para obtener más información sobre las consultas con DynamoDB, consulteUso de consultas en
DynamoDB (p. 497).
Note
Cada respuesta de Query contendrá los valores de ScannedCount y Count de los elementos que se
han procesado en esa solicitud Query concreta. Para obtener totales globales para todas las solicitudes
Query, puede llevar un recuento total de ScannedCount y Count.
De forma predeterminada, una operación Query no devuelve datos sobre la cantidad de capacidad de
lectura que consume. Sin embargo, puede especificar el parámetro ReturnConsumedCapacity en
una solicitud Query para obtener esta información. A continuación se muestran los ajustes válidos de
ReturnConsumedCapacity:
DynamoDB calcula el número de unidades de capacidad de lectura consumidas según el tamaño de los
elementos y no según la cantidad de datos que se devuelven a la aplicación. Por este motivo, el número
de unidades de capacidad consumidas es el mismo si se solicitan todos los atributos (el comportamiento
predeterminado) o solo algunos de ellos (mediante una expresión de proyección). El número también será
el mismo tanto si se utiliza una expresión de filtro como si no.
LaAWS SDK for JavaAdemás, proporciona un modelo de persistencia de objetos, que permite
mapear las clases del lado del cliente a las tablas de DynamoDB. Este enfoque puede reducir
la cantidad de código que hay que escribir. Para obtener más información, consulte Java:
DynamoDBMapper (p. 231).
A continuación se indican los pasos que hay que seguir para recuperar un elemento mediante la API de
documentos del AWS SDK for Java.
La respuesta incluye un objeto ItemCollection que proporciona todos los elementos devueltos por la
consulta.
En el siguiente ejemplo de código Java se muestran las tareas anteriores. Por ejemplo, suponga que
tiene una tabla Reply en la que se almacenan las respuestas de las conversaciones de un foro. Para
obtener más información, consulte Creación de tablas y carga de datos para ejemplos de código en
DynamoDB (p. 333).
Cada conversación de un foro tiene un identificador único y puede tener cero o más respuestas. Por lo
tanto, el atributo Id de la tabla Reply consta del nombre del foro y del asunto del foro. La clave principal
compuesta de la tabla consta de Id (clave de partición) y ReplyDateTime (clave de ordenación).
La siguiente consulta recupera todas las respuestas del asunto de una conversación concreta. La consulta
necesita el nombre de la tabla y el valor de Subject.
Example
En el siguiente ejemplo de código Java se recuperan las respuestas de las conversaciones de un foro
publicadas en los últimos 15 días. En el ejemplo se especifican parámetros opcionales mediante lo
siguiente:
En este ejemplo se utiliza un objeto QuerySpec que proporciona acceso a todos los parámetros de
entrada de bajo nivel de Query.
Example
Además, si lo desea puede limitar el número de elementos por página con el método withMaxPageSize.
Cuando se llama al método query, se obtiene una ItemCollection que contiene los elementos
resultantes. A continuación, puede recorrer los resultados paso a paso, procesando una página cada vez,
hasta que no queden más páginas.
Example
spec.withMaxPageSize(10);
Además, el SDK for Java proporciona un modelo de persistencia de objetos, que permite
mapear las clases del lado del cliente a las tablas de DynamoDB. Este enfoque puede reducir
la cantidad de código que hay que escribir. Para obtener más información, consulte Java:
DynamoDBMapper (p. 231).
Example
En este ejemplo de código Java, puede ejecutar variaciones de búsqueda de respuestas para la
conversación «DynamoDB Thread 1" del foro «DynamoDB».
En las dos consultas anteriores se muestra cómo especificar condiciones de clave de ordenación para
delimitar los resultados de la consulta y utilizar otros parámetros de consulta opcionales.
Note
En este ejemplo de código se supone que ya ha cargado datos en DynamoDB para su cuenta
siguiendo las instrucciones delCreación de tablas y carga de datos para ejemplos de código en
DynamoDB (p. 333)sección.
Para obtener instrucciones paso a paso acerca de cómo ejecutar el siguiente ejemplo, consulte
Ejemplos de código Java (p. 338).
/**
package com.amazonaws.codesamples.document;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.ItemCollection;
import com.amazonaws.services.dynamodbv2.document.Page;
import com.amazonaws.services.dynamodbv2.document.QueryOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;
findRepliesForAThread(forumName, threadSubject);
findRepliesForAThreadSpecifyOptionalLimit(forumName, threadSubject);
findRepliesInLast15DaysWithConfig(forumName, threadSubject);
findRepliesPostedWithinTimePeriod(forumName, threadSubject);
findRepliesUsingAFilterExpression(forumName, threadSubject);
}
System.out.println("\nfindRepliesForAThread results:");
System.out.println("\nfindRepliesForAThreadSpecifyOptionalLimit results:");
System.out.println("\nfindRepliesInLast15DaysWithConfig results:");
Iterator<Item> iterator = items.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next().toJSONPretty());
}
System.out.println("\nfindRepliesPostedWithinTimePeriod results:");
Iterator<Item> iterator = items.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next().toJSONPretty());
}
}
System.out.println("\nfindRepliesUsingAFilterExpression results:");
Iterator<Item> iterator = items.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next().toJSONPretty());
}
}
A continuación se indican los pasos que hay que seguir para consultar una tabla mediante la API de bajo
nivel de AWS SDK for .NET.
La respuesta incluye el objeto QueryResult que proporciona todos los elementos devueltos por la
consulta.
En el siguiente ejemplo de código C# se ponen en práctica las tareas anteriores. Por ejemplo, suponga
que tiene una tabla Reply en la que se almacenan las respuestas de las conversaciones de un foro.
Para obtener más información, consulte Creación de tablas y carga de datos para ejemplos de código en
DynamoDB (p. 333).
Example
Cada conversación de un foro tiene un identificador único y puede tener cero o más respuestas. Por lo
tanto, la clave principal consta de la clave de partición (Id) y la clave de ordenación (ReplyDateTime).
La siguiente consulta recupera todas las respuestas del asunto de una conversación concreta. La consulta
necesita el nombre de la tabla y el valor de Subject.
Example
• Una expresión KeyConditionExpression para recuperar solamente las respuestas de los últimos
15 días.
• Un parámetro ProjectionExpression para especificar una lista de atributos que deben recuperarse
para los elementos presentes en el resultado de la consulta.
• Un parámetro ConsistentRead para realizar una lectura de consistencia alta.
Example
Además, si lo desea puede limitar el tamaño de la página, es decir, el número de elementos por página,
agregando el parámetro opcional Limit. Cada vez que ejecute elQuery, se obtiene una página de
resultados con el número de elementos especificado. Para recuperar la página siguiente, ejecute la
operación deQueryDe nuevo, proporcionando el valor de clave principal del último elemento de la página
anterior, para que el método devuelva el siguiente conjunto de elementos. Esta información se proporciona
dentro de la solicitud estableciendo la propiedad ExclusiveStartKey. Inicialmente, esta propiedad
puede ser null. Para recuperar las páginas siguientes, debe actualizar el valor de esta propiedad de modo
que tome el valor de la clave principal del último elemento de la página anterior.
Example
do
{
var request = new QueryRequest
{
TableName = "Reply",
KeyConditionExpression = "Id = :v_Id",
ExpressionAttributeValues = new Dictionary<string, AttributeValue> {
{":v_Id", new AttributeValue { S = "Amazon DynamoDB#DynamoDB Thread 2" }}
},
// Optional parameters.
Limit = 1,
ExclusiveStartKey = lastKeyEvaluated
};
lastKeyEvaluated = response.LastEvaluatedKey;
Example
Esta función ilustra el uso de la paginación para procesar resultados de varias páginas. DynamoDB tiene
un límite de tamaño de página. Si el resultado supera este tamaño de página, solo se obtiene la primera
página de resultados. Este patrón de codificación garantiza que el código procese todas las páginas del
resultado de la consulta.
• Buscar las respuestas de los últimos 15 días.
• Buscar las respuestas de un intervalo de fechas determinado.
En las dos consultas anteriores se muestra cómo especificar condiciones de clave de ordenación para
delimitar los resultados de la consulta y utilizar otros parámetros de consulta opcionales.
Para obtener instrucciones paso a paso para probar el siguiente ejemplo, consulte Ejemplos de
código .NET (p. 340).
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using System;
using System.Collections.Generic;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;
using Amazon.Util;
namespace com.amazonaws.codesamples
{
class LowLevelQuery
{
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
FindRepliesForAThread(forumName, threadSubject);
FindRepliesForAThreadSpecifyOptionalLimit(forumName, threadSubject);
FindRepliesInLast15DaysWithConfig(forumName, threadSubject);
FindRepliesPostedWithinTimePeriod(forumName, threadSubject);
}
};
// Optional parameter.
ProjectionExpression = "Id, ReplyDateTime, PostedBy",
// Optional parameter.
ConsistentRead = true
};
Console.ReadLine();
}
Console.WriteLine(
attributeName + " " +
(value.S == null ? "" : "S=[" + value.S + "]") +
(value.N == null ? "" : "N=[" + value.N + "]") +
(value.SS == null ? "" : "SS=[" + string.Join(",", value.SS.ToArray())
+ "]") +
(value.NS == null ? "" : "NS=[" + string.Join(",", value.NS.ToArray())
+ "]")
);
}
Console.WriteLine("************************************************");
}
}
}
Una solaScanPuede recuperar un máximo de 1 MB de datos. Si lo desea, DynamoDB puede aplicar una
expresión de filtro a estos datos, para reducir los resultados antes de que se devuelvan al usuario.
Temas
• Expresiones de filtro para Scan (p. 516)
• Limitación del número de elementos del conjunto de resultados (p. 517)
• Paginación de los resultados (p. 517)
• Recuento de los elementos de los resultados (p. 518)
• Unidades de capacidad que Scan consume (p. 519)
• Consistencia de lectura de Scan (p. 519)
• Examen en paralelo (p. 520)
• Examen de tablas e índices: Java (p. 522)
• Examen de tablas e índices: .NET (p. 529)
Una expresión de filtro se aplica después de que la operación Scan haya finalizado, pero antes de
devolver los resultados. Por consiguiente, Scan consume la misma cantidad de capacidad de lectura
aunque se especifique una expresión de filtro.
AScanLa operación puede recuperar un máximo de 1 MB de datos. Este límite se aplica antes de evaluar
la expresión de filtro.
Con Scan, puede especificar cualquier atributo en una expresión de filtro, incluidos los atributos de clave
de partición y de clave de ordenación.
La sintaxis de una expresión de filtro es la misma que la de una expresión de condición. Las expresiones
de filtro pueden utilizar los comparadores, funciones y operadores lógicos que las expresiones de
condición. Para obtener más información, Expresiones de condición (p. 428).
Example
En el siguiente ejemplo de la AWS Command Line Interface (AWS CLI) se examina la tabla Thread y solo
se devuelven los últimos elementos publicados por un usuario determinado.
Por ejemplo, suponga que utiliza la operación Scan en una tabla con un valor de Limit de 6 y sin
expresión de filtro. LaScanEl resultado de contendrá los seis primeros elementos de la tabla.
Ahora, suponga que agrega una expresión de filtro a Scan. En este caso, DynamoDB aplica la expresión
de filtro a los seis elementos que se hayan devuelto y descartará los que no coincidan. El resultado de
Scan final contendrá 6 elementos o menos, según el número de elementos que el filtro elimine.
Una solaScandevuelve solamente un conjunto de resultados que se ajuste al límite de tamaño de 1 MB.
Para determinar si hay más resultados y para recuperarlos de página en página, las aplicaciones deben
hacer lo siguiente:
4. Ir al paso 1.
Puede utilizar la AWS CLI para ver este comportamiento. LaAWS CLIEnvíe bajo nivel deScansolicitudes
a DynamoDB, repetidamente, hasta queLastEvaluatedKeyya no está presente en los resultados.
Considere el siguiente ejemplo de la AWS CLI que examina toda la tabla Movies, pero solo devuelve las
películas de un determinado género.
El elemento LastEvaluatedKey de la respuesta indica que no se han recuperado todos los elementos.
LaAWS CLILuego emite otroScanpara DynamoDB. Este patrón de solicitud y respuesta continúa hasta la
respuesta final.
LaAWSLos SDK se encargan también de las respuestas de DynamoDB de bajo nivel (incluida
la presencia o ausencia deLastEvaluatedKey) y proporcionar varias abstracciones
para paginarScanResultados. Por ejemplo, la interfaz de documentos SDK for Java
proporcionajava.util.Iteratorsoporte para que pueda examinar los resultados de uno en
uno.
Para obtener ejemplos de código en diversos lenguajes de programación, consulte laGuía de
introducción a Amazon DynamoDBy laAWSDocumentación del SDK para su idioma.
Note
Cada respuesta de Scan contendrá los valores de ScannedCount y Count de los elementos que se han
procesado en esa solicitud Scan concreta. Para obtener totales globales para todas las solicitudes Scan,
puede llevar un recuento total de ScannedCount y Count.
De forma predeterminada, una operación Scan no devuelve datos sobre la cantidad de capacidad de
lectura que consume. Sin embargo, puede especificar el parámetro ReturnConsumedCapacity en
una solicitud Scan para obtener esta información. A continuación se muestran los ajustes válidos de
ReturnConsumedCapacity:
DynamoDB calcula el número de unidades de capacidad de lectura consumidas según el tamaño de los
elementos y no según la cantidad de datos que se devuelven a la aplicación. Por este motivo, el número
de unidades de capacidad consumidas es el mismo si se solicitan todos los atributos (el comportamiento
predeterminado) o solo algunos de ellos (mediante una expresión de proyección). El número también será
el mismo tanto si se utiliza una expresión de filtro como si no.
Si requiere lecturas de consistencia alta desde el momento en que se inicie la operación Scan, establezca
el parámetro ConsistentRead en true en la solicitud Scan. De este modo, se asegurará de que todas
las operaciones de escritura que se han completado antes de iniciar Scan se incluyan en la respuesta de
Scan.
Una operación Scan con ConsistentRead establecido en true consumirá el doble de unidades
de capacidad de lectura que si ConsistentRead se deja establecido en su valor predeterminado
(false).
Examen en paralelo
De forma predeterminada, la propiedadScanLa operación procesa los datos secuencialmente.
Amazon DynamoDB devuelve datos a la aplicación en incrementos de 1 MB y una aplicación lleva a
caboScanOperaciones de recuperar los siguientes 1 MB de datos.
Cuanto mayor es la tabla o el índice que se examina, más tiempo pasará aScantarda en completarse.
Además, una secuenciaScanes posible que no siempre pueda utilizar completamente la capacidad de
rendimiento de lectura aprovisionada: Aunque DynamoDB distribuye los datos de una tabla grande a través
de varias particiones físicas, unScanoperación solo puede leer una partición a la vez. Por este motivo,
el desempeño de una operación Scan se ve restringido por el desempeño máximo de cada partición
individual.
Para abordar estos problemas, elScanLa operación puede dividir lógicamente una tabla o un índice
secundario en variosSegmentos de, con varios trabajadores de aplicaciones escaneando los segmentos
en paralelo. Cada proceso de trabajo puede ser un subproceso (en los lenguajes de programación que
admiten la ejecución de múltiples subprocesos) o un proceso del sistema operativo. Para llevar a cabo un
examen en paralelo, cada proceso de trabajo emite su propia solicitud Scan con los siguientes parámetros:
• Segment: segmento que un proceso de trabajo concreto examinará. Cada proceso de trabajo debe
utilizar un valor diferente de Segment.
• TotalSegments: número total de segmentos del examen en paralelo. Este valor debe ser el mismo que
el número de procesos de trabajo que la aplicación va a utilizar.
En el siguiente diagrama se muestra cómo una aplicación multiproceso lleva a cabo una
operaciónScancon tres grados de paralelismo.
En este diagrama, la aplicación crea tres subprocesos y asigna un número a cada uno de ellos. Los
segmentos parten de cero, de modo que el primer número siempre es 0. Cada hilo emite unScansolicitud,
configuración deSegmenta su número designado y la configuraciónTotalSegmentsA 3. Cada
subproceso examina su segmento designado, recupera datos de 1 MB a la vez y devuelve los datos al
subproceso principal de la aplicación.
Un examen en paralelo con un gran número de procesos de trabajo puede consumir fácilmente
todo el desempeño provisionado de la tabla o el índice que se examina. Es preferible evitar este
tipo de exámenes si la tabla o el índice también llevan a cabo una intensa actividad de lectura o
escritura de otras aplicaciones.
Para controlar la cantidad de datos devueltos por cada solicitud, utilice laLimitParámetro. Esto
puede ayudar a evitar situaciones en las que un proceso de trabajo consume todo el desempeño
provisionado a costa de todos los demás procesos de trabajo.
A continuación se indican los pasos que hay que seguir para examinar una tabla con el API de documentos
del AWS SDK for Java.
Los siguientes ejemplos deReplyLa tabla almacena las respuestas de las conversaciones del foro.
Example
En la tabla se mantienen todas las respuestas de varias conversaciones del foro. Por lo tanto, la clave
principal consta de la clave de partición (Id) y la clave de ordenación (ReplyDateTime). En el siguiente
ejemplo de código Java se examina toda la tabla. La instancia de ScanRequest especifica el nombre de
la tabla que debe examinarse.
Example
• Una expresión de filtro para recuperar tan solo aquellos elementos cuyo precio sea menor que 0
(condición de error).
• Una lista de atributos que deben recuperarse para los elementos que aparezcan en los resultados de la
consulta.
Example
Además, si lo desea puede limitar el tamaño de la página, es decir, el número de elementos por página,
con la herramientawithLimitEl método de la solicitud de examen. Cada vez que ejecute elscan, se
obtiene una página de resultados con el número de elementos especificado. Para obtener la página
siguiente, ejecute elscanDe nuevo, proporcionando el valor de clave principal del último elemento de la
página anterior para que el métodoscanmétodo puede devolver el siguiente conjunto de elementos. Esta
información se proporciona dentro de la solicitud mediante lawithExclusiveStartKeyEl método de.
Inicialmente, el parámetro de este método puede ser null. Para recuperar las páginas siguientes, debe
actualizar el valor de esta propiedad de modo que tome el valor de la clave principal del último elemento de
la página anterior.
Example
Además, el SDK for Java proporciona un modelo de persistencia de objetos, que permite
mapear las clases del lado del cliente a las tablas de DynamoDB. Este enfoque puede reducir
la cantidad de código que hay que escribir. Para obtener más información, consulte Java:
DynamoDBMapper (p. 231).
Note
En este ejemplo de código se supone que ya ha cargado datos en DynamoDB para su cuenta
siguiendo las instrucciones delCreación de tablas y carga de datos para ejemplos de código en
DynamoDB (p. 333)sección.
Para obtener instrucciones paso a paso acerca de cómo ejecutar el siguiente ejemplo, consulte
Ejemplos de código Java (p. 338).
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.document;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.ItemCollection;
import com.amazonaws.services.dynamodbv2.document.ScanOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;
findProductsForPriceLessThanOneHundred();
}
System.out.println("Scan of " + tableName + " for items with a price less than
100.");
Iterator<Item> iterator = items.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next().toJSONPretty());
}
}
Además, el SDK for Java proporciona un modelo de persistencia de objetos, que permite
mapear las clases del lado del cliente a las tablas de DynamoDB. Este enfoque puede reducir
la cantidad de código que hay que escribir. Para obtener más información, consulte Java:
DynamoDBMapper (p. 231).
Note
En este ejemplo de código se supone que ya ha cargado datos en DynamoDB para su cuenta
siguiendo las instrucciones delCreación de tablas y carga de datos para ejemplos de código en
DynamoDB (p. 333)sección.
Para obtener instrucciones paso a paso acerca de cómo ejecutar el siguiente ejemplo, consulte
Ejemplos de código Java (p. 338).
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.document;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.ItemCollection;
import com.amazonaws.services.dynamodbv2.document.ScanOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.ScanSpec;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
shutDownExecutorService(executor);
}
@Override
public void run() {
System.out.println("Scanning " + tableName + " segment " + segment + " out of "
+ totalSegments
+ " segments " + itemLimit + " items at a time...");
int totalScannedItemCount = 0;
try {
ScanSpec spec = new
ScanSpec().withMaxResultSize(itemLimit).withTotalSegments(totalSegments)
.withSegment(segment);
}
catch (Exception e) {
System.err.println(e.getMessage());
}
finally {
System.out.println("Scanned " + totalScannedItemCount + " items from
segment " + segment + " out of "
+ totalSegments + " of " + tableName);
}
}
}
try {
System.out.println("Processing record #" + productIndex);
}
catch (Exception e) {
System.err.println("Failed to create item " + productIndex + " in " +
tableName);
System.err.println(e.getMessage());
}
}
}
catch (Exception e) {
System.err.println("Failed to delete table " + tableName);
e.printStackTrace(System.err);
}
}
try {
System.out.println("Creating table " + tableName);
// key
.add(new
AttributeDefinition().withAttributeName(partitionKeyName).withAttributeType(partitionKeyType));
if (sortKeyName != null) {
keySchema.add(new
KeySchemaElement().withAttributeName(sortKeyName).withKeyType(KeyType.RANGE)); // Sort
// key
attributeDefinitions
.add(new
AttributeDefinition().withAttributeName(sortKeyName).withAttributeType(sortKeyType));
}
.withReadCapacityUnits(readCapacityUnits).withWriteCapacityUnits(writeCapacityUnits));
System.out.println("Waiting for " + tableName + " to be created...this may take
a while...");
table.waitForActive();
}
catch (Exception e) {
System.err.println("Failed to create table " + tableName);
e.printStackTrace(System.err);
}
}
A continuación se indican los pasos que hay que seguir para examinar una tabla con elAWS SDK for .NET:
API de bajo nivel de
Los siguientes ejemplos deReplyLa tabla almacena las respuestas de las conversaciones del foro.
Example
En la tabla se mantienen todas las respuestas de varias conversaciones del foro. Por lo tanto, la clave
principal consta de la clave de partición (Id) y la clave de ordenación (ReplyDateTime). En el siguiente
ejemplo de código C# se examina toda la tabla. La instancia de ScanRequest especifica el nombre de la
tabla que debe examinarse.
Example
El método Scan admite varios parámetros opcionales. Por ejemplo, si lo desea puede utilizar un filtro de
examen para filtrar el resultado del examen. En un filtro de examen, puede especificar una condición, así
como un nombre de atributo respecto al que debe evaluarse esa condición. Para obtener más información,
consulteScan.
El código de C# siguiente examina elProductCatalogPara buscar elementos cuyo precio es menor que
0. En el ejemplo se especifican los parámetros opcionales siguientes:
• Un parámetro FilterExpression para recuperar tan solo aquellos elementos cuyo precio sea menor
que 0 (condición de error).
• Un parámetro ProjectionExpression para especificar los atributos que deben recuperarse para los
elementos que aparezcan en los resultados de la consulta.
Example
};
Además, si lo desea puede limitar el tamaño de la página o el número de elementos por página, agregando
la opciónLimitParámetro. Cada vez que ejecute elScan, se obtiene una página de resultados con
el número de elementos especificado. Para obtener la página siguiente, ejecute elScanDe nuevo,
proporcionando el valor de clave principal del último elemento de la página anterior para que el
métodoScanmétodo puede devolver el siguiente conjunto de elementos. Esta información se proporciona
dentro de la solicitud estableciendo la propiedad ExclusiveStartKey. Inicialmente, esta propiedad
puede ser null. Para recuperar las páginas siguientes, debe actualizar el valor de esta propiedad de modo
que tome el valor de la clave principal del último elemento de la página anterior.
Example
Para obtener instrucciones paso a paso para probar el siguiente ejemplo, consulte Ejemplos de
código .NET (p. 340).
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using System;
using System.Collections.Generic;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;
namespace com.amazonaws.codesamples
{
class LowLevelScan
{
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
Console.WriteLine(
attributeName + " " +
(value.S == null ? "" : "S=[" + value.S + "]") +
(value.N == null ? "" : "N=[" + value.N + "]") +
(value.SS == null ? "" : "SS=[" + string.Join(",", value.SS.ToArray())
+ "]") +
(value.NS == null ? "" : "NS=[" + string.Join(",", value.NS.ToArray())
+ "]")
);
}
Console.WriteLine("************************************************");
}
}
}
Para obtener instrucciones paso a paso para probar el siguiente ejemplo, consulte Ejemplos de
código .NET (p. 340).
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;
namespace com.amazonaws.codesamples
{
class LowLevelParallelScan
{
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
private static string tableName = "ProductCatalog";
private static int exampleItemCount = 100;
private static int scanItemLimit = 10;
private static int totalSegments = 5;
tasks[segment] = task;
}
WaitUntilTableReady(tableName);
}
});
Las operaciones PartiQL proporcionan la misma disponibilidad, latencia y rendimiento que las demás
operaciones del plano de datos de DynamoDB.
Temas
¿Qué es PartiQL?
PartiQLproporciona acceso a consultas compatible con SQL en múltiples almacenes de datos que
contienen datos estructurados, datos semiestructurados y datos anidados. Es ampliamente utilizado en
Amazon y ahora está disponible como parte de muchasAWS, incluido DynamoDB.
Para obtener la especificación PartiQL y un tutorial sobre el lenguaje de consulta principal, consulte
laDocumentación de PartiQL.
Note
• La consola de DynamoDB.
• NoSQL Workbench
• La AWS Command Line Interface (AWS CLI).
• API de DynamoDB.
Para obtener información sobre el uso de estos métodos para acceder a DynamoDB, consulteAcceso a
DynamoDB.
Para obtener información acerca de cómo usar la consola de DynamoDB,AWS Command Line Interfaceo
las API de DynamoDB para acceder a DynamoDB, consulteAcceso a DynamoDB.
Console
Note
PartiQL para DynamoDB solo está disponible en la nueva consola de DynamoDB. Para usar
la nueva consola de DynamoDB, elijaPruebe la vista previa de la nueva consolaEn el panel
de navegación del lado izquierdo de la consola.
NoSQL Workbench
1. SeleccionarInstrucción PartiQL.
2. Introduzca la siguiente PartiQLInstrucción de selección
SELECT *
FROM Music
WHERE Artist=? and SongTitle=?
Seleccione el idioma que desee en las pestañas mostradas. Ahora puede copiar este código y
utilizarlo en su aplicación.
5. Si desea que la operación se ejecute inmediatamente, elijaEjecución de.
AWS CLI
Java
import java.util.ArrayList;
import java.util.List;
import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import com.amazonaws.services.dynamodbv2.model.ConditionalCheckFailedException;
import com.amazonaws.services.dynamodbv2.model.ExecuteStatementRequest;
import com.amazonaws.services.dynamodbv2.model.ExecuteStatementResult;
import com.amazonaws.services.dynamodbv2.model.InternalServerErrorException;
import
com.amazonaws.services.dynamodbv2.model.ItemCollectionSizeLimitExceededException;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughputExceededException;
import com.amazonaws.services.dynamodbv2.model.RequestLimitExceededException;
import com.amazonaws.services.dynamodbv2.model.ResourceNotFoundException;
import com.amazonaws.services.dynamodbv2.model.TransactionConflictException;
try {
// Create ExecuteStatementRequest
ExecuteStatementRequest executeStatementRequest = new
ExecuteStatementRequest();
List<AttributeValue> parameters= getPartiQLParameters();
//Create an item in the Music table using the INSERT PartiQL statement
processResults(executeStatementRequest(dynamoDB, "INSERT INTO Music value
{'Artist':?,'SongTitle':?}", parameters));
//Retrieve an item from the Music table using the SELECT PartiQL statement.
processResults(executeStatementRequest(dynamoDB, "SELECT * FROM Music
where Artist=? and SongTitle=?", parameters));
//Update an item in the Music table using the UPDATE PartiQL statement.
processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET
AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} where Artist=? and SongTitle=?",
parameters));
//Add a new string set attribute for an item in the Music table.
processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET
BandMembers =<<'member1', 'member2'>> where Artist=? and SongTitle=?", parameters));
//Retrieve an item from the Music table using the SELECT PartiQL statement.
processResults(executeStatementRequest(dynamoDB, "SELECT * FROM Music
where Artist=? and SongTitle=?", parameters));
Examples
La instrucción siguiente muestra cómo insertar los siguientes tipos de
datos:String,Number,Map,List,Number SetyString Set.
UPDATE TypesTable
SET NumberType=NumberType + 100
SET MapType.NewMapEntry=[2020, 'stringvalue', 2.4]
SET ListType = LIST_APPEND(ListType, [4, <<'string1', 'string2'>>])
SET NumberSetType= SET_ADD(NumberSetType, <<345, 48.4>>)
SET StringSetType = SET_ADD(StringSetType, <<'stringsetvalue1', 'stringsetvalue2'>>)
WHERE primarykey='1'
UPDATE TypesTable
SET NumberType=NumberType - 1
REMOVE ListType[1]
REMOVE MapType.NewMapEntry
Realización de transacciones con PartiQL para DynamoDB (p. 558)yEjecución de operaciones Batch con
PartiQL para DynamoDB (p. 561)también son compatibles con PartiQL para DynamoDB.
Para obtener más información, consultePrácticas recomendadas para consultar y examinar datos, en la
guía para desarrolladores de DynamoDB.
Temas
• Syntax (p. 547)
• Parameters (p. 547)
• Examples (p. 548)
Syntax
Parameters
expresión
(Requerido) Una proyección formada a partir de la*comodín o una lista de proyección de uno o
más nombres de atributos o rutas de documentos del conjunto de resultados. Una expresión puede
consistir en llamadas aUso de funciones PartiQL con Amazon DynamoDB (p. 553)o campos
modificados porOperadores aritméticos, comparativos y lógicos de PartiQL para DynamoDB
(p. 557).
tabla
SELECT *
FROM Orders
WHERE OrderID = 100
SELECT *
FROM Orders
WHERE OrderID = 100 and Address='some address'
SELECT *
FROM Orders
WHERE OrderID = 100 or pk = 200
SELECT *
FROM Orders
WHERE OrderID IN [100, 300, 234]
SELECT *
FROM Orders
WHERE OrderID > 1
SELECT *
FROM Orders
WHERE Address='some address'
SELECT *
FROM Orders
WHERE OrderID = 100 OR Address='some address'
clave
(Opcional) Una clave hash o una clave de ordenación que se va a utilizar para ordenar los resultados
devueltos. El orden predeterminado es ascendente (ASC) especificaDESCsi desea que los resultados
se vuelvan a ejecutar en orden descendente.
Note
Examples
La siguiente consulta devuelve un elemento, si existe, de laOrdersespecificando la clave de
partición,OrderIDy el uso del operador de igualdad.
La siguiente consulta devuelve todos los elementos de la.OrdersTabla que tiene una clave de partición
específica,OrderID, valores utilizando el operador OR.
La siguiente consulta devuelve todos los elementos de la.OrdersTabla que tiene una clave de partición
específica,OrderID, valores utilizando el operador IN. Los resultados devueltos están en orden
descendente, según el parámetroOrderIDValor de atributo clave.
La siguiente consulta muestra un análisis de tabla completo que devuelve todos los elementos
delOrdersque tienen unTotalmayor que 500, dondeTotales un atributo que no es clave.
La siguiente consulta muestra un análisis de tabla completo que devuelve todos los elementos
delOrdersTabla específica de un valorTotalrango de órdenes, utilizando el operador IN y un atributo que
no es claveTotal.
La siguiente consulta muestra un análisis de tabla completo que devuelve todos los elementos
delOrdersTabla específica de un valorTotalrango de orden, utilizando el operador BETHE y un atributo
que no es claveTotal.
La siguiente consulta devuelve la primera fecha en que se utilizó un dispositivo firestick para ver
especificando la clave de particiónCustomerIDy clave de ordenaciónMovieIDen la condición de cláusula
WHERE y utilizando rutas de documento en la cláusula SELECT.
SELECT Devices.FireStick.DateWatched[0]
FROM WatchList
WHERE CustomerID= 'C1' AND MovieID= 'M1'
La siguiente consulta muestra un análisis de tabla completo que devuelve la lista de elementos en los que
un dispositivo de firestick se utilizó por primera vez después del 12/12/19 utilizando rutas de documento en
la condición de cláusula WHERE.
SELECT Devices
FROM WatchList
WHERE Devices.FireStick.DateWatched[0] >= '12/12/19'
Sólo puede actualizar un elemento a la vez; no puede emitir una sola instrucción de
DynamoDB PartiQL que actualice varios elementos. Para obtener más información acerca de
la actualización de varios elementos, consulteRealización de transacciones con PartiQL para
DynamoDB (p. 558)orEjecución de operaciones Batch con PartiQL para DynamoDB (p. 561).
Temas
• Syntax (p. 549)
• Parameters (p. 549)
• Valor devuelto (p. 550)
• Examples (p. 550)
Syntax
UPDATE table
[SET | REMOVE] path [= data] […]
WHERE condition [RETURNING returnvalues]
<returnvalues> ::= [ALL OLD | MODIFIED OLD | ALL NEW | MODIFIED NEW] *
Parameters
tabla
path
(Necesario) Criterios de selección para el elemento que se va a modificar. Esta condición debe
resolverse con un único valor de clave principal.
valores de retorno
(Opcional) Utilizarreturnvaluessi desea obtener los atributos del elemento tal como aparecen antes
o después de que se actualicen. Los valores válidos son:
• ALL OLD *: devuelve todos los atributos del elemento, tal y como aparecían antes de la operación
de actualización.
• MODIFIED OLD *: devuelve sólo los atributos actualizados, tal y como aparecían antes de la
operación de actualización.
• ALL NEW *: devuelve todos los atributos del elemento, tal como aparecen después de la operación
de actualización.
• MODIFIED NEW *: devuelve solamente los atributos actualizados, tal y como aparecen después de
la entradaUpdateItem.
Valor devuelto
Esta instrucción no devuelve un valor a menos quereturnvaluesse especifica.
Note
Si la cláusula WHERE de la instrucción UPDATE no se evalúa como true para cualquier elemento
de la tabla de DynamoDB,ConditionalCheckFailedExceptionse devuelve.
Examples
Actualizar un valor de atributo en un elemento existente. Si el atributo no existe, se crea.
UPDATE Music
SET AwardsWon=1
SET AwardDetail={'Grammys':[2020, 2018]}
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'
UPDATE Music
UPDATE Music
REMOVE AwardDetail.Grammys[2]
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'
UPDATE Music
SET AwardDetail.BillBoard=[2020]
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'
UPDATE Music
SET BandMembers =<<'member1', 'member2'>>
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'
UPDATE Music
SET BandMembers =set_add(BandMembers, <<'newbandmember'>>)
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'
Solo puede eliminar los elementos de uno en uno. No puede emitir una sola instrucción
de DynamoDB PartiQL que elimine varios elementos. Para obtener información sobre
cómo eliminar varios elementos, consulteRealización de transacciones con PartiQL para
DynamoDB (p. 558)orEjecución de operaciones Batch con PartiQL para DynamoDB (p. 561).
Temas
• Syntax (p. 551)
• Parameters (p. 552)
• Valor devuelto (p. 552)
• Examples (p. 552)
Syntax
Parameters
tabla
(Necesario) Criterios de selección para el elemento que se va a eliminar; esta condición debe
resolverse en un único valor de clave principal.
valores de retorno
(Opcional) UtilizarreturnvaluesSi desea obtener los atributos del elemento tal y como aparecían
antes de eliminarlos. Los valores válidos son:
• ALL OLD *: se devuelve el contenido del elemento anterior.
Valor devuelto
Esta instrucción no devuelve un valor a menos quereturnvaluesse especifica.
Note
Si la tabla de DynamoDB no tiene ningún elemento con la misma clave principal que la del
elemento para el que se emite DELETE, se devuelve SUCCESS con 0 elementos eliminados. Si
la tabla tiene un elemento con la misma clave principal, pero la condición de la cláusula WHERE
de la instrucción DELETE se evalúa como false,ConditionalCheckFailedExceptionse
devuelve.
Examples
DELETE FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks'
Sólo puede insertar un elemento a la vez; no puede emitir una sola instrucción de
DynamoDB PartiQL que inserte varios elementos. Para obtener información sobre
cómo insertar varios elementos, consulteRealización de transacciones con PartiQL para
DynamoDB (p. 558)orEjecución de operaciones Batch con PartiQL para DynamoDB (p. 561).
Temas
• Syntax (p. 552)
• Parameters (p. 553)
• Valor devuelto (p. 553)
• Examples (p. 553)
Syntax
Inserte un único elemento.
Parameters
tabla
(Obligatorio) La tabla en la que desea insertar los datos. La tabla debe existir previamente.
elemento
Valor devuelto
Esta instrucción no devuelve ningún valor.
Note
Si la tabla de DynamoDB ya tiene un elemento con la misma clave principal que la clave principal
del elemento que se va a insertar,DuplicateItemExceptionse devuelve.
Examples
INSERT INTO
Music value {'Artist' : 'Acme Band','SongTitle' : 'PartiQL Rocks'}
Funciones de agregación
• Uso de la función SIZE con PartiQL para Amazon DynamoDB (p. 556)
Funciones condicionales
• Uso de la función EXISTS con PartiQL para DynamoDB (p. 553)
• Uso de la función ATTRIBUTE_TYPE con PartiQL para DynamoDB (p. 555)
• Uso de la función BEGINS_WITH con PartiQL para DynamoDB (p. 554)
• Uso de la función CONTINS con PartiQL para DynamoDB (p. 556)
• Uso de la función FISTING con PartiQL para DynamoDB (p. 555)
Dado un valor, devuelveTRUEsi el valor es una colección no vacía. De lo contrario, devuelve FALSE.
Note
Syntax
EXISTS ( statement )
Arguments
statement
La instrucción SELECT debe especificar una clave principal completa y otra condición.
Tipo de retorno
bool
Examples
EXISTS(
SELECT * FROM "Music"
WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks')
Syntax
begins_with(path, value )
Arguments
path
Tipo de retorno
bool
Examples
Syntax
Arguments
attributeName
Tipo de retorno
bool
Examples
Syntax
Arguments
attributeName
(Necesario) Tipo de atributo que se va a comprobar. Para obtener una lista de valores válidos,
consulte DynamoDBtipo_atributo.
Tipo de retorno
bool
Examples
Syntax
Arguments
path
Tipo de retorno
bool
Examples
Syntax
size( path)
Arguments
path
Tipo de retorno
int
Examples
Operadores aritméticos
"." Descripción
+ Add
- Subtract (Sustracción)
Operadores de comparación
"." Descripción
= Igual que
Operadores lógicos
"." Descripción
"." Descripción
Temas
• Syntax (p. 558)
• Parameters (p. 558)
• Valores de retorno (p. 559)
• Examples (p. 559)
Syntax
[
{
"Statement":" statement ",
"Parameters":[
{
" parametertype " : " parametervalue "
}, ...]
} , ...
]
Parameters
statement
ParameterValue
Valores de retorno
Esta instrucción no devuelve ningún valor.
Note
Si alguna de las operaciones singleton INSERT, UPDATE o DELETE devuelve un error, las
transacciones se cancelan con la opciónTransactionCanceledException, y el código de
motivo de cancelación incluye los errores de las operaciones singleton individuales.
Examples
AWS CLI
[
{
"Statement": "EXISTS(SELECT * FROM Music where Artist='No One You Know' and
SongTitle='Call Me Today' and Awards is MISSING)"
},
{
"Statement": "INSERT INTO Music value {'Artist':'?','SongTitle':'?'}",
"Parameters": [{"S": "Acme Band"}, {"S": "Best Song"}]
},
{
"Statement": "UPDATE Music SET AwardsWon=1 SET AwardDetail={'Grammys':
[2020, 2018]} where Artist='Acme Band' and SongTitle='PartiQL Rocks'"
}
]
Java
try {
// Create ExecuteTransactionRequest
ExecuteTransactionRequest executeTransactionRequest =
createExecuteTransactionRequest();
ExecuteTransactionResult executeTransactionResult =
dynamoDB.executeTransaction(executeTransactionRequest);
System.out.println("ExecuteTransaction successful.");
// Handle executeTransactionResult
} catch (Exception e) {
handleExecuteTransactionErrors(e);
}
// Create statements
List<ParameterizedStatement> statements = getPartiQLTransactionStatements();
request.setTransactStatements(statements);
return request;
}
statements.add(new ParameterizedStatement()
.withStatement("EXISTS(SELECT * FROM Music where
Artist='No One You Know' and SongTitle='Call Me Today' and Awards is MISSING)"));
statements.add(new ParameterizedStatement()
.withStatement("INSERT INTO Music value
{'Artist':'?','SongTitle':'?'}")
.withParameters(new AttributeValue("Acme Band"),new
AttributeValue("Best Song")));
statements.add(new ParameterizedStatement()
.withStatement("UPDATE Music SET AwardsWon=1 SET
AwardDetail={'Grammys':[2020, 2018]} where Artist='Acme Band' and SongTitle='PartiQL
Rocks'"));
return statements;
}
Todo el lote debe constar de sentencias de lectura o de escritura; no se pueden mezclar ambas
en un solo lote.
Temas
• Syntax (p. 561)
• Parameters (p. 562)
• Examples (p. 562)
Syntax
[
{
"Statement":" statement ",
"Parameters":[
{
Parameters
statement
Examples
AWS CLI
[
{
"Statement": "INSERT INTO Music value {'Artist':'?','SongTitle':'?'}",
"Parameters": [{"S": "Acme Band"}, {"S": "Best Song"}]
},
{
"Statement": "UPDATE Music SET AwardsWon=1 SET AwardDetail={'Grammys':
[2020, 2018]} where Artist='Acme Band' and SongTitle='PartiQL Rocks'"
}
]
Java
try {
// Create BatchExecuteStatementRequest
BatchExecuteStatementRequest batchExecuteStatementRequest =
createBatchExecuteStatementRequest();
BatchExecuteStatementResult batchExecuteStatementResult =
dynamoDB.batchExecuteStatement(batchExecuteStatementRequest);
System.out.println("BatchExecuteStatement successful.");
// Handle batchExecuteStatementResult
} catch (Exception e) {
handleBatchExecuteStatementErrors(e);
}
}
return AmazonDynamoDBClientBuilder.standard().withRegion(region).build();
}
// Create statements
List<BatchStatementRequest> statements = getPartiQLBatchStatements();
request.setStatements(statements);
return request;
}
statements.add(new BatchStatementRequest()
.withStatement("INSERT INTO Music value {'Artist':'Acme
Band','SongTitle':'PartiQL Rocks'}"));
statements.add(new BatchStatementRequest()
.withStatement("UPDATE Music set
AwardDetail.BillBoard=[2020] where Artist='Acme Band' and SongTitle='PartiQL
Rocks'"));
return statements;
}
ptee.getErrorMessage());
} catch (ResourceNotFoundException rnfe) {
System.out.println("One of the tables was not found, verify table exists
before retrying. Error: " + rnfe.getErrorMessage());
} catch (AmazonServiceException ase) {
System.out.println("An AmazonServiceException occurred, indicates that the
request was correctly transmitted to the DynamoDB " +
"service, but for some reason, the service was not able to process it,
and returned an error response instead. Investigate and " +
"configure retry strategy. Error type: " + ase.getErrorType() + ".
Error message: " + ase.getErrorMessage());
} catch (AmazonClientException ace) {
System.out.println("An AmazonClientException occurred, indicates that the
client was unable to get a response from DynamoDB " +
"service, or the client was unable to parse the response from the
service. Investigate and configure retry strategy. "+
"Error: " + ace.getMessage());
} catch (Exception e) {
System.out.println("An exception occurred, investigate and configure retry
strategy. Error: " + e.getMessage());
}
}
• Para leer elementos que utilizan PartiQL para DynamoDB, debe tenerdynamodb:PartiQLSelecten la
tabla o el índice.
• Para insertar elementos utilizando PartiQL para DynamoDB, debe tenerdynamodb:PartiQLInserten
la tabla o el índice.
• Para actualizar elementos con PartiQL para DynamoDB, debe tenerdynamodb:PartiQLUpdateen la
tabla o el índice.
• Para eliminar elementos que utilizan PartiQL para DynamoDB, debe
tenerdynamodb:PartiQLDeleteen la tabla o el índice.
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"dynamodb:PartiQLInsert",
"dynamodb:PartiQLUpdate",
"dynamodb:PartiQLDelete",
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music"
]
}
]
}
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music"
]
}
]
}
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"dynamodb:PartiQLInsert"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music/index/index1"
]
}
]
}
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"dynamodb:PartiQLInsert",
"dynamodb:PartiQLUpdate",
"dynamodb:PartiQLDelete",
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music"
],
"Condition":{
"StringEquals":{
"dynamodb:EnclosingOperation":[
"ExecuteTransaction"
]
}
}
}
]
}
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Deny",
"Action":[
"dynamodb:PartiQLInsert",
"dynamodb:PartiQLUpdate",
"dynamodb:PartiQLDelete",
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music"
],
"Condition":{
"StringEquals":{
"dynamodb:EnclosingOperation":[
"ExecuteTransaction"
]
}
}
},
{
"Effect":"Allow",
"Action":[
"dynamodb:PartiQLInsert",
"dynamodb:PartiQLUpdate",
"dynamodb:PartiQLDelete",
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music"
]
}
]
}
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Deny",
"Action":[
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/WatchList"
],
"Condition":{
"Bool":{
"dynamodb:FullTableScan":[
"true"
]
}
}
},
{
"Effect":"Allow",
"Action":[
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/WatchList"
]
}
]
}
Amazon DynamoDB proporciona un acceso rápido a los elementos de una tabla especificando sus valores
de clave principal. Sin embargo, muchas aplicaciones podrían beneficiarse de disponer de una o varias
claves secundarias (o alternativas) para permitir un acceso eficiente a datos con otros atributos aparte de
la clave principal. Para responder a esta necesidad, puede crear uno o varios índices secundarios en una
tabla y emitir solicitudes Query o Scan para estos índices.
Aíndice secundarioEs una estructura de datos que contiene un subconjunto de atributos de una tabla,
además de una clave alternativa para admitirQueryOperaciones. Puede recuperar datos del índice usando
una operación Query prácticamente de la misma forma que Query se usa en una tabla. Una tabla puede
tener varios índices secundarios, lo que permite a las aplicaciones obtener acceso a distintos patrones de
consulta.
Note
También se pueden utilizar operaciones Scan en los índices, de un modo bastante similar a como
Scan se usaría en una tabla.
Cada índice secundario está asociado exactamente con una tabla de la que obtiene sus datos. Esta
se denomina tabla base del índice. Al crear un índice, se define una clave alternativa para él (clave de
partición y clave de ordenación). También se definen los atributos que se desee.Proyecciones, o copiado,
de la tabla base en el índice. DynamoDB copia estos atributos en el índice, junto con los atributos de clave
principal de la tabla base. A partir de ese momento, puede consultar o examinar el índice exactamente
igual que una tabla.
DynamoDB mantiene automáticamente cada índice secundario. Cuando se agregan, modifican o eliminan
elementos en la tabla base, los índices basados en esa tabla se actualizan también para reflejar estos
cambios.
• Índice secundario mundial—Índice con una clave de partición y una clave de ordenación que pueden
diferir de las claves de la tabla base. Un índice secundario global se considera "global" porque las
consultas que se realizan en el índice pueden abarcar todos los datos de la tabla base y todas las
particiones. Un índice secundario global se almacena en su propio espacio de partición lejos de la tabla
base y se escala por separado de la tabla base.
• Índice secundario local—Índice que tiene la misma clave de partición que la tabla base, pero una clave
de ordenación distinta. Un índice secundario local se considera "local" en el sentido de que el ámbito
de todas sus particiones se corresponde con una partición de la tabla base que tiene el mismo valor de
clave de partición.
Debe tener en cuenta los requisitos de la aplicación al determinar qué tipo de índice va a utilizar. En
la tabla siguiente se muestran las principales diferencias entre un índice secundario global y un índice
secundario local.
Restricciones de tamaño por No hay restricciones de tamaño Para cada valor de clave de
valor de clave de partición para los índices secundarios partición, el tamaño total de
globales. todos los elementos indexados
debe ser de 10 GB o menos.
Operaciones online con índices Los índices secundarios Los índices secundarios locales
globales se pueden crear al se crean a la vez que se crea la
mismo tiempo que se crea una tabla. No se puede agregar un
tabla. También puede agregar índice secundario local a una
un nuevo índice secundario tabla existente, ni tampoco se
global a una tabla existente o puede eliminar ningún índice
eliminar un índice secundario secundario local que ya exista.
global existente. Para obtener
más información, consulte
Administración de índices
secundarios globales (p. 579).
Consistencia de lectura Las consultas sobre los índices Cuando se consulta un índice
secundarios globales solo secundario local, se puede elegir
admiten la consistencia final. entre la consistencia final o alta.
Si desea crear más de una tabla con índices secundarios, debe hacerlo de forma secuencial. Por ejemplo,
tendría que crear la primera tabla y esperar a que su estado fuese ACTIVE, luego la siguiente tabla y
esperar a que adquiriese el estado ACTIVE, y así sucesivamente. Si intenta crear simultáneamente más de
una tabla con un índice secundario, DynamoDB devuelve unLimitExceededException.
• Tipo de índice que se va a crear, ya sea un índice secundario global o un índice secundario local.
• El nombre del índice. Las reglas de nomenclatura de los índices son las mismas que para las tablas,
como se indica en Cuotas de servicio, cuenta y tabla en Amazon DynamoDB (p. 1066). El nombre debe
ser único para la tabla base al que está asociado, pero puede utilizar el mismo nombre para índices que
estén asociados a tablas base distintas.
• El esquema de claves del índice. Cada atributo del esquema de claves del índice debe ser un atributo de
nivel superior debe de tipo String, Number y Binary. No se permiten otros tipos de datos, como los
documentos y los conjuntos. Los demás requisitos del esquema de claves dependen del tipo de índice:
• Para un índice secundario global, la clave de partición puede ser cualquier atributo escalar de la tabla
base. La clave de ordenación es opcional y también puede ser cualquier atributo escalar de la tabla
base.
• Para un índice secundario local, la clave de partición debe ser igual que la tabla de partición de la
tabla base y la clave de ordenación debe ser un atributo sin clave de la tabla base de claves.
• Los atributos adicionales, si los hay, de la tabla base que se proyectarán en el índice. Estos atributos
se agregan a los atributos de clave de la tabla, que se proyectan de forma automática en cada índice.
Puede proyectar atributos de cualquier tipo de datos, incluidos escalares, documentos y conjuntos.
• Los ajustes de desempeño provisionado del índice, si es preciso:
• Para un índice secundario global, debe especificar los ajustes de unidades de capacidad de lectura
y escritura. Estos ajustes de desempeño provisionado son independientes de los ajustes de la tabla
base.
• Para un índice secundario local, no es preciso especificar los ajustes de unidades de capacidad
de lectura y escritura. Todas las operaciones de lectura y escritura en un índice secundario local
consumen el desempeño provisionado configurado para su tabla base.
Para disfrutar de la máxima flexibilidad en las consultas, puede crear hasta 20 índices secundarios
globales (cuota predeterminada) y hasta 5 índices secundarios locales por tabla.
Para los índices secundarios globales, la cuota es de cinco para los siguientes índicesAWSRegiones:
Para obtener acceso a los datos de un índice secundario, utilice las opcionesQueryorScan. Debe
especificar el nombre de la tabla base y el nombre del índice que se desea utilizar, los atributos que se
devolverán en los resultados y las expresiones de condición o filtros que se van a aplicar. DynamoDB
puede devolver los resultados en orden ascendente o descendente.
Al eliminar una tabla, todos los índices asociados a ella se eliminan también.
Para obtener las prácticas recomendadas, consulte Prácticas recomendadas para utilizar índices
secundarios en DynamoDB (p. 1003).
Temas
• ESCENARIO Uso de un índice secundario global (p. 571)
• Proyecciones de atributos (p. 574)
Ahora, supongamos que desea escribir una aplicación de clasificación para mostrar las puntuaciones
máximas de cada juego. Una consulta que especifique los atributos de clave (UserId y GameTitle)
sería muy eficiente. Sin embargo, si la aplicación tuviese que recuperar datos de GameScores solo según
GameTitle, tendría que usar una operación Scan. A medida que se agregan elementos a la tabla, los
exámenes de todos los datos resultarían lentos e ineficientes. En consecuencia, resultaría difícil responder
a preguntas como estas:
Para agilizar las consultas de atributos sin clave, puede crear un índice secundario global. Un índice
secundario global contiene una selección de atributos de la tabla base, pero están organizados por una
clave principal distinta de la clave principal de la tabla. La clave de índice no requiere disponer de ninguno
de los atributos de clave de la tabla. Ni siquiera necesita el mismo esquema de claves que una tabla.
Por ejemplo, podría crear un índice secundario global denominadoGameTitleIndex, con una clave
de partición deGameTitley una clave de clasificación deTopScore. Puesto que los atributos de clave
principal de la tabla base siempre se proyectan en un índice, el atributo UserId también está presente. En
el siguiente diagrama se muestra el aspecto que tendría el índice GameTitleIndex.
Ahora, puede consultar GameTitleIndex y obtener fácilmente las puntuaciones de Meteor Blasters. Los
resultados se ordenan según los valores de la clave de ordenación, TopScore. Si establece el parámetro
ScanIndexForward en false, los resultados se devuelven en orden descendente, de modo que la
puntuación máxima se devuelve en primer lugar.
Cada índice secundario global debe tener una clave de partición y puede tener una clave de ordenación
opcional. El esquema de claves de índice puede ser distinto del de la tabla base. Puede tener una clave
principal simple (clave de partición) y, en cambio, se podría crear un índice secundario global con una
clave principal compuesta (clave de partición y clave de ordenación), o viceversa. Los atributos de clave
del índice pueden constar de cualquier atributo de nivel superior de tipo String, Number o Binary de la
tabla base. No se admite ningún otro tipo de escalar, documento ni conjunto.
Puede proyectar otros atributos de la tabla base en el índice si lo desea. Cuando se consulta el índice,
DynamoDB puede recuperar estos atributos proyectados de forma eficiente. Sin embargo, las consultas
globales de índice secundario no permiten recuperar atributos de la tabla base. Por ejemplo, si consulta
GameTitleIndex como se muestra en el diagrama anterior, la consulta no podría obtener acceso a
ningún atributo sin clave excepto a TopScore (aunque los atributos de clave GameTitle y UserId se
proyectarían automáticamente).
En una tabla de DynamoDB, cada valor de clave debe ser único. Sin embargo, no es obligatorio que
los valores de clave de un índice secundario global sean únicos. A modo de ejemplo, supongamos que
un juego denominado Comet Quest es especialmente difícil, de tal forma que muchos usuarios nuevos
intentan lograr una puntuación superior a cero, sin conseguirlo. A continuación se muestran algunos datos
que podrían representar esta situación.
Solo aparecerán en la respuesta los elementos que tengan los valores de clave especificados. Dentro de
ese conjunto de datos, los elementos no aparecen en ningún orden concreto.
Un índice secundario global solo realiza el seguimiento de los elementos de datos cuyos atributos de
clave existen realmente. Por ejemplo, supongamos que ha agregado otro elemento nuevo a la tabla
GameScores, pero que solo ha proporcionado los atributos de clave principal obligatorios.
UserId GameTitle
Una consulta parecida de GameTitleIndex devolvería tres elementos, en lugar de cuatro. Esto se debe a
que el elemento cuyo valor de TopScore no existe no se propaga al índice.
Proyecciones de atributos
AProjectiones el conjunto de atributos que se copia de una tabla en un índice secundario. La clave de
partición y la clave de ordenación de la tabla siempre se proyectan en el índice; puede proyectar otros
atributos para admitir los requisitos de consulta de la aplicación. Cuando consulta un índice, Amazon
DynamoDB puede acceder a cualquier atributo de la proyección como si esos atributos estuvieran en una
tabla propia.
Al crear un índice secundario, debe especificar los atributos que se proyectarán en el índice. DynamoDB
ofrece tres opciones diferentes para esto:
• KEYS_ONLY: cada elemento del índice consta únicamente de los valores de la clave de partición y la
clave de ordenación de la tabla, así como de los valores de las claves del índice. LaKEYS_ONLYda como
resultado el índice secundario más pequeño posible.
• INCLUDE— Además de los atributos descritos enKEYS_ONLY, el índice secundario incluirá otros
atributos sin clave que se especifiquen.
• TODO: el índice secundario incluye todos los atributos de la tabla de origen. Debido a que todos los
datos de la tabla están duplicados en el índice, unALLresultados de proyección en el índice secundario
más grande posible.
Dado que los atributos sin clave Wins y Losses se proyectan en el índice, una aplicación puede
determinar la proporción de partidas ganadas respecto a las perdidas en cualquier juego, o para cualquier
combinación de juego e identificador de usuario.
Al elegir los atributos para proyectarlos en un índice secundario global, debe estudiar el equilibrio entre los
costos de desempeño provisionado y de almacenamiento:
• Si solo necesita obtener acceso a algunos atributos con la menor latencia posible, puede ser
conveniente proyectar solamente esos atributos en un índice secundario global. Cuando menor es el
índice, menos cuesta almacenarlo y menos son los costos de escritura.
• Si la aplicación va a obtener acceso con frecuencia a determinados atributos sin clave, puede ser
interesante proyectarlos en un índice secundario global. Los costos del almacenamiento adicionales del
índice secundario global compensarán el costo que supondrían los frecuentes exámenes de la tabla.
• Si tiene que obtener acceso a la mayoría de los atributos sin clave con frecuencia, puede proyectar estos
atributos o, incluso, toda la tabla base, en un índice secundario global. Esto le da la máxima flexibilidad.
Sin embargo, el costo del almacenamiento aumentaría y podría llegar a duplicarse.
• Si la aplicación tiene que consultar una tabla con poca frecuencia, pero tiene que realizar gran cantidad
de escrituras o actualizaciones en los datos de la tabla, puede ser conveniente proyectar KEYS_ONLY.
El índice secundario global tendrá el tamaño mínimo, pero estaría disponible siempre que se requiriese
para actividades de consulta.
Tomemos los datos siguientes devueltos por una operación Query que solicita datos de juegos para una
aplicación de clasificación de juegos.
{
"TableName": "GameScores",
"IndexName": "GameTitleIndex",
"KeyConditionExpression": "GameTitle = :v_title",
"ExpressionAttributeValues": {
":v_title": {"S": "Meteor Blasters"}
},
"ProjectionExpression": "UserId, TopScore",
"ScanIndexForward": false
}
En esta consulta:
Los índices secundarios globales heredan el modo de capacidad de lectura/escritura de la tabla base. Para
obtener más información, consulte Consideraciones sobre el cambio del modo de capacidad de lectura/
escritura (p. 349).
Al crear un índice secundario global, debe especificar uno o varios atributos de clave de índice y sus
tipos de datos. Esto significa que, cada vez que se escribe un elemento en la tabla base, los tipos de
datos de esos atributos deben coincidir con los tipos de datos del esquema de claves de índice. En el
caso de GameTitleIndex, el tipo de datos de la clave de partición GameTitle del índice es String.
La clave de ordenación TopScore del índice es de tipo Number. Si intenta agregar un elemento a la
carpetaGameScoresy especifique un tipo de datos diferente paraGameTitleorTopScore, DynamoDB
devuelve unValidationExceptiondebido a la falta de coincidencia del tipo de datos.
Al colocar o eliminar elementos en una tabla, sus índices secundarios globales se actualizan de forma
consistente final. En condiciones normales, los cambios en los datos de la tabla se propagan a los índices
secundarios globales casi al instante. No obstante, en algunos escenarios de error improbables, pueden
producirse retardos de propagación más prolongados. Debido a ello, las aplicaciones deben prever y
controlar las situaciones en las que una consulta de un índice secundario global devuelva resultados que
no se encuentren actualizados.
Si escribe un elemento en una tabla, no tiene que especificar los atributos de ninguna clave de ordenación
del índice secundario global. Si utilizamos GameTitleIndex a modo de ejemplo, no sería preciso
especificar un valor para el atributo TopScore para poder escribir un nuevo elemento en la tabla
GameScores. En este caso, DynamoDB no escribe ningún dato en el índice para este elemento concreto.
Una tabla con muchos índices secundarios globales devengará costos más elevados por la actividad de
escritura que las tablas con menos índices. Para obtener más información, consulte Consideraciones sobre
el desempeño provisionado para los índices secundarios globales (p. 577).
Por ejemplo, siQuerySu solicitud se someterá a una limitación global y supere su capacidad de lectura
provisionada, la solicitud se someterá a una limitación controlada. Si realiza una intensa actividad de
escritura en la tabla, pero un índice secundario global de esa tabla no tiene suficiente capacidad de
escritura, la actividad de escritura de la tabla se someterá a una limitación limitada.
Note
Para evitar una posible limitación controlada, la capacidad de escritura provisionada para un
índice secundario global debe ser igual o mayor que la capacidad de escritura de la tabla base, ya
que las nuevas actualizaciones se escribirán tanto en la tabla base como en el índice secundario
global.
Para modificar los ajustes de desempeño provisionado de un índice secundario global, utilice
elDescribeTable. Se devuelve información detallada sobre cada índices secundario global de la tabla.
Para las consultas de índices secundarios globales, DynamoDB calcula la actividad de lectura provisionada
de la misma forma que para las consultas en una tabla. La única diferencia es que el cálculo se basa
en el tamaño de las entradas del índice, no en el tamaño del elemento en la tabla base. El número de
unidades de capacidad de lectura es la suma de todos los tamaños de los atributos proyectados para
todos los elementos devueltos. El resultado se redondea al múltiplo de inmediatamente superior a 4 KB.
Para obtener más información sobre cómo DynamoDB calcula el consumo de desempeño provisionado,
consulteAdministración de la configuración en tablas de capacidad provisionadas de DynamoDB (p. 350).
Tamaño máximo de los resultados que devuelve unQueryLa operación es de 1 MB. Esta cifra incluye los
tamaños de todos los nombres y valores de los atributos de todos los elementos devueltos.
Por ejemplo, tomemos un índice secundario global en el que cada elemento contiene 2000 bytes de
datos. Ahora supongamos queQueryeste índice y que elKeyConditionExpressioncoincide con ocho
elementos. El tamaño total de los elementos coincidentes es de 2000 bytes × 8 elementos = 16 000 bytes.
El resultado se redondea al múltiplo de 4 KB. Dado que las consultas de índices secundarios globales
presentan consistencia final, el costo total es de 0,5 × (16 KB/4 KB), lo que equivale a 2 unidades de
capacidad de lectura.
Para que una escritura en una tabla se lleve a cabo correctamente, la capacidad de desempeño
provisionada definida para la tabla y todos sus índices secundarios globales debe ser suficiente para
admitir esa escritura. De lo contrario, la escritura en la tabla se someterá a una limitación controlada.
• Si escribe un nuevo elemento en la tabla que define un atributo indexado o actualiza un elemento
existente para definir un atributo indexado no definido previamente, se requiere una operación de
escritura para colocar el elemento en el índice.
• Si al actualizar la tabla se cambia el valor de un atributo de clave indexado (de A a B), se requieren dos
escrituras, una para eliminar el elemento anterior del índice y otra para colocar el nuevo elemento en el
índice.
• Si ya hay un elemento en el índice, pero al escribir en la tabla se elimina el atributo indexado, se requiere
una escritura para eliminar la proyección del elemento anterior del índice.
• Si no hay ningún elemento presente en el índice antes o después de actualizar el elemento, no se
devenga ningún costo de escritura adicional para el índice.
• Si al actualizar la tabla solo se cambia el valor de los atributos proyectados en el esquema de claves del
índice, pero no se cambia el valor de ningún atributo de clave indexado, se requiere una escritura para
actualizar los valores de los atributos proyectados en el índice.
Al calcular las unidades de capacidad de escritura, en todos estos factores se presupone que el tamaño de
cada elemento del índice es menor o igual que el tamaño de elemento de 1 KB. Las entradas de índice de
mayor tamaño requieren más unidades de capacidad de escritura. Para minimizar los costos de escritura,
es conveniente estudiar qué atributos tendrán que devolver las consultas y proyectar solamente esos
atributos en el índice.
atributos. SusAWSSe aplica un cargo en su cuenta de almacenamiento por el elemento en la tabla base y
también por el almacenamiento de los atributos en todos los índices secundarios globales de esa tabla.
• El tamaño en bytes de la clave principal (clave de partición y clave de ordenación) de la tabla base
• El tamaño en bytes del atributo de clave de índice
• El tamaño en bytes de los atributos proyectados (si procede)
• 100 bytes de gastos generales por cada elemento de índice
Para calcular los requisitos de almacenamiento de un índice secundario global, puede calcular el tamaño
medio de un elemento del índice y, a continuación, multiplicarlo por el número de elementos de la tabla
base que tienen atributos de clave de índice secundario global.
Si una tabla contiene un elemento en el que no se ha definido un atributo determinado, pero ese atributo se
ha definido como clave de partición o de ordenación del índice, DynamoDB no escribirá ningún dato para
ese elemento en el índice.
Temas
• Creación de una tabla con índices secundarios globales (p. 579)
• Descripción de los índices secundarios globales en una tabla (p. 580)
• Agregar un índice secundario global a una tabla existente (p. 580)
• Eliminación de un índice secundario global (p. 582)
• Modificación de un índice secundario global durante la creación (p. 583)
• Detección y corrección de infracciones de claves de índice (p. 583)
Debe especificar un atributo que actúe como clave de partición del índice. También tiene la opción de
especificar otro atributo para la clave de ordenación del índice. No es necesario que ninguno de estos
atributos de clave sea igual que un atributo de clave de la tabla. Por ejemplo, en la tabla GameScores
(consulte Uso de índices secundarios en DynamoDB (p. 570)), ni TopScore ni TopScoreDateTime
son atributos de clave. Puede crear un índice secundario global con una clave de partición deTopScorey
una clave de clasificación deTopScoreDateTime. Se podría usar un índice de este tipo para determinar si
existe una correlación entre las mejores puntuaciones y la hora del día a la que se juega.
Todos los atributos de clave del índice deben ser escalares y pueden ser de tipo String, Number o
Binary. No pueden ser documentos ni conjuntos. Puede proyectar atributos de cualquier tipo de datos
en un índice secundario global. Esto incluye escalares, documentos y conjuntos. Para obtener una lista
completa de los tipos de datos, consulte Tipos de datos (p. 14).
Si usa el modo aprovisionado, debe proporcionar para el índice los ajustes de ProvisionedThroughput,
que constan de ReadCapacityUnits y WriteCapacityUnits. Estos ajustes de rendimiento
aprovisionado son independientes de los de la tabla pero se comportan de forma parecida. Para obtener
más información, consulte Consideraciones sobre el desempeño provisionado para los índices secundarios
globales (p. 577).
Los índices secundarios globales heredan el modo de capacidad de lectura/escritura de la tabla base. Para
obtener más información, consulte Consideraciones sobre el cambio del modo de capacidad de lectura/
escritura (p. 349).
Cuando DynamoDB ha terminado de crear un índice secundario global, el estado de este último cambia
deCREATINGDe aACTIVE.
• El nombre del índice. Este nombre debe ser único entre todos los índices de la tabla.
• El esquema de claves del índice. Debe especificar un atributo para la clave de partición del índice y, si
lo desea, otro atributo para la clave de ordenación del índice. No es necesario que ninguno de estos
atributos de clave sea igual que un atributo de clave de la tabla. Los tipos de datos de cada atributo del
esquema deben ser escalares: String, Number o Binary.
• Los atributos de la tabla que se van a proyectar en el índice:
• KEYS_ONLY: cada elemento del índice consta únicamente de los valores de la clave de partición y la
clave de ordenación de la tabla, así como de los valores de las claves del índice.
• INCLUDE— Además de los atributos descritos enKEYS_ONLY, el índice secundario incluye otros
atributos sin clave que se especifiquen.
• ALL: el índice incluye todos los atributos de la tabla de origen.
• Los ajustes de rendimiento aprovisionado del índice, que constan de ReadCapacityUnits
y WriteCapacityUnits. Estos ajustes de rendimiento aprovisionado son independientes de los de la
tabla.
Asignación de recursos
DynamoDB asigna los recursos de computación y almacenamiento que se necesitan para crear el
índice.
Durante la fase de asignación de recursos, el valor del atributo IndexStatus es CREATING y el valor
del atributo Backfilling es false. Use la operación DescribeTable para recuperar el estado de
una tabla y todos sus índices secundarios.
Para cada elemento de la tabla, DynamoDB determina el conjunto de atributos que se escribirá en el
índice según su proyección (KEYS_ONLY,INCLUDE, o bienALL). A continuación, escribe estos atributos
en el índice. Durante la fase de reposición, DynamoDB lleva un seguimiento de los elementos que
se agregan, eliminan o actualizan en la tabla. Los atributos de estos elementos también se agregan,
eliminan o actualizan en el índice, según proceda.
Mientras el índice se encuentra en la fase de reposición, no se puede eliminar su tabla principal. Sin
embargo, sí se puede eliminar el índice o modificar el rendimiento aprovisionado de la tabla y de
cualquiera de sus índices secundarios globales.
Note
Mientras las fases de asignación de recursos y reposición están en curso, el índice se encuentra en el
estado CREATING. Durante este plazo de tiempo, DynamoDB realiza operaciones de lectura en la tabla.
No se le cobrará por las operaciones de lectura de la tabla base para rellenar el índice secundario global.
Sin embargo, se le cobran las operaciones de escritura para rellenar el índice secundario global recién
creado.
Una vez que se completa la creación del índice, su estado cambia a ACTIVE. No puede Query ni Scan el
índice hasta que esté ACTIVE.
Note
En algunos casos, DynamoDB no puede escribir datos de la tabla en el índice porque se producen
infracciones en las claves del índice. Esto puede ocurrir si:
• El tipo de dato de un valor de atributo no coincide con el del esquema de claves de índice.
• El tamaño de un atributo supera la longitud máxima de un atributo de clave del índice.
• Un atributo de clave del índice tiene un valor binario o de cadena vacío.
Las infracciones de claves del índice no interfieren con la creación de un índice secundario global.
Sin embargo, cuando el índice adquiera el estado ACTIVE, las claves infractoras no estarán
presentes en él.
DynamoDB proporciona una herramienta independiente para encontrar y resolver estos
problemas. Para obtener más información, consulte Detección y corrección de infracciones de
claves de índice (p. 583).
• El tamaño de la tabla.
• El número de elementos de la tabla que son aptos para incluirlos en el índice.
• El número de atributos que se proyectan en el índice.
• La capacidad de escritura aprovisionada del índice.
• La actividad de escritura en la tabla principal mientras se crean los índices.
Si se va a agregar un índice secundario global a una tabla muy grande, el proceso de creación puede
tardar mucho tiempo en completarse. Para monitorizar el progreso y determinar si el índice tiene suficiente
capacidad de escritura, consulte las siguientes métricas de Amazon CloudWatch:
• OnlineIndexPercentageProgress
• OnlineIndexConsumedWriteCapacity
• OnlineIndexThrottleEvents
Note
Para obtener más información acerca de las métricas de CloudWatch relacionadas con
DynamoDB, consulteMétricas de DynamoDB (p. 940).
Si el ajuste de rendimiento de escritura aprovisionado del índice es demasiado bajo, la creación del índice
tardará más en completarse. Para reducir el tiempo que se tarda en crear un nuevo índice secundario
global, puede aumentar temporalmente su capacidad de escritura provisionada.
Note
Por regla general, recomendamos establecer la capacidad de escritura aprovisionada del índice
en 1,5 veces la capacidad de escritura de la tabla. Este ajuste es adecuado en muchos casos de
uso. No obstante, puede que sus requisitos reales sean superiores o inferiores.
Mientras el índice está en la fase de reposición, DynamoDB utiliza la capacidad interna del sistema para
leer la tabla. Esto permite minimizar el impacto de la creación del índice y asegurarse de que no se agote
la capacidad de lectura de la tabla.
Sin embargo, es posible que el volumen de una actividad de escritura entrante supere la capacidad de
lectura aprovisionada del índice. En este caso, se produciría un cuello de botella y la creación del índice
tardaría más porque la actividad de escritura en el índice sería objeto de una limitación controlada. Durante
la compilación del índice, recomendamos monitorizar las métricas de Amazon CloudWatch del índice para
determinar si su capacidad de escritura consumida es superior a la provisionada. Si se produce un cuello
de botella, debe aumentar la capacidad de escritura aprovisionada en el índice para evitar que se imponga
la limitación controlada a las escrituras durante la fase de reposición.
Una vez que se haya creado el índice, conviene establecer su capacidad de escritura aprovisionada de
modo que refleje el uso normal de la aplicación.
Mientras se elimina el índice secundario global, no afecta en absoluto a la actividad de lectura o escritura
en la tabla principal. Mientras la eliminación está en curso, puede modificar el rendimiento aprovisionado
de los demás índices.
Note
Al eliminar una tabla mediante la acción DeleteTable, todos los índices secundarios globales de
esa tabla se eliminan también.
Mientras que la reposición está en curso, puede actualizar los parámetros de rendimiento aprovisionado
del índice. Puede que decida hacerlo para acelerar la compilación del índice: Puede aumentar la
capacidad de escritura del índice mientras se crea y reducirla después. Para modificar los ajustes de
rendimiento aprovisionado del índice, utilice la operación UpdateTable. El estado del índice cambia a
UPDATING y el valor de Backfilling es true hasta que el índice esté listo para usarlo.
Durante la fase de reposición, puede eliminar el índice que se está creando. Durante esta fase, no se
pueden agregar ni eliminar otros índices de la tabla.
Note
En el caso de los índices que se han creado como parte de una operación CreateTable, el
atributo Backfilling no aparece en el resultado de DescribeTable. Para obtener más
información, consulte Fases de creación de los índices (p. 580).
• Los tipos de datos del valor de un atributo y del esquema de claves del índice no coinciden. Por ejemplo,
suponga que uno de los elementos delGameScorestenía unaTopScoreValor del tipoString. Si agregó
un índice secundario global con una clave de partición deTopScore, de tipoNumber, el elemento de la
tabla infringiría la clave de índice.
• El valor de atributo de la tabla supera la longitud máxima de un atributo de clave del índice. La longitud
máxima de una clave de partición es de 2048 bytes y la longitud máxima de una clave de ordenación
es de 1024 bytes. Si cualquiera de los valores de atributos correspondientes de la tabla supera estos
límites, el elemento de la tabla infringiría la clave de índice.
Note
Si se establece un valor binario o de cadena en un atributo que se utiliza como clave de índice,
este valor debe tener una longitud mayor que cero; de lo contrario, el elemento de la tabla podría
infringir la clave del índice.
En la actualidad, esta herramienta no indica esta infracción de clave de índice de ninguna forma.
Si se produce una infracción de clave de índice, la fase de reposición continúa sin interrupción. Sin
embargo, los elementos infractores no se incluyen en el índice. Una vez que haya finalizado la fase de
reposición, se rechazarán todas las escrituras en elementos que infringen el esquema de claves del nuevo
índice.
Para identificar y corregir los valores de los atributos de una tabla que infringen una clave de índice, se
utiliza la herramienta Detector de infracciones. Para ejecutar el Detector de infracciones, debe crear un
archivo de configuración que especifique el nombre de la tabla que se va a examinar, los nombres y los
tipos de datos de las claves de partición y de ordenación del índice secundario global y qué medidas
deben adoptarse si se detecta cualquier infracción de clave de índice. El Detector de infracciones puede
ejecutarse en dos modos diferentes:
• Modo de detección: detecta las infracciones de claves de índice. El modo de detección se utiliza para
registrar los elementos de la tabla que causarían infracciones de claves en un índice secundario global.
Si lo desea, puede solicitar que estos elementos infractores de la tabla se eliminen de inmediato en
cuanto se encuentren. El resultado del modo de detección se escribe en un archivo, que se puede
utilizar para analizar los datos posteriormente.
• Modo de corrección— Corrige las infracciones de claves de índice. En el modo de corrección, el
Detector de infracciones lee un archivo de información de entrada con el mismo formato que el archivo
de resultados del modo de detección. En el modo de corrección se leen los registros del archivo de
información de entrada y, para cada registro, se elimina o actualiza el elemento correspondiente de la
tabla. Tenga en cuenta que si decide actualizar los elementos, deberá editar el archivo de información de
entrada y establecer valores adecuados para estas actualizaciones.
accessKey
= access_key_id_goes_here
secretKey
= secret_key_goes_here
S | N | B
S | N | B
detectionOutputPath
= //local/path/
filename.csv
detectionOutputPath =
s3://bucket/filename.csv
El ajuste máximo de
numOfSegments es 4096.
El formato
decorrectionInputPathes
el mismo que el del
archivodetectionOutputPathfile.
Esto permite procesar el
resultado del modo de detección
como información de entrada en
el modo de corrección.
correctionOutputPath
= //local/path/
filename.csv
correctionOutputPath =
s3://bucket/filename.csv
Detection
Para detectar infracciones de claves de índice, use el Detector de infracciones con el--detectLa opción
de línea de comandos. Para mostrar cómo funciona esta opción, considere la opciónProductCatalogque
se muestra enCreación de tablas y carga de datos para ejemplos de código en DynamoDB (p. 333). A
continuación se muestra una lista de elementos de la tabla. Solo la clave principal (Id) y elPrice.
101 5
102 20
103 200
201 100
202 200
203 300
204 400
205 500
Todos los valores dePriceson de tipoNumber. No obstante, dado que en DynamoDB no se usan
esquemas, es posible agregar un elemento con un valor de no numéricoPrice. Por ejemplo, suponga que
agrega otro elemento al cuadro de diálogoProductCatalogTabla INTO
999 "Hello"
Ahora agrega un nuevo índice secundario global a la tabla: PriceIndex. La clave principal de este índice
es una clave de partición,Price, que es de tipoNumber. Después de crearlo, el índice contendrá ocho
elementos. Sin embargo, elProductCatalogtiene nueve elementos. La razón de esta discrepancia
es que el valor"Hello"es de tipoString, peroPriceIndextiene una clave principal de tipoNumber.
LaStringEl valor de este último infringe la clave global del índice secundario, por lo que no está presente
en el índice.
Para usar el Detector de infracciones en esta situación, primero se crea un archivo de configuración, como
el siguiente.
awsCredentialsFile = /home/alice/credentials.txt
dynamoDBRegion = us-west-2
tableName = ProductCatalog
gsiHashKeyName = Price
gsiHashKeyType = N
recordDetails = true
recordGsiValueInViolationRecord = true
detectionOutputPath = ./gsi_violation_check.csv
correctionInputPath = ./gsi_violation_check.csv
numOfSegments = 1
readWriteIOPSPercent = 40
Violation detection started: sequential scan, Table name: ProductCatalog, GSI name:
PriceIndex
Progress: Items scanned in total: 9, Items scanned by this thread: 9, Violations
found by this thread: 1, Violations deleted by this thread: 0
Violation detection finished: Records scanned: 9, Violations found: 1, Violations deleted:
0, see results at: ./gsi_violation_check.csv
Table Hash Key,GSI Hash Key Value,GSI Hash Key Violation Type,GSI Hash Key Violation
Description,GSI Hash Key Update Value(FOR USER),Delete Blank Attributes When Updating?(Y/
N)
El archivo de salida está en formato CSV. La primera línea del archivo es un encabezado, seguido de un
registro por cada elemento que infringe la clave del índice. Los campos de estos registros de infracción son
los siguientes:
Si alguno de estos campos no está en blanco, entonces Delete Blank Attribute When
Updating(Y/N) no surte ningún efecto.
Note
El formato de los resultados puede variar, en función del archivo de configuración y de las
opciones de la línea de comandos. Por ejemplo, si la tabla tiene una clave principal simple (sin
clave de ordenación), no habrá ningún campo de clave de ordenación en el resultado.
Los registros de infracción del archivo podrían no estar ordenados.
Correction
Para corregir infracciones de claves de índice, use el Detector de infracciones con el--correctLa
opción de línea de comandos. En el modo de corrección, el Detector de infracciones lee el archivo de
información de entrada especificado por elcorrectionInputPathParámetro. Este archivo tiene el
mismo formato que el archivo detectionOutputPath, lo que permite utilizar el resultado de la detección
como información de entrada para la corrección.
El Detector de infracciones ofrece dos maneras distintas de corregir las infracciones de claves de índice:
• Eliminar infracciones: se eliminan los elementos de la tabla que tienen valores de atributos infractores.
• Actualizar infracciones: actualiza los elementos de la tabla, reemplazando los atributos infractores por
otros que no infringen.
En ambos casos, puede utilizar el archivo de resultados del modo de detección como información de
entrada para el modo de corrección.
Continuando con laProductCatalogPor ejemplo, supongamos que desea eliminar el elemento infractor
de la tabla. Para ello, utilice la línea de comandos siguiente.
En este momento, le pedirá que confirme si desea eliminar los elementos infractores.
A continuación se indican los pasos comunes para las operaciones con tablas.
Temas
• Creación de una tabla con un índice secundario global (p. 592)
• Describir una tabla con un índice secundario global (p. 594)
• Consulta de un índice secundario global (p. 594)
• Ejemplo: Índices secundarios globales utilizando el parámetroAWS SDK for JavaDocumentación de la
API (p. 595)
A continuación se indican los pasos que hay que seguir para crear una tabla con un índice secundario
global mediante el API de documentos de DynamoDB.
Debe proporcionar el nombre de la tabla, su clave principal y los valores de desempeño provisionado.
Para el índice secundario global, debe proporcionar el nombre del índice, los ajustes de desempeño
provisionado, las definiciones de atributos de la clave de ordenación del índice, el esquema de claves
del índice y la proyección de atributos.
3. Llame al método createTable proporcionando el objeto de solicitud como parámetro.
En el siguiente ejemplo de código Java se muestran los pasos anteriores. El código crea una tabla
(WeatherData) con un índice secundario global (PrecipIndex). La clave de partición de índice esDatey
su clave de ordenación esPrecipitation. Todos los atributos de la tabla se proyectan en el índice. Los
usuarios pueden consultar este índice para obtener los datos meteorológicos de una determinada fecha y,
si lo desean, ordenarlos según la cantidad de precipitación.
// Attribute definitions
ArrayList<AttributeDefinition> attributeDefinitions = new ArrayList<AttributeDefinition>();
attributeDefinitions.add(new AttributeDefinition()
.withAttributeName("Location")
.withAttributeType("S"));
attributeDefinitions.add(new AttributeDefinition()
.withAttributeName("Date")
.withAttributeType("S"));
attributeDefinitions.add(new AttributeDefinition()
.withAttributeName("Precipitation")
.withAttributeType("N"));
// PrecipIndex
GlobalSecondaryIndex precipIndex = new GlobalSecondaryIndex()
.withIndexName("PrecipIndex")
.withProvisionedThroughput(new ProvisionedThroughput()
.withReadCapacityUnits((long) 10)
.withWriteCapacityUnits((long) 1))
.withProjection(new Projection().withProjectionType(ProjectionType.ALL));
indexKeySchema.add(new KeySchemaElement()
.withAttributeName("Date")
.withKeyType(KeyType.HASH)); //Partition key
indexKeySchema.add(new KeySchemaElement()
.withAttributeName("Precipitation")
.withKeyType(KeyType.RANGE)); //Sort key
precipIndex.setKeySchema(indexKeySchema);
Debe esperar hasta que DynamoDB cree la tabla y establezca el estado de esta última enACTIVE. A partir
de ese momento, puede comenzar a incluir elementos de datos en la tabla.
Los siguientes son los pasos para acceder a la información de índice secundario global de una tabla.
Example
Iterator<GlobalSecondaryIndexDescription> gsiIter =
tableDesc.getGlobalSecondaryIndexes().iterator();
while (gsiIter.hasNext()) {
GlobalSecondaryIndexDescription gsiDesc = gsiIter.next();
System.out.println("Info for index "
+ gsiDesc.getIndexName() + ":");
A continuación, se muestran los pasos para consultar un índice secundario global mediante elAWS SDK
for JavaDocumentación de la API
2. Cree una instancia de la clase Table para representar el índice que desea usar.
3. Cree una instancia de la clase Index para el índice que desea consultar.
4. Llame al método query del objeto Index.
Nombre de atributoDatees una palabra reservada de DynamoDB. Por consiguiente, debe usar un nombre
de atributo de expresión como marcador de posición en elKeyConditionExpression.
Example
Después de laIssues, el programa carga la tabla con datos que representan informes de errores de
software. A continuación, consulta los datos utilizando los índices secundarios globales. Por último, el
programa elimina el valor deIssuesTabla INTO
Para obtener instrucciones paso a paso para probar el siguiente ejemplo, consulte Ejemplos de código
Java (p. 338).
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.document;
import java.util.ArrayList;
import java.util.Iterator;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Index;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.ItemCollection;
import com.amazonaws.services.dynamodbv2.document.QueryOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.CreateTableRequest;
import com.amazonaws.services.dynamodbv2.model.GlobalSecondaryIndex;
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.Projection;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
createTable();
loadData();
queryIndex("CreateDateIndex");
queryIndex("TitleIndex");
queryIndex("DueDateIndex");
deleteTable(tableName);
// Attribute definitions
ArrayList<AttributeDefinition> attributeDefinitions = new
ArrayList<AttributeDefinition>();
attributeDefinitions.add(new
AttributeDefinition().withAttributeName("IssueId").withAttributeType("S"));
attributeDefinitions.add(new
AttributeDefinition().withAttributeName("Title").withAttributeType("S"));
attributeDefinitions.add(new
AttributeDefinition().withAttributeName("CreateDate").withAttributeType("S"));
attributeDefinitions.add(new
AttributeDefinition().withAttributeName("DueDate").withAttributeType("S"));
// key
tableKeySchema.add(new
KeySchemaElement().withAttributeName("Title").withKeyType(KeyType.RANGE)); // Sort
// key
// CreateDateIndex
GlobalSecondaryIndex createDateIndex = new
GlobalSecondaryIndex().withIndexName("CreateDateIndex")
.withProvisionedThroughput(ptIndex)
.withKeySchema(new
KeySchemaElement().withAttributeName("CreateDate").withKeyType(KeyType.HASH), // Partition
// key
new
KeySchemaElement().withAttributeName("IssueId").withKeyType(KeyType.RANGE)) // Sort
// key
.withProjection(
new
Projection().withProjectionType("INCLUDE").withNonKeyAttributes("Description", "Status"));
// TitleIndex
GlobalSecondaryIndex titleIndex = new
GlobalSecondaryIndex().withIndexName("TitleIndex")
.withProvisionedThroughput(ptIndex)
.withKeySchema(new
KeySchemaElement().withAttributeName("Title").withKeyType(KeyType.HASH), // Partition
// key
new
KeySchemaElement().withAttributeName("IssueId").withKeyType(KeyType.RANGE)) // Sort
// key
.withProjection(new Projection().withProjectionType("KEYS_ONLY"));
// DueDateIndex
GlobalSecondaryIndex dueDateIndex = new
GlobalSecondaryIndex().withIndexName("DueDateIndex")
.withProvisionedThroughput(ptIndex)
.withKeySchema(new
KeySchemaElement().withAttributeName("DueDate").withKeyType(KeyType.HASH)) // Partition
// key
.withProjection(new Projection().withProjectionType("ALL"));
.withAttributeDefinitions(attributeDefinitions).withKeySchema(tableKeySchema)
.withGlobalSecondaryIndexes(createDateIndex, titleIndex, dueDateIndex);
System.out.println("\n***********************************************************
\n");
System.out.print("Querying index " + indexName + "...");
if (indexName == "CreateDateIndex") {
System.out.println("Issues filed on 2013-11-01");
querySpec.withKeyConditionExpression("CreateDate = :v_date and
begins_with(IssueId, :v_issue)")
.withValueMap(new ValueMap().withString(":v_date",
"2013-11-01").withString(":v_issue", "A-"));
items = index.query(querySpec);
}
else if (indexName == "TitleIndex") {
System.out.println("Compilation errors");
querySpec.withKeyConditionExpression("Title = :v_title and
begins_with(IssueId, :v_issue)")
.withValueMap(new ValueMap().withString(":v_title", "Compilation
error").withString(":v_issue", "A-"));
items = index.query(querySpec);
}
else if (indexName == "DueDateIndex") {
System.out.println("Items that are due on 2013-11-30");
querySpec.withKeyConditionExpression("DueDate = :v_date")
.withValueMap(new ValueMap().withString(":v_date", "2013-11-30"));
items = index.query(querySpec);
}
else {
System.out.println("\nNo valid index name provided");
return;
}
while (iterator.hasNext()) {
System.out.println(iterator.next().toJSONPretty());
}
// IssueId, Title,
// Description,
// CreateDate, LastUpdateDate, DueDate,
// Priority, Status
putItem("A-102", "Can't read data file", "The main data file is missing, or the
permissions are incorrect",
"2013-11-01", "2013-11-04", "2013-11-30", 2, "In progress");
table.putItem(item);
}
A continuación se indican los pasos comunes para las operaciones con tablas mediante el API de bajo
nivel de .NET.
Por ejemplo, cree un objeto CreateTableRequest para crear una tabla y un objeto QueryRequest
para consultar una tabla o un índice.
3. Ejecute el método apropiado proporcionado por el cliente que ha creado en el paso anterior.
Temas
• Creación de una tabla con un índice secundario global (p. 600)
• Describir una tabla con un índice secundario global (p. 602)
• Consulta de un índice secundario global (p. 602)
• Ejemplo: Índices secundarios globales utilizando el parámetroAWS SDK for .NETAPI de bajo
nivel (p. 604)
A continuación se indican los pasos que hay que seguir para crear una tabla con un índice secundario
global mediante el API de bajo nivel de .NET.
Debe proporcionar el nombre de la tabla, su clave principal y los valores de desempeño provisionado.
Para el índice secundario global, debe proporcionar el nombre del índice, los ajustes de desempeño
provisionado, las definiciones de atributos de la clave de ordenación del índice, el esquema de claves
del índice y la proyección de atributos.
3. Ejecute laCreateTableMétodo proporcionando el objeto de solicitud como parámetro.
En el siguiente ejemplo de código C# se ponen en práctica los pasos anteriores. El código crea una tabla
(WeatherData) con un índice secundario global (PrecipIndex). La clave de partición de índice esDatey
su clave de ordenación esPrecipitation. Todos los atributos de la tabla se proyectan en el índice. Los
usuarios pueden consultar este índice para obtener los datos meteorológicos de una determinada fecha y,
si lo desean, ordenarlos según la cantidad de precipitación.
// Attribute definitions
var attributeDefinitions = new List<AttributeDefinition>()
{
{new AttributeDefinition{
AttributeName = "Location",
AttributeType = "S"}},
{new AttributeDefinition{
AttributeName = "Date",
AttributeType = "S"}},
{new AttributeDefinition(){
AttributeName = "Precipitation",
AttributeType = "N"}
}
};
// PrecipIndex
var precipIndex = new GlobalSecondaryIndex
{
IndexName = "PrecipIndex",
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = (long)10,
WriteCapacityUnits = (long)1
},
Projection = new Projection { ProjectionType = "ALL" }
};
precipIndex.KeySchema = indexKeySchema;
GlobalSecondaryIndexes = { precipIndex }
};
Debe esperar hasta que DynamoDB cree la tabla y establezca el estado de esta última enACTIVE. A partir
de ese momento, puede comenzar a incluir elementos de datos en la tabla.
A continuación se indican los pasos que hay que seguir para obtener acceso a la información de índice
secundario global de una tabla mediante el API de bajo nivel de .NET.
Example
List<GlobalSecondaryIndexDescription> globalSecondaryIndexes =
response.DescribeTableResult.Table.GlobalSecondaryIndexes;
// This code snippet will work for multiple indexes, even though
// there is only one index in this example.
if (projection.ProjectionType.ToString().Equals("INCLUDE")) {
Console.WriteLine("\t\tThe non-key projected attributes are: "
+ projection.NonKeyAttributes);
}
}
(si procede) del índice y los atributos que desea devolver. En este ejemplo, el índice esPrecipIndex, que
tiene una clave de partición deDatey una clave de clasificación dePrecipitation. La consulta del índice
devuelve todos los datos meteorológicos de una determinada fecha cuando el valor de Precipitation sea
mayor que cero.
A continuación se indican los pasos que hay que seguir para consultar un índice secundario global
mediante el API de bajo nivel de .NET.
Nombre de atributoDatees una palabra reservada de DynamoDB. Por consiguiente, debe usar un nombre
de atributo de expresión como marcador de posición en elKeyConditionExpression.
Example
}
Console.WriteLine();
}
Después de laIssues, el programa carga la tabla con datos que representan informes de errores de
software. A continuación, consulta los datos utilizando los índices secundarios globales. Por último, el
programa elimina el valor deIssuesTabla INTO
Para obtener instrucciones paso a paso para probar el siguiente ejemplo, consulte Ejemplos de
código .NET (p. 340).
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using System;
using System.Collections.Generic;
using System.Linq;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;
using Amazon.DynamoDBv2.DocumentModel;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;
using Amazon.SecurityToken;
namespace com.amazonaws.codesamples
{
class LowLevelGlobalSecondaryIndexExample
{
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
public static String tableName = "Issues";
QueryIndex("CreateDateIndex");
QueryIndex("TitleIndex");
QueryIndex("DueDateIndex");
DeleteTable(tableName);
// CreateDateIndex
var createDateIndex = new GlobalSecondaryIndex()
{
IndexName = "CreateDateIndex",
ProvisionedThroughput = ptIndex,
KeySchema = {
new KeySchemaElement {
AttributeName = "CreateDate", KeyType = "HASH" //Partition key
},
new KeySchemaElement {
AttributeName = "IssueId", KeyType = "RANGE" //Sort key
}
},
Projection = new Projection
{
ProjectionType = "INCLUDE",
NonKeyAttributes = {
"Description", "Status"
}
}
};
// TitleIndex
var titleIndex = new GlobalSecondaryIndex()
{
IndexName = "TitleIndex",
ProvisionedThroughput = ptIndex,
KeySchema = {
new KeySchemaElement {
AttributeName = "Title", KeyType = "HASH" //Partition key
},
new KeySchemaElement {
AttributeName = "IssueId", KeyType = "RANGE" //Sort key
}
},
Projection = new Projection
{
ProjectionType = "KEYS_ONLY"
}
};
// DueDateIndex
var dueDateIndex = new GlobalSecondaryIndex()
{
IndexName = "DueDateIndex",
ProvisionedThroughput = ptIndex,
KeySchema = {
new KeySchemaElement {
AttributeName = "DueDate",
KeyType = "HASH" //Partition key
}
},
Projection = new Projection
{
ProjectionType = "ALL"
}
};
WaitUntilTableReady(tableName);
}
// IssueId, Title,
// Description,
// CreateDate, LastUpdateDate, DueDate,
// Priority, Status
{
S = dueDate
});
item.Add("Priority", new AttributeValue
{
N = priority.ToString()
});
item.Add("Status", new AttributeValue
{
S = status
});
try
{
client.PutItem(new PutItemRequest
{
TableName = tableName,
Item = item
});
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
String keyConditionExpression;
Dictionary<string, AttributeValue> expressionAttributeValues = new
Dictionary<string, AttributeValue>();
if (indexName == "CreateDateIndex")
{
Console.WriteLine("Issues filed on 2013-11-01\n");
{
S = "Compilation error"
});
expressionAttributeValues.Add(":v_issue", new AttributeValue
{
S = "A-"
});
// Select
queryRequest.Select = "ALL_PROJECTED_ATTRIBUTES";
}
else if (indexName == "DueDateIndex")
{
Console.WriteLine("Items that are due on 2013-11-30\n");
// Select
queryRequest.Select = "ALL_PROJECTED_ATTRIBUTES";
}
else
{
Console.WriteLine("\nNo valid index name provided");
return;
}
queryRequest.KeyConditionExpression = keyConditionExpression;
queryRequest.ExpressionAttributeValues = expressionAttributeValues;
do
{
System.Threading.Thread.Sleep(5000); // Wait 5 seconds.
try
{
var res = client.DescribeTable(new DescribeTableRequest
{
TableName = tableName
});
while (tablePresent)
{
System.Threading.Thread.Sleep(5000); // Wait 5 seconds.
try
{
var res = client.DescribeTable(new DescribeTableRequest
{
TableName = tableName
});
Temas
• Crear una tabla con un índice secundario global (p. 611)
• Agregar un índice secundario global a una tabla existente (p. 611)
• Describir una tabla de con un índice secundario global (p. 612)
• Consulta de un índice secundario global (p. 612)
Debe esperar hasta que DynamoDB cree la tabla y establezca el estado de esta última enACTIVE. A partir
de ese momento, puede comenzar a incluir elementos de datos en la tabla. Puede usardescribir-tablaPara
determinar el estado de la creación de tablas.
Los únicos atributos devueltos son aquellos que se han proyectado en el índice. Puede modificar esta
consulta de modo que también seleccione atributos sin clave, pero esto requeriría realizar actividad
de recuperación en la tabla, lo que resulta relativamente costoso. Para obtener más información sobre
recuperaciones de tablas, consulte Proyecciones de atributos (p. 574).
Temas
• ESCENARIO Uso de un índice secundario local (p. 612)
• Proyecciones de atributos (p. 615)
• Creación de un índice secundario local (p. 616)
• Lectura de datos de un índice secundario local (p. 617)
• Escritura de elementos e índices secundarios (p. 618)
• Consideraciones sobre el desempeño provisionado para los índices secundarios locales (p. 619)
• Consideraciones sobre el almacenamiento para los índices secundarios locales (p. 620)
• Colecciones de elementos (p. 621)
• Uso de índices secundarios: Java (p. 624)
• Uso de índices secundarios: .NET (p. 634)
• Uso de índices secundarios:AWS CLI (p. 649)
DynamoDB almacena en posiciones contiguas todos los elementos que tienen el mismo valor de clave de
partición. En este ejemplo, dado un determinadoForumName, unQuerypuede localizar inmediatamente
todos los hilos de ese foro. Dentro de un grupo de elementos con el mismo valor de clave de partición,
los elementos se ordenan según el valor de la clave de ordenación. Si la clave de ordenación (Subject)
también se incluye en la consulta, DynamoDB puede afinar los resultados que se devuelven; por ejemplo,
devolvería todas las conversaciones del foro «S3" cuyo valor deSubjectcomenzando por la letra «a».
Algunas solicitudes podrían requerir patrones más complejos de acceso a los datos. Por ejemplo:
• ¿Qué conversaciones del foro son las que suscitan más visualizaciones y respuestas?
• ¿Qué conversación de un foro determinado tiene mayor cantidad de mensajes?
• ¿Cuántas conversaciones se han publicado en un foro determinado dentro de un periodo concreto?
Para responder a estas preguntas, elQueryLa acción no bastaría. En su lugar, habría queScanLa tabla
entera. Si la tabla contiene millones de elementos, esto consumiría una cantidad enorme de desempeño de
lectura provisionado y tardaría mucho tiempo en completarse.
Sin embargo, puede especificar uno o más índices secundarios locales en atributos sin clave, tales
comoRepliesorLastPostDateTime.
Aíndice secundario localmantiene una clave de ordenación alternativa para un determinado valor de clave
de partición. Un índice secundario local también contiene una copia parcial o total de los atributos de la
tabla base. Al crear la tabla, debe especificar qué atributos se proyectarán en el índice secundario local.
Los datos de un índice secundario local se organizan según la misma clave de partición que la tabla base,
pero con una clave de ordenación distinta. Esto le permite obtener acceso a los elementos de datos de
forma eficiente en esta otra dimensión. Para disfrutar de una mayor flexibilidad de consulta o examen,
puede crear hasta cinco índices secundarios locales por tabla.
Supongamos que una aplicación tiene que encontrar todas las conversaciones que se han publicado
en los últimos tres meses en un foro particular. Sin un índice secundario local, la aplicación tendría
queScanToda laThreadSin una operación, descartar aquellas publicaciones que no estuviesen
comprendidos en el periodo especificado. Con un índice secundario local, un índice secundario
localQueryoperación podría usarLastPostDateTimeComo clave de ordenación para encontrar
rápidamente los datos.
En este ejemplo, la clave de partición esForumNamey la clave de ordenación del índice secundario
local esLastPostDateTime. Además, el valor de clave de ordenación de la tabla base (en este
ejemplo,Subject) se proyecta en el índice, pero no forma parte de la clave de índice. Si una aplicación
requiere una lista basada enForumNameyLastPostDateTime, puede emitir unQuerysolicitud
contraLastPostIndex. Los resultados de la consulta se ordenan segúnLastPostDateTime, y se puede
devolver en orden ascendente o descendente. La consulta también puede aplicar condiciones de clave,
tales como devolver únicamente aquellos elementos cuyo valor deLastPostDateTimedentro de un
período de tiempo determinado.
Cada índice secundario local contiene automáticamente las claves de partición y ordenación de su
tabla base;. Si lo desea, puede proyectar atributos sin clave en el índice. Cuando se consulta el índice,
DynamoDB puede recuperar estos atributos proyectados de forma eficiente. Cuando se consulta un
índice secundario local, la consulta también puede recuperar atributos que sonnoproyectado en el índice.
DynamoDB recupera automáticamente estos atributos de la tabla base, pero con una mayor latencia y
costos más elevados de desempeño provisionado.
Para cualquier índice secundario local, puede almacenar hasta 10 GB de datos por cada valor diferente de
clave de partición. Esta cifra incluye todos los elementos de la tabla base, además de todos los elementos
de los índices, que tengan el mismo valor de clave de partición. Para obtener más información, consulte
Colecciones de elementos (p. 621).
Proyecciones de atributos
conLastPostIndex, una aplicación podría usarForumNameyLastPostDateTimeComo criterios de
consulta. Sin embargo, para recuperar cualquier atributo adicional, DynamoDB debe realizar operaciones
de lectura adicionales en elThreadTabla INTO Estas lecturas adicionales se denominan recuperaciones y
pueden aumentar la cantidad total de desempeño provisionado necesario para una consulta.
Supongamos que desea rellenar una página web con una lista de todas las conversaciones del foro «S3" y
el número de respuestas de cada conversación, ordenadas según la fecha y hora de la última respuesta y
comenzando por la respuesta más reciente. Para rellenar esta lista, se requieren los siguientes atributos:
• Subject
• Replies
• LastPostDateTime
La forma más eficiente de consultar estos datos y evitar operaciones de recuperación sería proyectar
elRepliesDe la tabla al índice secundario local, tal como se muestra en este diagrama.
AProjectiones el conjunto de atributos que se copia de una tabla en un índice secundario. La clave de
partición y la clave de ordenación de la tabla siempre se proyectan en el índice; puede proyectar otros
atributos para admitir los requisitos de consulta de la aplicación. Cuando consulta un índice, Amazon
DynamoDB puede acceder a cualquier atributo de la proyección como si esos atributos estuvieran en una
tabla propia.
Al crear un índice secundario, debe especificar los atributos que se proyectarán en el índice. DynamoDB
ofrece tres opciones diferentes para esto:
• KEYS_ONLY: cada elemento del índice consta únicamente de los valores de la clave de partición y la
clave de ordenación de la tabla, así como de los valores de las claves del índice. LaKEYS_ONLYda como
resultado el índice secundario más pequeño posible.
• INCLUDE— Además de los atributos descritos enKEYS_ONLY, el índice secundario incluirá otros
atributos sin clave que se especifiquen.
• TODO: el índice secundario incluye todos los atributos de la tabla de origen. Debido a que todos los
datos de la tabla están duplicados en el índice, unALLresultados de proyección en el índice secundario
más grande posible.
Desde el punto de vista de una aplicación, la recuperación de atributos adicionales de la tabla base se
lleva a cabo de forma automática y transparente, por lo que no es necesario volver a escribir la lógica de
la aplicación. Sin embargo, esta recuperación puede reducir en gran medida la ventaja de desempeño que
aporta el uso de un índice secundario local.
Al elegir los atributos para proyectarlos en un índice secundario local, debe estudiar el equilibrio entre los
costos de desempeño provisionado y de almacenamiento:
• Si solo necesita obtener acceso a algunos atributos con la menor latencia posible, puede ser
conveniente proyectar solamente esos atributos en un índice secundario local. Cuando menor es el
índice, menos cuesta almacenarlo y menos son los costos de escritura. Si hay atributos que solo tiene
que recuperar de vez en cuando, el costo del desempeño provisionado podría superar con creces el
costo a largo plazo de almacenar esos atributos.
• Si la aplicación va a obtener acceso con frecuencia a determinados atributos sin clave, puede ser
interesante proyectarlos en un índice secundario local. Los costos del almacenamiento adicionales del
índice secundario local compensarán el costo que supondrían los frecuentes exámenes de la tabla.
• Si tiene que obtener acceso a la mayoría de los atributos sin clave con frecuencia, puede proyectar estos
atributos o, incluso, toda la tabla base, en un índice secundario local. De este modo, dispondrá de la
máxima flexibilidad y el menor consumo de desempeño provisionado, porque no será preciso realizar
recuperaciones. Sin embargo, el costo del almacenamiento aumentaría y podría llegar a duplicarse si se
proyectan todos los atributos.
• Si la aplicación tiene que consultar una tabla con poca frecuencia, pero tiene que realizar gran cantidad
de escrituras o actualizaciones en los datos de la tabla, puede ser conveniente proyectarKEYS_ONLY.
El índice secundario local tendrá el tamaño mínimo, pero estaría disponible siempre que se requiriese
para actividades de consulta.
Debe especificar un atributo sin clave que actúe como clave de ordenación del índice secundario local. El
atributo que elija debe ser un escalarString,Number, o bienBinary. No se admite ningún otro tipo de
escalar, documento ni conjunto. Para obtener una lista completa de los tipos de datos, consulte Tipos de
datos (p. 14).
Important
Para las tablas con índices secundarios locales, existe un límite de tamaño de 10 GB por valor de
clave de partición. Una tabla con índices secundarios locales puede almacenar cualquier número
de elementos, siempre y cuando el tamaño total de cualquier valor de clave de partición individual
no supere los 10 GB. Para obtener más información, consulte Límite de tamaño de una colección
de elementos (p. 623).
Puede proyectar atributos de cualquier tipo de datos en un índice secundario local. Esto incluye escalares,
documentos y conjuntos. Para obtener una lista completa de los tipos de datos, consulte Tipos de
datos (p. 14).
Puede consultar un índice secundario local utilizando lecturas consistentes finales o de consistencia alta.
Para especificar qué tipo de consistencia desea utilizar, utilice la herramientaConsistentReadParámetro
deQuery. Una lectura de consistencia alta de un índice secundario local siempre devuelve los valores
actualizados más recientemente. Si la consulta tiene que recuperar atributos adicionales de la tabla base,
estos serán consistentes respecto al índice.
Example
Tomemos los datos siguientes devueltos por unQueryque solicita datos de los hilos de discusión de un
foro determinado.
{
"TableName": "Thread",
"IndexName": "LastPostIndex",
"ConsistentRead": false,
"ProjectionExpression": "Subject, LastPostDateTime, Replies, Tags",
"KeyConditionExpression":
"ForumName = :v_forum and LastPostDateTime between :v_start and :v_end",
"ExpressionAttributeValues": {
":v_start": {"S": "2015-08-31T00:00:00.000Z"},
":v_end": {"S": "2015-11-31T00:00:00.000Z"},
":v_forum": {"S": "EC2"}
}
}
En esta consulta:
Cuando crea un índice secundario local, especifica un atributo que actuará como clave de ordenación
del índice. También se puede especificar el tipo de datos de ese atributo. Esto significa que, cada
vez que se escribe un elemento en la tabla base, si el elemento define un atributo de clave de
índice, su tipo debe coincidir con el tipo de datos del esquema de claves de índice. En el caso
deLastPostIndex, elLastPostDateTimeLa clave de ordenación del índice se define comoStringTipo
de datos. Si intenta agregar un elemento a la carpetaThready especifique un tipo de datos diferente
paraLastPostDateTime(comoNumber), DynamoDB devuelve unValidationExceptiondebido a la
falta de coincidencia del tipo de datos.
No es obligatorio que exista una relación biunívoca entre los elementos de una tabla base y los elementos
de un índice secundario local. De hecho, este comportamiento puede ser ventajoso para muchas
aplicaciones.
Una tabla con muchos índices secundarios locales devengará costos más elevados por la actividad de
escritura que las tablas con menos índices. Para obtener más información, consulte Consideraciones sobre
el desempeño provisionado para los índices secundarios locales (p. 619).
Important
Para las tablas con índices secundarios locales, existe un límite de tamaño de 10 GB por valor de
clave de partición. Una tabla con índices secundarios locales puede almacenar cualquier número
de elementos, siempre y cuando el tamaño total de cualquier valor de clave de partición individual
no supere los 10 GB. Para obtener más información, consulte Límite de tamaño de una colección
de elementos (p. 623).
Para ver las tarifas vigentes de capacidad de desempeño provisionada, consultePrecios de Amazon
DynamoDB.
Al igual que ocurre con las consultas de tablas, las consultas de índices pueden utilizar lecturas
consistentes finales o de consistencia alta, según el valor deConsistentRead. Una lectura de
consistencia alta consume una unidad de capacidad de lectura; una lectura consistente final consume
solo la mitad. Por lo tanto, elegir la opción de lecturas consistentes finales permite reducir los cargos de
unidades de capacidad de lectura.
Para las consultas de índices que solo solicitan claves de índice y atributos proyectados, DynamoDB
calcula la actividad de lectura provisionada de la misma forma que para las consultas de tablas. La única
diferencia es que el cálculo se basa en el tamaño de las entradas del índice, no en el tamaño del elemento
en la tabla base. El número de unidades de capacidad de lectura es la suma de todos los tamaños de
los atributos proyectados para todos los elementos devueltos; el resultado se redondea al múltiplo de 4
KB siguiente. Para obtener más información sobre cómo DynamoDB calcula el consumo de desempeño
provisionado, consulteAdministración de la configuración en tablas de capacidad provisionadas de
DynamoDB (p. 350).
Para las consultas de índices que leen atributos no proyectados en el índice secundario local,
DynamoDB debe recuperar esos atributos de la tabla base, además de leer los atributos proyectados
en el índice. Estas recuperaciones se producen cuando se incluyen atributos no proyectados en
elSelectorProjectionExpressionParámetros deQuery. Las recuperaciones provocan latencia
adicional en las respuestas a las consultas y también devengan un mayor costo de desempeño
provisionado. Además de las lecturas en el índice secundario local que se han descrito anteriormente, se
le cobrarán unidades de capacidad de lectura por cada elemento recuperado de la tabla base. Este cargo
incluye la lectura de cada elemento completo de la tabla, no solo de los atributos solicitados.
Tamaño máximo de los resultados que devuelve unQueryLa operación es de 1 MB. Esta cifra incluye los
tamaños de todos los nombres y valores de los atributos de todos los elementos devueltos. Sin embargo,
si una consulta de un índice secundario local hace que DynamoDB recupere atributos de elementos de la
tabla base, el tamaño máximo de los datos de los resultados podría ser inferior. En este caso, el tamaño
del resultado es la suma de:
Usando esta fórmula, el tamaño máximo de los resultados que devuelve una operación Query también es
de 1 MB.
Por ejemplo, tomemos una tabla en la que el tamaño de cada elemento es de 300 bytes. Existe un
índice secundario local en esa tabla, pero solo se proyectan en él 200 bytes de cada elemento. Ahora
supongamos queQueryEste índice, que la consulta requiere recuperaciones en la tabla para cada
elemento y que la consulta devuelve 4 elementos. DynamoDB calcula lo siguiente:
• El tamaño de los elementos coincidentes en el índice: 200 bytes × 4 elementos = 800 bytes; este valor
se redondea hasta 4 KB.
• El tamaño de cada elemento coincidente de la tabla base: (300 bytes, redondeados al múltiplo de 4 KB)
× 4 elementos = 16 KB.
• Si escribe un nuevo elemento en la tabla que define un atributo indexado o actualiza un elemento
existente para definir un atributo indexado no definido previamente, se requiere una operación de
escritura para colocar el elemento en el índice.
• Si una actualización de la tabla cambia el valor de un atributo de clave indexado (de A a B), se requieren
dos escrituras: una para eliminar el elemento anterior del índice y otra para colocar el nuevo elemento en
el índice.
• Si ya hay un elemento en el índice, pero al escribir en la tabla se elimina el atributo indexado, se requiere
una escritura para eliminar la proyección del elemento anterior del índice.
• Si no hay ningún elemento presente en el índice antes o después de actualizar el elemento, no se
devenga ningún costo de escritura adicional para el índice.
Al calcular las unidades de capacidad de escritura, en todos estos factores se presupone que el tamaño de
cada elemento del índice es menor o igual que el tamaño de elemento de 1 KB. Las entradas de índice de
mayor tamaño requieren más unidades de capacidad de escritura. Para minimizar los costos de escritura,
es conveniente estudiar qué atributos tienen que devolver las consultas y proyectar solamente esos
atributos en el índice.
• El tamaño en bytes de la clave principal (clave de partición y clave de ordenación) de la tabla base
• El tamaño en bytes del atributo de clave de índice
• El tamaño en bytes de los atributos proyectados (si procede)
• 100 bytes de gastos generales por cada elemento de índice
Para calcular los requisitos de almacenamiento de un índice secundario local, puede calcular el tamaño
medio de un elemento del índice y, a continuación, multiplicarlo por el número de elementos de la tabla
base.
Si una tabla contiene un elemento en el que no se ha definido un atributo determinado, pero ese atributo se
ha definido como clave de ordenación del índice, DynamoDB no escribirá ningún dato para ese elemento
en el índice.
Colecciones de elementos
Note
Esta sección solo se refiere a las tablas que tienen índices secundarios locales.
Puede utilizar cualquiera de las siguientes operaciones de DynamoDB para devolver información sobre las
colecciones de elementos:
• BatchWriteItem
• DeleteItem
• PutItem
• UpdateItem
Example
{
ItemCollectionMetrics: {
ItemCollectionKey: {
ForumName: "EC2"
},
SizeEstimateRangeGB: [0.0, 1.0]
}
}
Para reducir el tamaño de una colección de elementos, puede elegir una de las siguientes opciones:
• Eliminar todos los elementos innecesarios que tengan el valor de clave de partición de que se trate. Al
eliminar estos elementos de la tabla base, DynamoDB también elimina las entradas de índice cuyo valor
de clave de partición sea el mismo.
• Actualizar los elementos eliminando atributos o reduciendo el tamaño de estos últimos. Si estos atributos
se han proyectado en uno de los índices secundarios locales, DynamoDB también reduce el tamaño de
las entradas de índice correspondientes.
• Crear una nueva tabla con las mismas clave de partición y clave de ordenación y, a continuación,
mover elementos de la tabla anterior a la nueva. Esto puede ser conveniente si una tabla contiene datos
históricos a los que se obtiene acceso con poca frecuencia. Puede también considerar la posibilidad de
archivar estos datos históricos en Amazon Simple Storage Service (Amazon S3).
Cuando el tamaño total de la colección de elementos disminuye por debajo de los 10 GB, puede volver a
agregar elementos con el mismo valor de clave de partición.
Debe diseñar las aplicaciones de tal forma que los datos de las tablas se distribuyan uniformemente entre
los distintos valores de clave de partición. Para las tablas con índices secundarios locales, las aplicaciones
no deben crear «puntos calientes» de actividad de lectura y escritura dentro de una misma colección de
elementos de una sola partición.
A continuación se indican los pasos comunes para las operaciones con tablas mediante el API de
documentos del AWS SDK for Java.
Temas
• Creación de una tabla con un índice secundario local (p. 624)
• Describir una tabla con un índice secundario local (p. 626)
• Consulta de un índice secundario local (p. 627)
• Ejemplo: Índices secundarios locales mediante el API de documentos Java (p. 627)
A continuación se indican los pasos que hay que seguir para crear una tabla con un índice secundario local
mediante el API de documentos de DynamoDB.
Debe proporcionar el nombre de la tabla, su clave principal y los valores de desempeño provisionado.
Para el índice secundario local, debe proporcionar el nombre de índice, el nombre y el tipo de datos de
la clave de ordenación del índice, el esquema de claves del índice y la proyección de atributos.
3. Llame al método createTable proporcionando el objeto de solicitud como parámetro.
En el siguiente ejemplo de código Java se muestran los pasos anteriores. El código crea una tabla (Music)
con un índice secundario en elAlbumTitleAtributo. La clave de partición y la clave de ordenación de la
tabla, además de la clave de ordenación del índice, son los únicos atributos proyectados en el índice.
//ProvisionedThroughput
createTableRequest.setProvisionedThroughput(new
ProvisionedThroughput().withReadCapacityUnits((long)5).withWriteCapacityUnits((long)5));
//AttributeDefinitions
ArrayList<AttributeDefinition> attributeDefinitions= new ArrayList<AttributeDefinition>();
attributeDefinitions.add(new
AttributeDefinition().withAttributeName("Artist").withAttributeType("S"));
attributeDefinitions.add(new
AttributeDefinition().withAttributeName("SongTitle").withAttributeType("S"));
attributeDefinitions.add(new
AttributeDefinition().withAttributeName("AlbumTitle").withAttributeType("S"));
createTableRequest.setAttributeDefinitions(attributeDefinitions);
//KeySchema
ArrayList<KeySchemaElement> tableKeySchema = new ArrayList<KeySchemaElement>();
tableKeySchema.add(new
KeySchemaElement().withAttributeName("Artist").withKeyType(KeyType.HASH)); //Partition
key
tableKeySchema.add(new
KeySchemaElement().withAttributeName("SongTitle").withKeyType(KeyType.RANGE)); //Sort key
createTableRequest.setKeySchema(tableKeySchema);
.withIndexName("AlbumTitleIndex").withKeySchema(indexKeySchema).withProjection(projection);
createTableRequest.setLocalSecondaryIndexes(localSecondaryIndexes);
Debe esperar hasta que DynamoDB cree la tabla y establezca el estado de esta última enACTIVE. A partir
de ese momento, puede comenzar a incluir elementos de datos en la tabla.
A continuación se indican los pasos que debe seguir para obtener acceso a la información de índice
secundario local de una tabla mediante elAWS SDK for JavaDocumentación de la API
Example
List<LocalSecondaryIndexDescription> localSecondaryIndexes
= tableDescription.getLocalSecondaryIndexes();
// This code snippet will work for multiple indexes, even though
// there is only one index in this example.
Los únicos atributos devueltos son aquellos que se han proyectado en el índice. Puede modificar esta
consulta de modo que también seleccione atributos sin clave, pero esto requeriría realizar actividad
de recuperación en la tabla, lo que resulta relativamente costoso. Para obtener más información sobre
recuperaciones de tablas, consulte Proyecciones de atributos (p. 615).
A continuación se indican los pasos para consultar un índice secundario local mediante la herramientaAWS
SDK for JavaDocumentación de la API
Example
while (itemsIter.hasNext()) {
Item item = itemsIter.next();
System.out.println(item.toJSONPretty());
}
• ProductName
• OrderStatus
• ShipmentTrackingId
• IsOpenIndex: clave de ordenación esIsOpen, y todos los atributos de la tabla se proyectan en el
índice.
Después de laCustomerOrders, el programa carga la tabla con datos que representan pedidos de
clientes. A continuación, consulta los datos utilizando los índices secundarios locales. Por último, el
programa elimina el valor deCustomerOrdersTabla INTO
Para obtener instrucciones paso a paso para probar el siguiente ejemplo, consulte Ejemplos de código
Java (p. 338).
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples.document;
import java.util.ArrayList;
import java.util.Iterator;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Index;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.ItemCollection;
import com.amazonaws.services.dynamodbv2.document.PutItemOutcome;
import com.amazonaws.services.dynamodbv2.document.QueryOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.CreateTableRequest;
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.LocalSecondaryIndex;
import com.amazonaws.services.dynamodbv2.model.Projection;
import com.amazonaws.services.dynamodbv2.model.ProjectionType;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.services.dynamodbv2.model.ReturnConsumedCapacity;
import com.amazonaws.services.dynamodbv2.model.Select;
createTable();
loadData();
query(null);
query("IsOpenIndex");
query("OrderCreationDateIndex");
deleteTable(tableName);
createTableRequest.setAttributeDefinitions(attributeDefinitions);
// key
tableKeySchema.add(new
KeySchemaElement().withAttributeName("OrderId").withKeyType(KeyType.RANGE)); // Sort
// key
createTableRequest.setKeySchema(tableKeySchema);
// OrderCreationDateIndex
LocalSecondaryIndex orderCreationDateIndex = new
LocalSecondaryIndex().withIndexName("OrderCreationDateIndex");
// key
indexKeySchema.add(new
KeySchemaElement().withAttributeName("OrderCreationDate").withKeyType(KeyType.RANGE)); //
Sort
// key
orderCreationDateIndex.setKeySchema(indexKeySchema);
orderCreationDateIndex.setProjection(projection);
localSecondaryIndexes.add(orderCreationDateIndex);
// IsOpenIndex
LocalSecondaryIndex isOpenIndex = new
LocalSecondaryIndex().withIndexName("IsOpenIndex");
// key
indexKeySchema.add(new
KeySchemaElement().withAttributeName("IsOpen").withKeyType(KeyType.RANGE)); // Sort
// key
isOpenIndex.setKeySchema(indexKeySchema);
isOpenIndex.setProjection(projection);
localSecondaryIndexes.add(isOpenIndex);
System.out.println("\n***********************************************************
\n");
System.out.println("Querying table " + tableName + "...");
if (indexName == "IsOpenIndex") {
querySpec.withProjectionExpression("OrderCreationDate, ProductCategory,
ProductName, OrderStatus");
while (iterator.hasNext()) {
System.out.println(iterator.next().toJSONPretty());
}
}
else if (indexName == "OrderCreationDateIndex") {
System.out.println("\nUsing index: '" + indexName + "': Bob's orders that were
placed after 01/31/2015.");
System.out.println("Only the projected attributes are returned\n");
Index index = table.getIndex(indexName);
querySpec.withSelect(Select.ALL_PROJECTED_ATTRIBUTES);
while (iterator.hasNext()) {
System.out.println(iterator.next().toJSONPretty());
}
}
else {
System.out.println("\nNo index: All of Bob's orders, by OrderId:\n");
querySpec.withKeyConditionExpression("CustomerId = :v_custid")
.withValueMap(new ValueMap().withString(":v_custid", "bob@example.com"));
while (iterator.hasNext()) {
System.out.println(iterator.next().toJSONPretty());
}
putItemOutcome = table.putItem(item);
putItemOutcome = table.putItem(item);
putItemOutcome = table.putItem(item);
putItemOutcome = table.putItem(item);
putItemOutcome = table.putItem(item);
putItemOutcome = table.putItem(item);
putItemOutcome = table.putItem(item);
putItemOutcome = table.putItem(item);
/* no IsOpen attribute */
.withNumber("OrderCreationDate", 20150324).withString("ProductCategory",
"Golf")
.withString("ProductName", "PGA Pro II").withString("OrderStatus", "OUT FOR
DELIVERY")
.withString("ShipmentTrackingId", "383283");
putItemOutcome = table.putItem(item);
assert putItemOutcome != null;
}
Puede utilizarAWS SDK for .NETPara crear una tabla de Amazon DynamoDB con uno o varios índices
secundarios locales, describir los índices de la tabla y utilizarlos para realizar consultas. Estas operaciones
se mapean a las acciones correspondientes del API de bajo nivel de DynamoDB. Para obtener más
información, consulte Ejemplos de código .NET (p. 340).
A continuación se indican los pasos comunes para las operaciones con tablas mediante el API de bajo
nivel de .NET.
Por ejemplo, cree un objeto CreateTableRequest para crear una tabla y un objeto QueryRequest
para consultar una tabla o un índice.
3. Ejecute el método apropiado proporcionado por el cliente que ha creado en el paso anterior.
A continuación se indican los pasos que hay que seguir para crear una tabla con un índice secundario local
mediante el API de bajo nivel de .NET.
Debe proporcionar el nombre de la tabla, su clave principal y los valores de desempeño provisionado.
Para el índice secundario local, debe proporcionar el nombre de índice, el nombre y el tipo de datos de
la clave de ordenación del índice, el esquema de claves del índice y la proyección de atributos.
En el siguiente ejemplo de código C# se ponen en práctica los pasos anteriores. El código crea una
tabla (Music) con un índice secundario en elAlbumTitleAtributo. La clave de partición y la clave de
ordenación de la tabla, además de la clave de ordenación del índice, son los únicos atributos proyectados
en el índice.
//ProvisionedThroughput
createTableRequest.ProvisionedThroughput = new ProvisionedThroughput()
{
ReadCapacityUnits = (long)5,
WriteCapacityUnits = (long)5
};
//AttributeDefinitions
List<AttributeDefinition> attributeDefinitions = new List<AttributeDefinition>();
attributeDefinitions.Add(new AttributeDefinition()
{
AttributeName = "Artist",
AttributeType = "S"
});
attributeDefinitions.Add(new AttributeDefinition()
{
AttributeName = "SongTitle",
AttributeType = "S"
});
attributeDefinitions.Add(new AttributeDefinition()
{
AttributeName = "AlbumTitle",
AttributeType = "S"
});
createTableRequest.AttributeDefinitions = attributeDefinitions;
//KeySchema
List<KeySchemaElement> tableKeySchema = new List<KeySchemaElement>();
createTableRequest.KeySchema = tableKeySchema;
Debe esperar hasta que DynamoDB cree la tabla y establezca el estado de esta última enACTIVE. A partir
de ese momento, puede comenzar a incluir elementos de datos en la tabla.
A continuación se indican los pasos que hay que seguir para obtener acceso a información de índice
secundario local de una tabla mediante el API de bajo nivel de .NET.
Example
// This code snippet will work for multiple indexes, even though
// there is only one index in this example.
foreach (LocalSecondaryIndexDescription lsiDescription in localSecondaryIndexes)
{
Console.WriteLine("Info for index " + lsiDescription.IndexName + ":");
if (projection.ProjectionType.ToString().Equals("INCLUDE"))
{
Console.WriteLine("\t\tThe non-key projected attributes are:");
}
}
Los únicos atributos devueltos son aquellos que se han proyectado en el índice. Puede modificar esta
consulta de modo que también seleccione atributos sin clave, pero esto requeriría realizar actividad
de recuperación en la tabla, lo que resulta relativamente costoso. Para obtener más información sobre
recuperaciones de tablas, consulte Proyecciones de atributos (p. 615).
A continuación se indican los pasos que hay que seguir para consultar un índice secundario local mediante
el API de bajo nivel de .NET.
Example
}
Console.WriteLine();
}
Después de laCustomerOrders, el programa carga la tabla con datos que representan pedidos de
clientes. A continuación, consulta los datos utilizando los índices secundarios locales. Por último, el
programa elimina el valor deCustomerOrdersTabla INTO
Para obtener instrucciones paso a paso para probar el siguiente ejemplo, consulte Ejemplos de
código .NET (p. 340).
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using System;
using System.Collections.Generic;
using System.Linq;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;
using Amazon.DynamoDBv2.DocumentModel;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;
using Amazon.SecurityToken;
namespace com.amazonaws.codesamples
{
class LowLevelLocalSecondaryIndexExample
{
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
Query(null);
Query("IsOpenIndex");
Query("OrderCreationDateIndex");
DeleteTable(tableName);
createTableRequest.AttributeDefinitions = attributeDefinitions;
};
createTableRequest.KeySchema = tableKeySchema;
// OrderCreationDateIndex
LocalSecondaryIndex orderCreationDateIndex = new LocalSecondaryIndex()
{
IndexName = "OrderCreationDateIndex"
};
orderCreationDateIndex.KeySchema = indexKeySchema;
orderCreationDateIndex.Projection = projection;
localSecondaryIndexes.Add(orderCreationDateIndex);
// IsOpenIndex
LocalSecondaryIndex isOpenIndex
= new LocalSecondaryIndex()
{
IndexName = "IsOpenIndex"
};
isOpenIndex.KeySchema = indexKeySchema;
isOpenIndex.Projection = projection;
localSecondaryIndexes.Add(isOpenIndex);
Console.WriteLine("\n***********************************************************\n");
Console.WriteLine("Querying table " + tableName + "...");
if (indexName == "IsOpenIndex")
{
Console.WriteLine("\nUsing index: '" + indexName
+ "': Bob's orders that are open.");
Console.WriteLine("Only a user-specified list of attributes are returned
\n");
queryRequest.IndexName = indexName;
// ProjectionExpression
queryRequest.ProjectionExpression = "OrderCreationDate, ProductCategory,
ProductName, OrderStatus";
}
else if (indexName == "OrderCreationDateIndex")
{
Console.WriteLine("\nUsing index: '" + indexName
+ "': Bob's orders that were placed after 01/31/2013.");
Console.WriteLine("Only the projected attributes are returned\n");
queryRequest.IndexName = indexName;
N = "20130131"
});
// Select
queryRequest.Select = "ALL_PROJECTED_ATTRIBUTES";
}
else
{
Console.WriteLine("\nNo index: All of Bob's orders, by OrderId:\n");
}
queryRequest.KeyConditionExpression = keyConditionExpression;
queryRequest.ExpressionAttributeValues = expressionAttributeValues;
N = "20130101"
};
item["ProductCategory"] = new AttributeValue
{
S = "Book"
};
item["ProductName"] = new AttributeValue
{
S = "The Great Outdoors"
};
item["OrderStatus"] = new AttributeValue
{
S = "PACKING ITEMS"
};
/* no ShipmentTrackingId attribute */
PutItemRequest putItemRequest = new PutItemRequest
{
TableName = tableName,
Item = item,
ReturnItemCollectionMetrics = "SIZE"
};
client.PutItem(putItemRequest);
Item = item,
ReturnItemCollectionMetrics = "SIZE"
};
client.PutItem(putItemRequest);
{
S = "DELIVERED"
};
item["ShipmentTrackingId"] = new AttributeValue
{
S = "645193"
};
putItemRequest = new PutItemRequest
{
TableName = tableName,
Item = item,
ReturnItemCollectionMetrics = "SIZE"
};
client.PutItem(putItemRequest);
};
item["ProductCategory"] = new AttributeValue
{
S = "Book"
};
item["ProductName"] = new AttributeValue
{
S = "How To Cook"
};
item["OrderStatus"] = new AttributeValue
{
S = "IN TRANSIT"
};
item["ShipmentTrackingId"] = new AttributeValue
{
S = "440185"
};
putItemRequest = new PutItemRequest
{
TableName = tableName,
Item = item,
ReturnItemCollectionMetrics = "SIZE"
};
client.PutItem(putItemRequest);
S = "bob@example.com"
};
item["OrderId"] = new AttributeValue
{
N = "7"
};
/* no IsOpen attribute */
item["OrderCreationDate"] = new AttributeValue
{
N = "20130324"
};
item["ProductCategory"] = new AttributeValue
{
S = "Golf"
};
item["ProductName"] = new AttributeValue
{
S = "PGA Pro II"
};
item["OrderStatus"] = new AttributeValue
{
S = "OUT FOR DELIVERY"
};
item["ShipmentTrackingId"] = new AttributeValue
{
S = "383283"
};
putItemRequest = new PutItemRequest
{
TableName = tableName,
Item = item,
ReturnItemCollectionMetrics = "SIZE"
};
client.PutItem(putItemRequest);
}
while (tablePresent)
{
System.Threading.Thread.Sleep(5000); // Wait 5 seconds.
try
{
var res = client.DescribeTable(new DescribeTableRequest
{
TableName = tableName
});
Temas
• Creación de una tabla con un índice secundario local (p. 649)
• Describir una tabla con un índice secundario local (p. 650)
• Consulta de un índice secundario local (p. 650)
Debe esperar hasta que DynamoDB cree la tabla y establezca el estado de esta última enACTIVE. A partir
de ese momento, puede comenzar a incluir elementos de datos en la tabla. Puede usardescribir-tablaPara
determinar el estado de la creación de tablas.
Los únicos atributos devueltos son aquellos que se han proyectado en el índice. Puede modificar esta
consulta de modo que también seleccione atributos sin clave, pero esto requeriría realizar actividad
de recuperación en la tabla, lo que resulta relativamente costoso. Para obtener más información sobre
recuperaciones de tablas, consulte Proyecciones de atributos (p. 615).
• Una popular aplicación para móviles modifica los datos de una tabla de DynamoDB a razón de miles de
actualizaciones por segundo. Otra aplicación captura y almacena los datos sobre estas actualizaciones y
ofrece métricas de uso de la aplicación para móviles prácticamente en tiempo real.
• Una aplicación financiera modifica los datos de mercado de valores de una tabla de DynamoDB.
Diferentes aplicaciones que se ejecutan en paralelo rastrean estos cambios en tiempo real, calculan el
valor en riesgo y reequilibran automáticamente las carteras en función de los movimientos del precio de
las acciones.
• Los sensores de los vehículos de transporte y los equipos industriales envían datos a una tabla de
DynamoDB. Diferentes aplicaciones supervisan el rendimiento y envían alertas de mensajería cuando
se detecta un problema, predicen posibles defectos aplicando algoritmos de aprendizaje automático y
comprimen y archiven datos en Amazon Simple Storage Service (Amazon S3).
• Una aplicación envía automáticamente notificaciones a los dispositivos móviles de todos los amigos de
un grupo tan pronto como uno de ellos carga una nueva imagen.
• Un nuevo cliente agrega datos a una tabla de DynamoDB. Este evento invoca otra aplicación que envía
un mensaje de correo electrónico de bienvenida al nuevo cliente.
Temas
• Opciones de streaming para la captura de datos de cambio (p. 651)
• Cambiar la captura de datos para Kinesis Data Streams con DynamoDB (p. 652)
• Captura de datos de cambio para DynamoDB Streams (p. 661)
Para ayudarle a elegir la solución adecuada para su aplicación, la siguiente tabla resume las
características de cada modelo de transmisión.
Compatibilidad con Kinesis Client AdmiteVersiones 1.X y 2.X de AdmiteKCL versión 1.X.
Library (KCL) KCL.
La transmisión por streaming de los datos de DynamoDB a una secuencia de datos de Kinesis permite
capturar y almacenar continuamente terabytes de datos por hora. Kinesis Data Streams le permite
aprovechar un tiempo de retención de datos más prolongado, una capacidad de ampliación mejorada
para más de dos aplicaciones de consumo simultáneas y una auditoría adicional y transparencia de
seguridad. Kinesis Data Streams también le da acceso a otros servicios de Kinesis, comoAmazon Kinesis
Data FirehoseyAmazon Kinesis Data Analytics. Esto permite crear aplicaciones para alimentar paneles
en tiempo real, generar alertas y aplicar precios y publicidad dinámicos y realizar análisis de datos
sofisticados, como la aplicación de algoritmos de aprendizaje automático.
Note
El uso de Kinesis Data Streams para DynamoDB está sujeto aPrecios de Kinesis Data
Streamspara el flujo de datos yPrecios de DynamoDBpara la tabla de origen.
Los registros de datos se publican casi en tiempo real en su flujo de datos de Kinesis. Después de que
se escriban en el flujo de datos de Kinesis, puede leer los registros escritos como lo haría con cualquier
otro registro de cualquier secuencia de datos de Kinesis. Por ejemplo, puede usar la biblioteca de
clientes Kinesis,AWS Lambdao llame a la API de Kinesis Data Streams. Para obtener más información,
consulteLectura de datos de Amazon Kinesis Data StreamsEn la Guía para desarrolladores de Amazon
Kinesis Data Streams.
Los registros de transmisión almacenados en el flujo de datos de Kinesis se cifran en reposo. Para obtener
más información, consulteProtección de datos en Amazon Kinesis Data Streams.
Para cada elemento que se modifica de una tabla de DynamoDB, los registros de secuencia de datos de
Kinesis pueden aparecer en una secuencia diferente a la de las modificaciones del elemento. Los registros
de transmisión pueden aparecer más de una vez en el flujo de datos de Kinesis. Puede utilizar el atributo
timestampApproximateCreationDateTimeen cada registro para identificar el orden real en el que se
produjeron modificaciones de elementos e identificar registros duplicados en la secuencia.
DynamoDB cobra la captura de datos de cambio para Kinesis Data Streams en unidades de captura de
datos de cambio. DynamoDB carga una unidad de captura de datos de cambio por cada escritura de
elementos (hasta 1 KB). Las escrituras de más de 1 KB requieren unidades de captura de datos de cambio
adicionales. DynamoDB calcula las unidades de captura de datos de cambio basándose en el mayor de
las imágenes «antes» y «después» que constituyen un registro de cambios, utilizando la misma lógica
queconsumo de unidad de capacidad para operaciones de escritura. No es necesario aprovisionar el
rendimiento de capacidad para cambiar unidades de captura de datos, de manera similar a la forma en que
DynamoDBBajo demandafunciona el modo.
En las secciones siguientes se describen los conceptos y comportamientos básicos de Amazon Kinesis
Data Streams for Amazon DynamoDB.
Temas
• Desarrollo de Amazon Kinesis Data Streams para Amazon Kinesis Data Streams para Amazon
Dynamo (p. 653)
• Consideraciones sobre la administración de fragmentos para Amazon Kinesis Data Streams (p. 653)
• Supervisión de Amazon Kinesis Data Streams para Amazon Kinesis para Amazon
DynamoDB (p. 654)
Desarrollo de Amazon Kinesis Data Streams para Amazon Kinesis Data Streams
para Amazon Dynamo
Puede habilitar o deshabilitar la transmisión a Kinesis en una tabla de DynamoDB existente mediante el
comandoAWS Management Console, elAWSSDK, o elAWS Command Line Interface(AWS CLI).
• Solo puede habilitar la transmisión de Amazon Kinesis Data Streams para Amazon DynamoDB a una
transmisión de datos de Kinesis desde el mismoAWSCuenta de yAWSRegión como su tabla.
• Sólo puede habilitar la transmisión de Amazon Kinesis Data Streams para Amazon DynamoDB desde
una tabla de DynamoDB a una secuencia de datos de Kinesis.
Los siguientes valores de entrada le ayudan a determinar el número de fragmentos necesarios para que la
secuencia de datos de Kinesis admita la tabla de DynamoDB:
Esta fórmula refleja únicamente los fragmentos necesarios para adaptarse al rendimiento de transmisión
de DynamoDB. No representa el número total de fragmentos necesarios en el flujo de datos de Kinesis,
como los fragmentos necesarios para admitir a los consumidores de secuencias de datos de Kinesis.
Para obtener más información sobre cómo determinar el tamaño de una secuencia de datos de Kinesis,
consulteDeterminar el tamaño inicial de una secuencia de datos Kinesis.
Supervisión de Amazon Kinesis Data Streams para Amazon Kinesis para Amazon
DynamoDB
DynamoDB proporciona varias métricas de Amazon CloudWatch para ayudarle a supervisar la replicación
de la captura de datos de cambio en Kinesis. Para obtener una lista completa de las métricas de
CloudWatch, consulteDimensiones y métricas de DynamoDB (p. 940).
Le recomendamos que supervise los siguientes elementos tanto durante la activación de la transmisión
como en la producción para determinar si la transmisión tiene suficiente capacidad:
Puede crear alarmas de Amazon CloudWatch que envíen un mensaje de Amazon Simple Notification
Service (Amazon SNS) para notificación cuando cualquiera de las métricas anteriores supere un umbral
específico. Para obtener más información, consulte Creación de alarmas de CloudWatch para monitorear
DynamoDB (p. 962).
En esta sección se describe cómo utilizar Amazon Kinesis Data Streams para Amazon DynamoDB con la
consola de Amazon DynamoDB, laAWS Command Line Interface(AWS CLI) y las API.
Todos estos ejemplos utilizan el métodoMusicTabla de DynamoDB creada como parte de laIntroducción a
DynamoDB"Hello, World!"
Console
AWS CLI
4. Compruebe si la transmisión por secuencias de Kinesis está activa en la tabla mediante el uso de
DynamoDBdescribe-kinesis-streaming-destination.
/**
* Takes as input a Record fetched from Kinesis and does arbitrary processing as an
example.
*/
public void processRecord(Record kinesisRecord) throws IOException {
ByteBuffer kdsRecordByteBuffer = kinesisRecord.getData();
JsonNode rootNode = OBJECT_MAPPER.readTree(kdsRecordByteBuffer.array());
JsonNode dynamoDBRecord = rootNode.get("dynamodb");
JsonNode oldItemImage = dynamoDBRecord.get("OldImage");
JsonNode newItemImage = dynamoDBRecord.get("NewImage");
Instant recordTimestamp = fetchTimestamp(dynamoDBRecord);
/**
* Say for example our record contains a String attribute named "stringName"
and we want to fetch the value
* of this attribute from the new item image. The following code fetches this
value.
*/
JsonNode attributeNode = newItemImage.get("stringName");
JsonNode attributeValueNode = attributeNode.get("S"); // Using DynamoDB "S"
type attribute
String attributeValue = attributeValueNode.textValue();
System.out.println(attributeValue);
}
Java
1. Siga las instrucciones de la guía para desarrolladores de Kinesis Data Streams paracreateUn flujo
de datos de Kinesis llamadosamplestreamUso de Java.
EnableKinesisStreamingDestinationRequest enableKdsRequest =
EnableKinesisStreamingDestinationRequest.builder()
.tableName(tableName)
.streamArn(kdsArn)
.build();
EnableKinesisStreamingDestinationResponse enableKdsResponse =
ddbClient.enableKinesisStreamingDestination(enableKdsRequest);
3. Siga las instrucciones de la guía para desarrolladores de Kinesis Data Streams parareadEn la
secuencia de datos creada.
4. Utilice el fragmento de código siguiente para desserializar el contenido de la secuencia
/**
* Takes as input a Record fetched from Kinesis and does arbitrary processing as an
example.
*/
public void processRecord(Record kinesisRecord) throws IOException {
ByteBuffer kdsRecordByteBuffer = kinesisRecord.getData();
JsonNode rootNode = OBJECT_MAPPER.readTree(kdsRecordByteBuffer.array());
JsonNode dynamoDBRecord = rootNode.get("dynamodb");
JsonNode oldItemImage = dynamoDBRecord.get("OldImage");
JsonNode newItemImage = dynamoDBRecord.get("NewImage");
Instant recordTimestamp = fetchTimestamp(dynamoDBRecord);
/**
* Say for example our record contains a String attribute named "stringName"
and we wanted to fetch the value
* of this attribute from the new item image, the below code would fetch this.
*/
JsonNode attributeNode = newItemImage.get("stringName");
JsonNode attributeValueNode = attributeNode.get("S"); // Using DynamoDB "S"
type attribute
String attributeValue = attributeValueNode.textValue();
System.out.println(attributeValue);
}
Para obtener más información sobre cómo crear consumidores y conectar su flujo de datos de Kinesis
a otrosAWSservicios, consulteLectura de datos de Amazon Kinesis Data Streams, en la Guía para
desarrolladores de Amazon Kinesis Data Streams.
Para obtener más información acerca roles vinculados a servicios, consulte Uso de roles vinculados a
servicios en la Guía del usuario de IAM.
En los siguientes ejemplos se muestra cómo utilizar directivas de IAM para conceder permisos a Amazon
Kinesis Data Streams para Amazon DynamoDB.
• Para habilitar Amazon Kinesis Data Streams para Amazon DynamoDB, debe
tenerdynamodb:EnableKinesisStreamingDestinationen la mesa.
• Para deshabilitar Amazon Kinesis Data Streams para Amazon DynamoDB, debe
tenerdynamodb:DisableKinesisStreamingDestinationen la mesa.
• Para describir Amazon Kinesis Data Streams para Amazon DynamoDB para una tabla de DynamoDB
determinada, debe tenerdynamodb:DescribeKinesisStreamingDestinationen la mesa.
Ejemplo: Activar Amazon Kinesis Data Streams para Amazon Kinesis Data
Streams para Amazon Dynamo
La siguiente política de IAM concede permisos para habilitar Amazon Kinesis Data Streams for Amazon
DynamoDB para laMusicy no concede permisos para deshabilitar o describir Kinesis Data Streams para
DynamoDB para elMusicTabla INTO.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::*:role/aws-service-role/
kinesisreplication.dynamodb.amazonaws.com/
AWSServiceRoleForDynamoDBKinesisDataStreamsReplication",
"Condition": {"StringLike": {"iam:AWSServiceName":
"kinesisreplication.dynamodb.amazonaws.com"}}
},
{
"Effect": "Allow",
"Action": [
"dynamodb:EnableKinesisStreamingDestination"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/Music"
}
]
}
Ejemplo: Deshabilitar Amazon Kinesis Data Streams para Amazon Kinesis Data
Streams para Amazon Dynamo
La siguiente política de IAM concede permisos para deshabilitar Amazon Kinesis Data Streams para
Amazon DynamoDB para laMusicy no concede permisos para habilitar o describir Amazon Kinesis Data
Streams para Amazon DynamoDB para elMusicTabla INTO.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:DisableKinesisStreamingDestination"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/Music"
}
]
}
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:EnableKinesisStreamingDestination",
"dynamodb:DescribeKinesisStreamingDestination"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/Music"
},
{
"Effect": "Deny",
"Action": [
"dynamodb:DisableKinesisStreamingDestination"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/Orders"
}
]
}
Uso de roles vinculados a servicios para Kinesis Data Streams para DynamoDB
Amazon Kinesis Data Streams para Amazon DynamoDB utilizaAWS Identity and Access
Management(IAM)Roles vinculados a servicios. Un rol vinculado a un servicio es un tipo único de rol
de IAM que está vinculado directamente a Kinesis Data Streams for DynamoDB. Los roles vinculados a
servicios están predefinidos por Kinesis Data Streams for DynamoDB e incluyen todos los permisos que el
servicio requiere para llamar a otrosAWSEn su nombre.
Un rol vinculado a un servicio simplifica la configuración de Kinesis Data Streams para DynamoDB porque
ya no tendrá que añadir manualmente los permisos necesarios. Kinesis Data Streams for DynamoDB
define los permisos de sus roles vinculados a servicios y, a menos que esté definido de otra manera,
solo Kinesis Data Streams for DynamoDB pueden asumir sus roles. Los permisos definidos incluyen las
políticas de confianza y de permisos, y que la política de permisos no se puede asociar a ninguna otra
entidad de IAM
Para obtener información sobre otros servicios que admiten roles vinculados a servicios, consulte Servicios
de AWS que funcionan con IAM y busque los servicios que tienen Sí en la columna Rol vinculado a
servicio. Seleccione una opción Sí con un enlace para ver la documentación acerca del rol vinculado al
servicio en cuestión.
Permisos de roles vinculados a servicios para Kinesis Data Streams para DynamoDB
Kinesis Data Streams para DynamoDB usa el rol vinculado al servicio
denominadoAWSServiceRoleForDynamodBkinesisDataStreamsReplication. El propósito de la función
vinculada a servicios es permitir que Amazon DynamoDB administre la replicación de cambios a nivel de
elemento en Kinesis Data Streams, en su nombre.
• kinesisreplication.dynamodb.amazonaws.com
La política de permisos del rol permite que Kinesis Data Streams for DynamoDB realice las siguientes
acciones en los recursos especificados:
Debe configurar permisos para permitir a una entidad de IAM (como un usuario, grupo o función) crear,
editar o eliminar la descripción de una función vinculada a un servicio. Para obtener más información,
consulte Permisos de roles vinculados a servicios en la Guía del usuario de IAM..
Creación de un rol vinculado a un servicio para Kinesis Data Streams para DynamoDB
No necesita crear manualmente un rol vinculado a un servicio. Cuando habilita Kinesis Data Streams
para DynamoDB en elAWS Management Console, elAWS CLI, o elAWSAPI, Kinesis Data Streams para
DynamoDB crea automáticamente el rol vinculado al servicio.
Si elimina este rol vinculado a servicio y necesita crearlo de nuevo, puede utilizar el mismo proceso para
volver a crear el rol en su cuenta. Cuando habilita Kinesis Data Streams para DynamoDB, Kinesis Data
Streams para DynamoDB vuelve a crear el rol vinculado al servicio.
Edición de un rol vinculado a un servicio para Kinesis Data Streams para DynamoDB
Kinesis Data Streams para DynamoDB no le permite editar
laAWSServiceRoleForDynamoDBKinesisDataStreamsReplicationFunción vinculada a un servicio.
Después de crear un rol vinculado a un servicio, no puede cambiarle el nombre, ya que varias entidades
pueden hacer referencia al mismo. Sin embargo, puede editar la descripción del rol utilizando IAM. Para
obtener más información, consulte Editar un rol vinculado a servicios en la Guía del usuario de IAM..
Eliminación de un rol vinculado a un servicio para Kinesis Data Streams para DynamoDB
También puede utilizar la consola de IAM,AWS CLIo elAWSAPI para eliminar manualmente el rol vinculado
al servicio. Para ello, primero debe limpiar manualmente los recursos del rol vinculado al servicio para
poder eliminarlo después manualmente.
Note
Si Kinesis Data Streams for DynamoDB está utilizando el rol cuando intenta eliminar los recursos,
es posible que no se pueda borrar. En tal caso, espere unos minutos e intente de nuevo la
operación.
El cifrado en reposo cifra los datos de las secuencias de DynamoDB. Para obtener más información,
consulte DynamoDB ado en reposo (p. 884).
Aflujo de DynamoDBes un flujo ordenado de información sobre los cambios que se realizan en los
elementos de una tabla de DynamoDB. Cuando se habilita una secuencia en una tabla de, DynamoDB
obtiene información sobre cada modificación de los elementos de datos de esa tabla.
Cada vez que una aplicación crea, actualiza o elimina elementos en la tabla, DynamoDB Streams escribe
un registro de secuencia con los atributos de clave principal de los elementos modificados. ARegistro de la
secuenciaContiene información sobre una modificación de los datos de un solo elemento de una tabla de
DynamoDB. Puede configurar la secuencia de tal forma que sus registros capturen información adicional;
por ejemplo, las imágenes de "antes" y "después" de los elementos modificados.
DynamoDB Streams escribe los registros de secuencia prácticamente en tiempo real, para que se puedan
crear aplicaciones que consuman estas secuencias y adopten medidas en función de su contenido.
Temas
• Puntos finales de DynamoDB Streams (p. 661)
• Habilitación de una secuencia (p. 662)
• Lectura y procesamiento de secuencias (p. 663)
• DynamoDB Streams y tiempo de vida (p. 665)
• Uso de DynamoDB Streams Kinesis Adapter para procesar registros de secuencia (p. 665)
• API de bajo nivel de DynamoDB Streams: Ejemplo de Java (p. 677)
• y DynamoDB StreamsAWS LambdaDesencadenadores (p. 681)
Note
Para obtener una lista completa de las regiones y los puntos de enlace de las secuencias de
DynamoDB y DynamoDB, consulteRegiones y puntos de enlace deen laAWSReferencia general
de.
LaAWSLos SDK proporcionan clientes independientes para DynamoDB y DynamoDB Streams. Según
cuáles sean sus necesidades, la aplicación puede obtener acceso a un punto de enlace de DynamoDB,
a un punto de enlace de DynamoDB Streams o a ambos al mismo tiempo. Para conectarse a ambos
puntos de enlace, la aplicación tiene que crear instancias de dos clientes: uno para DynamoDB y otro para
DynamoDB Streams.
La forma más sencilla de administrar DynamoDB Streams es usar laAWS Management Console.
También puede usar las operaciones de la API CreateTable o UpdateTable para habilitar o modificar
una secuencia, respectivamente. El parámetro StreamSpecification determina cómo se configura la
secuencia:
• StreamEnabled— Especifica si una secuencia está habilitada (true) o deshabilitado (false) para la
tabla.
• StreamViewType: especifica la información que se escribirá en la secuencia cada vez que se
modifiquen los datos de la tabla:
• KEYS_ONLY: solo los atributos de clave del elemento modificado.
• NEW_IMAGE: el elemento completo tal y como aparece después de modificarlo.
• OLD_IMAGE: el elemento completo tal y como aparecía antes de modificarlo.
• NEW_AND_OLD_IMAGES: ambas imágenes del elemento, la nueva y la anterior.
Puede habilitar o deshabilitar una secuencia en cualquier momento. Sin embargo, tenga en cuenta que
recibirá una excepción ResourceInUseException si intenta habilitar una secuencia en una tabla que ya
tiene una. Recibirá una excepción ValidationException si intenta deshabilitar una secuencia en una
tabla que no tiene ninguna.
Cuando configuraStreamEnabledDe atrue, DynamoDB crea una nueva secuencia con un descriptor de
secuencia único asignado a ella. Si deshabilita y vuelve a habilitar una secuencia en la tabla, se crea una
secuencia nueva con un descriptor de secuencia distinto.
Cada secuencia se identifica de forma exclusiva mediante un nombre de recurso de Amazon (ARN).
A continuación se muestra un ejemplo de ARN de una secuencia de una tabla de DynamoDB
denominadaTestTable.
arn:aws:dynamodb:us-west-2:111122223333:table/TestTable/stream/2015-05-11T21:21:33.291
Para determinar el último descriptor de secuencia de una tabla, DynamoDB emite unDescribeTabley
busque elLatestStreamArnelemento en la respuesta.
Una secuencia consta de registros de secuencia. Cada registro de secuencia representa una única
modificación de datos de la tabla de DynamoDB a la que pertenece la secuencia. A cada registro de
secuencia se le asigna un número de secuencia que refleja el orden en que el registro se ha publicado en
la secuencia.
Los registros de secuencia se organizan en grupos, o fragmentos. Cada fragmento actúa como contenedor
de varios registros de secuencia y contiene la información necesaria para obtener acceso a estos registros
y recorrerlos en iteración. Los registros de secuencia de un fragmento se eliminan automáticamente
transcurridas de 24 horas.
Los fragmentos son efímeros: Se crean y eliminan automáticamente, según sea necesario. Además,
cualquier fragmento se puede dividir en varios fragmentos nuevos; esto también sucede automáticamente.
(Cabe destacar que un fragmento principal puede tener un solo fragmento secundario). Un fragmento se
puede dividir en respuesta a niveles de actividad de escritura elevados en la tabla principal, para que las
aplicaciones puedan procesar en paralelo los registros de varios fragmentos.
Si se deshabilita una secuencia, todos fragmentos que estén abiertos se cerrarán. Los datos de la
secuencia continuarán disponibles para leerlos durante 24 horas.
Como los fragmentos poseen un parentesco (principales y secundarios), las aplicaciones siempre deben
procesar los fragmentos principales antes de procesar los secundarios. Esto ayuda a garantizar que
los registros de secuencia se procesen también en el orden correcto. (Si utiliza DynamoDB Streams
Kinesis Adapter, esto se lleva a cabo de forma automatizada). La aplicación procesará los fragmentos
y registros de secuencia en el orden correcto. También administrará automáticamente los fragmentos
nuevos o vencidos, así como aquellos que se dividan mientras se ejecuta la aplicación. Para obtener
más información, consulteUso de DynamoDB Streams Kinesis Adapter para procesar registros de
secuencia (p. 665).)
En el siguiente diagrama se muestra la relación entre una secuencia, sus fragmentos y los registros de
secuencia contenidos en los fragmentos.
Note
Si realiza unaPutItemorUpdateItemOperación que no modifica ningún dato de un elemento,
DynamoDB Streams sínoescribir un registro de flujo para esa operación.
Para obtener acceso a una secuencia y procesar los registros que contiene, proceda como sigue:
Note
Nunca debe haber más de dos procesos leyendo el mismo fragmento de secuencia a la vez.
Usar más de dos procesos de lectura por fragmento puede provocar que se aplique la limitación
controlada.
La API de DynamoDB Streams ofrece las siguientes acciones para usarlas en los programas de aplicación:
Para obtener descripciones completas de estas operaciones de la API, así como ejemplos de solicitudes y
respuestas, consulteReferencia de la API de Amazon DynamoDB Streams.
Si deshabilita una secuencia en una tabla, los datos de esa secuencia continuarán disponibles para leerlos
durante 24 horas. Transcurrido ese tiempo, los datos vencen y los registros de secuencia se eliminan
automáticamente. No existe ningún mecanismo para eliminar manualmente las secuencias. Tiene que
esperar hasta que se alcance el límite de retención (24 horas) para que se eliminen los registros de
secuencia.
Los elementos que el proceso Tiempo de vida elimina tras su vencimiento tienen los campos siguientes:
• Records[<index>].userIdentity.type
"Service"
• Records[<index>].userIdentity.principalId
"dynamodb.amazonaws.com"
"Records": [
{
...
"userIdentity": {
"type": "Service",
"principalId": "dynamodb.amazonaws.com"
}
...
}
]
Puede escribir aplicaciones para Kinesis Data Streams mediante Kinesis Client Library (KCL). KCL
simplifica la codificación porque proporciona abstracciones útiles por encima del API de bajo nivel de
Kinesis Data Streams. Para obtener más información sobre KCL, consulte laDesarrollo de consumidores
mediante Kinesis Client Libraryen laGuía para desarrolladores de Amazon Kinesis Data Streams.
Como usuario de DynamoDB Streams, puede utilizar los patrones de diseño contenidos en KCL para
procesar los fragmentos de DynamoDB Streams y los registros de secuencia. Para ello, se utiliza
DynamoDB Streams Adapter. Kinesis Adapter implementa la interfaz de Kinesis Data Streams, de tal forma
que se pueda usar KCL para consumir y procesar registros desde DynamoDB Streams.
Si DynamoDB Streams Kinesis Adapter está implementado, puede comenzar a desarrollar para la interfaz
de KCL y dirigir las llamadas al API de forma transparente al punto de enlace de DynamoDB Streams.
Cuando se inicia la aplicación, llama a KCL para crear una instancia de un proceso de trabajo. Debe
proporcionar al programa de trabajo información sobre la configuración de la aplicación, como el descriptor
de secuencia yAWSLas credenciales de y el nombre de una clase de procesador de registros que usted
proporcione. A medida que el proceso de trabajo ejecuta el código en el procesador de registros, lleva a
cabo las siguientes tareas:
• Se conecta a la secuencia.
• Enumerates los fragmentos de la secuencia.
• Coordina la asociación de los fragmentos con otros procesos de trabajo (si procede).
• Crea instancias de un procesador de registros para cada fragmento que administra.
• Extrae registros de la secuencia.
• Inserta los registros en el procesador de registros correspondiente.
• Genera puntos de comprobación para los registros procesados.
• Balancea las asociaciones entre fragmentos y procesos de trabajo cuando cambia el recuento de
instancias de procesos de trabajo.
• Balancea las asociaciones entre fragmentos y procesos de trabajo cuando los fragmentos se dividen.
Note
Para obtener una descripción de los conceptos de KCL enumerados aquí, consulteDesarrollo de
consumidores mediante Kinesis Client Libraryen laGuía para desarrolladores de Amazon Kinesis
Data Streams.
Estos pasos se describen en las siguientes secciones y la aplicación completa se muestra al final del
tutorial.
Temas
• Paso 1: Creación de tablas de DynamoDB (p. 667)
• Paso 2: Generar actividad de actualización en la tabla de origen (p. 668)
• Paso 3: Procesar la secuencia (p. 668)
• Paso 4: Compruebe que el contenido de ambas tablas es idéntico (p. 669)
• Paso 5: Eliminación (p. 670)
• Programa completo: DynamoDB Streams Adapter (p. 670)
El primer paso consiste en crear dos tablas de DynamoDB, una de origen y una de destino. El
StreamViewType de la secuencia de la tabla de origen es NEW_IMAGE. Esto significa que cada vez que
se modifica un elemento en esta tabla, su imagen de "después" se escribe en la secuencia. De esta forma,
se realiza un seguimiento en la secuencia de todas las actividades de escritura en la tabla.
En el siguiente ejemplo se muestra el código utilizado para crear las dos tablas.
.withProvisionedThroughput(provisionedThroughput).withStreamSpecification(streamSpecification);
En la aplicación se define una clase auxiliar con métodos que llaman a las operaciones de API PutItem,
UpdateItem y DeleteItem para escribir los datos. En el siguiente ejemplo se muestra cómo se utilizan
estos métodos.
• Crea una nueva instancia del proceso de trabajo Worker de la KCL, asociado con el generador de
clases.
• Cierra el proceso de trabajo Worker cuando ha finalizado de procesar registros.
Para obtener más información acerca de la definición de interfaz KCL, consulteDesarrollo de consumidores
mediante Kinesis Client Libraryen laGuía para desarrolladores de Amazon Kinesis Data Streams.
switch (streamRecord.getEventName()) {
case "INSERT":
case "MODIFY":
StreamsAdapterDemoHelper.putItem(dynamoDBClient, tableName,
streamRecord.getDynamodb().getNewImage());
break;
case "REMOVE":
StreamsAdapterDemoHelper.deleteItem(dynamoDBClient, tableName,
streamRecord.getDynamodb().getKeys().get("Id").getN());
}
}
checkpointCounter += 1;
if (checkpointCounter % 10 == 0) {
try {
checkpointer.checkpoint();
}
catch (Exception e) {
e.printStackTrace();
}
}
}
En este punto, el contenido de las tablas de origen y destino está sincronizado. La aplicación emite
solicitudes Scan en las dos tablas para comprobar que su contenido sea realmente idéntico.
La clase DemoHelper contiene un método ScanTable que llama a la API de bajo nivel Scan. El siguiente
ejemplo le muestra cómo se usa.
if (StreamsAdapterDemoHelper.scanTable(dynamoDBClient, srcTable).getItems()
.equals(StreamsAdapterDemoHelper.scanTable(dynamoDBClient, destTable).getItems())) {
System.out.println("Scan result is equal.");
}
else {
System.out.println("Tables are different!");
}
Paso 5: Eliminación
La demostración ha finalizado. Por consiguiente, la aplicación elimina las tablas de origen y destino.
Consulte el siguiente ejemplo de código. Incluso después de que las tablas se hayan eliminado, sus
secuencias permanecerán disponibles durante un máximo de 24 horas; transcurrido este periodo se
eliminan automáticamente.
dynamoDBClient.deleteTable(new DeleteTableRequest().withTableName(srcTable));
dynamoDBClient.deleteTable(new DeleteTableRequest().withTableName(destTable));
A continuación encontrará el programa de Java completo que lleva a cabo las tareas descritas en Tutorial:
DynamoDB Streams Adapter (p. 667). Cuando lo ejecute, debería ver un resultado similar al siguiente.
Important
Para ejecutar este programa, utilice políticas con el fin de asegurarse de que la aplicación cliente
tenga acceso a DynamoDB y a Amazon CloudWatch. Para obtener más información, consulte
Uso de políticas basadas en identidad (políticas de IAM) con Amazon DynamoDB (p. 898).
• StreamsAdapterDemo.java
• StreamsRecordProcessor.java
• StreamsRecordProcessorFactory.java
• StreamsAdapterDemoHelper.java
StreamsAdapterDemo.java
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.cloudwatch.AmazonCloudWatch;
import com.amazonaws.services.cloudwatch.AmazonCloudWatchClientBuilder;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBStreams;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBStreamsClientBuilder;
import com.amazonaws.services.dynamodbv2.model.DeleteTableRequest;
import com.amazonaws.services.dynamodbv2.model.DescribeTableResult;
import com.amazonaws.services.dynamodbv2.streamsadapter.AmazonDynamoDBStreamsAdapterClient;
import com.amazonaws.services.dynamodbv2.streamsadapter.StreamsWorkerFactory;
import com.amazonaws.services.kinesis.clientlibrary.interfaces.v2.IRecordProcessorFactory;
import com.amazonaws.services.kinesis.clientlibrary.lib.worker.InitialPositionInStream;
import
com.amazonaws.services.kinesis.clientlibrary.lib.worker.KinesisClientLibConfiguration;
import com.amazonaws.services.kinesis.clientlibrary.lib.worker.Worker;
/**
* @param args
*/
public static void main(String[] args) throws Exception {
System.out.println("Starting demo...");
dynamoDBClient = AmazonDynamoDBClientBuilder.standard()
.withRegion(awsRegion)
.build();
cloudWatchClient = AmazonCloudWatchClientBuilder.standard()
.withRegion(awsRegion)
.build();
dynamoDBStreamsClient = AmazonDynamoDBStreamsClientBuilder.standard()
.withRegion(awsRegion)
.build();
adapterClient = new AmazonDynamoDBStreamsAdapterClient(dynamoDBStreamsClient);
String srcTable = tablePrefix + "-src";
String destTable = tablePrefix + "-dest";
recordProcessorFactory = new StreamsRecordProcessorFactory(dynamoDBClient,
destTable);
setUpTables();
Thread.sleep(25000);
worker.shutdown();
t.join();
if (StreamsAdapterDemoHelper.scanTable(dynamoDBClient, srcTable).getItems()
.equals(StreamsAdapterDemoHelper.scanTable(dynamoDBClient, destTable).getItems())) {
System.out.println("Scan result is equal.");
}
else {
System.out.println("Tables are different!");
}
System.out.println("Done.");
cleanupAndExit(0);
}
awaitTableCreation(srcTable);
performOps(srcTable);
}
StreamsRecordProcessor.java
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.streamsadapter.model.RecordAdapter;
import com.amazonaws.services.kinesis.clientlibrary.interfaces.v2.IRecordProcessor;
import com.amazonaws.services.kinesis.clientlibrary.lib.worker.ShutdownReason;
import com.amazonaws.services.kinesis.clientlibrary.types.InitializationInput;
import com.amazonaws.services.kinesis.clientlibrary.types.ProcessRecordsInput;
import com.amazonaws.services.kinesis.clientlibrary.types.ShutdownInput;
import com.amazonaws.services.kinesis.model.Record;
import java.nio.charset.Charset;
@Override
public void initialize(InitializationInput initializationInput) {
checkpointCounter = 0;
}
@Override
public void processRecords(ProcessRecordsInput processRecordsInput) {
for (Record record : processRecordsInput.getRecords()) {
switch (streamRecord.getEventName()) {
case "INSERT":
case "MODIFY":
StreamsAdapterDemoHelper.putItem(dynamoDBClient, tableName,
streamRecord.getDynamodb().getNewImage());
break;
case "REMOVE":
StreamsAdapterDemoHelper.deleteItem(dynamoDBClient, tableName,
streamRecord.getDynamodb().getKeys().get("Id").getN());
}
}
checkpointCounter += 1;
if (checkpointCounter % 10 == 0) {
try {
processRecordsInput.getCheckpointer().checkpoint();
}
catch (Exception e) {
e.printStackTrace();
}
}
}
@Override
public void shutdown(ShutdownInput shutdownInput) {
if (shutdownInput.getShutdownReason() == ShutdownReason.TERMINATE) {
try {
shutdownInput.getCheckpointer().checkpoint();
}
catch (Exception e) {
e.printStackTrace();
}
}
}
}
StreamsRecordProcessorFactory.java
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.kinesis.clientlibrary.interfaces.v2.IRecordProcessor;
import com.amazonaws.services.kinesis.clientlibrary.interfaces.v2.IRecordProcessorFactory;
@Override
public IRecordProcessor createProcessor() {
return new StreamsRecordProcessor(dynamoDBClient, tableName);
}
}
StreamsAdapterDemoHelper.java
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.model.AttributeAction;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import com.amazonaws.services.dynamodbv2.model.AttributeValueUpdate;
import com.amazonaws.services.dynamodbv2.model.CreateTableRequest;
import com.amazonaws.services.dynamodbv2.model.CreateTableResult;
import com.amazonaws.services.dynamodbv2.model.DeleteItemRequest;
import com.amazonaws.services.dynamodbv2.model.DescribeTableRequest;
import com.amazonaws.services.dynamodbv2.model.DescribeTableResult;
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.services.dynamodbv2.model.PutItemRequest;
import com.amazonaws.services.dynamodbv2.model.ResourceInUseException;
import com.amazonaws.services.dynamodbv2.model.ScanRequest;
import com.amazonaws.services.dynamodbv2.model.ScanResult;
import com.amazonaws.services.dynamodbv2.model.StreamSpecification;
import com.amazonaws.services.dynamodbv2.model.StreamViewType;
import com.amazonaws.services.dynamodbv2.model.UpdateItemRequest;
/**
* @return StreamArn
*/
public static String createTable(AmazonDynamoDB client, String tableName) {
java.util.List<AttributeDefinition> attributeDefinitions = new
ArrayList<AttributeDefinition>();
attributeDefinitions.add(new
AttributeDefinition().withAttributeName("Id").withAttributeType("N"));
// key
.withProvisionedThroughput(provisionedThroughput).withStreamSpecification(streamSpecification);
try {
System.out.println("Creating table " + tableName);
CreateTableResult result = client.createTable(createTableRequest);
return result.getTableDescription().getLatestStreamArn();
}
catch (ResourceInUseException e) {
System.out.println("Table already exists.");
return describeTable(client, tableName).getTable().getLatestStreamArn();
}
}
El código que se presenta en esta página no es exhaustivo y no contempla todos los escenarios
de consumo de Amazon DynamoDB Streams. La manera recomendada de consumir registros de
secuencia de DynamoDB consiste en usar Amazon Kinesis Adapter con la Kinesis Client Library
(KCL), tal y como se describe enUso de DynamoDB Streams Kinesis Adapter para procesar
registros de secuencia (p. 665).
Esta sección contiene un programa de Java que muestra el funcionamiento de las DynamoDB Streams. El
programa realiza lo siguiente:
Example
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazon.codesamples;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.amazonaws.AmazonClientException;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBStreams;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBStreamsClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AttributeAction;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import com.amazonaws.services.dynamodbv2.model.AttributeValueUpdate;
import com.amazonaws.services.dynamodbv2.model.CreateTableRequest;
import com.amazonaws.services.dynamodbv2.model.DescribeStreamRequest;
import com.amazonaws.services.dynamodbv2.model.DescribeStreamResult;
import com.amazonaws.services.dynamodbv2.model.DescribeTableResult;
import com.amazonaws.services.dynamodbv2.model.GetRecordsRequest;
import com.amazonaws.services.dynamodbv2.model.GetRecordsResult;
import com.amazonaws.services.dynamodbv2.model.GetShardIteratorRequest;
import com.amazonaws.services.dynamodbv2.model.GetShardIteratorResult;
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.services.dynamodbv2.model.Record;
import com.amazonaws.services.dynamodbv2.model.Shard;
import com.amazonaws.services.dynamodbv2.model.ShardIteratorType;
import com.amazonaws.services.dynamodbv2.model.StreamSpecification;
import com.amazonaws.services.dynamodbv2.model.StreamViewType;
import com.amazonaws.services.dynamodbv2.util.TableUtils;
AmazonDynamoDBStreams streamsClient =
AmazonDynamoDBStreamsClientBuilder
.standard()
.withRegion(Regions.US_EAST_2)
.withCredentials(new DefaultAWSCredentialsProviderChain())
.build();
try {
TableUtils.waitUntilActive(dynamoDBClient, tableName);
} catch (AmazonClientException e) {
e.printStackTrace();
}
// Get all the shard IDs from the stream. Note that DescribeStream returns
// the shard IDs one page at a time.
String lastEvaluatedShardId = null;
do {
DescribeStreamResult describeStreamResult = streamsClient.describeStream(
new DescribeStreamRequest()
.withStreamArn(streamArn)
.withExclusiveStartShardId(lastEvaluatedShardId));
List<Shard> shards = describeStreamResult.getStreamDescription().getShards();
.withShardId(shardId)
.withShardIteratorType(ShardIteratorType.TRIM_HORIZON);
GetShardIteratorResult getShardIteratorResult =
streamsClient.getShardIterator(getShardIteratorRequest);
String currentShardIter = getShardIteratorResult.getShardIterator();
System.out.println("Demo complete");
}
}
Amazon DynamoDB está integrado conAWS Lambdapara que pueda crearDisparadores de: fragmentos
de código que responden automáticamente a los eventos de DynamoDB Streams. Con los disparadores,
puede crear aplicaciones que reaccionan ante las modificaciones de datos en las tablas de DynamoDB.
Si habilita DynamoDB Streams en una tabla de, puede asociar el nombre de recurso de Amazon (ARN)
de la secuencia con unAWS Lambdafunción que se escribe. Inmediatamente después de modificar un
elemento de la tabla, aparece un nuevo registro en la secuencia de la tabla.AWS Lambdasondea la
secuencia y llama a la función Lambda de forma sincrónica cuando detecta nuevos registros en él.
La función Lambda puede realizar cualquier acción que especifique, como, por ejemplo, enviar una
notificación o iniciar un flujo de trabajo. Por ejemplo, puede escribir una función Lambda que simplemente
copie cada registro del secuencia en el almacenamiento persistente, como Amazon Simple Storage
Service (Amazon S3), para crear un rastro de auditoría permanente de la actividad de escritura que tiene
lugar en la tabla. O bien suponga que tiene una aplicación de juegos para móviles que escribe en una
tabla GameScores. Cada vez que se actualiza el atributo TopScore de la tabla GameScores, se escribe
el registro correspondiente en la secuencia de la tabla. Este evento, a su vez, puede activar una función
Lambda que publique un mensaje de felicitación en una red social. Sencillamente, la función deberá
pasar por alto todos los registros de secuencia que no sean actualizaciones de GameScores o que no
modifiquen el atributo TopScore.
Para obtener más información sobre AWS Lambda, consulte la Guía para desarrolladores de AWS
Lambda.
En este tutorial, va a crear unAWS Lambdapara procesar una secuencia de una tabla de DynamoDB.
El escenario en que tiene lugar este tutorial es Woofer, una red social sencilla. Los usuarios de Woofer se
comunican utilizando ladridos (mensajes de texto breves) que se envían a otros usuarios de Woofer. En el
siguiente diagrama se muestran los componentes y el flujo de trabajo de esta aplicación.
1. Un usuario escribe un elemento en una tabla de DynamoDB (BarkTable). Cada elemento de la tabla
representa un ladrido.
2. Se escribe un nuevo registro de secuencia para reflejar que se ha agregado un elemento nuevo a
BarkTable.
Antes de empezar
En este tutorial se utiliza la AWS Command Line Interface AWS CLI. Si aún no lo ha hecho, siga las
instrucciones que figuran en laAWS Command Line InterfaceGuía del usuarioPara instalar y configurar
laAWS CLI.
En este paso, se crea una tabla de DynamoDB (BarkTable) para almacenar todos los ladridos de los
usuarios de Woofer. La clave principal consta de Username (clave de partición) y Timestamp (clave de
ordenación). Ambos atributos son de tipo String.
BarkTable tiene una secuencia habilitada. Más adelante en este tutorial, asociará una función de AWS
Lambda a la secuencia para crear un disparador.
...
"LatestStreamArn": "arn:aws:dynamodb:region:accountID:table/BarkTable/stream/timestamp
...
Anote el valor de region y accountID, porque los necesitará para los demás pasos de este tutorial.
En este paso, va a crear unAWS Identity and Access ManagementRol de (IAM) deWooferLambdaRole) y
asignarle permisos. Esta función lo utilizará la función Lambda que va a crear enPaso 4: Creación y prueba
de una función Lambda (p. 685).
Asimismo, va a crear una política para el rol. La política contiene todos los permisos que la función Lambda
necesita en tiempo de ejecución.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:region:accountID:function:publishNewBark*"
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:region:accountID:*"
},
{
"Effect": "Allow",
"Action": [
"dynamodb:DescribeStream",
"dynamodb:GetRecords",
"dynamodb:GetShardIterator",
"dynamodb:ListStreams"
],
"Resource": "arn:aws:dynamodb:region:accountID:table/BarkTable/stream/*"
},
{
"Effect": "Allow",
"Action": [
"sns:Publish"
],
"Resource": [
"*"
]
}
]
}
La política tiene cuatro instrucciones que permiten que WooferLambdaRole realice las siguientes
acciones:
• (Ejecute una función Lambda) (publishNewBark). Creará la función más adelante en este tutorial.
• Acceso a Amazon CloudWatch Logs. La función Lambda escribe diagnósticos en CloudWatch Logs
en tiempo de ejecución.
• Leer datos de la secuencia de DynamoDB paraBarkTable.
Versión de API 2012-08-10
684
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams
En este paso, se crea un tema de Amazon SNS (wooferTopic) y suscribe una dirección de correo
electrónico a ella. La función Lambda utiliza este tema para publicar los ladridos nuevos de los usuarios de
Woofer.
3. Amazon SNS envía un mensaje de confirmación a la dirección de correo electrónico indicada. Elija
el enlace Confirm subscription (Confirmar suscripción) del mensaje para completar el proceso de
suscripción.
En este paso, va a crear una función de AWS Lambda (publishNewBark) para procesar los registros de
secuencia de BarkTable.
'use strict';
var AWS = require("aws-sdk");
var sns = new AWS.SNS();
event.Records.forEach((record) => {
console.log('Stream record: ', JSON.stringify(record, null, 2));
if (record.eventName == 'INSERT') {
var who = JSON.stringify(record.dynamodb.NewImage.Username.S);
var when = JSON.stringify(record.dynamodb.NewImage.Timestamp.S);
var what = JSON.stringify(record.dynamodb.NewImage.Message.S);
var params = {
Subject: 'A new bark from ' + who,
Message: 'Woofer user ' + who + ' barked the following at ' + when + ':
\n\n ' + what,
TopicArn: 'arn:aws:sns:region:accountID:wooferTopic'
};
sns.publish(params, function(err, data) {
if (err) {
console.error("Unable to send message. Error JSON:",
JSON.stringify(err, null, 2));
} else {
console.log("Results from sending message: ", JSON.stringify(data,
null, 2));
}
});
}
});
callback(null, `Successfully processed ${event.Records.length} records.`);
};
2. Cree un archivo zip que contenga publishNewBark.js. Si tiene la utilidad de línea de comandos
zip, puede introducir el siguiente comando para hacerlo.
...
"Arn": "arn:aws:iam::region:role/service-role/WooferLambdaRole"
...
Introduzca el siguiente comando para crear la función Lambda. Sustituya roleARN por el ARN de
WooferLambdaRole.
4. Ahora pruebe publishNewBark para comprobar que funciona. Para ello, le facilitamos información
de entrada que parece un registro auténtico de DynamoDB Streams.
{
"Records": [
{
"eventID": "7de3041dd709b024af6f29e4fa13d34c",
"eventName": "INSERT",
"eventVersion": "1.1",
"eventSource": "aws:dynamodb",
Versión de API 2012-08-10
686
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams
"awsRegion": "region",
"dynamodb": {
"ApproximateCreationDateTime": 1479499740,
"Keys": {
"Timestamp": {
"S": "2016-11-18:12:09:36"
},
"Username": {
"S": "John Doe"
}
},
"NewImage": {
"Timestamp": {
"S": "2016-11-18:12:09:36"
},
"Message": {
"S": "This is a bark from the Woofer social network"
},
"Username": {
"S": "John Doe"
}
},
"SequenceNumber": "13021600000000001596893679",
"SizeBytes": 112,
"StreamViewType": "NEW_IMAGE"
},
"eventSourceARN": "arn:aws:dynamodb:region:123456789012:table/BarkTable/
stream/2016-11-16T20:42:48.104"
}
]
}
{
"StatusCode": 200
}
EnPaso 4: Creación y prueba de una función Lambda (p. 685), ha probado la función Lambda para
asegurarse de que se ejecutaba correctamente. En este paso, va a crear unDisparadorasociando la
función Lambda (publishNewBark) con un origen de evento (elBarkTablestream).
...
"LatestStreamArn": "arn:aws:dynamodb:region:accountID:table/BarkTable/stream/timestamp
...
2. Introduzca el siguiente comando para crear el disparador. Sustituya streamARN por el ARN de la
secuencia real.
La función Lambda procesa solamente los elementos nuevos que se agregan aBarkTable. Si
actualiza o elimina un elemento de la tabla, la función no hace nada.
Note
Una función Lambda tiene unhandlerque se ejecuta una vez por invocación. El controlador contiene la
lógica empresarial principal de la función. Por ejemplo, la función Lambda que se muestra enPaso 4:
Creación y prueba de una función Lambda (p. 685)tiene un controlador que puede procesar los registros
de una secuencia de DynamoDB.
También puede proporcionar código de inicialización que se ejecuta una sola vez después de crear el
contenedor, pero antes deAWS Lambdaejecuta el controlador por primera vez. La función Lambda que
se muestra enPaso 4: Creación y prueba de una función Lambda (p. 685)tiene código de inicialización
que importa el SDK for JavaScript in Node.js y crea un cliente para Amazon SNS. Node.js Estos objetos
únicamente deben definirse una vez, fuera del controlador.
Una vez que se ejecuta la función,AWS LambdaPuede optar por reutilizar el contenedor en invocaciones
posteriores de la función. En este caso, el controlador de la función podría volver a utilizar los recursos que
se han definido en el código de inicialización. (No se puede controlar durante cuánto tiempo AWS Lambda
conservará el contenedor ni si este se reutilizará o no).
Puede usar las API de lectura y escritura transaccional de DynamoDB para administrar flujos de trabajo de
negocio complejos que requieren agregar, actualizar o eliminar varios elementos en una única operación
de tipo «todo o nada». Por ejemplo, un desarrollador de videojuegos puede garantizar que los perfiles de
los jugadores se actualicen correctamente cuando intercambien elementos en un juego o realicen compras
dentro de este.
Con la API de escritura de transacciones, puede agrupar varias acciones Put, Update, Delete y
ConditionCheck. A continuación, puede presentarlas como una sola operación TransactWriteItems
que se realiza correctamente o da error como unidad. Lo mismo sucede con varias acciones Get, que se
pueden agrupar y enviar como una sola operación TransactGetItems.
Habilitar las transacciones para las tablas de DynamoDB no conlleva ningún costo adicional. Usted paga
sólo por las lecturas o escrituras que forman parte de su transacción. DynamoDB lleva a cabo dos lecturas
o escrituras subyacentes de cada elemento de la transacción: una para preparar la transacción y otra para
confirmarla. Estas dos operaciones de lectura/escritura subyacentes están visibles en las métricas de
Amazon CloudWatch.
Para comenzar a trabajar con transacciones de DynamoDB, descargue la versión más reciente
deAWSSDK o la propiedad deAWS Command Line Interface(AWS CLI). A continuación, siga el Ejemplo de
transacciones de DynamoDB (p. 698).
En las secciones siguientes, se proporciona información general detallada sobre las API de transacciones
y cómo usarlas en DynamoDB.
Temas
• Amazon DynamoDB Transactions: Cómo funciona (p. 690)
• Uso de IAM con transacciones de DynamoDB (p. 696)
• Ejemplo de transacciones de DynamoDB (p. 698)
Temas
• API TransactWriteItems (p. 690)
• API TransactGetItems (p. 692)
• Niveles de aislamiento para transacciones DynamoDB (p. 692)
• Gestión de conflictos de transacciones en DynamoDB (p. 694)
• Uso de las API transaccionales en DynamoDB Accelerator (DAX) (p. 694)
• Administración de la capacidad para las transacciones (p. 694)
• Prácticas recomendadas para transacciones (p. 695)
• Uso de las API transaccionales con tablas globales (p. 695)
• Biblioteca de clientes de transacciones de DynamoDB (p. 696)
API TransactWriteItems
TransactWriteItems es una operación de escritura síncrona e idempotente que agrupa hasta
25 acciones de escritura en una única operación de tipo "todo o nada". Estas acciones pueden estar
dirigidas a un máximo de 25 elementos diferenciados en una o varias tablas de DynamoDB dentro del
mismoAWSCuenta y en la misma región. El tamaño total de los elementos de la transacción no puede
superar 4 MB. Las acciones se realizan atómicamente, de tal forma que se llevan a cabo correctamente
todas o ninguna de ellas.
No se pueden dirigir varias operaciones de la misma transacción al mismo elemento. Por ejemplo, no se
puede realizar una acción ConditionCheck y también una acción Update en el mismo elemento de la
misma transacción.
• Put— Inicia una propiedad dePutItempara crear un nuevo elemento o reemplazar un elemento antiguo
por otro nuevo, ya sea de forma condicional o sin especificar ninguna condición.
• UpdateInicia una propiedad deUpdateItempara editar los atributos de un elemento existente o agregar
un nuevo elemento a la tabla, si no existe ya. Esta acción se utiliza para agregar, eliminar o actualizar
atributos a un elemento existente, de forma condicional o sin condiciones.
• Delete— Inicia una propiedad deDeleteItemOperación para eliminar un solo elemento de una tabla
identificado por su clave principal.
• ConditionCheck: comprueba la existencia de un elemento o la condición de atributos concretos del
elemento.
Una vez que la transacción se completa, los cambios realizados con transacciones se propagan a índices
secundarios globales (GSI), secuencias y copias de seguridad. Como la propagación no es inmediata
ni instantánea, si se restaura una tabla a partir de una copia de seguridad a un punto en el medio de la
propagación, esta podría contener algunos pero no todos los cambios realizados durante una transacción
reciente.
Idempotency
Opcionalmente, puede incluir un token de cliente al realizar una llamada a TransactWriteItems para
asegurarse de que la solicitud sea idempotente. Hacer que las transacciones sean idempotentes ayuda a
evitar errores de aplicaciones si se envía la misma operación varias veces debido a una interrupción de la
conexión u otro problema de conectividad.
• Un token de cliente es válido durante 10 minutos desde que finaliza la solicitud que lo utiliza.
Transcurridos esos 10 minutos, cualquier solicitud que use el mismo token de cliente se tratará como
si fuera nueva. No debe reutilizar el mismo token de cliente para la misma solicitud si han pasado
10 minutos.
• Si repite una solicitud con el mismo token de cliente dentro del periodo de idempotencia
de 10 minutos, pero cambia algún otro parámetro de la solicitud, DynamoDB devolverá
unaIdempotentParameterMismatchExcepción.
Para obtener más información acerca de cómo se manejan los conflictos con operaciones
TransactWriteItems, consulte Gestión de conflictos de transacciones en DynamoDB (p. 694).
API TransactGetItems
TransactGetItems es una operación de lectura síncrona que agrupa hasta 25 acciones Get. Estas
acciones pueden estar dirigidas a un máximo de 25 elementos diferenciados en una o varias tablas de
DynamoDB dentro del mismoAWSCuenta y región. El tamaño total de los elementos de la transacción no
puede superar 4 MB.
Las acciones Get se realizan atómicamente, de tal forma que se llevan a cabo correctamente todas o
ninguna de ellas:
• Get— Inicia una propiedad deGetItemOperación para recuperar un conjunto de atributos del elemento
con la clave principal indicada. Si no se encuentra ningún elemento que coincida, Get no devuelve
ningún dato.
• Cuando una solicitud TransactGetItems está en conflicto con una operación TransactWriteItems
en curso para uno o varios elementos de la solicitud TransactGetItems. En este caso, la solicitud
genera un error TransactionCanceledException.
• Cuando no hay suficiente capacidad aprovisionada para completar la transacción.
• Cuando hay algún error de usuario, como un formato de datos no válido.
Para obtener más información acerca de cómo se manejan los conflictos con operaciones
TransactGetItems, consulte Gestión de conflictos de transacciones en DynamoDB (p. 694).
SERIALIZABLE
El aislamiento serializable garantiza que los resultados de varias operaciones concurrentes sean iguales
que si ninguna operación se hubiera iniciado antes de finalizar la anterior.
Aunque existe aislamiento serializable entre las operaciones transaccionales y cada escritura estándar
individual escribe en una operación BatchWriteItem, no se produce aislamiento serializable entre la
transacción y la operación BatchWriteItem como una unidad.
Del mismo modo, el nivel de aislamiento entre una operación transaccional y una operación GetItems
individual de una operación BatchGetItem es serializable. Pero el nivel de aislamiento entre la
transacción y la operación BatchGetItem como unidad es de lectura confirmada.
LECTURA CONFIRMADA
El aislamiento de lectura confirmada garantiza que las operaciones de lectura siempre devuelvan valores
confirmados para un elemento. El aislamiento de lectura confirmada no impide las modificaciones del
elemento inmediatamente después de la operación de lectura.
Resumen de la operación
A modo de resumen, en la siguiente tabla se indican los niveles de aislamiento entre una operación
transaccional (TransactWriteItems o TransactGetItems) y otras operaciones.
DeleteItem Serializable
PutItem Serializable
UpdateItem Serializable
GetItem Serializable
BatchWriteItem NO serializable*
Los niveles marcados con un asterisco (*) se aplican a la operación como una unidad. Sin embargo, las
acciones individuales contenidas en esas operaciones tienen el nivel de aislamiento serializable.
• Una solicitud PutItem, UpdateItem o DeleteItem de un elemento entra en conflicto con una solicitud
TransactWriteItems en curso que incluye el mismo elemento.
• Un elemento incluido en una solicitud TransactWriteItems forma parte de otra solicitud
TransactWriteItems en curso.
• Un elemento incluido en una solicitud TransactGetItems forma parte de otra solicitud
TransactWriteItems, BatchWriteItem, PutItem, UpdateItem o DeleteItem en curso.
Note
La métrica TransactionConflict de CloudWatch se incrementa para cada solicitud de nivel de elemento que
no se realiza correctamente.
TransactGetItemsLas llamadas se pasan por DAX sin que los elementos se almacenen caché
localmente. Es el mismo comportamiento que tienen las API de lectura de consistencia alta en DAX.
o escrituras subyacentes de cada elemento de la transacción: una para preparar la transacción y otra
para confirmarla. Las dos operaciones de lectura/escritura subyacentes están visibles en las métricas de
Amazon CloudWatch.
Planee las lecturas y escrituras adicionales que requieren las API transaccionales al aprovisionar la
capacidad para las tablas. Por ejemplo, supongamos que la aplicación ejecuta una transacción por
segundo y que cada transacción escribe tres elementos de 500 bites en la tabla. Cada elemento requiere
dos unidades de capacidad de escritura (WCU): una para preparar la transacción y otra para confirmarla.
Por consiguiente, tendría que aprovisionar seis WCU para la tabla.
Si utilizó el Accelerator de DynamoDB (DAX) en el ejemplo anterior, también debió utilizar dos unidades de
capacidad de lectura (RCU) para cada elemento delTransactWriteItemsLlame a. Por tanto, tendría que
aprovisionar seis RCU adicionales para la tabla.
Del mismo modo, si la aplicación ejecuta una transacción de lectura por segundo y cada transacción lee
tres elementos de 500 bites en la tabla, debería aprovisionar seis unidades de capacidad de lectura (RCU)
para la tabla. Para leer cada elemento, se requieren dos RCU: una para preparar la transacción y otra para
confirmarla.
• Habilite el escalado automático en las tablas o asegúrese de haber aprovisionado suficiente capacidad
de rendimiento para llevar a cabo las dos operaciones de lectura o escritura para cada elemento de la
transacción.
• Si no utiliza una propiedad deAWSproporcionado SDK, incluya unClientRequestTokencuando se
crea un atributoTransactWriteItemsLlame a para asegurarse de que la solicitud sea idempotente.
• No agrupe las operaciones en una transacción si no es necesario. Por ejemplo, si una misma
transacción compuesta de 10 operaciones se puede desglosar en varias transacciones de modo que
la aplicación continúe siendo correcta, recomendamos dividir la transacción. Usar transacciones más
sencillas mejora el rendimiento y aumenta la probabilidad de que se ejecuten correctamente.
• Si varias transacciones actualizan los mismos elementos de forma simultánea, pueden provocar
conflictos que cancelen las transacciones. Recomendamos las siguientes prácticas recomendadas de
DynamoDB para modelar los datos de tal forma que se reduzcan al
• Si un conjunto de atributos se actualiza a menudo para varios elementos durante una misma
transacción, puede ser conveniente agrupar los atributos en un solo elemento para reducir el ámbito de
la transacción.
• Evite utilizar transacciones para la ingesta masiva de datos. Para las escrituras masivas, es preferible
usar BatchWriteItem.
Los permisos para las acciones Put, Update, Delete y Get se rigen por los permisos usados
para las operaciones PutItem, UpdateItem, DeleteItem y GetItem subyacentes. Para
elConditionCheckPuede utilizar la propiedad dedynamodb:ConditionChecken las directivas de IAM.
A continuación, se proporcionan ejemplos de políticas de IAM que puede utilizar para configurar las
transacciones de DynamoDB.
"Condition": {
"ForAnyValue:StringEquals": {
"dynamodb:EnclosingOperation": [
"TransactWriteItems",
"TransactGetItems"
]
}
}
}
]
}
{
"Effect": "Allow",
"Action": [
"dynamodb:ConditionCheckItem",
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:GetItem"
],
"Resource": "arn:aws:dynamodb:*:*:table/table01",
"Condition": {
"StringEqualsIfExists": {
"dynamodb:ReturnValues": "NONE"
}
}
}
]
}
• Customers: en esta tabla se almacenan detalles sobre los clientes del mercado. Su clave principal es
una propiedad deCustomerIdun identificador único.
• ProductCatalog: en esta tabla se almacenan detalles como el precio y la disponibilidad de los
productos que se venden en el mercado. Su clave principal es una propiedad deProductIdun
identificador único.
• Orders: en esta tabla se almacenan detalles sobre los pedidos de la plataforma. Su clave principal es
una propiedad deOrderIdun identificador único.
Hacer un pedido
Los siguientes fragmentos de código ilustran cómo utilizar las transacciones de DynamoDB para coordinar
los múltiples pasos necesarios para crear y procesar un pedido. El uso de una única operación todo o nada
garantiza que si falla alguna parte de la transacción, no se ejecuten acciones en la transacción y no se
realicen cambios.
Validar al cliente
Primero, defina una acción para verificar que un cliente concustomerIdigual que09e8e9c8-ec48existe
en la tabla de clientes.
Crear el pedido
Por último, cree el pedido siempre y cuando un pedido con eseOrderIdNo existe ya.
Ejecutar la transacción
El siguiente ejemplo muestra cómo ejecutar las acciones definidas anteriormente como una única
operación de tipo «todo o nada».
new TransactWriteItem().withPut(createOrder));
Ejemplos adicionales
• Uso de transacciones de DynamoDBMapper
Backups de DynamoDB
Temas
• Backup bajo demanda y restauración para DynamoDB (p. 701)
• Recuperación a un momento dado para DynamoDB (p. 715)
Puede utilizar la capacidad de copia de seguridad bajo demanda de DynamoDB para crear copias de
seguridad completas de las tablas con el fin de conservarlas a largo plazo y archivarlas para satisfacer las
necesidades de conformidad normativa. Puede realizar una copia de seguridad y restaurar los datos de
la tabla con un solo clic en la AWS Management Console o con una única llamada a la API. Las acciones
Backup y restauración se ejecutan sin ningún tipo de impacto en el desempeño o la disponibilidad de la
tabla.
El proceso de restauración y copia de seguridad bajo demanda tiene la capacidad de crecer sin que se
degrade el rendimiento o la disponibilidad de las aplicaciones. Utiliza una tecnología distribuida nueva y
única que le permite completar las copias de seguridad en cuestión de segundos, independientemente del
tamaño de la tabla. En cuestión de segundos, puede crear backups coherentes de miles de particiones
sin tener que preocuparse por la programación o los procesos de backup de ejecución larga. Todos los
backup bajo demanda se catalogan, se pueden detectar y se retienen hasta que se eliminen de forma
explícita.
Además, las operaciones de backup y restauración bajo demanda no afectan al desempeño ni a las
latencias de la API. Los backups se conservan independientemente de la eliminación de la tabla.
Para obtener más información, consulte Hacer un backup y restaurar tablas de DynamoDB: Cómo
funciona (p. 702).
Puede crear backups de tabla mediante la consola de, laAWS Command Line Interface(AWS CLI) o
la API de DynamoDB. Para obtener más información, consulte Copia de seguridad de una tabla de
DynamoDB (p. 703).
Para obtener información sobre la restauración de una tabla a partir de un backup, consulte Restaurar una
tabla de DynamoDB a partir de un Backup (p. 705).
Los backups bajo demanda de DynamoDB están disponibles sin costo adicional aparte de los precios
normales asociados con el tamaño del almacenamiento del backup. Para obtener más información acerca
deAWSDisponibilidad y precios de regiones; consultePrecios de Amazon DynamoDB.
Temas
• Hacer un backup y restaurar tablas de DynamoDB: Cómo funciona (p. 702)
• Copia de seguridad de una tabla de DynamoDB (p. 703)
• Restaurar una tabla de DynamoDB a partir de un Backup (p. 705)
• Eliminación de un backup de unta tabla de DynamoDB (p. 710)
• Uso de IAM con Backup y restauración de DynamoDB (p. 712)
Backups
Al crear un backup bajo demanda, se cataloga un marcador de tiempo de la solicitud. Para crear el backup
de forma asíncrona, todos los cambios realizados hasta el momento en el que se realiza la solicitud se
aplican en la instantánea de tabla completa. Las solicitudes de backup se procesan de forma instantánea y
se pueden restaurar en cuestión de minutos.
Note
Cada vez que cree un backup bajo demanda, se crea igualmente un backup con todos los datos
de la tabla. No existe ningún límite en cuanto a los backup bajo demanda que se pueden realizar.
Todos los backup de DynamoDB funcionan sin tener que consumir el rendimiento aprovisionado de la
tabla.
Los backups de DynamoDB no garantizan la coherencia entre los elementos; no obstante, el sesgo entre
actualizaciones en un backup suele ser bastante menos de un segundo.
Puede programar backups periódicos o futuros mediante las funciones de AWS Lambda. Para obtener más
información, consulte la publicación de blog A serverless solution to schedule your Amazon DynamoDB
On-Demand Backup.
Si utiliza la consola, las copias de seguridad creadas utilizando AWS Backup se mostrarán en la pestaña
Backups (Copias de seguridad) con el Backup type (Tipo de copia de seguridad) establecido en AWS.
Note
No se pueden eliminar copias de seguridad marcadas con unTipo BackupdeAWSUso de la
consola de DynamoDB. Para administrar estas copias de seguridad, utilice la consola de AWS
Backup.
Para obtener información sobre cómo realizar un backup, consulte Copia de seguridad de una tabla de
DynamoDB (p. 703).
Restores
Una tabla se restaura sin tener que consumir el rendimiento aprovisionado de la misma. Puede realizar
una restauración completa de la tabla desde la copia de seguridad de DynamoDB o puede configurar los
valores de la tabla de destino. Al realizar una restauración, puede cambiar la siguiente configuración de
tabla:
Important
Cuando realiza una restauración de tabla completa, la tabla de destino se establece con las
mismas unidades de capacidad de lectura y escritura aprovisionadas que la tabla de origen,
ya que se registran en el momento en que se solicita la copia de seguridad. El proceso de
restauración también restaura los índices secundarios locales y globales.
También puede restaurar los datos de la tabla de DynamoDB enAWSRegiones de modo que la
tabla restaurada se cree en una región distinta a donde reside la copia de seguridad. Puede hacer
restauraciones entre regiones entreAWSRegiones comerciales,AWSRegiones de China, yAWSRegiones
GovCloud (US). Solo paga por los datos que transfiera fuera de la región de origen y por restaurar a una
nueva tabla en la región de destino.
Las restauraciones pueden ser más rápidas y más económicas si elige excluir la creación de algunos o de
todos los índices secundarios en la nueva tabla restaurada.
Solo puede restaurar todos los datos de la tabla en una nueva tabla a partir de un backup. Solo puede
escribir en la tabla restaurada después de que se active.
Note
No puede sobrescribir una tabla existente durante una operación de restauración.
Las métricas de servicio muestran que el 95% de las restauraciones de mesa de los clientes se completan
en menos de una hora. Sin embargo, los tiempos de restauración están directamente relacionados con la
configuración de las tablas (como el tamaño de las tablas y el número de particiones subyacentes) y otras
variables relacionadas. Una práctica recomendada a la hora de planificar la recuperación ante desastres
es documentar regularmente los tiempos promedio de finalización de la restauración y establecer cómo
estos tiempos afectan a su objetivo general de tiempo de recuperación.
Para obtener información sobre cómo realizar una restauración, consulte Restaurar una tabla de
DynamoDB a partir de un Backup (p. 705).
Puede usar las políticas de IAM de control de acceso. Para obtener más información, consulte Uso de IAM
con Backup y restauración de DynamoDB (p. 712).
La consola de backup y restauración y las acciones de API se capturan y registran en AWS CloudTrail para
su registro, supervisión y auditoría.
Temas
• Creación de un backup de una tabla (consola) (p. 704)
• Creación de un backup de una tabla (AWS CLI) (p. 705)
• En la pestaña Backups (Copias de seguridad) de la tabla Music, seleccione Create backup (Crear
copia de seguridad).
• En el panel de navegación del lado izquierdo de la consola, elija Backups. A continuación, elija
Create backup (Crear backup).
3. Asegúrese de que Music es el nombre de la tabla y escriba MusicBackup para el nombre de la copia
de seguridad. A continuación, elija Create (Crear) para crear el backup.
Note
Mientras se está creando el backup, su estado se establece en Creating (Creando). Una vez que se
haya completado la copia de seguridad, el estado de la misma cambia a Available (Disponible).
• Cree una copia de seguridad con el nombre MusicBackup para la tabla Music:
{
"BackupDetails": {
"BackupName": "MusicBackup",
"BackupArn": "arn:aws:dynamodb:us-east-1:123456789012:table/Music/
backup/01489602797149-73d8d5bc",
"BackupStatus": "CREATING",
"BackupCreationDateTime": 1489602797.149
}
}
Una vez completada la copia de seguridad, su BackupStatus debe cambiar a AVAILABLE. Para
confirmarlo, use el comando describe-backup. Puede obtener el valor de entrada de backup-arn
desde la salida del paso anterior o usar el comando list-backups.
Para realizar un seguimiento de los backups, puede usar el comando list-backups. Permite enumerar
todas las copias de seguridad que están en estado CREATING o AVAILABLE:
Si quiere utilizar la AWS CLI, primero tendrá que configurarla. Para obtener más información,
consulte Acceso a DynamoDB (p. 60).
Temas
• Restaurar una tabla a partir de un backup (consola) (p. 706)
• Restaurar una tabla a partir de un backup (AWS CLI) (p. 708)
Este procedimiento asume que la tabla Music ya no existe antes de restaurarla utilizando el
archivo MusicBackup.
5. Especifique Music como nuevo nombre de tabla. Confirme el nombre del backup y otros detalles del
mismo. A continuación, elija Restore table (Restaurar tabla) para iniciar el proceso de restauración.
Note
La tabla que se va a restaurar se muestra con el estado Creating (Creando). Una vez finalizado el
proceso de restauración, el estado de la tabla Music cambia a Active (Activa).
1. Confirme el backup que quiere restaurar mediante el comando list-backups. En este ejemplo se
utiliza MusicBackup.
Para obtener detalles adicionales del backup, use el comando describe-backup. Puede obtener la
entrada backup-arn del paso anterior.
2. Restaure la tabla a partir del backup. En este caso, laMusicBackuprestaura laMusica la misma
tablaAWSRegión .
3. Restaure la tabla desde la copia de seguridad con la configuración de tabla personalizada. En este
caso, MusicBackup restaura la tabla Music y especifica un modo de cifrado para la tabla restaurada.
Note
--backup-arn arn:aws:dynamodb:us-east-1:123456789012:table/Music/backup/01581080476474-
e177ebe2 \
--sse-specification-override Enabled=true,SSEType=KMS,KMSMasterKeyId=abcd1234-abcd-1234-
a123-ab1234a1b234
Puede excluir la creación de algunos o de todos los índices secundarios en la tabla restaurada.
Note
Las restauraciones pueden ser más rápidas y más económicas si elige excluir la creación de
algunos o de todos los índices secundarios en la tabla restaurada.
Note
Los índices secundarios proporcionados deben coincidir con los índices existentes. No puede
crear nuevos índices en el momento de la restauración.
Puede utilizar una combinación de distintas anulaciones. Por ejemplo, puede utilizar un único
índice secundario global y cambiar el rendimiento aprovisionado al mismo tiempo, como se indica a
continuación.
--global-secondary-index-override IndexName=singers-
index,KeySchema=["{AttributeName=SingerName,KeyType=HASH}"],Projection="{ProjectionType=KEYS_ONLY}",P
\
--sse-specification-override Enabled=true,SSEType=KMS
Para comprobar la restauración, use el comando describe-table para describir la tabla Music.
La tabla que se va a restaurar a partir del backup se muestra con el estado Creating (Creando). Una vez
finalizado el proceso de restauración, el estado de la tabla Music cambia a Active (Activa).
Important
Mientras la restauración esté en curso, no modifique ni elimine su política de roles de IAM ya que
podría conllevar comportamientos inesperados. Por ejemplo, suponga que eliminó los permisos
de escritura de una tabla mientras esta se restauraba. En ese caso, la operación subyacente
RestoreTableFromBackup no puede escribir ninguno de los datos restaurados en la tabla.
Después de que se complete la operación de restauración, puede modificar o eliminar su política
de roles de IAM.
Políticas de IAM relacionadas conrestricciones de IP de origenpara acceder a la tabla de
restauración de destino debe tener elaws:ViaAWSServiceConfiguración de la clavefalsePara
garantizar que las restricciones se aplican únicamente a las solicitudes presentadas directamente
por un principal. De lo contrario, la restauración se cancelará.
Si su copia de seguridad está cifrada con unAWSSi lo hace la restauración no se realizará
correctamente.
Una vez finalizada la operación de restauración, puede cambiar la clave de cifrado de la tabla
restaurada y deshabilitar o eliminar la clave anterior.
Si quiere utilizar la AWS CLI, primero tendrá que configurarla. Para obtener más información,
consulte Mediante AWS CLI (p. 62).
Temas
• Eliminación de un backup de una tabla (consola) (p. 710)
• Eliminación de un backup de una tabla (AWS CLI) (p. 711)
Para obtener más información acerca del uso de políticas de IAM en DynamoDB, consulteUso de políticas
basadas en identidad (políticas de IAM) con Amazon DynamoDB (p. 898).
A continuación, se proporcionan ejemplos de políticas de IAM que puede utilizar para configurar
funcionalidades de backup y restauración específicas en DynamoDB.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:CreateBackup",
"dynamodb:RestoreTableFromBackup",
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:GetItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:BatchWriteItem"
],
"Resource": "*"
}
]
}
Important
Son necesarios los permisos de escritura de DynamoDB para restaurar la funcionalidad.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["dynamodb:CreateBackup"],
"Resource": "*"
},
{
"Effect": "Deny",
"Action": ["dynamodb:RestoreTableFromBackup"],
"Resource": "*"
}
]
}
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["dynamodb:ListBackups"],
"Resource": "*"
},
{
"Effect": "Deny",
"Action": [
"dynamodb:CreateBackup",
"dynamodb:RestoreTableFromBackup"
],
"Resource": "*"
}
]
}
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["dynamodb:ListBackups"],
"Resource": "*"
},
{
"Effect": "Deny",
"Action": ["dynamodb:DeleteBackup"],
"Resource": "*"
}
]
}
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:DescribeBackup",
"dynamodb:RestoreTableFromBackup",
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:GetItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:BatchWriteItem"
],
"Resource": "*"
},
{
"Effect": "Deny",
"Action": [
"dynamodb:DeleteBackup"
],
"Resource": "arn:aws:dynamodb:us-east-1:123456789012:table/Music/
backup/01489173575360-b308cd7d"
}
]
}
Important
Son necesarios los permisos de escritura de DynamoDB para restaurar la funcionalidad.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["dynamodb:CreateBackup"],
"Resource": [
"arn:aws:dynamodb:us-east-1:123456789012:table/Movies"
]
}
]
}
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["dynamodb:ListBackups"],
"Resource": "*"
}
]
}
Important
Además, las operaciones relacionadas con la recuperación a un momento dado no afectan al desempeño
ni a las latencias de la API. Para obtener más información, consulte Recuperación a un momento dado:
Cómo funciona (p. 715).
Puede restaurar tablas de DynamoDB a un momento dado mediante laAWS Management Console, elAWS
Command Line Interface(AWS CLI) o la API de DynamoDB. El proceso de recuperación a un momento
dado restaura la información a una tabla nueva. Para obtener más información, consulte Restaurar una
tabla de DynamoDB a un momento dado (p. 717).
Temas
• Recuperación a un momento dado: Cómo funciona (p. 715)
• Antes de empezar a usar la recuperación a un momento dado (p. 717)
• Restaurar una tabla de DynamoDB a un momento dado (p. 717)
puede modificar. Cualquier cantidad de usuarios puede ejecutar hasta cuatro restauraciones simultáneas
(cualquier tipo de restauración) en una misma cuenta.
Important
Si deshabilita la recuperación a un momento dado y vuelve a habilitarla más tarde en una tabla,
estará reiniciando la hora de inicio de recuperación de dicha tabla. Por lo tanto, solo podrá
restaurarla inmediatamente con LatestRestorableDateTime.
Al restaurar mediante la recuperación a un momento dado, DynamoDB restaura los datos de la tabla al
estado en el que se encontraban en la fecha y hora seleccionadas (day:hour:minute:second) a una
nueva tabla.
Una tabla se restaura sin tener que consumir el rendimiento aprovisionado de la misma. Puede realizar
una restauración completa de la tabla mediante la recuperación a un momento dado o puede configurar los
valores de la tabla de destino. Puede cambiar la siguiente configuración de tabla en la tabla restaurada:
Important
Cuando realiza una restauración de tabla completa, todos los valores de la tabla restaurada
provienen de la configuración actual de la tabla de origen en el momento de la restauración.
Por ejemplo, suponga que el rendimiento aprovisionado de una tabla se acaba de reducir a
50 unidades de capacidad de lectura y 50 unidades de capacidad de escritura. A continuación,
restaura el estado de la tabla a hace tres semanas, en aquel momento el rendimiento
aprovisionado de la tabla era de 100 unidades de capacidad de lectura y 100 unidades de
capacidad de escritura. En este caso, DynamoDB restaura los datos de la tabla a ese momento,
pero utiliza el rendimiento aprovisionado actual (50 unidades de capacidad de lectura y 50
unidades de capacidad de escritura).
También puede restaurar los datos de la tabla de DynamoDB enAWSRegiones de modo que la tabla
restaurada se cree en una región distinta a donde reside la tabla de origen. Puede hacer restauraciones
entre regiones entreAWSRegiones comerciales,AWSRegiones de China, yAWSRegiones GovCloud (US).
Solo pagará por los datos que transfiera fuera la de región de origen y por la restauración a una nueva
tabla en la región de destino.
Note
No se admite la restauración entre regiones si la región de origen o destino es Asia Pacífico (Hong
Kong) o Medio Oriente (Baréin).
Las restauraciones pueden ser más rápidas y más rentables si excluye la creación de algunos o de todos
los índices en la nueva tabla restaurada.
El tiempo necesario para restaurar una tabla dependerá de varios factores. Los plazos de restauración a
un momento dado no siempre están relacionados directamente con el tamaño de la tabla. Para obtener
más información, consulte Restores (p. 702).
• Si deshabilita la recuperación a un momento dado y vuelve a habilitarla más tarde en una tabla,
estará reiniciando la hora de inicio de recuperación de dicha tabla. Por lo tanto, solo podrá restaurarla
inmediatamente con LatestRestorableDateTime.
• Si elimina una tabla con la característica de recuperación a un momento dado habilitada, se crea un
backup del sistema y se mantiene durante 35 días (sin costo adicional). Los backups del sistema
le permiten restaurar la tabla eliminada al estado en que se encontraba junto antes del punto de
eliminación. Todas las copias de seguridad del sistema siguen una convención de nomenclatura
estándar: tabla-nombre$DeletedTableBackup.
• Puede habilitar la recuperación a un momento dado (PITR) en cada réplica de una misma tabla global.
Al restaurar la tabla, el backup se vuelca a una tabla independiente que no es parte de esa tabla
global. Si usa Versión 2019.11.21 (actual) (p. 372) de tablas globales, puede crear una nueva tabla
global a partir de la tabla restaurada. Para obtener más información, consulte Tablas globales: Cómo
funciona (p. 372).
• También puede restaurar los datos de la tabla de DynamoDB enAWSRegiones de modo que la tabla
restaurada se cree en una región distinta a donde reside la tabla de origen. Puede hacer restauraciones
entre regiones entreAWSRegiones comerciales,AWSRegiones de China, yAWSRegiones GovCloud
(US). Solo pagará por los datos que transfiera fuera la de región de origen y por la restauración a una
nueva tabla en la región de destino.
• AWS CloudTrail registra todas las acciones de la consola y de la API vinculadas a la recuperación a un
momento dado para permitir el mantenimiento de registros, una monitorización continua y auditorías.
Para obtener más información, consulte Registro de operaciones de DynamoDB utilizandoAWS
CloudTrail (p. 964).
Si quiere utilizar la AWS CLI, primero tendrá que configurarla. Para obtener más información, consulte
Acceso a DynamoDB (p. 60).
Temas
• Restaurar una tabla a un momento dado (consola) (p. 717)
• Restaurar una tabla a un momento dado (AWS CLI) (p. 718)
la sección Table details (Detalles de la tabla) y seleccione la opción Enable (Habilitar) en Point-in-
time recovery (Recuperación a un momento dado).
La tabla que se va a restaurar se muestra con el estado Restoring (Restaurándose). Una vez
finalizado el proceso de restauración, el estado de la tabla MusicMinutesAgo cambia a Active
(Activa).
1. Para confirmar que la recuperación a un momento dado está habilitada en Music, utilice el comando
describe-continuous-backups.
{
"ContinuousBackupsDescription": {
"PointInTimeRecoveryDescription": {
"PointInTimeRecoveryStatus": "ENABLED",
"EarliestRestorableDateTime": 1519257118.0,
"LatestRestorableDateTime": 1520018653.01
},
"ContinuousBackupsStatus": "ENABLED"
}
}
Note
También puede restaurarla a un momento dado específico. Para ello, ejecute el comando
utilizando el argumento --restore-date-time y especifique una marca temporal. Puede
especificar cualquier momento de los últimos 35 días. Por ejemplo, el siguiente comando
restaura la tabla al a fecha y hora del valor EarliestRestorableDateTime.
Puede especificar un modo de cifrado distinto para la tabla restaurada, como se indica a continuación.
Note
Note
Puede excluir la creación de algunos o de todos los índices secundarios en la tabla restaurada.
Note
Las restauraciones pueden ser más rápidas y más económicas si excluye la creación de
algunos o de todos los índices secundarios en la nueva tabla restaurada.
Puede utilizar una combinación de distintas anulaciones. Por ejemplo, puede utilizar un único
índice secundario global y cambiar el rendimiento aprovisionado al mismo tiempo, como se indica a
continuación.
Mientras la restauración esté en curso, no modifique ni elimine laAWS Identity and Access
ManagementLas políticas de (IAM) que conceden a la entidad de IAM (usuario, grupo o rol)
permiso para restaurar. De lo contrario, puede ocurrir un comportamiento inesperado. Por
ejemplo, suponga que elimina los permisos de escritura de una tabla mientras esta se restauraba.
En este caso, elRestoreTableToPointInTimeno puede escribir ninguno de los datos
restaurados en la tabla. Las políticas de IAM que imponen restricciones a las IP de origen para
obtener acceso a la tabla de restauración de destino también pueden causar problemas.
Puede modificar o eliminar los permisos solo después de que finalice la operación de
restauración.
DAX es un servicio de almacenamiento en caché compatible con DynamoDB que permite beneficiarse de
un rápido desempeño en memoria para aplicaciones exigentes. DAX aborda tres escenarios principales:
1. Como caché en memoria, DAX reduce los tiempos de respuesta de las cargas de trabajo de lectura
consistente final en un orden de magnitud, de cifras en milisegundos de un solo dígito a microsegundos.
2. DAX reduce la complejidad operativa y de las aplicaciones al ofrecer un servicios administrado que
es compatible mediante API con DynamoDB. Por consiguiente, solo requiere unos mínimos cambios
funcionales para poder usarlo con una aplicación existente.
3. Para cargas de trabajo intensas o en ráfagas, DAX proporciona mayor desempeño y un posibles
ahorros en costos, porque disminuye la necesidad de sobreprovisionar las unidades de capacidad de
lectura. Esto resulta especialmente beneficioso para las aplicaciones que requieren lecturas reiteradas
de claves individuales.
DAX es compatible con el cifrado en el lado del servidor. Con el cifrado en reposo, los datos conservados
por DAX en el disco se cifrarán. DAX escribe datos en disco como parte de la propagación de cambios
desde el nodo principal a las réplicas de lectura. Para obtener más información, consulte Cifrado DAX en
reposo (p. 825) .
DAX también admite el cifrado en tránsito, lo que garantiza que todas las solicitudes y respuestas entre
la aplicación y el clúster estén cifradas por seguridad de nivel de transporte (TLS), y las conexiones al
clúster se pueden autenticar mediante la verificación de un certificado x509 del clúster. Para obtener más
información, consulte Cifrado de DAX en tránsito (p. 826) .
Temas
• Casos de uso de DAX (p. 723)
• Notas de uso de DAX (p. 723)
• DAX: Cómo funciona (p. 724)
• Componentes de los clústeres (p. 728)
• Creación de Cluster de DAX (p. 732)
• Modelos de consistencia DAX y DynamoDB (p. 741)
• Desarrollo de DynamoDB Accelerator (DAX) (p. 747)
• Administración de clústeres de DAX (p. 791)
• Monitorización de DAX (p. 797)
• Instancias de ráfagas DAX T3/T2 (p. 813)
• Control de acceso DAX (p. 814)
• Cifrado DAX en reposo (p. 825)
• Las aplicaciones que requieren realizar lecturas con la máxima rapidez de respuesta posible. Algunos
ejemplos de ello son las aplicaciones de puja en tiempo real, juegos de azar u operaciones comerciales
con valores. DAX proporciona un rápido desempeño en memoria para estos casos de uso.
• Las aplicaciones que leen una pequeña cantidad de elementos con más frecuencia que otros. Por
ejemplo, tomemos un sistema de comercio electrónico (e-commerce) que durante un día promociona
un producto popular a menos precio. Durante esta promoción, la demanda de ese producto (y de
sus datos en DynamoDB) experimentaría un aumento drástica en comparación con todos los demás
productos. Para mitigar los efectos de una clave «caliente» y de una distribución desigual del tráfico,
podría transferir la actividad de lectura a una caché DAX hasta que finalice el día de promoción.
• Las aplicaciones con gran intensidad de lectura sujetas a requisitos de costos. Con DynamoDB, se
provisiona la cantidad de lecturas por segundo que la aplicación requiere. Si la actividad de lectura
aumenta, puede incrementar el desempeño de lectura provisionado de la tabla (lo que supone un costo
adicional). Si lo prefiere, puede transferir la actividad de la aplicación a un clúster de DAX y reducir la
cantidad de unidades de capacidad de lectura que, de no hacerlo, tendría que adquirir.
• Las aplicaciones que requieren realizar lecturas reiteradas de un conjunto de datos voluminoso. Una
aplicación de este tipo podría desviar recursos de base de datos de otras aplicaciones. Por ejemplo,
un análisis de los datos meteorológicos regionales tardaría tiempo en ejecutarse y podría consumir
temporalmente toda la capacidad de lectura de una tabla de DynamoDB. Esto tendría un efecto negativo
en otras aplicaciones que necesitasen obtener acceso a los mismos datos. En cambio, con DAX, el
análisis de los datos meteorológicos podría llevarse a cabo usando datos almacenados en caché.
• Las aplicaciones que requieran lecturas de consistencia alta (o que no toleran las lecturas consistentes
finales).
• Las aplicaciones que no requieran tiempos de respuesta en microsegundos para lecturas o que no
necesiten delegar la actividad de lectura reiterada de tablas subyacentes.
• Las aplicaciones con gran intensidad de escrituras o sin gran actividad de lectura.
• Aplicaciones que ya utilizan otra solución de almacenamiento en caché distinta con DynamoDB y que
utilizan su propia lógica del lado del cliente para trabajar con dicha solución.
• DAX admite aplicaciones escritas en Go, Java, Node.js, Python y .NET utilizandoAWS-proporciona
clientes para esos lenguajes de programación.
• DAX solo está disponible para la plataforma EC2-VPC. No se admite la plataforma EC2-Classic.
• La política de rol del servicio de clúster de DAX debe permitir que eldynamodb:DescribeTablePara
mantener los metadatos sobre la tabla de DynamoDB.
• Los clústeres DAX conservan metadatos sobre los nombres de atributo de los elementos que
almacenan. Dichos metadatos se conservan indefinidamente (incluso después de que el elemento
haya vencido o se haya desalojado de la caché). Las aplicaciones que utilizan un número ilimitado de
nombres de atributo pueden, con el tiempo, agotar la memoria en el clúster de DAX. Esta limitación se
aplica solo a los nombres de atributo de nivel superior, no a los nombres de atributo anidados. Ejemplos
de nombres de atributo de nivel superior problemáticos son las marcas temporales, los UUID y los ID de
sesión.
Esta limitación solo se aplica a los nombres de atributo, no a sus valores. Los elementos como el
siguiente no son un problema.
{
"Id": 123,
"Title": "Bicycle 123",
"CreationDate": "2017-10-24T01:02:03+00:00"
}
Pero los elementos como el siguiente sí lo son, si hay suficientes y tienen cada uno de ellos una marca
temporal diferente.
{
"Id": 123,
"Title": "Bicycle 123",
"2017-10-24T01:02:03+00:00": "created"
}
Para crear un clúster de DAX, se usa el método deAWS Management Console. A menos que especifique
otra cosa, el clúster de DAX se ejecuta dentro de la VPC predeterminada. Para ejecutar la aplicación, lance
una instancia Amazon EC2 en su Amazon VPC. A continuación, implemente la aplicación (con el cliente de
DAX) en la instancia EC2.
En tiempo de ejecución, el cliente de DAX dirige todas las solicitudes de API de DynamoDB de la
aplicación al clúster de DAX. Si DAX puede procesar una de estas solicitudes del API directamente, lo
hace. En caso contrario, transmite la solicitud a DynamoDB.
Temas
• Cómo procesa DAX las solicitudes (p. 725)
• Caché de elementos (p. 727)
• Caché de consultas (p. 727)
La aplicación puede obtener acceso a DAX especificando el punto de enlace del clúster de DAX. El
software del cliente de DAX de funciona con el punto de enlace del clúster para realizar el ruteo y el
balanceo de carga inteligente.
Operaciones de lectura
DAX puede responder a las siguientes llamadas al API:
• GetItem
• BatchGetItem
• Query
• Scan
• Si DAX tiene el elemento disponible (unacierto de cachéDAX devuelve el elemento a la aplicación sin
obtener acceso a DynamoDB.
• Si DAX no tiene el elemento disponible en (unerror de caché), DAX transmite la solicitud a DynamoDB.
Cuando recibe la respuesta de DynamoDB, DAX devuelve los resultados a la aplicación. También
escribe los resultados en la caché en el nodo principal.
Note
Si el clúster contiene réplicas de lectura, DAX las mantiene automáticamente sincronizadas con el
nodo principal. Para obtener más información, consulte Clusters (p. 728).
Operaciones de escritura
Las siguientes operaciones del API de DAX se consideran de «escritura indirecta» (write-through):
• BatchWriteItem
• UpdateItem
• DeleteItem
• PutItem
Con estas operaciones, los datos se escriben primero en la tabla de DynamoDB y, a continuación, en el
clúster de DAX. La operación solo se lleva a cabo correctamente si los datos se escriben correctamente
enBOTHla tabla y DAX.
Otras operaciones de
DAX no reconoce ninguna operación de DynamoDB de administración de tablas (tales
como:CreateTable,UpdateTable, y así sucesivamente.). Si la aplicación tiene que realizar estas
operaciones, debe obtener acceso a DynamoDB directamente, sin usar DAX.
Para obtener información sobre el funcionamiento de las transacciones en DAX, consulteUso de las API
transaccionales en DynamoDB Accelerator (DAX) (p. 694).
Puede monitorizar laMétrica ThrottledRequestCount (p. 800)que DAX publica en Amazon CloudWatch. Si
ve estas excepciones periódicamente, debería plantearse escalar el clúster (p. 793).
Caché de elementos
DAX mantiene uncaché de elementosPara almacenar los resultados
deGetItemyBatchGetItemoperaciones. Los elementos de la caché representan datos con consistencia
final de DynamoDB y se almacenan según sus valores de clave principal.
Cuando una aplicación envía unGetItemorBatchGetItemDAX intenta leer los elementos directamente
en la caché de elementos con los valores de clave especificados. Si encuentra los elementos (aciertos de
caché), DAX los devuelve a la aplicación de forma inmediata. Si los elementos no se encuentran (error
de caché), DAX envía la solicitud a DynamoDB. DynamoDB procesa las solicitudes usando lecturas
consistentes finales y devuelve los elementos a DAX. DAX los almacena en la caché los elementos y, a
continuación, los devuelve a la aplicación.
La caché de elementos tiene un ajuste de tiempo de vida (TL, por sus siglas en inglés), cuyo valor
predeterminado es de 5 minutos. DAX asigna una marca temporal a cada elemento que escribe en la
caché de elementos. Un elemento vence cuando ha permanecido en la caché más tiempo del indicado en
el ajuste de TTL. Si emite unGetItemen un elemento vencido, se considera un error de caché, en cuyo
caso DAX envía la solicitud deGetItema DynamoDB.
Note
DAX también mantiene una lista de elementos menos usados recientemente (LRU, por sus siglas en
inglés) para la caché de elementos. La lista LRU rastrea cuándo se escribió un elemento por primera vez
en la caché y cuándo se leyó por última vez en ella. Si la caché de elementos se llena, DAX expulsa los
elementos más antiguos (aunque todavía no hayan vencido) para dejar espacio a los nuevos. El algoritmo
LRU siempre está habilitado para la caché de elementos y no es configurable por el usuario.
Caché de consultas
DAX también mantiene uncaché de consultasPara almacenar los resultados deQueryyScanoperaciones.
Los elementos de esta caché representan los conjuntos de resultados de las consultas y los exámenes de
las tablas de DynamoDB. Estos conjuntos de resultados se almacenan por los valores de sus parámetros.
Cuando una aplicación envía unQueryorScan, DAX intenta leer un conjunto de resultados coincidente
en la caché de consultas, para lo cual utiliza los valores de los parámetros especificados. Si encuentra
el conjunto de resultados (acierto de caché), DAX lo devuelve a la aplicación de forma inmediata. Si el
conjunto de resultados no se encuentra (error de caché), DAX envía la solicitud a DynamoDB. DynamoDB
procesa las solicitudes usando lecturas consistentes finales y devuelve el conjunto de resultados a DAX.
DAX lo almacena en la caché las consultas y, a continuación, lo devuelve a la aplicación.
Note
Puede especificar el ajuste de TL de la caché de consultas al crear un clúster de DAX nuevo. Para
obtener más información, consulte Administración de clústeres de DAX (p. 791).
DAX también mantiene una lista LRU para la caché de consultas. La lista rastrea cuándo se escribió un
conjunto de resultados por primera vez en la caché y cuándo se leyó por última vez en ella. Si la caché
de consultas se llena, DAX expulsa los conjuntos de resultados más antiguos (aunque todavía no hayan
vencido) para dejar espacio a los nuevos. El algoritmo LRU siempre está habilitado para la caché de
consultas y no es configurable por el usuario.
Temas
• Nodes (p. 728)
• Clusters (p. 728)
• Regiones y zonas de disponibilidad (p. 729)
• Grupos de parámetros (p. 730)
• Grupos de seguridad (p. 730)
• ARN del clúster (p. 730)
• Punto de enlace de clúster (p. 730)
• Puntos de enlace de nodos (p. 731)
• Grupos de subredes (p. 731)
• Events (p. 731)
• Maintenance Window (Período de mantenimiento) (p. 731)
Nodes
Anodoes el elemento básico más pequeño de un clúster de DAX. Cada nodo ejecuta una instancia del
software DAX y mantiene una única réplica de los datos almacenados en caché de.
• Agregando más nodos al clúster. Con ello aumenta el desempeño de lectura general del clúster.
• Utilizando un tipo de nodo mayor. Los tipos nodos mayores proporcionan más capacidad y pueden
aumentar el desempeño. (Debe crear un nuevo clúster con el nuevo tipo de nodo).
Todos los nodos contenidos en un clúster son del mismo tipo y ejecutan el mismo software de
almacenamiento en caché de DAX. Para obtener una lista de los tipos de nodos disponibles,
consultePrecios de Amazon DynamoDB.
Clusters
Aclústeres una agrupación lógica de uno o varios nodos que DAX administra como una unidad. Uno de los
nodos del clúster se designa como nodo principal y los demás (si los hay), son las réplicas de lectura.
Cuando se producen cambios en los datos almacenados en caché en el nodo principal, DAX propaga los
cambios a todos los nodos de réplica de lectura.
Sin embargo, al contrario que el nodo principal, las réplicas de lectura no escriben en DynamoDB.
• Escalabilidad. Si tiene gran cantidad de clientes de aplicación que deben obtener acceso a DAX
simultáneamente, puede agregar más réplicas para escalar la lectura. DAX distribuye la carga de forma
uniforme entre todos los nodos del clúster. (Otra forma de aumentar el desempeño es utilizar tipos de
nodos de caché mayores).
• Alta disponibilidad En el caso de que se produzca un error en el nodo principal, DAX automáticamente
realiza una conmutación por error a una réplica de lectura y la designa como nuevo nodo principal. Si se
produce un error en un nodo de réplica, otros nodos del clúster de DAX pueden seguir atendiendo las
solicitudes hasta que se consigue recuperar el nodo defectuoso. Para disfrutar de la máxima tolerancia
a errores, debe implementar réplicas de lectura en zonas de disponibilidad distintas. Esta configuración
garantiza que el clúster de continúe funcionando aunque una zona de disponibilidad completa deje de
estar disponible.
Un clúster de DAX admite hasta 10 nodos por clúster (el nodo principal y un máximo de nueve réplicas de
lectura).
Important
Para su uso en producción, se recomienda encarecidamente utilizar DAX con al menos tres
nodos, con cada nodo colocado en zonas de disponibilidad diferentes. Se requieren tres nodos
para que un clúster de DAX sea tolerante a errores.
Un clúster de DAX se puede implementar con uno o dos nodos para cargas de trabajo de
desarrollo o pruebas. Los clústeres de uno o dos nodos no son tolerantes a errores y no se
recomiendan menos de tres nodos para su uso en producción. Si los clústeres de uno o dos
nodos tienen errores de software o hardware, el clúster podría dejar de estar disponible o podrían
perderse los datos almacenados en caché.
Cada región se ha diseñado para que esté totalmente aislada de las demás regiones. Dentro de cada
región hay varias zonas de disponibilidad. Al lanzar los nodos en zonas de disponibilidad diferentes, puede
lograr la máxima tolerancia a errores.
Important
No coloque todos los nodos del clúster en la misma zona de disponibilidad. En esta configuración,
el clúster de deja de estar disponible si se produce un error en la zona de disponibilidad.
Para su uso en producción, se recomienda encarecidamente utilizar DAX con al menos tres
nodos, con cada nodo colocado en zonas de disponibilidad diferentes. Se requieren tres nodos
para que un clúster de DAX sea tolerante a errores.
Un clúster de DAX se puede implementar con uno o dos nodos para cargas de trabajo de
desarrollo o pruebas. Los clústeres de uno o dos nodos no son tolerantes a errores y no se
recomiendan menos de tres nodos para su uso en producción. Si los clústeres de uno o dos
nodos tienen errores de software o hardware, el clúster podría dejar de estar disponible o podrían
perderse los datos almacenados en caché.
Grupos de parámetros
Grupos de parámetrosPara administrar los ajustes de tiempo de ejecución de los clústeres de DAX.
DAX tiene varios parámetros que puede utilizar para optimizar el desempeño (por ejemplo, puede definir
una política de TTL para los datos almacenados en caché). Un grupo de parámetros es un conjunto de
parámetros con nombre que se pueden aplicar a un clúster. De este modo, se garantiza que todos los
nodos de ese clúster estén configurados exactamente de la misma forma.
Grupos de seguridad
Un clúster de DAX se ejecuta en un entorno de Amazon Virtual Private Cloud (Amazon VPC). Este entorno
es una red virtual que está dedicada aAWSy está aislado de otras VPC. Un grupo de seguridad funciona
como un firewall virtual para la VPC que le permite para controlar el tráfico de red entrante y saliente.
Al lanzar un clúster en la VPC, puede agregar una regla de entrada al grupo de seguridad para que permita
el tráfico procedente de la red. La regla de entrada especifica el protocolo (TCP) y el número de puerto
(8111) del clúster. Después de agregar esta regla al grupo de seguridad, las aplicaciones que se ejecutan
dentro de la VPC podrán obtener acceso al clúster de DAX.
arn:aws:dax:region:accountID:cache/clusterName
El ARN del clúster se utiliza en las políticas de IAM para definir los permisos para las operaciones de la
API de DAX. Para obtener más información, consulte Control de acceso DAX (p. 814) .
dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
A continuación, se muestra un ejemplo de punto de enlace de un clúster en la misma región que está
configurado para utilizar el cifrado en tránsito.
daxs://my-encrypted-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
myDAXcluster-a.2cmrwl.clustercfg.dax.use1.cache.amazonaws.com:8111
La aplicación puede obtener acceso directamente a un nodo utilizando su punto de enlace. Sin embargo,
se recomienda tratar el clúster de como una sola unidad y obtener acceso a él mediante el punto de enlace
del clúster. El punto de enlace de clúster aísla la aplicación para que no tenga que mantener una lista de
nodos ni actualizarla cada vez que se agreguen o eliminen nodos del clúster.
Grupos de subredes
El acceso a los nodos del clúster de DAX está restringido a las aplicaciones que se ejecutan en instancias
de Amazon EC2 en un entorno de Amazon VPC. Puede utilizarGrupos de subredesPara conceder acceso
al clúster desde las instancias de Amazon EC2 que se ejecutan en subredes concretas. Un grupo de
subredes es una colección de subredes (que suelen ser privadas) que puede designar para los clústeres
que se ejecutan en un entorno de Amazon VPC.
Al crear un clúster de, debe especificar un grupo de subredes. DAX utiliza dicho grupo de subredes para
seleccionar una subred y direcciones IP perteneciente a ella, y asociárselas a los nodos.
Events
DAX registra los eventos significativos que tienen lugar en los clústeres, tales como los errores al
agregar un nodo, las adiciones de nodos correctas o los cambios en los grupos de seguridad. Puede
monitorizar los eventos clave para conocer el estado actual de los clústeres y, según el evento, adoptar
medidas correctivas. Puede obtener acceso a estos eventos desde laAWS Management Consoleo
elDescribeEventsen la API de administración DAX.
También puede solicitar que se envíen notificaciones a un tema de Amazon Simple Notification Service
(Amazon SNS) concreto. De ese modo, sabrá de inmediato cuando se produce un evento en el clúster de
DAX.
La ventana de mantenimiento debe corresponder al momento de mínimo uso y, por tanto, podría ser
preciso modificarla cada cierto tiempo. Puede especificar un intervalo de tiempo de hasta 24 horas durante
las cuales deban llevarse a cabo todas las actividades de mantenimiento que solicite.
Una vez que haya creado el clúster de DAX, podrá obtener acceso a él desde una instancia de Amazon
EC2 que se ejecute en la misma VPC. A partir de ese momento, podrá utilizar el clúster de DAX con un
programa de aplicación. Para obtener más información, consulte Desarrollo de DynamoDB Accelerator
(DAX) (p. 747) .
Temas
• Creación de un rol de servicio de IAM para que DAX obtenga acceso a DynamoDB (p. 732)
• Creación de clústeres de DAX mediante laAWS CLI (p. 734)
• Creación de clústeres de DAX mediante laAWS Management Console (p. 738)
Si utiliza la consola, el flujo de trabajo para crear un clúster comprueba si ya existe un rol de servicio
DAX. Si no encuentra ninguno, la consola crea un nuevo rol de servicio en su nombre. Para obtener más
información, consulte the section called “Paso 2: Creación de Cluster de DAX” (p. 739) .
Si utiliza laAWS CLI, tendrá que especificar un rol de servicio de DAX creado previamente. De lo contrario,
deberá crear un nuevo rol de servicio de antemano. Para obtener más información, consulte Paso 1: Cree
un rol de servicio de IAM para que DAX obtenga acceso a DynamoDB mediante laAWS CLI (p. 734) .
De lo contrario, deberá agregar los siguientes permisos a la política de IAM para que el usuario de IAM
pueda crear el rol de servicio:
• iam:CreateRole
• iam:CreatePolicy
• iam:AttachRolePolicy
• iam:PassRole
Laiam:CreateRole,iam:CreatePolicy,iam:AttachRolePolicy,
yiam:PassRolePermisos de no están incluidos en laAWSPolíticas administradas de DynamoDB.
Esto es por diseño porque estos permisos proporcionan la posibilidad de escalar privilegios: Es
decir, un usuario podría utilizarlos para crear una nueva política de administrador y adjuntársela
a un rol existente. Por este motivo, usted (el administrador del clúster de DAX) debe agregar
explícitamente estos permisos a la política.
Troubleshooting
Si la política de usuario no incluye los permisos iam:CreateRole, iam:CreatePolicy e
iam:AttachPolicy, se producirán mensajes de error. En la tabla siguiente se muestran estos mensajes
y se describe cómo corregir los problemas.
Para obtener más información sobre las políticas de IAM que se requieren para administrar clústeres de
DAX, consulteControl de acceso DAX (p. 814).
Important
Para administrar clústeres DAX mediante elAWS CLI, instale o actualice a la versión 1.11.110 o
superior.
En todos los ejemplos relativos a la AWS CLI se utiliza la región us-west-2 e identificadores de cuenta
ficticios.
Temas
• Paso 1: Cree un rol de servicio de IAM para que DAX obtenga acceso a DynamoDB mediante laAWS
CLI (p. 734)
• Paso 2: Creación de un grupo de subredes (p. 736)
• Paso 3: Cree un clúster de DAX mediante laAWS CLI (p. 736)
• Paso 4: Configure las reglas de entrada del grupo de seguridad mediante laAWS CLI (p. 737)
En este paso, se crea una política de IAM y, a continuación, se adjunta a un rol de IAM. Esto le permitirá
asignar el rol a un clúster de DAX de tal forma que pueda llevar a cabo operaciones de DynamoDB en su
nombre.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "dax.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"dynamodb:DescribeTable",
"dynamodb:PutItem",
"dynamodb:GetItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:BatchGetItem",
"dynamodb:BatchWriteItem",
"dynamodb:ConditionCheckItem"
],
"Effect": "Allow",
"Resource": [
"arn:aws:dynamodb:us-west-2:accountID:*"
]
}
]
}
En el resultado, tome nota del ARN de la política que ha creado, como en el siguiente ejemplo.
arn:aws:iam::123456789012:policy/DAXServicePolicyForDynamoDBAccess
5. Asocie la política al rol de servicio. Sustituya arn en el siguiente código por el ARN real del rol del
paso anterior.
--role-name DAXServiceRoleForDynamoDBAccess \
--policy-arn arn
Si ya ha creado un grupo de subredes para la VPC predeterminada, puede omitir este paso.
DAX está diseñado para ejecutarse dentro de un entorno de Amazon Virtual Private Cloud (Amazon
VPC). Si ha creado suAWSUna vez que haya pasado el 4 de diciembre de 2013, ya dispone de una VPC
predeterminada en cadaAWSRegión . Para obtener más información, consulteVPC predeterminada y
subredes predeterminadasen laGuía del usuario de Amazon VPC.
En el resultado, tome nota del identificador de la VPC predeterminada, como en el siguiente ejemplo.
vpc-12345678
2. Determine los identificadores de las subredes asociadas a la VPC predeterminada.
ReemplazarvpcIDCon su ID de VPC real, por ejemplo,vpc-12345678.
Para crear el clúster, consulte Paso 3: Cree un clúster de DAX mediante laAWS CLI (p. 736).
En el resultado, tome nota del ARN del rol de servicio, como en el siguiente ejemplo.
arn:aws:iam::123456789012:role/DAXServiceRoleForDynamoDBAccess
2. Cree el clúster de DAX. Sustituya roleARN por el ARN del paso anterior.
Todos los nodos en el clúster son del tipo dax.r4.large (--node-type). Hay tres nodos (--
replication-factor): un nodo principal y dos réplicas.
Note
Desdesudoygrepson palabras clave reservadas, no puede crear un clúster DAX con estas
palabras en el nombre del clúster. Por ejemplo,sudoysudoclusterson nombres de clúster
no válidos.
En el resultado, tome nota del identificador del grupo de seguridad, por ejemplo,sg-01234567.
2. A continuación, introduzca lo siguiente. Sustituya sgID por el identificador del grupo de seguridad real.
Utilizar puerto8111para clústeres no cifrados y9111Para clústeres cifrados.
Temas
• Paso 1: Cree un grupo de subredes mediante laAWS Management Console (p. 738)
• Paso 2: Cree un clúster de DAX mediante laAWS Management Console (p. 739)
• Paso 3: Configure las reglas de entrada del grupo de seguridad mediante laAWS Management
Console (p. 740)
Si ya ha creado un grupo de subredes para la VPC predeterminada, puede omitir este paso.
DAX está diseñado para ejecutarse dentro de un entorno de Amazon Virtual Private Cloud (Amazon
VPC). Si ha creado suAWSUna vez que haya pasado el 4 de diciembre de 2013, ya dispone de una VPC
predeterminada en cadaAWSRegión . Para obtener más información, consulteVPC predeterminada y
subredes predeterminadasen laGuía del usuario de Amazon VPC.
Durante el proceso de creación de un clúster de DAX, debe especificar unGrupo de subredes de. Un grupo
de subredes es una colección de una o varias subredes de la VPC. Al crear un clúster de DAX, los nodos
se implementan en las subredes del grupo de subredes.
Las subredes se distribuyen entre varias zonas de disponibilidad. Si tiene previsto crear
un clúster de DAX de varios nodos (un nodo principal y una o más réplicas de lectura),
recomendamos elegir varios identificadores de subredes. A continuación, DAX puede
implementar los nodos del clúster en varias zonas de disponibilidad. Si una zona de
disponibilidad deja de estar disponible, DAX realiza automáticamente una conmutación
por error a una de las zonas de disponibilidad restantes. El clúster de DAX seguirá
funcionando sin interrupción.
Cuando esté conforme con los ajustes, elija Create subnet group (Crear grupo de subredes).
Para crear el clúster, consulte Paso 2: Cree un clúster de DAX mediante laAWS Management
Console (p. 739).
a. Cluster name (Nombre del clúster): escriba el nombre corto del clúster de DAX.
Note
Un clúster de DAX se puede implementar con uno o dos nodos para cargas
de trabajo de desarrollo o pruebas. Los clústeres de uno o dos nodos no son
tolerantes a errores y no se recomiendan menos de tres nodos para su uso
en producción. Si los clústeres de uno o dos nodos tienen errores de software
o hardware, el clúster podría dejar de estar disponible o podrían perderse los
datos almacenados en caché.
e. Cifrado: elijaHabilitar cifradoPara su clúster de DAX con el fin de proteger los datos en reposo.
Para obtener más información, consulte Cifrado DAX en reposo (p. 825) .
f. Role de servicio de IAM para acceder a DynamoDB: elijaCrear nuevosy escriba la información
siguiente:
• IAM role name (Nombre de rol de IAM): escriba el nombre de un rol de IAM, por
ejemplo,DAXServiceRole. La consola crea un nuevo rol de IAM y el clúster de DAX lo
asumirá en el tiempo de ejecución.
• Nombre de la política de IAM: escriba un nombre para una política de IAM, por
ejemplo,DAXServicePolicy. La consola crea una nueva política de IAM y asocia la política al
rol de IAM.
• Política de rol de IAM: elijaLectura/escritura. Esto permite que el clúster de DAX lleve a cabo
operaciones de lectura y escritura en DynamoDB.
• Tabla de DynamoDB de destino: elijaTodas las tablas.
g. Subnet group: elija el grupo de subredes que ha creado enPaso 1: Cree un grupo de subredes
mediante laAWS Management Console (p. 738).
h. Grupos de seguridad: elijapredeterminada.
También se requiere un rol de servicio independiente para que DAX acceda a Amazon EC2. DAX
creará automáticamente este rol de servicio. Para obtener más información, consulte Uso de roles
vinculados a servicios para DAX.
5. Cuando la configuración sea la que desea, elija Launch cluster (Lanzar clúster).
La creación del clúster tarda varios minutos. Cuando el clúster esté listo, su estado cambiará a
Available (Disponible).
Mientras tanto, continúe con Paso 3: Configure las reglas de entrada del grupo de seguridad
mediante laAWS Management Console (p. 740) y siga las instrucciones que se facilitan.
Si ha lanzado el clúster de DAX con un grupo de seguridad distinto (que no seadefault), tendrá
que llevar a cabo este procedimiento para ese grupo.
3. Elija el grupo de seguridad default (predeterminada). En el menú Actions (Acciones), elija Edit inbound
rules (Editar reglas de entrada).
4. Elija Add Rule (Añadir regla) y especifique la siguiente información:
• Rango de puertos: introduzca8111(si su clúster no está cifrado) o9111(si su clúster está cifrado).
En muchos casos de uso, la forma de usar DAX en la aplicación afecta a la consistencia de datos en el
clúster de DAX y a la consistencia de datos entre DAX y DynamoDB.
Temas
• Consistencia entre los nodos de los clúst (p. 741)
• Comportamiento de la caché de elementos de (p. 741)
• Comportamiento de la caché de consultas de (p. 744)
• Lecturas transaccionales y de consistencia alta (p. 744)
• Almacenamiento en caché negativo (p. 745)
• Estrategias de escritura (p. 745)
Cuando el clúster de DAX se está ejecutando, replica los datos entre todos los nodos del clúster (siempre
y cuando haya provisionado más de uno). Considere una aplicación que realiza correctamente una
solicitudUpdateItemUso de DAX. Esta acción hace que la caché de elementos del nodo principal se
modifique con el nuevo valor. A continuación, este valor se replica en todos los demás nodos del clúster.
Esta replicación presenta consistencia final y suele tardar menos de un segundo en llevarse a cabo.
En esta situación, es posible que dos clientes lean la misma clave del mismo clúster de DAX pero
reciban valores distintos, según a qué nodo haya obtenido acceso cada cliente. Todos los nodos serán
consistentes cuando la actualización haya terminado de replicarse en todos los nodos del clúster. (Este
comportamiento se asemeja al carácter consistente final de DynamoDB.
Si va a crear una aplicación que utiliza DAX, dicha aplicación deberá diseñarse de forma que tolere los
datos de consistencia final.
En esta sección se abordan las implicaciones para la consistencia de las lecturas y escrituras en la caché
de elementos de DAX.
Consistencia de lectura
Con DynamoDB, elGetItemDe forma predeterminada, con la operación lleva a cabo una lectura
consistente final. Suponga que utilizaUpdateItemcon el cliente de DynamoDB. Si inmediatamente
después intenta leer el mismo elemento, es posible que los datos aparezcan igual que antes de la
actualización. Esto se debe al retraso de propagación entre todas las ubicaciones de almacenamiento
de DynamoDB. Normalmente, se logra la coherencia en cuestión de segundos. Si reintenta la lectura,
probablemente verá el elemento actualizado.
Cuando se utilizaGetItemCon el cliente de DAX, la operación (en este caso, una lectura consistente final)
se lleva a cabo como se muestra a continuación.
1. El cliente de DAX emite una solicitudGetItemrequest. DAX intenta leer el elemento solicitado en la
caché de elementos. Si el elemento está presente en la caché (acierto de cachéDAX lo devuelve a la
aplicación.
2. Si el elemento no está disponible (Memoria caché), DAX realiza unaGetItemOperación contra
DynamoDB.
3. DynamoDB devuelve el elemento solicitado y DAX lo almacena en la caché de elementos.
4. DAX devuelve el elemento a la aplicación.
5. (No se muestra) Si el clúster de DAX contiene más de un nodo, el elemento se replica en todos los
demás nodos del clúster.
Sin embargo, durante este periodo, DAX no vuelve a leer el elemento en DynamoDB. Si otra
persona actualiza el elemento utilizando un cliente de DynamoDB, omitiendo DAX por completo,
unGetItemusando el cliente DAX produce resultados diferentes de la mismaGetItemmediante el cliente
de DynamoDB. En este escenario, DAX y DynamoDB contendrán valores inconsistentes de la misma clave
hasta que venza el TTL del elemento de DAX.
Si una aplicación modifica los datos de una tabla de DynamoDB subyacente eludiendo DAX, la aplicación
tendrá que prever y tolerar las inconsistencias de datos que surjan.
Note
Consistencia de escritura
DAX es una caché de escritura indirecta (write-through). Esto simplifica el proceso de mantener la
consistencia entre la caché de elementos de DAX y las tablas de DynamoDB subyacentes.
El cliente de DAX admite las mismas operaciones de API de escritura que DynamoDB
(PutItem,UpdateItem,DeleteItem,BatchWriteItem, yTransactWriteItems). Cuando se utilizan
estas operaciones con el cliente de DAX, los elementos se modifican tanto en DAX como en DynamoDB.
DAX actualiza los elementos en la caché de elementos, con independencia del valor de TTL que tengan.
Por ejemplo, suponga que emite una solicitudGetItemSolicitud del cliente de DAX para leer un elemento
deProductCatalogTabla INTO (La clave de partición es Id y no hay clave de ordenación). Recupera
el elemento cuyo Id es 101. LaQuantityOnHandpara ese elemento es42. DAX almacena el elemento
en su caché de elementos con un TTL concreto. En este ejemplo, vamos a suponer que el TTL es de diez
minutos. Después, 3 minutos más tarde, otra aplicación utiliza el cliente de DAX para actualizar el mismo
elemento, de forma que suQuantityOnHandahora es41. Suponiendo que el elemento no se vuelva
a actualizar, todas las lecturas posteriores del mismo elemento que tengan lugar en los próximos diez
minutos devolverán el valor de QuantityOnHand almacenado en caché (41).
Si una escritura en DynamoDB falla por cualquier motivo, incluida la limitación limitada, el elemento no se
almacenará en caché en DAX. Se devuelve al solicitante la excepción correspondiente al error. De este
modo se garantiza que los datos no se escriban en la caché de DAX a no ser que antes se hayan escrito
correctamente en DynamoDB.
Note
Cada escritura en DAX altera el estado de la caché de elementos. Sin embargo, las escrituras en
ella no afectan a la caché de consultas. La caché de elementos y la caché de consultas de DAX
se utilizan con fines diferentes y funcionan de manera independiente una de la otra.
Consistencia de consulta-actualización-consulta
Las actualizaciones de la caché de elementos o de la tabla de DynamoDB subyacente no invalidan ni
modifican los resultados almacenados en la caché de consultas.
A modo de ejemplo, considere la siguiente situación. Una aplicación está trabajando con la
tabla DocumentRevisions, que tiene una clave de partición DocId y una clave de ordenación
RevisionNumber.
1. Un cliente de emite una solicitudQuery: paraDocId 101, para todos los elementos
conRevisionNumbermayor o igual que5. DAX almacena el conjunto de resultados en la caché de
consultas y se lo devuelve al usuario.
2. El cliente de emite una solicitudPutItemsolicitarDocId 101con unRevisionNumberValor de20.
3. El cliente de emite el mismoQuerycomo se describe en el paso 1 (DocId 101yRevisionNumber >=5).
La aplicación debe tener en cuenta el valor de TTL de la caché de consultas y el tiempo durante el cual la
aplicación puede tolerar resultados inconsistentes entre las cachés de consultas y de elementos.
Por ejemplo, suponga que una aplicación de envía una solicitudGetItemsolicitud a un clúster de DAX y
que no hay ningún elemento coincidente en la caché de elementos de DAX. Esto hacer que DAX lea el
elemento correspondiente en la tabla de DynamoDB subyacente. Si el elemento no existe en DynamoDB,
DAX almacena un elemento vacío en su caché de elementos y se lo devuelve a la aplicación. Ahora
supongamos que la aplicación envía otroGetItemsolicitar el mismo elemento. DAX encuentra el elemento
vacío en la caché de elementos y se lo devuelve a la aplicación de inmediato. No consultará DynamoDB en
absoluto.
Una entrada de caché negativos se conserva en la caché de elementos de DAX de hasta que vence
el TTL del elemento, se invoca su LRU o el elemento se modifica mediantePutItem,UpdateItem, o
bienDeleteItem.
La caché de consultas de DAX administra los resultados de caché negativos de forma similar. Si una
aplicación realiza unaQueryo bienScanSi esto sucede, pero la caché de consultas de DAX no contiene un
resultado almacenado en caché, DAX envía la solicitud a DynamoDB. Si no hay elementos coincidentes
en el conjunto de resultados, DAX almacena un conjunto de resultados vacío en la caché de consultas y
devuelve el conjunto de resultados vacío a la aplicación. Las solicitudes Query o Scan producen el mismo
conjunto de resultados (vacío), hasta que vence su TTL.
Estrategias de escritura
El comportamiento de escritura indirecta (write-through) de DAX es adecuado para muchos patrones de
aplicaciones. No obstante, existen algunos patrones de aplicación en los que este modelo de escritura
indirecta podría no ser el adecuado.
En las aplicaciones que son sensibles a la latencia, la escritura a través de DAX genera un salto de red
más. Por eso, la escritura en DAX es algo más lenta que si se realiza directamente en DynamoDB. Si la
aplicación es sensible a la latencia de escritura, puede reducir esa latencia escribiendo directamente en
DynamoDB. Para obtener más información, consulte Escritura directa (p. 746).
Para las aplicaciones con gran intensidad de escrituras (como las que llevan a cabo la carga de datos
masivos), no es recomendable escribir todos los datos a través de DAX, puesto que la aplicación solo leerá
un pequeño porcentaje de ellos. Cuando se escriben grandes cantidades de datos a través de DAX, debe
invocar el algoritmo LRU con el fin de dejar espacio en la caché para los nuevos elementos que hay que
leer. Esto reduce la eficacia de DAX como caché de lectura.
Al escribir un elemento en DAX, el estado de la caché de elementos se modifica para dar cabida al nuevo
elemento. Por ejemplo, DAX podría tener que expulsar datos antiguos de la caché de elementos con el fin
de dejar espacio para el nuevo elemento. El nuevo elemento permanecerá en la caché de elementos, de
conformidad con el algoritmo LRU y el ajuste de TTL de esta última. Mientras el elemento persista en la
caché de elementos, DAX no volverá a leerlo en DynamoDB.
Escritura indirecta
La caché de elementos de DAX implementa una política de escritura automática. Para obtener más
información, consulte Procesamiento de escrituras en DAX (p. 743).
Al escribir un elemento, DAX se asegura de que el elemento almacenado en caché esté sincronizado con
el elemento presente en DynamoDB. Esto resulta útil para las aplicaciones que tienen que volver a leer un
elemento inmediatamente después de escribirlo. Sin embargo, si otras aplicaciones escriben directamente
en una tabla de DynamoDB, el elemento contenido en la caché de elementos de DAX dejará de estar
sincronizada con DynamoDB.
Por ejemplo, tomemos dos usuarios (Alice y Bob) que están utilizando la tabla ProductCatalog. Alice
obtiene acceso a la tabla mediante DAX, pero Bob elude DAX y obtiene acceso a la tabla directamente en
DynamoDB.
En este caso, Alice y Bob obtienen representaciones distintas del mismo elemento ProductCatalog.
Esto continuará siendo así hasta que DAX expulse el elemento de la caché de elementos o hasta que otro
usuario lo vuelva a actualizar mediante DAX.
Escritura directa
Si la aplicación tiene que escribir grandes cantidades de datos (por ejemplo, en una carga de datos
masivos), puede ser más lógico eludir DAX y escribir los datos directamente en DynamoDB. Esta
estrategia de escritura directa (write-around) reduce la latencia. Sin embargo, la caché de elementos no se
mantendrá sincronizada con los datos de DynamoDB.
Si decide utilizar una estrategia de escritura directa, recuerde que DAX rellena su caché de elementos
cada vez que las aplicaciones utilizan el cliente de DAX para leer los datos. Esto puede ser beneficioso
en algunos casos, ya que garantiza que solo se almacenen en caché los datos que se leen con mayor
frecuencia (en lugar de los datos que se escriben con mayor frecuencia).
Tomemos, por ejemplo, que un usuario (Charlie) desea trabajar con una tabla diferente, el
parámetroGameScores, utilizando DAX. La clave de partición de GameScores es UserId, por lo que
todas las puntuaciones de Charlie tendrían el mismo UserId.
1. Charlie desea recuperar todas sus puntuaciones, por lo que envía una solicitudQueryDAX. Suponiendo
que esta consulta no se haya emitido antes, DAX se la reenvía a DynamoDB para procesarla. Almacena
los resultados en la caché de consultas de DAX y, por último, devuelve los resultados a Charlie. El
conjunto de resultados seguirá disponible en la caché de consultas hasta que se expulse.
2. Ahora, supongamos que Charlie juega a Blasters Meteor y logra una puntuación máxima. Charlie envía
una solicitudUpdateItemMoDynamoDB de un elemento enGameScoresTabla INTO
3. Por último, Charlie decide volver a ejecutar la operación Query anterior para recuperar todos sus
datos de GameScores. Charlie no ve su puntuación máxima en Meteor Blasters en los resultados.
Esto se debe a que los resultados de la consulta proceden de la caché de consultas, no de la caché de
elementos. Las dos cachés son independientes entre sí, de modo que un cambio en una de ellas no
afecta a la otra.
DAX no actualiza los conjuntos de resultados de la caché de consultas con los datos más recientes de
DynamoDB. Cada conjunto de resultados de la caché de consultas estaba actualizado en el momento
de ejecutar la operación Query o Scan. Por lo tanto, los resultados que Charlie obtiene con la operación
Query no reflejan su operación PutItem. Esto continuará siendo así hasta que DAX expulse el conjunto
de resultados de la caché de consultas.
Los clientes de DAX para diversos lenguajes de programación están disponibles en el siguiente
sitio:
• http://dax-sdk.s3-website-us-west-2.amazonaws.com
En esta sección se muestra cómo lanzar una instancia Amazon EC2 en la Amazon VPC predeterminada,
conectarse a la instancia y ejecutar una aplicación de ejemplo. También se ofrece información sobre cómo
modificar la aplicación existente para que pueda utilizar el clúster de DAX.
Temas
• Tutorial: Ejecución de una aplicación de ejemplo de utilizando DynamoDB Accelerator (DAX) (p. 748)
• Modificación de una aplicación existente para que use DAX (p. 785)
• Consulta de índices secundarios globales (p. 788)
Temas
• Paso 1: Lanzamiento de una instancia de Amazon EC2 (p. 748)
• Paso 2: Crear un usuario y una política de IAM (p. 749)
• Paso 3: Configurar una instancia de Amazon EC2 (p. 751)
• Paso 4: Ejecución de un ejemplo de aplicación (p. 751)
1. Inicie sesión en AWS Management Console y abra la consola de Amazon EC2 en https://
console.aws.amazon.com/EC2/.
2. Elija Launch Instance (Lanzar instancia) y proceda del modo siguiente:
1. En la lista de AMI, busque la Amazon Linux AMI (AMI de Amazon Linux) y elija Select (Seleccionar).
1. Elija para omitir este pasoSiguiente: Página Configure Security Group (Configurar grupo de
seguridad).
1. Elija Launch.
3. En la ventana Select an existing key pair or create a new key pair, proceda del modo siguiente:
• Si no dispone de un key pair Amazon EC2, elijaCrear un nuevo key pairSiga las instrucciones. Se
le pedirá que descargue un archivo de claves privadas (archivo .pem). Necesitará este archivo más
tarde cuando inicie sesión en su instancia de Amazon EC2.
• Si ya dispone de un key pair Amazon EC2, vaya aSeleccionar un par de clavesElija el key pair de
la lista. Debe disponer del archivo de clave privada (.pemPara poder iniciar sesión en la instancia
Amazon EC2.
4. Después de configurar el par de claves, elija Launch instances (Lanzar instancias).
5. En el panel de navegación de la consola, elija EC2 Dashboard (Panel de EC2) y, a continuación,
seleccione la instancia que ha lanzado. En el panel inferior, en la pestañaDescripción,
busque la pestañaDNS públicoPara su instancia, por ejemplo: ec2-11-22-33-44.us-
west-2.compute.amazonaws.com. Anote el nombre de DNS público, pues lo necesita paraPaso 3:
Configurar una instancia de Amazon EC2 (p. 751).
Note
La instancia de Amazon EC2 tardará unos minutos en estar disponible. Mientras tanto, continúe
con Paso 2: Crear un usuario y una política de IAM (p. 749) y siga las instrucciones que se
facilitan.
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"dax:*"
],
"Effect": "Allow",
"Resource": [
"*"
]
},
{
"Action": [
"dynamodb:*"
],
"Effect": "Allow",
"Resource": [
"*"
]
}
]
}
Debe especificar el archivo de clave privada (archivo .pem) y el nombre de DNS público de la
instancia. (Consulte Paso 1: Lanzamiento de una instancia de Amazon EC2 (p. 748)).
aws configure
Después de lanzar y configurar su instancia Amazon EC2, puede probar la funcionalidad de DAX utilizando
una de las aplicaciones de ejemplo disponibles. Para obtener más información, consulte Paso 4: Ejecución
de un ejemplo de aplicación (p. 751) .
Temas
• DAX SDK for Go (p. 751)
• Java y DAX (p. 753)
• .NET y DAX (p. 762)
• Node.js y DAX (p. 771)
• Python y DAX (p. 779)
go version
go get github.com/aws-samples/aws-dax-go-sample
3. Ejecute los siguientes programas de Golang. El primer programa crea una tabla de DynamoDB
denominadaTryDaxGoTable. El segundo programa escribe datos en la tabla.
Tome nota de la información de tiempo; es decir, del número de milisegundos necesarios para realizar
las pruebas de GetItem, Query y Scan.
5. En el paso anterior, hemos ejecutado los programas en el punto de enlace de DynamoDB. Ahora,
ejecute los programas de nuevo, pero, esta vez,GetItem,Query, yScanson procesadas por el clúster
DAX.
Para determinar el punto de enlace del clúster de DAX, elija una de las opciones siguientes:
• Uso de la consola de DynamoDBElija su clúster de DAX. El punto de enlace del clúster se muestra
en la consola, como en el siguiente ejemplo.
Versión de API 2012-08-10
752
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación
dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
{
"Address": "my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com",
"Port": 8111,
"URL": "dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com"
}
Ahora, vuelva a ejecutar los programas, pero, esta vez, especifique el punto de enlace del clúster
como parámetro en la línea de comandos.
Fíjese en el resto del resultado y tome nota de la información sobre tiempos. Los tiempos transcurridos
paraGetItem,Query, yScanDebería ser significativamente menor con DAX que con DynamoDB.
6. Ejecute el siguiente programa de Golang para eliminar TryDaxGoTable.
Java y DAX
Siga este procedimiento para ejecutar el ejemplo de Java para Amazon DynamoDB Accelerator (DAX) en
su instancia Amazon EC2.
2. Descargue el archivo del AWS SDK for Java (archivo .zip) y, a continuación, extráigalo.
wget http://sdk-for-java.amazonwebservices.com/latest/aws-java-sdk.zip
unzip aws-java-sdk.zip
wget http://dax-sdk.s3-website-us-west-2.amazonaws.com/java/DaxJavaClient-latest.jar
Note
El cliente del SDK de DAX para Java está disponible en Apache Maven. Para obtener más
información, consulte Uso del cliente como dependencia de Apache Maven (p. 756) .
4. Establezca la variable CLASSPATH. En este ejemplo, reemplacesdkVersionCon el número de
versión real delAWS SDK for Java(por ejemplo,1.11.112).
export SDKVERSION=sdkVersion
export CLASSPATH=$(pwd)/TryDax/java:$(pwd)/DaxJavaClient-latest.jar:$(pwd)/aws-java-
sdk-$SDKVERSION/lib/aws-java-sdk-$SDKVERSION.jar:$(pwd)/aws-java-sdk-$SDKVERSION/third-
party/lib/*
wget http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/samples/TryDax.zip
unzip TryDax.zip
cd TryDax/java/
javac TryDax*.java
7. Ejecute el programa.
java TryDax
Tome nota de la información de tiempo; es decir, del número de milisegundos necesarios para realizar
las pruebas de GetItem, Query y Scan.
8. En el paso anterior, hemos ejecutado el programa en el punto de enlace de DynamoDB. Ahora,
ejecute el programa de nuevo, pero, esta vez,GetItem,Query, yScanson procesadas por el clúster
DAX.
Para determinar el punto de enlace del clúster de DAX, elija una de las opciones siguientes:
• Uso de la consola de DynamoDBElija su clúster de DAX. El punto de enlace del clúster se muestra
en la consola, como en el siguiente ejemplo.
dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
{
"Address": "my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com",
"Port": 8111,
"URL": "dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com"
}
Ahora, vuelva a ejecutar el programa, pero, esta vez, especifique el punto de enlace del clúster como
parámetro en la línea de comandos.
Fíjese en el resto del resultado y tome nota de la información sobre tiempos. Los tiempos transcurridos
paraGetItem,Query, yScanDebería ser significativamente menor con DAX que con DynamoDB.
Para obtener más información sobre este programa, consulte las siguientes secciones:
Siga estos pasos para utilizar el cliente para el SDK de DAX para Java en su aplicación como una
dependencia.
1. Descargue e instale Apache Maven. Para obtener más información, consulte Downloading Apache
Maven e Installing Apache Maven.
2. Agregue la dependencia de Maven del cliente al archivo POM (Project Object Model) de la aplicación.
En este ejemplo, sustituya x.x.x.x por el número de versión real del cliente (por ejemplo:
1.0.200704.0).
<!--Dependency:-->
<dependencies>
<dependency>
<groupId>com.amazonaws</groupId>
<artifactId>amazon-dax-client</artifactId>
<version>x.x.x.x</version>
</dependency>
</dependencies>
TryDax.java
El archivo TryDax.java contiene el método main. Si ejecuta el programa sin parámetros de línea de
comandos, se crea un cliente de Amazon DynamoDB que se utiliza para todas las operaciones del API. Si
especifica el punto de enlace de un clúster de DynamoDB Accelerator (DAX) en la línea de comandos, el
programa crea también un cliente de DAX y lo utiliza paraGetItem,Query, yScanOperaciones.
• Utilice el cliente DAX en lugar del cliente DynamoDB. Para obtener más información, consulte Java y
DAX (p. 753) .
• Elegir otro nombre para la tabla de prueba.
• Cambiar los parámetros de helper.writeData para modificar el número de elementos que se
escriben. El segundo parámetro es el número de claves de partición y el tercero, el número de claves de
ordenación. De forma predeterminada, el programa entre 1 y 10 valores de clave de partición y entre 1 y
10 valores de clave de ordenación, lo que equivale a un total de 100 elementos escritos en la tabla. Para
obtener más información, consulte TryDaxHelper.java (p. 757) .
• Modificar el número de pruebas de GetItem, Query y Scan, así como sus parámetros.
• Marcar como comentarios las líneas que contienen helper.createTable y helper.deleteTable,
sin no desea crear y eliminar la tabla cada vez que ejecute el programa.
Note
Para ejecutar este programa, puede configurar Maven para usar el cliente para el SDK de DAX
para Java y elAWS SDK for JavaDependencias de. Para obtener más información, consulte Uso
del cliente como dependencia de Apache Maven (p. 756) .
Como alternativa, puede descargar e incluir el cliente Java de DAX y de laAWS SDK for Javaen
tu classpath. Consulte Java y DAX (p. 753) para ver un ejemplo de cómo establecer la variable
CLASSPATH.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
System.out.println("Creating table...");
helper.createTable(tableName, ddbClient);
System.out.println("Populating table...");
helper.writeData(tableName, ddbClient, 10, 10);
// GetItem
tests.getItemTest(tableName, testClient, 1, 10, 5);
// Query
tests.queryTest(tableName, testClient, 5, 2, 9, 5);
// Scan
tests.scanTest(tableName, testClient, 5);
helper.deleteTable(tableName, ddbClient);
}
TryDaxHelper.java
Note
Para ejecutar este programa, puede configurar Maven para usar el cliente para el SDK de DAX
para Java y elAWS SDK for JavaDependencias de. Para obtener más información, consulte Uso
del cliente como dependencia de Apache Maven (p. 756) .
O, puede descargar e incluir el cliente Java de DAX y de laAWS SDK for Javaen tu classpath.
Consulte Java y DAX (p. 753) para ver un ejemplo de cómo establecer la variable CLASSPATH.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
import java.util.Arrays;
import com.amazon.dax.client.dynamodbv2.AmazonDaxClientBuilder;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.services.dynamodbv2.model.ScalarAttributeType;
import com.amazonaws.util.EC2MetadataUtils;
DynamoDB getDynamoDBClient() {
table = client.createTable(tableName,
Arrays.asList(
new KeySchemaElement("pk", KeyType.HASH), // Partition key
new KeySchemaElement("sk", KeyType.RANGE)), // Sort key
Arrays.asList(
new AttributeDefinition("pk", ScalarAttributeType.N),
new AttributeDefinition("sk", ScalarAttributeType.N)),
new ProvisionedThroughput(10L, 10L));
table.waitForActive();
System.out.println("Successfully created table. Table status: " +
table.getDescription().getTableStatus());
} catch (Exception e) {
System.err.println("Unable to create table: ");
e.printStackTrace();
}
}
try {
for (Integer ipk = 1; ipk <= pkmax; ipk++) {
System.out.println(("Writing " + skmax + " items for partition key: " +
ipk));
for (Integer isk = 1; isk <= skmax; isk++) {
table.putItem(new Item()
.withPrimaryKey("pk", ipk, "sk", isk)
.withString("someData", someData));
}
}
} catch (Exception e) {
System.err.println("Unable to write item:");
e.printStackTrace();
}
}
} catch (Exception e) {
System.err.println("Unable to delete table: ");
e.printStackTrace();
}
}
TryDaxTests.java
LaTryDaxTests.javaEl archivo contiene métodos que llevan a cabo operaciones de lectura en una
tabla de prueba de Amazon DynamoDB. Estos métodos no tienen en cuenta cómo obtiene acceso a los
datos (mediante el cliente de DynamoDB o de DAX), por lo que no es necesario modificar la lógica de la
aplicación.
Note
Para ejecutar este programa, puede configurar Maven para usar el cliente para el SDK de DAX
para Java y elAWS SDK for JavaDependencias de. Para obtener más información, consulte Uso
del cliente como dependencia de Apache Maven (p. 756) .
O, puede descargar e incluir el cliente Java de DAX y de laAWS SDK for Javaen tu classpath.
Consulte Java y DAX (p. 753) para ver un ejemplo de cómo establecer la variable CLASSPATH.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
import java.util.HashMap;
import java.util.Iterator;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.ItemCollection;
import com.amazonaws.services.dynamodbv2.document.QueryOutcome;
import com.amazonaws.services.dynamodbv2.document.ScanOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec;
void getItemTest(String tableName, DynamoDB client, int pk, int sk, int iterations) {
long startTime, endTime;
System.out.println("GetItem test - partition key " + pk + " and sort keys 1-" +
sk);
Table table = client.getTable(tableName);
void queryTest(String tableName, DynamoDB client, int pk, int sk1, int sk2, int
iterations) {
long startTime, endTime;
System.out.println("Query test - partition key " + pk + " and sort keys between " +
sk1 + " and " + sk2);
Table table = client.getTable(tableName);
try {
Iterator<Item> iter = items.iterator();
while (iter.hasNext()) {
iter.next();
}
} catch (Exception e) {
System.err.println("Unable to query table:");
e.printStackTrace();
}
endTime = System.nanoTime();
printTime(startTime, endTime, iterations);
}
}
.NET y DAX
Siga estos pasos para ejecutar el ejemplo de .NET en su instancia de Amazon EC2.
Note
En este tutorial se utiliza el SDK de .NET Core. Muestra cómo puede ejecutar un programa
en la VPC predeterminada de Amazon para obtener acceso al clúster de Amazon DynamoDB
Accelerator (DAX). Si lo prefiere, puede utilizar AWS Toolkit for Visual Studio para escribir una
aplicación .NET e implementarla en su VPC.
Para obtener más información, consulteCrear e implementar aplicaciones Elastic Beanstalk
en .NET utilizandoAWSToolkit for Visual Studioen laAWS Elastic BeanstalkGuía para
desarrolladores.
1. Vaya a la página de descargas de Microsoft y descargue el SDK de .NET Core para Linux más
reciente. El archivo descargable es dotnet-sdk-N.N.N-linux-x64.tar.gz.
2. Extraiga los archivos de .NET Core.
mkdir dotnet
tar zxvf dotnet-sdk-N.N.N-linux-x64.tar.gz -C dotnet
Sustituya N.N.N por el número de versión real del SDK de .NET Core ( por ejemplo: 2.1.4).
3. Verifique la instalación.
alias dotnet=$HOME/dotnet/dotnet
dotnet --version
Error: libunwind.so.8: no se puede abrir el archivo de objeto compartido: No existe tal archivo
o directorio
Para resolver el error, instale el paquete libunwind.
Después de esto, debería poder ejecutar el comando dotnet --version sin errores.
4. Creación de un nuevo proyecto de .NET.
Esto requiere algunos minutos para llevar a cabo una configuración solo una vez. Cuando se
complete, ejecute el proyecto de ejemplo.
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>netcoreapp2.0</TargetFramework>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="AWSSDK.DAX.Client" Version="*" />
</ItemGroup>
</Project>
wget http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/samples/TryDax.zip
unzip TryDax.zip
7. Ahora ejecute los programas de ejemplo, uno cada vez. Para cada programa, copie su contenido en
myApp/Program.cs y, a continuación, ejecute el proyecto MyApp.
Ejecute los siguientes programas de .NET. El primer programa crea una tabla de DynamoDB
denominadaTryDaxTable. El segundo programa escribe datos en la tabla.
cp 01-CreateTable.cs myApp/Program.cs
dotnet run --project myApp
cp 02-Write-Data.cs myApp/Program.cs
dotnet run --project myApp
• Uso de la consola de DynamoDBElija su clúster de DAX. El punto de enlace del clúster se muestra
en la consola, como en el siguiente ejemplo.
Versión de API 2012-08-10
763
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación
dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
{
"Address": "my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com",
"Port": 8111,
"URL": "dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com"
}
Ahora, ejecute los programas siguientes, especificando el punto de enlace del clúster como parámetro
en la línea de comandos. (Reemplace el punto de enlace por el punto de enlace de clúster de DAX
real).
cp 03-GetItem-Test.cs myApp/Program.cs
dotnet run --project myApp dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
cp 04-Query-Test.cs myApp/Program.cs
dotnet run --project myApp dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
cp 05-Scan-Test.cs myApp/Program.cs
dotnet run --project myApp dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
Tome nota de la información de tiempo; es decir, del número de milisegundos necesarios para realizar
las pruebas de GetItem, Query y Scan.
9. Ejecute el siguiente programa de .NET para eliminar TryDaxTable.
cp 06-DeleteTable.cs myApp/Program.cs
dotnet run --project myApp
Para obtener más información sobre estos programas, consulte las siguientes secciones:
01-CreateTable.cs
El programa 01-CreateTable.cs crea una tabla (TryDaxTable). Los demás programas de .NET en
esta sección dependerán de esta tabla.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using Amazon.DynamoDBv2.Model;
using System.Collections.Generic;
using System;
using Amazon.DynamoDBv2;
namespace ClientTest
{
class Program
{
static void Main(string[] args)
{
02-Write-Data.cs
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using Amazon.DynamoDBv2.Model;
using System.Collections.Generic;
using System;
using Amazon.DynamoDBv2;
namespace ClientTest
{
class Program
{
static void Main(string[] args)
{
}
}
03-GetItem-Test.cs
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using Amazon.Runtime;
using Amazon.DAX;
using Amazon.DynamoDBv2.Model;
using System.Collections.Generic;
using System;
using Amazon.DynamoDBv2;
using Amazon;
namespace ClientTest
{
class Program
{
static void Main(string[] args)
{
};
var client = new ClusterDaxClient(clientConfig);
var pk = 1;
var sk = 10;
var iterations = 5;
04-Query-Test.cs
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using Amazon.Runtime;
using Amazon.DAX;
using Amazon.DynamoDBv2.Model;
using System.Collections.Generic;
using System;
using Amazon.DynamoDBv2;
using Amazon;
namespace ClientTest
{
class Program
{
static void Main(string[] args)
{
};
var client = new ClusterDaxClient(clientConfig);
var pk = 5;
var sk1 = 2;
var sk2 = 9;
var iterations = 5;
05-Scan-Test.cs
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using Amazon.Runtime;
using Amazon.DAX;
using Amazon.DynamoDBv2.Model;
using System.Collections.Generic;
using System;
using Amazon.DynamoDBv2;
using Amazon;
namespace ClientTest
{
class Program
{
static void Main(string[] args)
{
};
var client = new ClusterDaxClient(clientConfig);
var iterations = 5;
06-DeleteTable.cs
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using Amazon.DynamoDBv2.Model;
using System;
using Amazon.DynamoDBv2;
namespace ClientTest
{
class Program
{
static void Main(string[] args)
{
Node.js y DAX
Siga estos pasos para ejecutar la aplicación de ejemplo de Node.js en su instancia de Amazon EC2.
wget http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/samples/TryDax.zip
unzip TryDax.zip
4. Ejecute los siguientes programas de Node.js. El primer programa crea una tabla Amazon DynamoDB
denominadaTryDaxTable. El segundo programa escribe datos en la tabla.
node 01-create-table.js
node 02-write-data.js
node 03-getitem-test.js
node 04-query-test.js
node 05-scan-test.js
Tome nota de la información de tiempo; es decir, del número de milisegundos necesarios para realizar
las pruebas de GetItem, Query y Scan.
6. En el paso anterior, hemos ejecutado los programas en el punto de enlace de DynamoDB. Ejecute los
programas de nuevo, pero, esta vez, seGetItem,QueryyScanson procesadas por el clúster DAX.
Para determinar el punto de enlace del clúster de DAX, elija una de las opciones siguientes.
• Uso de la consola de DynamoDB: elija su clúster de DAX. El punto de enlace del clúster se muestra
en la consola, como en el siguiente ejemplo.
dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
{
"Address": "my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com",
"Port": 8111,
"URL": "dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com"
}
Ahora, vuelva a ejecutar los programas, pero, esta vez, especifique el punto de enlace del clúster
como parámetro en la línea de comandos.
Fíjese en el resto del resultado y tome nota de la información sobre tiempos. Los tiempos transcurridos
paraGetItem,Query, yScanDebería ser significativamente menor con DAX que con DynamoDB.
7. Ejecute el siguiente programa de Node.js para eliminar TryDaxTable.
Versión de API 2012-08-10
772
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación
node 06-delete-table
Para obtener más información sobre estos programas, consulte las siguientes secciones:
01-create-table.js
El programa 01-create-table.js crea una tabla (TryDaxTable). Los demás programas de Node.js en
esta sección dependerán de esta tabla.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
const AmazonDaxClient = require('amazon-dax-client');
var AWS = require("aws-sdk");
AWS.config.update({
region: region
});
var params = {
TableName : tableName,
KeySchema: [
{ AttributeName: "pk", KeyType: "HASH"}, //Partition key
{ AttributeName: "sk", KeyType: "RANGE" } //Sort key
],
AttributeDefinitions: [
{ AttributeName: "pk", AttributeType: "N" },
{ AttributeName: "sk", AttributeType: "N" }
],
ProvisionedThroughput: {
ReadCapacityUnits: 10,
WriteCapacityUnits: 10
}
};
02-write-data.js
El programa 02-write-data.js escribe datos de prueba en TryDaxTable.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
const AmazonDaxClient = require('amazon-dax-client');
var AWS = require("aws-sdk");
AWS.config.update({
region: region
});
//
//put item
} else {
console.log("PutItem succeeded");
}
});
}
}
03-getitem-test.js
El programa 03-getitem-test.js escribe realiza operaciones GetItem en TryDaxTable.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
const AmazonDaxClient = require('amazon-dax-client');
var AWS = require("aws-sdk");
AWS.config.update({
region: region
});
if (process.argv.length > 2) {
var dax = new AmazonDaxClient({endpoints: [process.argv[2]], region: region})
daxClient = new AWS.DynamoDB.DocumentClient({service: dax });
}
var pk = 1;
var sk = 10;
var iterations = 5;
var params = {
TableName: tableName,
Key:{
"pk": ipk,
"sk": isk
}
};
04-query-test.js
El programa 04-query-test.js escribe realiza operaciones Query en TryDaxTable.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
const AmazonDaxClient = require('amazon-dax-client');
var AWS = require("aws-sdk");
AWS.config.update({
region: region
});
if (process.argv.length > 2) {
var dax = new AmazonDaxClient({endpoints: [process.argv[2]], region: region})
daxClient = new AWS.DynamoDB.DocumentClient({service: dax });
}
var pk = 5;
var sk1 = 2;
var sk2 = 9;
var iterations = 5;
var params = {
TableName: tableName,
05-scan-test.js
El programa 05-scan-test.js escribe realiza operaciones Scan en TryDaxTable.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
const AmazonDaxClient = require('amazon-dax-client');
var AWS = require("aws-sdk");
AWS.config.update({
region: region
});
if (process.argv.length > 2) {
var dax = new AmazonDaxClient({endpoints: [process.argv[2]], region: region})
daxClient = new AWS.DynamoDB.DocumentClient({service: dax });
}
var iterations = 5;
var params = {
TableName: tableName
};
var startTime = new Date().getTime();
for (var i = 0; i < iterations; i++) {
06-delete-table.js
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
const AmazonDaxClient = require('amazon-dax-client');
var AWS = require("aws-sdk");
AWS.config.update({
region: region
});
var params = {
TableName : tableName
};
Python y DAX
Siga este procedimiento para ejecutar la aplicación de ejemplo de Python en su instancia de Amazon EC2.
wget http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/samples/TryDax.zip
unzip TryDax.zip
3. Ejecute los siguientes programas de Python. El primer programa crea una tabla Amazon DynamoDB
denominadaTryDaxTable. El segundo programa escribe datos en la tabla.
python 01-create-table.py
python 02-write-data.py
python 03-getitem-test.py
python 04-query-test.py
python 05-scan-test.py
Tome nota de la información de tiempo; es decir, del número de milisegundos necesarios para realizar
las pruebas de GetItem, Query y Scan.
5. En el paso anterior, hemos ejecutado los programas en el punto de enlace de DynamoDB. Ahora,
ejecute los programas de nuevo, pero, esta vez,GetItem,Query, yScanson procesadas por el clúster
DAX.
Para determinar el punto de enlace del clúster de DAX, elija una de las opciones siguientes:
• Uso de la consola de DynamoDBElija su clúster de DAX. El punto de enlace del clúster se muestra
en la consola, como en el siguiente ejemplo.
dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
{
"Address": "my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com",
"Port": 8111,
"URL": "dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com"
}
Vuelva a ejecutar los programas, pero, esta vez, especifique el punto de enlace del clúster como
parámetro en la línea de comandos.
Fíjese en el resto del resultado y tome nota de la información sobre tiempos. Los tiempos transcurridos
paraGetItem,Query, yScanDebería ser significativamente menor con DAX que con DynamoDB.
6. Ejecute el siguiente programa de Python para eliminar TryDaxTable.
python 06-delete-table.py
Para obtener más información sobre estos programas, consulte las siguientes secciones:
01-create-table.py
El programa 01-create-table.py crea una tabla (TryDaxTable). Los demás programas de Python en
esta sección dependerán de esta tabla.
import boto3
def create_dax_table(dyn_resource=None):
"""
Creates a DynamoDB table.
table_name = 'TryDaxTable'
params = {
'TableName': table_name,
'KeySchema': [
{'AttributeName': 'partition_key', 'KeyType': 'HASH'},
{'AttributeName': 'sort_key', 'KeyType': 'RANGE'}
],
'AttributeDefinitions': [
if __name__ == '__main__':
dax_table = create_dax_table()
print(f"Created table.")
02-write-data.py
import boto3
:param key_count: The number of partition and sort keys to use to populate the
table. The total number of items is key_count * key_count.
:param item_size: The size of non-key data for each test item.
:param dyn_resource: Either a Boto3 or DAX resource.
"""
if dyn_resource is None:
dyn_resource = boto3.resource('dynamodb')
table = dyn_resource.Table('TryDaxTable')
some_data = 'X' * item_size
if __name__ == '__main__':
write_key_count = 10
write_item_size = 1000
print(f"Writing {write_key_count*write_key_count} items to the table. "
f"Each item is {write_item_size} characters.")
write_data_to_dax_table(write_key_count, write_item_size)
03-getitem-test.py
import argparse
import sys
import time
import amazondax
import boto3
:param key_count: The number of items to get from the table in each iteration.
:param iterations: The number of iterations to run.
:param dyn_resource: Either a Boto3 or DAX resource.
:return: The start and end times of the test.
"""
if dyn_resource is None:
dyn_resource = boto3.resource('dynamodb')
table = dyn_resource.Table('TryDaxTable')
start = time.perf_counter()
for _ in range(iterations):
for partition_key in range(1, key_count + 1):
for sort_key in range(1, key_count + 1):
table.get_item(Key={
'partition_key': partition_key,
'sort_key': sort_key
})
print('.', end='')
sys.stdout.flush()
print()
end = time.perf_counter()
return start, end
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument(
'endpoint_url', nargs='?',
help="When specified, the DAX cluster endpoint. Otherwise, DAX is not used.")
args = parser.parse_args()
test_key_count = 10
test_iterations = 50
if args.endpoint_url:
print(f"Getting each item from the table {test_iterations} times, "
f"using the DAX client.")
# Use a with statement so the DAX client closes the cluster after completion.
with amazondax.AmazonDaxClient.resource(endpoint_url=args.endpoint_url) as dax:
test_start, test_end = get_item_test(
test_key_count, test_iterations, dyn_resource=dax)
else:
print(f"Getting each item from the table {test_iterations} times, "
f"using the Boto3 client.")
test_start, test_end = get_item_test(
test_key_count, test_iterations)
print(f"Total time: {test_end - test_start:.4f} sec. Average time: "
f"{(test_end - test_start)/ test_iterations}.")
04-query-test.py
El programa 04-query-test.py escribe realiza operaciones Query en TryDaxTable.
import argparse
import time
import sys
import amazondax
import boto3
from boto3.dynamodb.conditions import Key
:param partition_key: The partition key value to use in the query. The query
returns items that have partition keys equal to this value.
:param sort_keys: The range of sort key values for the query. The query returns
items that have sort key values between these two values.
:param iterations: The number of iterations to run.
:param dyn_resource: Either a Boto3 or DAX resource.
:return: The start and end times of the test.
"""
if dyn_resource is None:
dyn_resource = boto3.resource('dynamodb')
table = dyn_resource.Table('TryDaxTable')
key_condition_expression = \
Key('partition_key').eq(partition_key) & \
Key('sort_key').between(*sort_keys)
start = time.perf_counter()
for _ in range(iterations):
table.query(KeyConditionExpression=key_condition_expression)
print('.', end='')
sys.stdout.flush()
print()
end = time.perf_counter()
return start, end
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument(
'endpoint_url', nargs='?',
help="When specified, the DAX cluster endpoint. Otherwise, DAX is not used.")
args = parser.parse_args()
test_partition_key = 5
test_sort_keys = (2, 9)
test_iterations = 100
if args.endpoint_url:
print(f"Querying the table {test_iterations} times, using the DAX client.")
# Use a with statement so the DAX client closes the cluster after completion.
with amazondax.AmazonDaxClient.resource(endpoint_url=args.endpoint_url) as dax:
test_start, test_end = query_test(
test_partition_key, test_sort_keys, test_iterations, dyn_resource=dax)
else:
print(f"Querying the table {test_iterations} times, using the Boto3 client.")
test_start, test_end = query_test(
test_partition_key, test_sort_keys, test_iterations)
05-scan-test.py
import argparse
import time
import sys
import amazondax
import boto3
table = dyn_resource.Table('TryDaxTable')
start = time.perf_counter()
for _ in range(iterations):
table.scan()
print('.', end='')
sys.stdout.flush()
print()
end = time.perf_counter()
return start, end
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument(
'endpoint_url', nargs='?',
help="When specified, the DAX cluster endpoint. Otherwise, DAX is not used.")
args = parser.parse_args()
test_iterations = 100
if args.endpoint_url:
print(f"Scanning the table {test_iterations} times, using the DAX client.")
# Use a with statement so the DAX client closes the cluster after completion.
with amazondax.AmazonDaxClient.resource(endpoint_url=args.endpoint_url) as dax:
test_start, test_end = scan_test(test_iterations, dyn_resource=dax)
else:
print(f"Scanning the table {test_iterations} times, using the Boto3 client.")
test_start, test_end = scan_test(test_iterations)
print(f"Total time: {test_end - test_start:.4f} sec. Average time: "
f"{(test_end - test_start)/test_iterations}.")
06-delete-table.py
El programa 06-delete-table.py elimina TryDaxTable. Ejecute este programa después de haber
terminado las pruebas de la funcionalidad del acelerador de Amazon DynamoDB (DAX).
import boto3
def delete_dax_table(dyn_resource=None):
"""
Deletes the demonstration table.
if dyn_resource is None:
dyn_resource = boto3.resource('dynamodb')
table = dyn_resource.Table('TryDaxTable')
table.delete()
print(f"Deleting {table.name}...")
table.wait_until_not_exists()
if __name__ == '__main__':
delete_dax_table()
print("Table deleted!")
Supongamos que tiene una tabla de DynamoDB denominadaMusic. La clave de partición de la tabla es
Artist y la de ordenación SongTitle. El siguiente programa lee un elemento directamente desde la
tabla Music.
import java.util.HashMap;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import com.amazonaws.services.dynamodbv2.model.GetItemRequest;
import com.amazonaws.services.dynamodbv2.model.GetItemResult;
try {
System.out.println("Attempting to read the item...");
GetItemResult result = client.getItem(request);
System.out.println("GetItem succeeded: " + result);
} catch (Exception e) {
System.err.println("Unable to read item");
System.err.println(e.getMessage());
}
}
}
import java.util.HashMap;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazon.dax.client.dynamodbv2.AmazonDaxClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import com.amazonaws.services.dynamodbv2.model.GetItemRequest;
import com.amazonaws.services.dynamodbv2.model.GetItemResult;
/*
** ...
** Remaining code omitted (it is identical)
** ...
*/
}
}
La interfaz de documentos también se pueden utilizar con el cliente de bajo nivel de, tal y como se muestra
en el siguiente ejemplo.
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazon.dax.client.dynamodbv2.AmazonDaxClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.GetItemOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;
try {
System.out.println("Attempting to read the item...");
GetItemOutcome outcome = table.tgetItemOutcome(
}
}
El programa siguiente ilustra cómo utilizar ClusterDaxAsyncClient con Future de Java para
implementar una solución que no genere ningún bloqueo.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
import java.util.HashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import com.amazon.dax.client.dynamodbv2.ClientConfig;
import com.amazon.dax.client.dynamodbv2.ClusterDaxAsyncClient;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.handlers.AsyncHandler;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBAsync;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import com.amazonaws.services.dynamodbv2.model.GetItemRequest;
import com.amazonaws.services.dynamodbv2.model.GetItemResult;
.withTableName("Music").withKey(key);
// Java Futures
Future<GetItemResult> call = client.getItemAsync(request);
while (!call.isDone()) {
// Do other processing while you're waiting for the response
System.out.println("Doing something else for a few seconds...");
Thread.sleep(3000);
}
// The results should be ready by now
try {
call.get();
// Async callbacks
call = client.getItemAsync(request, new AsyncHandler<GetItemRequest, GetItemResult>() {
@Override
public void onSuccess(GetItemRequest request, GetItemResult getItemResult) {
System.out.println("Result: " + getItemResult);
}
@Override
public void onError(Exception e) {
System.out.println("Unable to read item");
System.err.println(e.getMessage());
// Callers can also test if exception is an instance of
// AmazonServiceException or AmazonClientException and cast
// it to get additional information
}
});
call.get();
}
}
El siguiente ejemplo muestra cómo usar DAX para consultar elCreateDateIndexíndice secundario global
que se crea enEjemplo: Índices secundarios globales utilizando elAWS SDK for JavaAPI de documentos.
LaDAXClientLa clase crea instancias de los objetos de cliente que se necesitan para interactuar con las
interfaces de programación de DynamoDB.
import com.amazon.dax.client.dynamodbv2.AmazonDaxClientBuilder;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMapper;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.util.EC2MetadataUtils;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
daxClientBuilder.withRegion(region).withEndpointConfiguration(daxEndpoint);
AmazonDynamoDB client = daxClientBuilder.build();
daxClientBuilder.withRegion(region).withEndpointConfiguration(daxEndpoint);
AmazonDynamoDB client = daxClientBuilder.build();
import java.util.Iterator;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMapper;
import java.util.List;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBQueryExpression;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import java.util.HashMap;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;
import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec;
import com.amazonaws.services.dynamodbv2.document.QueryOutcome;
import com.amazonaws.services.dynamodbv2.document.ItemCollection;
import com.amazonaws.services.dynamodbv2.document.Index;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
System.out.println("\n***********************************************************\n");
System.out.print("Querying index " + indexName + "...");
if (indexName == "CreateDateIndex") {
System.out.println("Issues filed on 2013-11-01");
querySpec.withKeyConditionExpression("CreateDate = :v_date and
begins_with(IssueId, :v_issue)")
.withValueMap(new ValueMap().withString(":v_date",
"2013-11-01").withString(":v_issue", "A-"));
items = index.query(querySpec);
} else {
System.out.println("\nNo valid index name provided");
return;
}
while (iterator.hasNext()) {
System.out.println(iterator.next().toJSONPretty());
}
while (iterator.hasNext()) {
CreateDate iterObj = iterator.next();
System.out.println(iterObj.getCreateDate());
System.out.println(iterObj.getIssueId());
}
}
}
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBTable;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBIndexHashKey;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBIndexRangeKey;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBHashKey;
@DynamoDBTable(tableName = "Issues")
public class CreateDate {
private String createDate;
@DynamoDBHashKey(attributeName = "IssueId")
private String issueId;
return createDate;
}
Temas
• Permisos de IAM para administrar clústeres de DAX (p. 791)
• Escalado de un clúster de DAX (p. 793)
• Personalización de los ajustes de los clústeres (p. 794)
• Configuración de los ajustes de TTL (p. 795)
• Compatibilidad con el etiquetado en DAX (p. 796)
• Integración de AWS CloudTrail (p. 797)
• Supresión de clústeres de DAX (p. 797)
La explicación siguiente se centra en el control de acceso a las API de administración de DAX. Para
obtener más información, consulteAmazon DynamoDB Acceleratoren laReferencia de la API de Amazon
DynamoDB.
Note
Para obtener información más detallada sobre la administración deAWS Identity and Access
ManagementPermisos de (IAM), consulte lo siguiente:
El alcance de las acciones de los API de administración de DAX no se puede limitar a un recurso concreto.
El componente Resource debe establecerse en "*". Esto difiere de las operaciones del API del plano
de datos de DAX, tales comoGetItem,Query, yScan. Las operaciones del plano de datos se exponen a
través del cliente DAX y estas operacionesCANa recursos específicos.
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"dax:*"
],
"Effect": "Allow",
"Resource": [
"arn:aws:dax:us-west-2:123456789012:cache/DAXCluster01"
]
}
]
}
Supongamos que el objetivo de esta política es permitir las llamadas al API de administración de DAX para
el clústerDAXCluster01— y sólo ese grupo.
Este comando producirá un error con la excepción Not Authorized, porque el alcance de la llamada a la
API DescribeClusters subyacente no puede limitarse a un clúster específico. Aunque sintácticamente
la política es válida, el comando no se ejecuta, porque el componente Resource debe establecerse en
"*". Sin embargo, si el usuario ejecuta un programa que envía llamadas del plano de datos DAX (por
ejemplo,GetItemorQuery) aDAXCluster01, esas llamadasDOque tengan éxito. Esto se debe a que
el alcance de las API de plano de datos de DAX se puede limitar a recursos concretos (en este caso,
aDAXCluster01).
Si desea escribir una única política de IAM que abarque todos los supuestos (tanto los API de
administración como los API de plano de datos de DAX), le sugerimos que incluya dos instrucciones
diferenciadas en el documento de políticas. Una de las instrucciones debe abordar las API de plano de
datos de DAX, mientras que la otra, las API de administración de DAX.
En el ejemplo de política siguiente se muestra este enfoque. Observe que el alcance de la instrucción
DAXDataAPIs se limita al recurso DAXCluster01, pero que el recurso correspondiente a
DAXManagementAPIs ha de ser "*". Las acciones que se muestran en cada instrucción son meramente
ilustrativas. Puede personalizarlas como considere oportuno para su aplicación.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DAXDataAPIs",
"Action": [
"dax:GetItem",
"dax:BatchGetItem",
"dax:Query",
"dax:Scan",
"dax:PutItem",
"dax:UpdateItem",
"dax:DeleteItem",
"dax:BatchWriteItem"
],
"Effect": "Allow",
"Resource": [
"arn:aws:dax:us-west-2:123456789012:cache/DAXCluster01"
]},
{
"Sid": "DAXManagementAPIs",
"Action": [
"dax:CreateParameterGroup",
"dax:CreateSubnetGroup",
"dax:DecreaseReplicationFactor",
"dax:DeleteCluster",
"dax:DeleteParameterGroup",
"dax:DeleteSubnetGroup",
"dax:DescribeClusters",
"dax:DescribeDefaultParameters",
"dax:DescribeEvents",
"dax:DescribeParameterGroups",
"dax:DescribeParameters",
"dax:DescribeSubnetGroups",
"dax:IncreaseReplicationFactor",
"dax:ListTags",
"dax:RebootNode",
"dax:TagResource",
"dax:UntagResource",
"dax:UpdateCluster",
"dax:UpdateParameterGroup",
"dax:UpdateSubnetGroup"
],
"Effect": "Allow",
"Resource": [
"*"
]
}
]
}
Escalado horizontal
Con el escalado horizontal, puede mejorar el rendimiento de las operaciones de lectura agregando más
réplicas de lectura al clúster. Un único clúster de DAX admite hasta 10 réplicas de lectura y puede agregar
o eliminar mientras el clúster se está ejecutando.
En los siguientes ejemplos de la AWS CLI se muestra cómo incrementar o reducir el número de nodos.
El argumento --new-replication-factor especifica el número total de nodos del clúster. Uno de los
nodos es el principal y los demás, las réplicas de lectura.
Note
El estado del clúster cambia a modifying cuando se modifica el factor de replicación. El estado
cambia a available cuando se complete la modificación.
Escalado vertical
Si tiene un gran conjunto de datos con los que trabajar, seguramente la aplicación se beneficiará si usa
los tipos de nodos mayores. Los nodos mayores pueden permitir que el clúster almacene más datos en
memoria, lo que reduce los errores de caché y mejorar el rendimiento de la aplicación en general. (Todos
los nodos de un clúster de DAX deben ser del mismo tipo).
Si el clúster de DAX tiene una alta tasa de operaciones de escritura o errores de caché, la aplicación
también podría beneficiarse de utilizar tipos de nodos mayores. Las operaciones de escritura y los errores
de caché consumen recursos en el nodo principal del clúster. Por lo tanto, el uso de tipos de nodos
mayores podría aumentar el rendimiento del nodo principal y, por lo tanto, permitir un mayor rendimiento
para estos tipos de operaciones.
No puede modificar los tipos de los nodos en un clúster de DAX en ejecución. En lugar de ello, deberá
crear un nuevo clúster con el tipo de nodo deseado. Para ver una lista de los tipos de nodos admitidos,
consulte Nodes (p. 728).
Puede crear un clúster de DAX nuevo mediante laAWS Management Console,AWS CloudFormation,
elAWS CLI, o elAWSSDK. (Para la AWS CLI, use el parámetro --node-type para especificar el tipo de
nodo).
Para los nuevos clústeres, puede personalizar los ajustes en el momento de su creación. Para hacerlo en
la AWS Management Console, desactive Use default settings (Usar la configuración predeterminada) para
modificar los siguientes ajustes:
• Redes y seguridad: permite ejecutar nodos de clústeres de DAX individuales en distintas zonas de
disponibilidad de laAWSRegión . Si elige No Preference (Sin preferencias), los nodos se distribuirán
automáticamente entre las zonas de disponibilidad.
• Parameter Group: conjunto de parámetros con nombre que se aplican a todos los nodos del clúster.
Puede utilizar un grupo de parámetros para especificar el comportamiento de la caché con respecto al
TTL. Puede cambiar el valor de cualquier parámetro dado dentro de un grupo de parámetros (excepto el
grupo de parámetros predeterminado default.dax.1.0) en cualquier momento.
• Maintenance Window (Periodo de mantenimiento): periodo semanal durante el cual se aplicarán los
parches y las actualizaciones de software a los nodos del clúster. Puede elegir el día y la hora de
comienzo, así como la duración del tiempo de mantenimiento. Si elige No Preference (Sin preferencias),
el periodo de mantenimiento se selecciona al azar dentro de un bloque de 8 horas por región. Para
obtener más información, consulte Maintenance Window (Período de mantenimiento) (p. 731) .
Note
Parameter Group (Grupo de parámetros) y Maintenance Window (Ventana de mantenimiento)
también se pueden cambiar en cualquier momento en un clúster en ejecución.
Cuando se produce un evento de mantenimiento, DAX puede notificarle mediante Amazon Simple
Notification Service (Amazon SNS). Para configurar las notificaciones, elija una opción en el selector Topic
for SNS notification (Tema para notificación de SNS). Puede crear un tema de Amazon SNS nuevo o elegir
uno disponible.
Para obtener más información sobre la configuración y la suscripción a un tema de Amazon SNS,
consulteIntroducción a Amazon SNSen laGuía del desarrollador de Amazon Simple Notification Service.
Para obtener más información, consulte Caché de elementos (p. 727) y Caché de consultas (p. 727).
El TTL predeterminado de cada una de estas cachés es de 5 minutos. Si desea utilizar otros ajustes de
TTL, puede lanzar un clúster de DAX mediante un grupo de parámetros personalizados. Para hacer esto
en la consola, elija DAX | Parameter groups (DAX | Grupos de parámetros) en el panel de navegación.
También puede llevar a cabo estas tareas utilizando la AWS CLI. En el siguiente ejemplo se muestra cómo
lanzar un nuevo clúster de DAX con un grupo de parámetros personalizados. En este ejemplo, el TTL de la
caché de elementos se establece en 10 minutos y el de la caché de consultas, en 3 minutos.
A partir de ahora, puede lanzar un nuevo clúster de DAX con este grupo de parámetros.
Note
No se puede modificar un grupo de parámetros que se encuentre en uso en una instancia de DAX
en ejecución.
Para obtener más información, consulte Agregar etiquetas a los recursos (p. 394) .
Cuando la configuración sea la que desea, elija Apply Changes (Aplicar cambios).
--tag-keys ClusterUsage
Puede eliminar un clúster de DAX mediante la consola o laAWS CLI. A continuación se muestra un
ejemplo.
Monitorización de DAX
La monitorización es una parte importante del mantenimiento de la fiabilidad, la disponibilidad y el
rendimiento de Amazon DynamoDB Accelerator (DAX) y suAWSSoluciones de. Debe recopilar datos de
monitoreo de todas las partes de suAWSPara que pueda depurar con mayor facilidad un error que se
produce en distintas partes del código, en caso de que ocurra.
Antes de comenzar a monitorear DAX, debe crear un plan de monitorización que incluya respuestas a las
siguientes preguntas:
El siguiente paso consiste en establecer un punto de referencia del desempeño de DAX normal en
su entorno. Para ello se mide el desempeño en distintos momentos y bajo distintas condiciones de
carga. Cuando monitorice DAX, debe tener en cuenta el almacenamiento de los datos históricos de
monitorización. Estos datos almacenados le ofrecen un punto de referencia con el que comparar los datos
de rendimiento actuales, identificar los patrones de rendimiento normales y las anomalías de rendimiento,
así como desarrollar métodos de resolución de problemas.
Para establecer una línea de referencia, como mínimo, debe monitorear los siguientes elementos durante
las pruebas de carga y en producción:
• La utilización de CPU y las solicitudes de limitación controlada, de modo que pueda determinar si podría
necesitar utilizar un tipo de nodo mayor en el clúster. La utilización de la CPU del clúster está disponible
a través delCPUUtilization Métrica CloudWatch (p. 800).
• La latencia de operación (medida en el lado del cliente) debe mantenerse de forma coherente dentro de
los requisitos de latencia de la aplicación.
Aparte de los elementos anteriores, como mínimo, debe monitorear los siguientes elementos adicionales
en producción:
• El tamaño de la base de datos estimado y el tamaño desalojado, para que pueda determinar si el tipo de
nodo del clúster tiene memoria suficiente para contener su conjunto de trabajo.
• Conexiones cliente, para que pueda monitorizar cualquier pico insólito en las conexiones con el clúster.
Temas
• Herramientas de monitorización (p. 798)
• Monitorización con Amazon CloudWatch (p. 799)
• Registro de operaciones de DAX con DAXAWS CloudTrail (p. 813)
Herramientas de monitorización
AWSproporciona herramientas que puede utilizar para monitorear Amazon DynamoDB Accelerator
(DAX). Puede configurar algunas de estas herramientas para que realicen la labor de monitorización
automáticamente; sin embargo, otras requieren intervención manual. Le recomendamos que automatice
las tareas de monitorización en la medida de lo posible.
Temas
• Herramientas de monitorización automatizadas (p. 798)
• Herramientas de monitorización manual (p. 799)
• Alarmas de Amazon CloudWatch: vigile una métrica durante un periodo de tiempo especificado y realice
una o varias acciones según el valor que tenga la métrica en comparación con un determinado umbral
durante una serie de periodos de tiempo. La acción es una notificación que se envía a un tema de
Amazon Simple Notification Service (Amazon SNS) o a una política de Amazon EC2 Auto Scaling. Las
alarmas de CloudWatch no invocan acciones tan solo por tener un estado determinado; es necesario
que el estado haya cambiado y se mantenga durante un número específico de periodos. Para obtener
más información, consulte Monitorización con Amazon CloudWatch (p. 940).
• Amazon CloudWatch LogsMonitorizar, almacenar y obtener acceso a los archivos de registro deAWS
CloudTrailu otras fuentes de. Para obtener más información, consulte Monitoreo de archivos de registro
en la guía del usuario de Amazon CloudWatch.
• Amazon CloudWatch Events: seleccione los eventos y diríjalos hacia uno o varios flujos o funciones
de destino para realizar cambios, capturar información de estado y aplicar medidas correctivas. Para
obtener más información, consulteQué son los Amazon CloudWatch Eventsen laGuía del usuario de
Amazon CloudWatch.
• AWS CloudTrailMonitoreo de registros de: compartir archivos de registro entre cuentas, monitorear
archivos de registro de CloudTrail en tiempo real mediante su envío a CloudWatch Logs, escribir
aplicaciones de procesamiento de registros en Java y validar que sus archivos de registro no hayan
cambiado después de que CloudTrail los entregue. Para obtener más información, consulteUso de
archivos de registro de CloudTrailen laAWS CloudTrailGuía del usuario.
Temas
• ¿Cómo utilizo las métricas de DAX? (p. 799)
• Visualización de dimensiones y métricas de DAX DAX (p. 800)
• Crear alarmas de CloudWatch para monitorear DAX (p. 811)
Monitorizar la tasa de aciertos de Utilice CloudWatch Metric Math para definir una métrica de tasa de
caché aciertos de la caché con expresiones matemáticas.
Las métricas se agrupan en primer lugar por el espacio de nombres de servicio y, a continuación, por las
diversas combinaciones de dimensiones dentro de cada espacio de nombres.
Métricas de DAX
Las siguientes métricas están disponibles en DAX. DAX solo envía métricas a CloudWatch cuando tienen
un valor distinto de cero.
Note
• CPUUtilization
• CacheMemoryUtilization
• NetworkBytesIn
• NetworkBytesOut
• NetworkPacketsIn
• NetworkPacketsOut
• GetItemRequestCount
• BatchGetItemRequestCount
• BatchWriteItemRequestCount
• DeleteItemRequestCount
• PutItemRequestCount
• UpdateItemRequestCount
• TransactWriteItemsCount
• TransactGetItemsCount
• ItemCacheHits
• ItemCacheMisses
• QueryCacheHits
• QueryCacheMisses
• ScanCacheHits
• ScanCacheMisses
• TotalRequestCount
• ErrorRequestCount
• FaultRequestCount
• FailedRequestCount
• QueryRequestCount
• ScanRequestCount
• ClientConnections
• EstimatedDbSize
• EvictedSize
• CPUCreditUsage
• CPUCreditBalance
• CPUSurplusCreditBalance
• CPUSurplusCreditsCharged
No todas las estadísticas, comoAverageorSum, son aplicables para todas las métricas. Sin
embargo, todos estos valores están disponibles a través de la consola DAX o mediante la consola de
CloudWatch,AWS CLI, o bienAWSSDK para todas las métricas de. En la tabla siguiente, cada métrica
tiene una lista de estadísticas válidas aplicables a esa métrica.
Métrica Descripción
Unidades:Percent
Estadísticas válidas:
• Minimum
• Maximum
• Average
Métrica Descripción
ser desalojados antes de que la utilización de la memoria
llegue al 100% (consulteEvictedSizeMétricas de).
SiCacheMemoryUtilizationalcanza el 100% en cualquier nodo,
las solicitudes de escritura se limitarán y debe considerar cambiar a
un clúster con un tipo de nodo más grande.
Unidades:Percent
Estadísticas válidas:
• Minimum
• Maximum
• Average
Unidades:Bytes
Estadísticas válidas:
• Minimum
• Maximum
• Average
Unidades:Bytes
Estadísticas válidas:
• Minimum
• Maximum
• Average
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
Métrica Descripción
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Métrica Descripción
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Métrica Descripción
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Métrica Descripción
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Métrica Descripción
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Métrica Descripción
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Bytes
Estadísticas válidas:
• Minimum
• Maximum
• Average
Métrica Descripción
Unidades:Bytes
Estadísticas válidas:
• Minimum
• Maximum
• Average
• Sum
Unidades:Credits (vCPU-minutes)
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Métrica Descripción
Unidades:Credits (vCPU-minutes)
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Credits (vCPU-minutes)
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Métrica Descripción
Unidades:Credits (vCPU-minutes)
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Note
LaCPUCreditUsage,CPUCreditBalance,CPUSurplusCreditBalance,
yCPUSurplusCreditsChargedsolo están disponibles para nodos T3.
Las métricas de DAX se califican según los valores de la combinación de cuenta, ID de clúster o ID de
clúster e ID de nodo. Puede usar la consola de CloudWatch para recuperar datos de DAX junto con
cualquier dimensión de la tabla siguiente.
Dimensión Espacio
Descripción
de
nombres
de
métricas
de
CloudWatch
durante el periodo especificado. Realiza una o varias acciones según el valor de la métrica con respecto a
un umbral dado durante varios períodos de tiempo. La acción es una notificación que se envía a un tema
de Amazon SNS o a una política de Auto Scaling. Las alarmas invocan acciones únicamente para los
cambios de estado prolongados. Las alarmas de CloudWatch no invocan acciones simplemente porque
se encuentren en un estado determinado. El estado debe haber cambiado y debe mantenerse durante el
número de periodos especificado.
Para obtener más información, consulteConfigurar Amazon Simple Notificationen laGuía del usuario
de Amazon CloudWatch.
2. Cree la alarma.
3. Pruebe la alarma.
Note
Puede aumentar o reducir el umbral de manera que tenga sentido para su organización. También
puede usar CloudWatch Metric Math para definir una métrica de porcentaje de errores de la caché
y establecer una alarma que se active con esa métrica.
Para obtener más información, consulteConfigurar Amazon Simple Notificationen laGuía del usuario
de Amazon CloudWatch.
2. Cree la alarma.
--metric-name FaultRequestCount \
--dimensions Name=ClusterID,Value=myCluster \
--statistic Sum \
--threshold 0 \
--comparison-operator GreaterThanThreshold \
--period 60 \
--unit Count \
--evaluation-periods 1 \
--alarm-actions arn:aws:sns:us-east-1:123456789012:notify-on-system-errors
3. Pruebe la alarma.
Para obtener más información sobre DAX y CloudTrail, consulte la sección de DynamoDB Accelerator
(DAX) enRegistro de operaciones de DynamoDB utilizandoAWS CloudTrail (p. 964).
El rendimiento básico y la capacidad de ampliarse por encima de él se rigen por créditos de CPU. Las
instancias de rendimiento de fragmentación acumulan créditos de CPU de forma continua, a una velocidad
determinada por el tamaño de la instancia, cuando la carga de trabajo está por debajo del umbral de
línea base. Estos créditos se pueden consumir cuando aumenta la carga de trabajo. Un crédito de CPU
proporciona el desempeño de un núcleo de CPU completo durante un minuto.
Muchas cargas de trabajo no necesitan niveles altos de CPU consistentemente, pero se benefician
significativamente de tener acceso completo a CPU muy rápidas cuando las necesitan. Las instancias
de rendimiento en ráfagas están diseñadas específicamente para estos casos de uso. Si necesita un
alto rendimiento de CPU constante para su base de datos, le recomendamos que utilice instancias de
rendimiento fijo.
gradualmente hasta el nivel básico. Para obtener más información sobre el modo estándar, consulteModo
estándar para las instancias de rendimiento ampliableEn la Guía del usuario de Amazon EC2 para
instancias de Linux.
Las instancias DAX T3 pueden mantener un alto rendimiento de CPU durante el tiempo que lo requiera
una carga de trabajo. Para la mayoría de las cargas de trabajo de uso general, las instancias T3
proporcionarán un rendimiento amplio sin cargos adicionales. El precio por hora de la instancia T3 cubre
automáticamente todos los picos de uso provisionales cuando la utilización media de la CPU de una
instancia T3 está a la par o menos que la base de referencia en una ventana de 24 horas.
Mientras que las instancias DAX T2 están restringidas al rendimiento de línea base una vez que el saldo
de crédito de la CPU se reduce a cero, las instancias de DAX T3 pueden reventar la línea base incluso
cuando su saldo de crédito de CPU es cero. Para la gran mayoría de las cargas de trabajo, donde la
utilización media de la CPU de una CPU está a la par o por debajo del rendimiento básico, el precio por
hora det3.smallcubre todas las ráfagas de CPU. Si la instancia se ejecuta a un promedio de utilización
de CPU del 25% (5% por encima de la línea base) durante un período de 24 horas después de que su
saldo de crédito de CPU se haya extraído a cero, se le cobrará 11,52 centavos adicionales (9,6 cents/
vCPU por hora × 1 vCPU × 5% × 24 horas). ConsultePrecios de Amazon DynamoDBPara obtener más
información sobre precios.
Recomendamos encarecidamente que comprenda los dos modelos de seguridadPara poder implementar
las medidas de seguridad adecuadas en las aplicaciones que utilizan DAX.
En esta sección, se describen los mecanismos de control de acceso proporcionados por DAX y se facilitan
ejemplos de políticas de IAM que puede adaptar a sus necesidades.
Con DynamoDB, puede crear políticas de IAM que limiten las acciones que el usuario puede llevar a cabo
con los recursos de DynamoDB individuales. Por ejemplo, puede crear un rol de usuario que únicamente
permita al usuario realizar acciones de solo lectura en una tabla de DynamoDB determinada. (Para
obtener más información, consulte the section called “Identity and Access Management” (p. 894).) En
comparación, el modelo de seguridad de DAX se centra en la seguridad de los clústeres y en la capacidad
de estos para llevar a cabo las acciones del API de DynamoDB en nombre de usted.
Warning
Si está utilizando los roles y las políticas de IAM para restringir el acceso a los datos de las tablas
de DynamoDB, el uso de DAX puedesubvertiresas políticas. Por ejemplo, un usuario podría tener
acceso a una tabla de DynamoDB mediante DAX aunque no tuviese acceso explícito a ella si el
acceso se llevase a cabo directamente a través de DAX. Para obtener más información, consulte
the section called “Identity and Access Management” (p. 894).
DAX no aplica la separación de nivel de usuario de los datos en DynamoDB. En lugar de ello, los
usuarios heredan los permisos de la política de IAM del clúster de DAX cuando obtienen acceso
a ese clúster. Por lo tanto, al obtener acceso a las tablas de DynamoDB a través de DAX, los
únicos controles que surten efecto son los permisos de la política de IAM del clúster de DAX. No
se reconoce ningún otro permiso.
Si requiere aislamiento, recomendamos crear clústeres de DAX adicionales y que defina en
consecuencia el alcance la política de IAM para cada clúster. Por ejemplo, podría crear varios
clústeres de DAX y permitir que cada uno de ellos obtenga acceso a una sola tabla.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "dax.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
Esta relación de confianza permite que un clúster DAX asumaDaxServiceRoley realice llamadas a la API
de DynamoDB en su nombre.
Las acciones del API de DynamoDB permitidas se describen en un documento de política de IAM que se
adjunta aDaxServiceRole. A continuación se muestra el ejemplo de documento de política.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DaxAccessPolicy",
"Effect": "Allow",
"Action": [
"dynamodb:DescribeTable",
"dynamodb:PutItem",
"dynamodb:GetItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:BatchGetItem",
"dynamodb:BatchWriteItem",
"dynamodb:ConditionCheckItem"
],
"Resource": [
"arn:aws:dynamodb:us-west-2:123456789012:table/Books"
]
}
]
}
Esta política permite a DAX llevar a cabo las acciones de la API de DynamoDB necesarias en una tabla
de DynamoDB. Ladynamodb:DescribeTablePara que DAX mantenga metadatos sobre la tabla y las
demás son acciones de lectura y escritura realizadas en los elementos de la tabla. La tabla, denominada
Books, está en la región us-west-2 y es propiedad del ID de cuenta de AWS 123456789012.
Por ejemplo, supongamos que desea conceder acceso aDaxCluster01a un usuario de IAM llamado Alice.
En primer lugar, crearía una política de IAM (AliceAccessPolicy) que define los clústeres de DAX y las
acciones de la API de DAX a los que el destinatario puede obtener acceso. Posteriormente, le concedería
acceso adjuntando esta política a la usuaria Alice.
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"dax:*"
],
"Effect": "Allow",
"Resource": [
"arn:aws:dax:us-west-2:123456789012:cache/DAXCluster01"
]
}
]
}
El documento de política permite obtener acceso al clúster de DAX, pero no concede ningún permiso de
DynamoDB. Los permisos de DynamoDB los concede el rol de servicio de DAX.
Para la usuaria Alice, primero habría que crear AliceAccessPolicy con el documento de política que se
muestra más arriba. Posteriormente, se adjuntaría la política a Alice.
Note
En lugar de adjuntar la política a un usuario de IAM, podría adjuntársela a un rol de IAM. De ese
modo, todos los usuarios que asuman ese rol tendrían los permisos definidos en la política.
La política de usuario, junto con el rol de servicio de DAX, determinan los recursos de DynamoDB y las
acciones del API a los que el destinatario puede obtener acceso a través de DAX.
Es posible permitir el acceso directo a una tabla de DynamoDB, pero impedir el acceso indirecto a través
de un clúster de DAX. Para acceder directamente a DynamoDB, los permisos deBobUserRoleestán
determinados porBobAccessPolicy(que se adjunta a la función).
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DynamoDBAccessStmt",
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:BatchGetItem",
"dynamodb:Query",
"dynamodb:Scan"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/Books"
}
]
}
DAX no aparece en esta política, por lo que el acceso a través de DAX se denegará.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DynamoDBAccessStmt",
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:BatchGetItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:BatchWriteItem",
"dynamodb:ConditionCheckItem"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/Books"
}
]
}
Una vez más, DAX no aparece en esta política, por lo que el acceso a través de DAX se denegará.
Para permitir el acceso a un clúster de DAX, debe incluir las acciones específicas de DAX en una política
de IAM.
Las siguientes acciones específicas de DAX se corresponden con sus homólogas de nombres parecidos
del API de DynamoDB:
• dax:GetItem
• dax:BatchGetItem
• dax:Query
• dax:Scan
• dax:PutItem
• dax:UpdateItem
• dax:DeleteItem
• dax:BatchWriteItem
• dax:ConditionCheckItem
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DAXAccessStmt",
"Effect": "Allow",
"Action": [
"dax:GetItem",
"dax:BatchGetItem",
"dax:Query",
"dax:Scan"
],
"Resource": "arn:aws:dax:us-west-2:123456789012:cache/DAXCluster01"
},
{
"Sid": "DynamoDBAccessStmt",
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:BatchGetItem",
"dynamodb:Query",
"dynamodb:Scan"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/Books"
}
]
}
La política tiene una instrucción para el acceso DAX (DAXAccessStmt) y otra instrucción para
DynamoDBAccess (DynamoDBAccessStmt). Estas instrucciones permitirían que Bob envíe solicitudes
GetItem, BatchGetItem, Query y Scan a DAXCluster01.
Sin embargo, el rol de servicio de para elDAXCluster01también requeriría acceso de solo lectura a
laBooksen DynamoDB. La siguiente política de IAM, asociada aDAXServiceRole, permitiría cumplir este
requisito.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DynamoDBAccessStmt",
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:BatchGetItem",
"dynamodb:Query",
"dynamodb:Scan"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/Books"
}
]
}
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DAXAccessStmt",
"Effect": "Allow",
"Action": [
"dax:GetItem",
"dax:BatchGetItem",
"dax:Query",
"dax:Scan"
],
"Resource": "arn:aws:dax:us-west-2:123456789012:cache/DAXCluster01"
},
{
"Sid": "DynamoDBAccessStmt",
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:BatchGetItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:BatchWriteItem",
"dynamodb:DescribeTable",
"dynamodb:ConditionCheckItem"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/Books"
}
]
}
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DynamoDBAccessStmt",
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:BatchGetItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:DescribeTable"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/Books"
}
]
}
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DAXAccessStmt",
"Effect": "Allow",
"Action": [
"dax:GetItem",
"dax:BatchGetItem",
"dax:Query",
"dax:Scan",
"dax:PutItem",
"dax:UpdateItem",
"dax:DeleteItem",
"dax:BatchWriteItem",
"dax:ConditionCheckItem"
],
"Resource": "arn:aws:dax:us-west-2:123456789012:cache/DAXCluster01"
},
{
"Sid": "DynamoDBAccessStmt",
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:BatchGetItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:BatchWriteItem",
"dynamodb:DescribeTable",
"dynamodb:ConditionCheckItem"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/Books"
}
]
}
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DynamoDBAccessStmt",
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:BatchGetItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:BatchWriteItem",
"dynamodb:DescribeTable"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/Books"
}
]
}
Si está utilizando los roles y las políticas de IAM para restringir el acceso a los datos y las tablas de
DynamoDB, el uso de DAX puede modificar las políticas. En la política siguiente, Bob tiene acceso a
una tabla de DynamoDB mediante DAX, aunque no tiene acceso explícito directo a esa misma tabla en
DynamoDB.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DAXAccessStmt",
"Effect": "Allow",
"Action": [
"dax:GetItem",
"dax:BatchGetItem",
"dax:Query",
"dax:Scan",
"dax:PutItem",
"dax:UpdateItem",
"dax:DeleteItem",
"dax:BatchWriteItem",
"dax:ConditionCheckItem"
],
"Resource": "arn:aws:dax:us-west-2:123456789012:cache/DAXCluster01"
}
]
}
En esta política de acceso, no hay permisos para obtener acceso a DynamoDB directamente.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DynamoDBAccessStmt",
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:BatchGetItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:BatchWriteItem",
"dynamodb:DescribeTable",
"dynamodb:ConditionCheckItem"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/Books"
}
]
}
Como se muestra en este ejemplo, cuando se configura el control de acceso para la política de acceso
de usuario y la política de acceso de clúster de DAX, es preciso comprender perfectamente todos los
permisos de acceso que se conceden, con el fin de asegurarse de cumplir el principio de mínimos
privilegios. Además, debe asegurarse de que, al conceder a un usuario acceso a un clúster de DAX, no se
modificen las políticas de control de acceso establecidas previamente.
Con el cifrado en reposo, los datos mantenidos por DAX en disco se cifran utilizando el estándar de cifrado
avanzado de 256 bits, también conocido como cifrado AES-256. DAX escribe datos en disco como parte
de la propagación de cambios desde el nodo principal a las réplicas de lectura.
El cifrado DAX en reposo se integra automáticamente conAWS Key Management Service(AWS KMS) para
administrar la única clave de servicio predeterminada que se utiliza para cifrar los clústeres. Si no existe
una clave de servicio predeterminada al crear el clúster de DAX cifrado,AWS KMScrea automáticamente
un nuevoAWSclave administrada para usted. Esta clave se utilizará con los clústeres cifrados que se
creen en el futuro. AWS KMS combina hardware y software seguros de alta disponibilidad para ofrecer un
sistema de administración de claves adaptado a la nube.
Una vez cifrados los datos, DAX se encarga del descifrado de los datos de forma transparente, con un
impacto mínimo en el desempeño. No es necesario modificar las aplicaciones para utilizar el cifrado.
Note
DAX no llamaAWS KMSpara cada operación DAX. DAX sólo utiliza la clave durante el
lanzamiento del clúster. Incluso si se revoca el acceso, DAX puede seguir obteniendo acceso a
los datos hasta que se cierra el clúster. Las claves de AWS KMS especificadas por el cliente no
se admiten.
El cifrado DAX en reposo de está disponible para los siguientes tipos de nodo de clúster.
dax.r4.xlarge
dax.r4.2xlarge
dax.r4.4xlarge
dax.r4.8xlarge
dax.r4.16xlarge
dax.r5.large
dax.r5.xlarge
dax.r5.2xlarge
dax.r5.4xlarge
dax.r5.8xlarge
dax.r5.12xlarge
dax.r5.16xlarge
dax.r5.24xlarge
dax.t2.medium
Important
No puede habilitar o deshabilitar el cifrado en reposo después de haber creado un clúster. Debe volver a
crear el clúster para habilitar el cifrado en reposo si no se habilitó durante la creación.
El cifrado DAX en reposo se ofrece sin costo adicional (AWS KMSse aplican cargos por uso de claves de
cifrado). Para obtener información sobre precios, consultePrecios de Amazon DynamoDB.
6. Después de elegir el rol de IAM, grupo de subred, grupos de seguridad y configuración de clúster, elija
Launch cluster (Lanzar clúster).
Para confirmar que el clúster está cifrado, compruebe los datos del clúster en el panel Clusters (Clústeres).
El cifrado debe estar ENABLED (HABILITADO).
grupos de seguridad, segmentación de subredes con ACL de red y seguimiento de flujo de VPC. El cifrado
DAX en tránsito añade a este nivel básico de confidencialidad, lo que garantiza que todas las solicitudes y
respuestas entre la aplicación y el clúster estén cifradas por seguridad de nivel de transporte (TLS), y las
conexiones al clúster se pueden autenticar mediante la verificación de un certificado x509 del clúster. Los
datos escritos en disco por DAX también se pueden cifrar si eligeCifrado en reposo (p. 825)Al crear su
clúster de DAX.
Usar cifrado en tránsito con DAX es fácil. Simplemente seleccione esta opción al crear un nuevo clúster y
utilice una versión reciente de cualquiera de losClientes de DAX (p. 747)En su aplicación. Los clústeres
que usan cifrado en tránsito no admiten tráfico no cifrado, por lo que no hay posibilidad de configurar
mal la aplicación y eludir el cifrado. El cliente DAX utilizará el certificado x509 del clúster para autenticar
la identidad del clúster cuando establezca conexiones, garantizando que las solicitudes DAX vayan
donde se desee. Todos los métodos de creación de clústeres DAX admiten el cifrado en tránsito: elAWS
Management Console,AWS CLI, todos los SDK, yAWS CloudFormation.
El cifrado en tránsito no se puede habilitar en un clúster DAX existente. Para utilizar el cifrado en tránsito
en una aplicación DAX existente, cree un nuevo clúster con el cifrado en tránsito habilitado, mueva el
tráfico de la aplicación a él y, a continuación, elimine el clúster anterior.
Un rol vinculado a un servicio simplifica la configuración de DAX porque ya no tendrá que añadir
manualmente los permisos necesarios. DAX define los permisos de sus roles vinculados a servicios y, a
menos que se defina lo contrario, solo DAX puede asumir sus roles. Los permisos definidos incluyen la
política de confianza y la política de permisos. Dicha política de permisos no se puede asociar a ninguna
otra entidad de IAM.
Las funciones se pueden eliminar únicamente después de eliminar primero sus recursos relacionados. De
esta forma, se protegen los recursos de DAX, ya que se evita que se puedan eliminar accidentalmente
permisos de acceso a los recursos.
Para obtener información sobre otros servicios que admiten los roles vinculados a servicios,
consulteAWSServicios que funcionan con IAMen laGuía del usuario de IAM. Busque los servicios para los
que se indique Yes (Sí) en la columna Service-linked roles (Roles vinculados a servicios). Elija el vínculo
Yes (Sí) para ver la documentación acerca del rol vinculado a un servicio en cuestión.
Temas
• Permisos de roles vinculados a servicios para DAX (p. 827)
• Creación de un rol vinculado a un servicio para DAX (p. 828)
• Edición de un rol vinculado a un servicio para DAX (p. 829)
• Eliminación de un rol vinculado a un servicio para DAX (p. 829)
Important
La función vinculada al servicio AWSServiceRoleForDAX confía en los siguientes servicios para asumir la
función:
• dax.amazonaws.com
La política de permisos del rol permite que DAX realice las siguientes acciones en los recursos
especificados:
• Acciones en ec2:
• AuthorizeSecurityGroupIngress
• CreateNetworkInterface
• CreateSecurityGroup
• DeleteNetworkInterface
• DeleteSecurityGroup
• DescribeAvailabilityZones
• DescribeNetworkInterfaces
• DescribeSecurityGroups
• DescribeSubnets
• DescribeVpcs
• ModifyNetworkInterfaceAttribute
• RevokeSecurityGroupIngress
Debe configurar permisos para permitir a una entidad de IAM (como un usuario, grupo o función) crear,
editar o eliminar la descripción de una función vinculada a un servicio. Para obtener más información,
consulte Permisos de roles vinculados a servicios en la Guía del usuario de IAM..
Para permitir a una entidad de IAM crear roles vinculados a servicios AWSServiceRoleForDAX
Añada la siguiente instrucción de política a los permisos para esa entidad de IAM.
{
"Effect": "Allow",
"Action": [
"iam:CreateServiceLinkedRole"
],
"Resource": "*",
"Condition": {"StringLike": {"iam:AWSServiceName": "dax.amazonaws.com"}}
}
Important
Si utilizaba el servicio DAX antes del 28 de febrero de 2018, fecha en que comenzó a admitir los
roles vinculados a servicios, DAX creó elAWSServiceRoleForDAXEn su cuenta. Para obtener
más información, consulteUn nuevo rol ha aparecido enAWSCuentaen laGuía del usuario de IAM.
Si elimina este rol vinculado a un servicio y necesita crearlo de nuevo, puede utilizar el mismo proceso
para volver a crear el rol en su cuenta. Al crear una instancia o un clúster, DAX vuelve a crear el rol
vinculado al servicio automáticamente.
Para comprobar si el rol vinculado al servicio tiene una sesión activa en la consola de IAM
Si desea eliminar la funciónAWSServiceRoleForDAX, primero debe eliminar todos los clústeres de DAX.
Use la consola de IAM, la CLI de IAM o la API de IAM para eliminar elAWSServiceRoleForDAXRol
vinculado al servicio. Para obtener más información, consulte Eliminación de un rol vinculado a servicios en
la Guía del usuario de IAM.
Temas
• Configurar IAM (p. 830)
• Configurar una VPC (p. 832)
• Modificar el cliente de DAX para permitir el acceso de entre cuentas (p. 834)
Configurar IAM
1. Cree un archivo de texto denominadoAssumeDaxRoleTrust.jsonCon el contenido siguiente, que
permite a Amazon EC2 actuar en su nombre.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "ec2.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
2. En la cuenta B, cree un rol que Amazon EC2 pueda utilizar al lanzar instancias.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::accountA:role/DaxCrossAccountRole"
}
]
}
5. Cree un perfil de instancia para permitir que las instancias utilicen el rol.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::accountB:role/AssumeDaxRole"
},
"Action": "sts:AssumeRole"
}
]
}
--role-name DaxCrossAccountRole \
--assume-role-policy-document file://DaxCrossAccountRoleTrust.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dax:GetItem",
"dax:BatchGetItem",
"dax:Query",
"dax:Scan",
"dax:PutItem",
"dax:UpdateItem",
"dax:DeleteItem",
"dax:BatchWriteItem",
"dax:ConditionCheckItem"
],
"Resource": "dax-cluster-arn"
}
]
}
4. Desde la cuenta B, cree una VPC utilizando un CIDR diferente y no superpuesto que el encontrado en
el paso anterior. A continuación, cree al menos una subred. Puede utilizar el asistente de creación de
VPC en la AWS Management Console o en la AWS CLI.
5. Desde la cuenta B, solicite una interconexión a la VPC de la cuenta A como se describe en Creación y
aceptación de interconexiones de VPC. Desde la cuenta A, acepte la conexión.
6. En la cuenta B, busque la nueva tabla de ruteo de la VPC. Reemplace vpc-id por el ID de la VPC
que creó en la cuenta B.
7. Agregue una ruta para enviar tráfico destinado al CIDR de la cuenta A a la interconexión de VPC.
Recuerde reemplazar cada marcador de posición de entrada de usuario por los valores
correctos para sus cuentas.
8. En la cuenta A, busque la tabla de ruteo del clúster de DAX mediante elvpc-c-c-c-cque encontraste
anteriormente.
9. Desde la cuenta A, agregue una ruta para enviar tráfico destinado al CIDR de la cuenta B a la
interconexión de VPC. Reemplace cada marcador de posición de entrada de usuario por
los valores correctos para sus cuentas.
10. Desde la cuenta B, lance una instancia EC2 en la VPC que creó anteriormente. Dele el
AssumeDaxInstanceProfile. Puede utilizar el asistente de inicio en la AWS Management Console
o en la AWS CLI. Tome nota del grupo de seguridad de la instancia.
11. En la cuenta A, busque el grupo de seguridad utilizado por el clúster de DAX. Recuerde
reemplazarcluster-nameCon el nombre del clúster de DAX.
12. Actualice el grupo de seguridad del clúster de DAX para permitir el tráfico entrante desde el grupo
de seguridad de la instancia EC2 que creó en la cuenta B. Recuerde sustituir elMarcadores de
posición de entradaCon los valores correctos para sus cuentas.
En este punto, una aplicación en la instancia EC2 de la cuenta B puede utilizar el perfil de instancia para
asumir elarn:aws:iam::accountA-id:role/DaxCrossAccountRoley utilice el clúster de DAX.
Las credenciales de AWS Security Token Service ( AWS STS ) son credenciales temporales.
Algunos clientes manejan la actualización automáticamente, mientras que otros requieren lógica
adicional para actualizar las credenciales. Le recomendamos que siga las instrucciones de la
documentación correspondiente.
Java
Esta sección le ayuda a modificar el código de cliente de DAX existente para permitir el acceso de
DAX entre cuentas. Si aún no tiene código de cliente de DAX, puede encontrar ejemplos de código de
trabajo en elJava y DAX (p. 753)"Hello, World!"
import com.amazonaws.auth.STSAssumeRoleSessionCredentialsProvider;
import com.amazonaws.services.securitytoken.AWSSecurityTokenService;
import com.amazonaws.services.securitytoken.AWSSecurityTokenServiceClientBuilder;
2. Obtenga un proveedor de credenciales de AWS STS y cree un objeto cliente DAX. Recuerde
reemplazar cada marcador de posición de entrada de usuario por los valores
correctos para sus cuentas.
AWSSecurityTokenService awsSecurityTokenService =
AWSSecurityTokenServiceClientBuilder
.standard()
.withRegion(region)
.build();
.NET
Esta sección le ayuda a modificar el código de cliente de DAX existente para permitir el acceso de
DAX entre cuentas. Si aún no tiene código de cliente de DAX, puede encontrar ejemplos de código de
trabajo en el.NET y DAX (p. 762)"Hello, World!"
using Amazon.SecurityToken;
using Amazon.SecurityToken.Model;
};
Go
Esta sección le ayuda a modificar el código de cliente de DAX existente para permitir el acceso de
DAX entre cuentas. Si aún no tiene código de cliente de DAX, puede encontrarejemplos de código de
trabajo en GitHub.
import (
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/sts"
"github.com/aws/aws-sdk-go/aws/credentials/stscreds"
)
stsClient := sts.New(sess)
arp := &stscreds.AssumeRoleProvider{
Duration: 900 * time.Second,
ExpiryWindow: 10 * time.Second,
RoleARN: "arn:aws:iam::accountA:role/role_name",
Client: stsClient,
RoleSessionName: "session_name",
}cfg := dax.DefaultConfig()
cfg.HostPorts = []string{dax_endpoint}
cfg.Region = region
cfg.Credentials = credentials.NewCredentials(arp)
daxClient := dax.New(cfg)
Python
Esta sección le ayuda a modificar el código de cliente de DAX existente para permitir el acceso de
DAX entre cuentas. Si aún no tiene código de cliente de DAX, puede encontrar ejemplos de código de
trabajo en elPython y DAX (p. 779)"Hello, World!"
1. Importar boto3.
import boto3
sts = boto3.client('sts')
stsresponse =
sts.assume_role(RoleArn='arn:aws:iam::accountA:role/
RoleName',RoleSessionName='tryDax')
credentials = botocore.session.get_session()['Credentials']
Node.js
Esta sección le ayuda a modificar el código de cliente de DAX existente para permitir el acceso de
DAX entre cuentas. Si aún no tiene código de cliente de DAX, puede encontrar ejemplos de código
de trabajo en elNode.js y DAX (p. 771)"Hello, World!" Recuerde reemplazar cada marcador de
posición de entrada de usuario por los valores correctos para sus cuentas.
};
createDaxClient().then((client) => {
client.get(...);
...
}).catch((error) => {
console.log('Caught an error: ' + error);
});
Si tiene un clúster de DAX existente y desea evaluar si tiene el número y el tamaño de nodos adecuados,
consulteEscalado de un clúster de DAX (p. 793).
Temas
• Overview (p. 837)
• Estimación del tráfico (p. 837)
• Prueba de carga (p. 838)
Overview
Es importante escalar el clúster de DAX de forma adecuada para su carga de trabajo, ya sea que esté
creando un clúster nuevo o manteniendo un clúster existente. A medida que pasa el tiempo y cambia la
carga de trabajo de la aplicación, debe revisar periódicamente las decisiones de escalado para asegurarse
de que sigan siendo apropiadas.
1. Estimación del tráfico. En este paso, realiza predicciones sobre el volumen de tráfico que enviará
la aplicación a DAX, la naturaleza del tráfico (operaciones de lectura frente a escritura) y la tasa de
aciertos de caché esperada.
2. Prueba de carga. En este paso, crea un clúster y le envía tráfico reflejando las estimaciones del paso
anterior. Repita este paso hasta que encuentre una configuración de clúster adecuada.
3. Monitoreo de la producción. Mientras su aplicación está usando DAX en producción, debeMonitoreo del
clúster (p. 797)Para validar continuamente que aún se ha escalado correctamente a medida que la
carga de trabajo cambia con el tiempo.
Al realizar estimaciones de tráfico, planifique el crecimiento futuro y los picos esperados e inesperados
para asegurarse de que el clúster tenga suficiente margen de ampliación para los aumentos de tráfico.
Prueba de carga
El siguiente paso después de estimar el tráfico consiste en probar la configuración del clúster bajo carga.
1. Para la prueba de carga inicial, le recomendamos que comience con el tipo de nodo dax.r4.large, el
rendimiento fijo de menor costo y el tipo de nodo optimizado para memoria.
2. Un clúster tolerante a errores requiere al menos tres nodos, distribuidos en tres zonas de disponibilidad.
En este caso, si una zona de disponibilidad deja de estar disponible, el número efectivo de zonas de
disponibilidad se reduce en un tercio. Para la prueba de carga inicial, se recomienda comenzar con un
clúster de dos nodos, que simula el error de una zona de disponibilidad en un clúster de tres nodos.
3. Dirija tráfico sostenido (como se estimó en el paso anterior) al clúster de prueba durante la duración de
la prueba de carga.
4. Monitoree el rendimiento del clúster durante la prueba de carga.
Idealmente, el perfil de tráfico que dirija durante la prueba de carga debería ser lo más similar posible
al tráfico real de la aplicación. Esto incluye la distribución de operaciones (por ejemplo, 70 por ciento
GetItem, 25 por ciento Query, y 5 por ciento PutItem), la tasa de solicitudes para cada operación, el
número de elementos a los que se accede por solicitud y la distribución de tamaños de elementos. Para
lograr una tasa de aciertos de caché similar a la tasa de aciertos de caché esperada de su aplicación,
preste atención a la distribución de claves en el tráfico de prueba.
Note
Tenga cuidado al probar los tipos de nodos T2 (dax.t2.small y dax.t2.medium). Los tipos de
nodos T2 proporcionan un rendimiento de CPU con ráfagas que varía con el tiempo en función del
saldo de crédito de CPU del nodo. Un clúster de DAX que se ejecuta en nodos T2 puede parecer
que funciona con normalidad, pero si algún nodo tiene ráfagas por encima de laRendimiento
de referenciade su instancia, el nodo está gastando su saldo de crédito acumulado de la CPU.
Cuando el saldo de crédito es bajo, el rendimiento se reduce gradualmente al nivel de rendimiento
de referencia.
Supervisar el clúster DAX (p. 797)Durante la prueba de carga para determinar si el tipo de nodo que está
utilizando para la prueba de carga es el tipo de nodo adecuado para usted. Además, durante una prueba
de carga, debe monitorear la tasa de solicitudes y la tasa de aciertos de caché para asegurarse de que su
infraestructura de prueba realmente está dirigiendo la cantidad de tráfico que desea.
Si las pruebas de carga indican que la configuración del clúster seleccionada no puede soportar la carga
de trabajo de la aplicación, se recomiendaCambiar a un tipo de nodo más grande (p. 794), especialmente
si observa un uso de CPU elevado en el nodo principal del clúster, altas tasas de expulsión o un uso de
memoria de caché elevado. Si las tasas de aciertos son altas de forma coherente y la proporción de tráfico
de lectura a escritura es alta, es posible que desee plantearse la posibilidad de agregar más nodos al
clúster (p. 793). Consulte Escalado de un clúster de DAX (p. 793) para obtener información adicional
sobre cuándo utilizar un tipo de nodo mayor (escalado vertical) o agregar más nodos (escalado horizontal).
Debe repetir la prueba de carga después de realizar cambios en la configuración del clúster.
Referencia de la API de
Para obtener más información sobre las API de Amazon DynamoDB Accelerator (DAX), consulteAmazon
DynamoDB AcceleratorEn la Referencia de la API de Amazon DynamoDB.
Modelado de datos
Con NoSQL Workbench para DynamoDB, puede crear nuevos modelos de datos o diseñar modelos
basados en modelos de datos existentes que satisfagan los patrones de acceso a datos de su
aplicación. También puede importar y exportar el modelo de datos diseñado al final del proceso. Para
obtener más información, consulte Creación de modelos de datos con NoSQL Workbench (p. 841).
Visualización de datos
El visualizador de modelos de datos proporciona un lienzo donde puede mapear las consultas y
visualizar los patrones de acceso (facetas) de la aplicación sin tener que escribir código. Cada faceta
corresponde a un patrón de acceso diferente en DynamoDB. Puede añadir datos manualmente a
su modelo de datos. Para obtener más información, consulte Visualización de patrones de acceso a
datos (p. 855).
Generación de operaciones
NoSQL Workbench proporciona una completa interfaz gráfica de usuario rica para que desarrolle y
pruebe las consultas. Puede utilizar el generador de operaciones para visualizar, explorar y consultar
conjuntos de datos. También puede utilizar el generador de operaciones estructurado para crear y
realizar operaciones de plano de datos. Admite expresiones de proyección y condición, y le permite
generar código de muestra en varios idiomas. Para obtener más información, consulte Exploración de
conjuntos de datos y creación de operaciones con NoSQL Workbench (p. 864).
Temas
• Descargar NoSQL Workbench (p. 840)
• Creación de modelos de datos con NoSQL Workbench (p. 841)
• Visualización de patrones de acceso a datos (p. 855)
• Exploración de conjuntos de datos y creación de operaciones con NoSQL Workbench (p. 864)
• Modelos de datos de ejemplo para NoSQL Workbench (p. 879)
• Historial de versiones de NoSQL Workbench (p. 882)
* NoSQL Workbench es compatible con Ubuntu 12.04, Fedora 21 y Debian 8 o cualquier versión más
reciente de estas distribuciones de Linux.
2. Inicie la aplicación que ha descargado y siga las instrucciones que aparecen en la pantalla para
instalar NoSQL Workbench.
Temas
• Creación de un nuevo modelo de datos (p. 841)
• Importación de un modelo de datos existente (p. 848)
• Exportación de un modelo de datos (p. 851)
• Edición de un modelo de datos existente (p. 853)
1. Abra NoSQL Workbench y, en el panel de navegación de la izquierda, elija el icono Data modeler
(Modelador de datos).
3. Escriba un nombre, un autor y una descripción para el modelo de datos y, a continuación, elija.Crear.
4. Elija Add table (Añadir tabla).
Para obtener más información sobre las tablas, consulte Uso de tablas en DynamoDB.
5. Especifique lo siguiente:
• Especifique lo siguiente:
• El nombre de la faceta en Facet name.
• Un Partition key alias (Alias de clave de partición).
• Un alias de clave de ordenación en Sort key alias.
• Seleccione los Other attributes (Otros atributos) que forman parte de esta faceta.
Especifique los valores de Global secondary index name (Nombre de índice secundario global), el
atributo Partition key (Clave de partición) y Projection type (Tipo de partición).
Para obtener más información acerca de cómo trabajar con índices secundarios globales en
DynamoDB, consulte.Índices secundarios globales.
En la lista desplegable, elija si el modelo que desea importar está en formato de modelo NoSQL
Workbench o en formato de plantilla JSON de CloudFormation. Si tiene abierto un modelo de datos
existente en NoSQL Workbench, tendrá la opción de importar una plantilla de CloudFormation al
modelo actual.
4. Si el modelo que va a importar está en formato de plantilla de CloudFormation, verá una lista de tablas
que se van a importar y tendrá la oportunidad de especificar un nombre, un autor y una descripción del
modelo de datos.
En la lista desplegable, elija si desea exportar el modelo de datos en formato de modelo de NoSQL
Workbench o en formato de plantilla JSON de CloudFormation.
Elija Edit.
3. Realice las ediciones necesarias y, a continuación, seleccione Save edits (Guardar ediciones).
Añada una matriz TableFacets que represente todas las facetas de la tabla.
Para cada faceta, añada un objeto a la matriz TableFacets. Cada elemento de la matriz tiene las
siguientes propiedades:
• FacetName: un nombre para la faceta. Este valor debe ser único en todo el modelo.
• PartitionKeyAlias— Un nombre fácil de mencionar para la clave de partición de la tabla. Este
alias se muestra cuando visualiza la faceta en NoSQL Workbench.
• SortKeyAlias— Un nombre fácil de mencionar para la clave de ordenación de la tabla. Este alias
se muestra cuando visualiza la faceta en NoSQL Workbench. Esta propiedad no es necesaria si la
tabla no tiene definida ninguna clave de clasificación.
• NonKeyAttributes— Una matriz de nombres de atributos que se necesitan para el patrón de
acceso. Estos nombres deben mapearse a los nombres de atributo definidos para la tabla.
{
"ModelName": "Music Library Data Model",
"DataModel": [
{
"TableName": "Songs",
"KeyAttributes": {
"PartitionKey": {
"AttributeName": "Id",
"AttributeType": "S"
},
"SortKey": {
"AttributeName": "Metadata",
"AttributeType": "S"
}
},
"NonKeyAttributes": [
{
"AttributeName": "DownloadMonth",
"AttributeType": "S"
},
{
"AttributeName": "TotalDownloadsInMonth",
"AttributeType": "S"
},
{
"AttributeName": "Title",
"AttributeType": "S"
},
{
"AttributeName": "Artist",
"AttributeType": "S"
},
{
"AttributeName": "TotalDownloads",
"AttributeType": "S"
},
{
"AttributeName": "DownloadTimestamp",
"AttributeType": "S"
}
],
"TableFacets": [
{
"FacetName": "SongDetails",
"KeyAttributeAlias": {
"PartitionKeyAlias": "SongId",
"SortKeyAlias": "Metadata"
},
"NonKeyAttributes": [
"Title",
"Artist",
"TotalDownloads"
]
},
{
"FacetName": "Downloads",
"KeyAttributeAlias": {
"PartitionKeyAlias": "SongId",
"SortKeyAlias": "Metadata"
},
"NonKeyAttributes": [
"DownloadTimestamp"
]
}
]
}
]
}
4. Ahora puede importar el modelo modificado a NoSQL Workbench. Para obtener más información,
consulte Importación de un modelo de datos existente (p. 848).
Temas
• Incorporación de datos de muestreo a un modelo de datos (p. 856)
Siga estos pasos para agregar datos de muestra a un modelo de datos utilizando NoSQL Workbench para
Amazon DynamoDB.
4. Escriba los datos de muestra en los campos de texto vacíos y elijaAñadir nueva filaPara agregar filas
adicionales. Cuando haya terminado, elijaSave (Guardar).
También puede editar las definiciones de facetas mediante el modelador de datos. Para obtener más
información, consulte Edición de un modelo de datos existente (p. 853).
• Esta acción produce la creación de recursos del lado del servidor enAWSPara las tablas e
índices secundarios globales representados en el modelo de datos.
• Las tablas se crean con las siguientes características:
• El escalado automático se establece en un 70 % del objetivo de utilización.
• La capacidad aprovisionada se establece en 5 unidades de capacidad de lectura y en 5
unidades de capacidad de escritura.
• Los índices secundarios globales se crean con una capacidad aprovisionada de 10 unidades de
capacidad de lectura y 5 unidades de capacidad de escritura.
3. Elija una conexión ya existente o cree una nueva; para ello, elija la pestaña Add new remote
connection (Añadir nueva conexión remota).
Para obtener más información acerca de cómo obtener las claves de acceso, consulteRecibir
unaAWSClave de acceso.
• Si lo desea, puede especificar lo siguiente:
• Token de sesión
• ARN del rol de IAM
• Si no desea registrarse para obtener una cuenta de la capa gratuita, puede configurar y prefiere
usar DynamoDB Local (versión descargable).
1. Elija la pestaña Add a new DynamoDB local connection (Añadir una nueva conexión local de
DynamoDB).
2. Especifique el Connection name (Nombre de conexión) y el Port (Puerto).
4. Elija Commit (Confirmar).
Temas
• Exploración de conjuntos de datos (p. 864)
• Generación de operaciones complejas (p. 868)
Para obtener más información acerca de cómo obtener las claves de acceso, consulteRecibir
unaAWSClave de acceso.
• Token de sesión
• ARN del rol de IAM
4. Elija Connect.
Si no desea registrarse para obtener una cuenta de la capa gratuita, puede configurar y prefiere usar
DynamoDB Local (versión descargable).
1. En la lista Attribute name (Nombre de atributo), elija el atributo del que desea hacer consultas.
2. Especifique el operador de comparación.
3. Especifique el tipo de datos del valor.
4. Especifique el valor que desea consultar.
5. Seleccione Scan (Analizar).
Para obtener más información acerca de esta operación, veaScanen laReferencia de la API de Amazon
DynamoDB.
Para utilizar NoSQL Workbench para generar operaciones, en el panel de navegación de la izquierda,
seleccione la opciónGenerador de operacionesIcono .
Temas
• Creación de sentencias PartiQL (p. 869)
Temas
• Instrucciones Singlet.com (p. 869)
• Transactions (p. 870)
• Batch (p. 871)
Instrucciones Singlet.com
Para ejecutar o generar código para una instrucción PartiQL, haga lo siguiente.
1. SeleccionarDeclaración PartiQL.
2. Introduzca una de las opcionesDeclaración PartiQL.
3. Si su declaración utiliza parámetros
Seleccione el idioma que desee en las pestañas mostradas. Ahora puede copiar este código y
utilizarlo en su aplicación.
Transactions
Para ejecutar o generar código para una transacción de PartiQL, haga lo siguiente.
1. SeleccionarPartiQL (transacción).
2. SeleccionarAgregar una nueva instrucción.
3. Introduzca una de las opcionesDeclaración PartiQL.
Note
Seleccione el idioma que desee en las pestañas mostradas. Ahora puede copiar este código y
utilizarlo en su aplicación.
7. Si desea que la operación se ejecute inmediatamente, seleccioneEjecución de.
Batch
Para ejecutar o generar código para un lote de PartiQL, haga lo siguiente.
1. SeleccionarLote de PartiQL.
2. SeleccionarAgregar una nueva instrucción.
3. Introduzca una de las opcionesDeclaración PartiQL.
Note
Las operaciones de lectura y escritura no se admiten en la misma solicitud por lotes PartiQL,
lo que significa que una instrucción SELECT no puede estar en la misma solicitud con
instrucciones INSERT, UPDATE y DELETE. No se permiten operaciones de escritura
en el mismo elemento. Al igual que con la operación BatchGetItem, solo se admiten
operaciones de lectura singleton. No se admiten las operaciones de análisis y consultas.
ConsulteEjecución de operaciones Batch con PartiQL para DynamoDBpara obtener más
información.
4. Si su declaración utiliza parámetros
Seleccione el idioma que desee en las pestañas mostradas. Ahora puede copiar este código y
utilizarlo en su aplicación.
7. Si desea que la operación se ejecute inmediatamente, seleccioneEjecución de.
Temas
• Recibir artículo (p. 872)
• Put Item (p. 873)
• Update Item (p. 874)
• Delete Item (p. 875)
• Query (p. 876)
• Scan (p. 876)
• TransactGetItems (p. 877)
• TransactWriteItems (p. 878)
Recibir artículo
Para ejecutar o generar código para unGet Item, realice una de las siguientes opciones.
a. SeleccionarExpresiones de proyección.
b. Elija el icono+(signo más) junto aExpresiones de proyección.
c. Especifique la propiedadNombre de atributo,.
Seleccione el idioma que desee en las pestañas mostradas. Ahora puede copiar este código y
utilizarlo en su aplicación.
4. Si desea que la operación se ejecute inmediatamente, seleccioneEjecución de.
Para obtener más información acerca de esta operación, veaPutItemen laReferencia de la API de Amazon
DynamoDB.
Put Item
Para ejecutar o generar código para unPut Item, realice una de las siguientes opciones.
Seleccione el idioma que desee en las pestañas mostradas. Ahora puede copiar este código y
utilizarlo en su aplicación.
6. Si desea que la operación se ejecute inmediatamente, seleccioneEjecución de.
Para obtener más información acerca de esta operación, veaPutItemen laReferencia de la API de Amazon
DynamoDB.
Update Item
Para ejecutar o generar código para unUpdate Item, realice una de las siguientes opciones:
Elija la pestaña del idioma que desee. Ahora puede copiar este código y utilizarlo en su aplicación.
9. Si desea que la operación se ejecute inmediatamente, seleccioneEjecución de.
Para obtener más información acerca de esta operación, veaUpdateItemen laReferencia de la API de
Amazon DynamoDB.
Delete Item
Para ejecutar o generar código para unDelete Item, realice una de las siguientes opciones.
Elija la pestaña del idioma que desee. Ahora puede copiar este código y utilizarlo en su aplicación.
5. Si desea que la operación se ejecute inmediatamente, seleccioneEjecución de.
Para obtener más información acerca de esta operación, veaDeleteItemen laReferencia de la API de
Amazon DynamoDB.
Query
Para ejecutar o generar código para unQuery, realice una de las siguientes opciones.
Elija la pestaña del idioma que desee. Ahora puede copiar este código y utilizarlo en su aplicación.
9. Si desea que la operación se ejecute inmediatamente, seleccioneEjecución de.
Para obtener más información acerca de esta operación, veaConsultaen laReferencia de la API de
Amazon DynamoDB.
Scan
Para ejecutar o generar código para unScan, realice una de las siguientes opciones.
1. Si no se deben devolver todos los atributos con el resultado de la operación, seleccione Projection
expression (Expresión de proyección).
Elija la pestaña del idioma que desee. Ahora puede copiar este código y utilizarlo en su aplicación.
7. Si desea que la operación se ejecute inmediatamente, seleccioneEjecución de.
TransactGetItems
Para ejecutar o generar código para unTransactGetItems, realice una de las siguientes opciones.
Cuando termine de especificar los detalles de la operación, seleccione la+(signo más) si desea añadir
más operaciones.
Para cambiar el orden de las acciones, seleccione una acción en la lista de la izquierda y, a
continuación, elija las flechas hacia arriba o hacia abajo para subirla o bajarla en la lista.
Para eliminar una acción, seleccione la acción de la lista y, a continuación, el icono Delete (Eliminar)
(papelera).
3. Si desea generar código, seleccione Generate code (Generar código).
Elija la pestaña del idioma que desee. Ahora puede copiar este código y utilizarlo en su aplicación.
4. Si desea que la operación se ejecute inmediatamente, seleccioneEjecución de.
Para obtener más información sobre las transacciones, consulte Amazon DynamoDB Transactions.
TransactWriteItems
Para ejecutar o generar código para unTransactWriteItems, realice una de las siguientes opciones.
• Para DeleteItem, siga las instrucciones de la operación Delete Item (p. 875).
• Para PutItem, siga las instrucciones de la operación Put Item (p. 873).
• Para UpdateItem, siga las instrucciones de la operación Update Item (p. 874).
Para cambiar el orden de las acciones, seleccione una acción en la lista de la izquierda y, a
continuación, elija las flechas hacia arriba o hacia abajo para subirla o bajarla en la lista.
Para eliminar una acción, seleccione la acción de la lista y, a continuación, el icono Delete (Eliminar)
(papelera).
Elija la pestaña del idioma que desee. Ahora puede copiar este código y utilizarlo en su aplicación.
3. Si desea que la operación se ejecute inmediatamente, seleccioneEjecución de.
Para obtener más información sobre las transacciones, consulte Amazon DynamoDB Transactions.
Temas
• Modelo de datos de empleados (p. 880)
• Modelo de datos del foro de debate (p. 880)
• Modelo de datos de biblioteca de música (p. 880)
• Modelo de datos de estación de esquí (p. 881)
• Modelo de datos de ofertas de tarjetas de crédito (p. 881)
• Modelo de datos de marcadores (p. 881)
Este modelo de datos representa algunas técnicas como el manejo de atributos complejos, como tener
más de una habilidad. Este modelo es también un ejemplo de relación uno a muchos a través del gerente y
sus empleados de informes que se ha logrado mediante el índice secundario DirectReports.
• Recuperación de un registro de empleado utilizando el alias de inicio de sesión del empleado, facilitada
por una tabla llamada Employee.
• Buscar empleados por nombre, facilitado por el índice secundario global de la tabla Empleado llamado
Name.
• Recuperación de todos los informes directos de un gerente utilizando el alias de inicio de sesión del
gerente, facilitada por el índice secundario global de la tabla Empleado llamado DirectReports.
• Recuperación de un registro de foro utilizando el nombre del foro, facilitada por una tabla llamada
Forum.
• Recuperación de un hilo específico o todos los hilos de un foro, facilitada por una tabla llamadaThread.
• Busque respuestas utilizando la dirección de correo electrónico del usuario de publicación, facilitado por
el índice secundario global de la tabla Respuesta llamado PostedBy-Message-Index.
• Recuperación de todos los datos de un remonte determinado o complejo general, dinámico y estático,
facilitada por una tabla llamada SkiLifts.
• Recuperación de todos los datos dinámicos (incluidos los jinetes de ascensor únicos, la cobertura de
nieve, el peligro de avalancha y el estado del ascensor) para un telesilla o el centro vacacional en una
fecha específica, facilitada por una tabla llamadaSkiLifts.
• Recuperación de todos los datos estáticos (incluyendo si el ascensor es solo para ciclistas
experimentados, pies verticales el ascensor se eleva y tiempo de conducción en el ascensor) para un
telesilla específico, facilitado por una mesa llamadaSkiLifts.
• Recuperación de la fecha de los datos registrados para un remonte específico o el complejo general
ordenado por usuarios individuales totales, facilitada por el índice secundario global de la tabla SkiLifts
llamado SkiLiftsByRiderss.
Un proveedor de tarjeta de crédito produce ofertas a lo largo del tiempo. Estas ofertas incluyen
transferencias de saldo sin cargos, mayores límites de crédito, tasas de interés más bajas, devolución de
efectivo y millas aéreas. Después de que un cliente acepte o rechace estas ofertas, el estado de la oferta
correspondiente se actualiza en consecuencia.
Un cliente puede tener muchos marcadores y un marcador puede pertenecer a muchos clientes. Este
modelo de datos representa una relación de muchos a muchos.
• Una sola consulta de customerId ahora puede devolver datos de clientes, así como marcadores.
• Un índice ByEmail de consulta devuelve los datos del cliente por dirección de correo electrónico. Tenga
en cuenta que este índice no recupera los marcadores.
• ConsultaByUrlobtiene datos de marcadores por URL. Tenga en cuenta que tenemos customerId como
clave de ordenación para el índice porque la misma URL puede ser marcada por varios clientes.
• ConsultaByCustomerFolderobtiene marcadores por carpeta para cada cliente.
NoSQL Workbench para Amazon NoSQL Workbench for Amazon 2 de marzo de 2020
DynamoDB – GA. DynamoDB ya se encuentra
disponible de forma general.
Compatibilidad con roles de IAM NoSQL Workbench para Amazon 19 de diciembre de 2019
y credenciales de seguridad DynamoDB ahora admite
temporales. losAWS Identity and Access
Management(IAM) y credenciales
de seguridad temporales.
Temas
• Protección de datos en DynamoDB (p. 883)
• Identity and Access Management (p. 893)
• Validación de conformidad por sector para DynamoDB (p. 925)
• Resiliencia y recuperación ante desastres en Amazon DynamoDB (p. 926)
• Seguridad de la infraestructura en Amazon DynamoDB (p. 926)
• Configuración y análisis de vulnerabilidades en Amazon DynamoDB (p. 933)
• Prácticas recomendadas de seguridad para Amazon DynamoDB (p. 933)
DynamoDB protege los datos del usuario almacenados en reposo y también los datos en tránsito entre
clientes locales y DynamoDB, y entre DynamoDB y otrosAWSrecursos dentro de la mismaAWSRegión .
Temas
• DynamoDB ado en reposo (p. 884)
• Protección de datos en DynamoDB Accelerator (p. 893)
El cifrado en reposo de DynamoDB proporciona una capa adicional de seguridad de los datos, porque
los protege en una tabla cifrada que incluye su clave principal, los índices secundarios locales y globales,
las secuencias, las tablas globales, las copias de seguridad y los clústeres de DynamoDB Accelerator
(DAX) siempre que los datos se almacenen en en un soporte duradero. Las políticas de la organización,
las normativas industriales o gubernamentales y los requisitos de conformidad suelen requerir el uso del
cifrado en reposo para aumentar la seguridad de los datos de las aplicaciones.
El cifrado en reposo se integra de forma automática con AWS KMS para administrar la clave de cifrado
que se utiliza para cifrar las tablas. Para obtener más información, consulteAWS Key Management
ServiceConceptosen laAWS Key Management ServiceGuía para desarrolladores.
Al crear una tabla nueva, puede elegir una de las siguientes claves maestras de cliente (CMK) para cifrarla:
• AWSCMK propiedad de: tipo de cifrado predeterminado. La clave es propiedad de DynamoDB (sin cargo
adicional).
• AWSCMK administrada por: la clave se almacena en su cuenta y la administraAWS KMS(AWS KMSSe
aplican cargos).
• CMK administrada por el cliente: la clave se almacena en su cuenta y usted la crea, posee y administra.
Usted controla plenamente la CMK (se aplican cargos de AWS KMS).
Note
Al crear un nuevo clúster DAX con el cifrado en reposo habilitado, se crea unAWSCMK
administrada por se utilizará para cifrar datos en reposo en el clúster.
Cuando accede a una tabla cifrada, DynamoDB descifra los datos de la tabla de forma transparente.
Puede cambiar entreAWSCMK propiedad de,AWSCMK administrada por el cliente y CMK administrada
por el cliente en cualquier momento. No es necesario cambiar ningún código ni aplicación para usar o
administrar tablas de cifrado. DynamoDB continúa proporcionando la misma latencia en milisegundos de
un solo dígito que cabe esperar de nosotros y todas las consultas de DynamoDB funcionan de manera
transparente con los datos cifrados.
Puede especificar una clave de cifrado al crear una tabla o cambiar las claves de cifrado en una
tabla existente con laAWS Management Console,AWS Command Line Interface(AWS CLI) o la API
de Amazon DynamoDB. Para saber cómo hacerlo, consulte Administración de tablas de cifrado en
DynamoDB (p. 888).
Cifrado en reposo medianteAWSCMK propiedad de se ofrece sin cargo adicional. Sin embargo,AWS
KMSSe aplican cargos porAWSCMK administrada por el cliente y CMK administrada por el cliente. Para
obtener más información acerca de los precios, consulte Precios de AWS KMS.
Cifrado en reposo se integra conAWS Key Management Service(AWS KMS) para administrar la clave de
cifrado que se utiliza para cifrar las tablas.
Al crear una tabla o cambiar las claves de cifrado en una tabla existente, puede elegir una de las siguientes
claves maestras del cliente (CML) de:
• AWSCMK propiedad de: tipo de cifrado predeterminado. La clave es propiedad de DynamoDB (sin cargo
adicional).
• AWSCMK administrada por: la clave se almacena en su cuenta y la administraAWS KMS(AWS KMSSe
aplican cargos).
• CMK administrada por el cliente: la clave se almacena en su cuenta y usted la crea, posee y administra.
Usted controla plenamente la CMK (se aplican cargos de AWS KMS).
AWSCMK propiedad de
AWSCMK propiedad de no se almacenan enAWSaccount. Forman parte de una recopilación de CMK
propiedad de AWS y que administra para usar en distintas cuentas de AWS. Los servicios de AWS pueden
usar las CMK propiedad de AWS para proteger sus datos.
No puede ver, administrar ni usar las CMK propiedad de AWS ni auditar su uso. Sin embargo, no es
necesario que realice ninguna acción ni que cambie programas para proteger las claves que cifran sus
datos.
No se le cobra ninguna tarifa mensual ni tarifa de uso deAWSCMK propiedad de, y no cuentan contraAWS
KMSCuotas de su cuenta de.
Para obtener más información acerca de la administración de permisos deAWSCMK administrada por,
consulteAutorización del uso deAWSCMK administrada poren laAWS Key Management ServiceGuía para
desarrolladores.
de su eliminación. Para obtener más información acerca de la administración de permisos de una CMK
administrada por el cliente, consultePolítica de claves de CMK administrada por el cliente.
Cuando especifica un CMK administrado por el cliente como clave de cifrado de nivel de tabla, la tabla de
DynamoDB, los índices secundarios locales y globales y las transmisiones se cifran con el mismo CMK
administrado por el cliente. Las copias de seguridad bajo demanda se cifran con la clave de cifrado de
nivel de tabla que se especifica en el momento en que se crea la copia de seguridad. La actualización de
la clave de cifrado de nivel de tabla no cambia la clave de cifrado asociada a las copias de seguridad bajo
demanda existentes.
Establecer el estado del CMK administrado por el cliente en deshabilitado o programarlo para su
eliminación impide que todos los usuarios y el servicio DynamoDB puedan cifrar o descifrar datos y realizar
operaciones de lectura y escritura en la tabla. DynamoDB debe tener acceso a la clave de cifrado para
asegurarse de que puede seguir accediendo a la tabla y evitar la pérdida de datos.
Puede usarAWS CloudTraily los Amazon CloudWatch Logs para realizar un seguimiento de las solicitudes
que DynamoDB envía aAWS KMSen su nombre. Para obtener más información, consulteSupervisión de la
interacción de DynamoDBAWS KMSen laAWS Key Management ServiceGuía para desarrolladores.
DynamoDB no llamaAWS KMSpara cada operación de DynamoDB. La clave se actualiza una vez cada 5
minutos por conexión de cliente con tráfico activo.
Asegúrese de haber configurado el SDK para reutilizar las conexiones. De lo contrario, experimentará
latencias de DynamoDB al tener que restablecer nuevasAWS KMSentradas de caché para cada operación
de DynamoDB. Además, es posible que tenga que enfrentarse aAWS KMSy CloudTrail. Por ejemplo,
para hacer esto usando el SDK Node.js, puede crear un nuevo agente HTTPS conkeepAliveActivada.
Para obtener más información, consulteConfiguración de maxSockets en Node.jsen laAWS SDK for
JavaScriptGuía para desarrolladores.
El cifrado en reposo solo cifra los datos mientras están estáticos (en reposo) en un medio de
almacenamiento persistente. Si le preocupa la seguridad de los datos cuando están en tránsito o en uso,
puede ser conveniente adoptar medidas adicionales:
• Datos en tránsito: Todos los datos de DynamoDB se cifran en tránsito (excepto los datos de DAX). De
forma predeterminada, las comunicaciones de entrada y salida de DynamoDB usan el protocolo HTTPS,
que protege el tráfico de la red mediante el uso del cifrado de capa de conexión segura (SSL) /seguridad
de la capa de transporte (TLS).
• Datos en uso: Proteja sus datos antes de enviarlos a DynamoDB mediante el cifrado del lado del
cliente. Para obtener más información, consulteCifrado del lado del cliente y del servidoren laGuía del
desarrollador de Amazon DynamoDB Cifrado.
Puede usar secuencias con tablas cifradas. Las secuencias de DynamoDB siempre se cifran con una clave
de cifrado de nivel de tabla. Para obtener más información, consulte Captura de datos de cambio para
DynamoDB Streams (p. 661) .
Las copias de seguridad de DynamoDB se cifran y la tabla que se restaura a partir de una copia de
seguridad también tiene el cifrado habilitado. Puede utilizar laAWSCMK propiedad de,AWSCMK
administrada por el cliente para cifrar los datos de copia de seguridad. Para obtener más información,
consulte Backup bajo demanda y restauración para DynamoDB (p. 701) .
Los índices secundarios locales y globales se cifran usando la misma clave que la tabla base.
Tipos de cifrado
En la páginaAWS Management Console, el tipo de cifrado esKMScuando se utiliza elAWSCMK
administrada por el cliente o CMK administrada por el cliente para cifrar sus datos. El tipo de cifrado es
DEFAULT cuando se usa la CMK propiedad de AWS. En la API de Amazon DynamoDB, el tipo de cifrado
esKMScuando se utiliza elAWSCMK administrada por el cliente. En ausencia del tipo de cifrado, sus datos
se cifran mediante laAWSCMK propiedad de. Puede cambiar entreAWSCMK propiedad de,AWSCMK
administrada por el cliente y CMK administrada por el cliente en cualquier momento. Puede utilizar la
consola deAWS Command Line Interface(AWS CLI) o la API de Amazon DynamoDB para alternar entre
claves de cifrado.
Tenga en cuenta las limitaciones siguientes al usar CMK administradas por el cliente:
• No se puede usar una CMK administrada por el cliente con clústeres de DynamoDB Accelerator (DAX).
Para obtener más información, consulte Cifrado DAX en reposo (p. 825) .
• Una CMK administrada por el cliente se puede usar para cifrar tablas que utilizan transacciones. Sin
embargo, para garantizar la durabilidad de la propagación de las transacciones, el servicio almacena
temporalmente una copia de la solicitud de transacción y se cifra mediante unAWSCMK propiedad de.
Los datos confirmados en las tablas e índices secundarios siempre se cifran en reposo utilizando el CMK
administrado por el cliente.
• Una CMK administrada por el cliente se puede usar para cifrar tablas que utilizan Contributor Insights.
Sin embargo, los datos que se transmiten a Amazon CloudWatch se cifran conAWSCMK propiedad de.
• Si deshabilita su CMK administrada por el cliente o la programa para su eliminación, todos los datos de
DynamoDB Streams quedarán sujetos a un tiempo de vida de 24 horas. Todos los datos de actividad
que no se hayan recuperado se podrán recortar cuando alcancen una antigüedad superior a 24 horas.
• Si deshabilita la CMK administrada por el cliente o la programa para su eliminación, las eliminaciones
de tiempo de vida (TTL) continuarán durante 30 minutos. Estas eliminaciones de TTL continúan
emitiéndose a DynamoDB Streams y están sujetas al intervalo estándar de recorte/retención.
Temas
• Especificación de la clave de cifrado para una tabla nueva (p. 888)
• Configuración de una clave de cifrado (p. 890)
Note
6. Elija Create (Crear) para crear la tabla cifrada. Para confirmar el tipo de cifrado, compruebe los
detalles de la tabla en la pestaña Overview (Información general).
UsarAWS CLIpara crear una tabla con el valor predeterminadoAWSCMK propiedad de,AWSo un CMK
administrado por el cliente para Amazon DynamoDB.
Note
Para crear una tabla cifrada mediante laAWSCMK administrada por DynamoDB
AttributeName=Artist,AttributeType=S \
AttributeName=SongTitle,AttributeType=S \
--key-schema \
AttributeName=Artist,KeyType=HASH \
AttributeName=SongTitle,KeyType=RANGE \
--provisioned-throughput \
ReadCapacityUnits=10,WriteCapacityUnits=5 \
--sse-specification Enabled=true,SSEType=KMS
"SSEDescription": {
"SSEType": "KMS",
"Status": "ENABLED",
"KMSMasterKeyArn": "arn:aws:kms:us-east-1:123456789012:key/abcd1234-abcd-1234-a123-
ab1234a1b234",
}
Para crear una tabla cifrada mediante la CMK administrada por el cliente para DynamoDB
"SSEDescription": {
"SSEType": "KMS",
"Status": "ENABLED",
"KMSMasterKeyArn": "arn:aws:kms:us-east-1:123456789012:key/abcd1234-abcd-1234-a123-
ab1234a1b234",
}
3. Seleccione la tabla que desea actualizar y, a continuación, elija la pestaña Overview (Información
general).
4. Elija Manage Encryption (Administrar cifrado).
A continuación, elija Save (Guardar) para actualizar la tabla cifrada. Para confirmar el tipo de cifrado,
compruebe los detalles de la tabla en la pestaña Overview (Información general).
Note
Para actualizar una tabla cifrada mediante laAWSCMK administrada por DynamoDB
"SSEDescription": {
"SSEType": "KMS",
"Status": "ENABLED",
"KMSMasterKeyArn": "arn:aws:kms:us-east-1:123456789012:key/abcd1234-abcd-1234-a123-
ab1234a1b234",
}
Para actualizar una tabla cifrada con una CMK administrada por el cliente para DynamoDB
administrada por el cliente
"SSEDescription": {
"SSEType": "KMS",
"Status": "ENABLED",
"KMSMasterKeyArn": "arn:aws:kms:us-east-1:123456789012:key/abcd1234-abcd-1234-a123-
ab1234a1b234",
}
Para obtener más información acerca de la protección de datos en DAX, consulteCifrado DAX en
reposo (p. 825).
• Una conexión de AWS Site-to-Site VPN. Para obtener más información, consulte ¿Qué es AWS Site-to-
Site VPN? en la Guía del usuario de AWS Site-to-Site VPN.
• Una conexión de AWS Direct Connect. Para obtener más información, consulte ¿Qué es AWS Direct
Connect? en la Guía del usuario de AWS Direct Connect.
El acceso a DynamoDB a través de la red es aAWSAPI publicadas por. Los clientes deben admitir
Transport Layer Security (TLS) 1.0. Nosotros recomendamos TLS 1.2 o una versión posterior. Los
clientes también deben admitir conjuntos de cifrado con confidencialidad directa total (PFS) tales como
Ephemeral Diffie-Hellman (DHE) o Elliptic Curve Diffie-Hellman Ephemeral (ECDHE). La mayoría de los
sistemas modernos como Java 7 y posteriores son compatibles con estos modos. Además, debe firmar
las solicitudes con un ID de clave de acceso y una clave de acceso secreta que estén asociados a una
entidad principal de IAM, o bien, puede usar AWS Security Token Service (STS) para generar credenciales
de seguridad temporales a la hora de firmar solicitudes.
Temas
• Identity and Access Management (p. 894)
Authentication
Puede obtener acceso a AWS con los siguientes tipos de identidades:
• AWSUsuario raíz de la cuenta de— Cuando crea por primera vez unAWS, comienza con una única
identidad de inicio de sesión que tiene acceso completo a todos losAWSServicios y recursos de la
cuenta. Esta identidad se denominaAWSaccountUsuario raízPara obtener acceso a ella, inicie sesión
con la dirección de correo electrónico y la contraseña que utilizó para crear la cuenta. Le recomendamos
que no utilice el usuario raíz en sus tareas cotidianas, incluso las tareas administrativas. En lugar de
ello, es mejor ceñirse a la práctica recomendada de utilizar el usuario final exclusivamente para crear
al primer usuario de IAM. A continuación, guarde las credenciales del usuario raíz en un lugar seguro y
utilícelas tan solo para algunas tareas de administración de cuentas y servicios.
• Usuario de IAM— UnUsuario de IAMes una identidad dentro de suAWSLa cuenta tiene permisos
personalizados específicos (por ejemplo, permisos para crear una tabla de en DynamoDB). Puede
utilizar un nombre de usuario y contraseña de IAM para iniciar sesión yAWSPáginas web comoAWS
Management Console,AWSForos de debate de, o elAWS SupportCenter.
Además de un nombre de usuario y una contraseña, también puede generar claves de acceso para
cada usuario. Puede utilizar estas claves al acceder a los servicios de AWS mediante programación,
ya sea a través de uno de los varios SDK o mediante la AWS Command Line Interface (CLI). El SDK y
las herramientas de CLI usan claves de acceso para firmar criptográficamente su solicitud. Si no utiliza
las herramientas de AWS, debe firmar usted mismo la solicitud. DynamoDB admiteSignature Version
4, un protocolo para autenticar solicitudes de API de entrada. Para obtener más información acerca de
la autenticación de solicitudes, consulteProceso de firma de Signature Version 4en laAWSReferencia
general de.
• Rol de IAM: un rol de IAM es una identidad de IAM que puede crear en la cuenta y que tiene permisos
específicos. Un rol de IAM es similar a un usuario de IAM, ya que se trata de unAWSidentidad con
políticas de permisos que determinan lo que la identidad puede y no puede hacer enAWS. Sin embargo,
en lugar de asociarse exclusivamente a una persona, la intención es que cualquier usuario pueda asumir
un rol que necesite. Además, un rol no tiene asociadas credenciales a largo plazo estándar, como una
contraseña o claves de acceso. En su lugar, cuando se asume un rol, este proporciona credenciales de
seguridad temporales para la sesión de rol. Los roles de IAM con credenciales temporales son útiles en
las siguientes situaciones:
• Acceso de usuarios federados: en lugar de crear un usuario de IAM, puede utilizar identidades
existentes deAWS Directory Service, el directorio de usuarios de la compañía o un proveedor de
identidades web. A estas identidades se les llama usuarios federados. AWS asigna una función a
un usuario federado cuando se solicita acceso a través de un proveedor de identidad. Para obtener
más información acerca de los usuarios federados, consulte Usuarios federados y roles en la Guía del
usuario de IAM.
• AWSAcceso a servicios de :— Un rol de servicio es unRol de IAMUn servicio asume para realizar
acciones en su nombre. Los roles de servicio ofrecen acceso solo dentro de su cuenta y no se pueden
utilizar para otorgar acceso a servicios en otras cuentas. Un administrador de IAM puede crear,
modificar y eliminar un rol de servicio desde IAM. Para obtener más información, consulteCreación de
un rol para delegar permisos a unAWSServicioen laGuía del usuario de IAM.
• Aplicaciones que se ejecutan en Amazon EC2: puede utilizar un rol de IAM para administrar
credenciales temporales para las aplicaciones que se ejecutan en una instancia EC2 y realizanAWS
CLIorAWSSolicitudes de API. Es preferible hacerlo de este modo a almacenar claves de acceso en la
instancia EC2. Para asignar un rol de AWS a una instancia EC2 y ponerla a disposición de todas las
aplicaciones, cree un perfil de instancia asociado a la misma. Un perfil de instancia contiene el rol y
permite a los programas que se ejecutan en la instancia EC2 obtener credenciales temporales. Para
obtener más información, consulte Uso de un rol de IAM para conceder permisos a aplicaciones que
se ejecutan en instancias Amazon EC2 en la Guía del usuario de IAM.
Control de acceso
Puede tener credenciales válidas para autenticar las solicitudes pero, a menos que tenga permisos, no
podrá crear recursos de Amazon DynamoDB ni obtener acceso a ellos. Por ejemplo, debe tener permiso
para crear una tabla de Amazon DynamoDB.
En las siguientes secciones se describe cómo administrar los permisos de Amazon DynamoDB. Le
recomendamos que lea primero la información general.
Cuando concede permisos, decide quién debe obtener los permisos, para qué recursos se obtienen
permisos y qué acciones específicas desea permitir en esos recursos.
Temas
• Recursos y operaciones de DynamoDB (p. 896)
• Titularidad de los recursos (p. 896)
• Administración del acceso a los recursos (p. 896)
• Especificación de elementos de política: Acciones, efectos y entidades principales (p. 898)
• Especificación de las condiciones de una política (p. 898)
En DynamoDB, los recursos principales sonTablas de. DynamoDB también admite otros tipos de
recursos,índices, yFlujos de. Sin embargo, puede crear índices y secuencias solamente en el contexto de
una tabla de DynamoDB existente. Estos elementos se denominan subrecursos.
Estos recursos principales y secundarios tienen asociado un Nombre de recursos de Amazon (ARN) único,
tal y como se muestra en la siguiente tabla:
Tabla arn:aws:dynamodb:region:account-id:table/table-name
Índice arn:aws:dynamodb:region:account-id:table/table-name/
index/index-name
De streaming arn:aws:dynamodb:region:account-id:table/table-name/
stream/stream-label
DynamoDB proporciona un conjunto de operaciones para trabajar con recursos de DynamoDB. Para
obtener una lista de las operaciones disponibles, consulte Amazon DynamoDBActions.
• Si usa suAWScredenciales de usuario raíz de la cuenta para crear una tabla, suAWSLa cuenta de es la
propietaria del recurso (en DynamoDB, el recurso es una tabla).
• Si crea un usuario de IAM en suAWSLa cuenta de y concede permisos para crear una tabla a ese
usuario, el usuario puede crear una tabla. Sin embargo, suAWSLa cuenta de a la que pertenece el
usuario será la propietaria del recurso de tabla.
• Si crea un rol de IAM en suAWSUna cuenta de con permisos para crear una tabla, cualquier persona
que pueda asumir el rol podrá crear una tabla. SusAWSLa cuenta de a la que pertenece el rol será la
propietaria del recurso de tabla.
Las políticas que se asocian a una identidad de IAM se denominan políticas basadas en identidades (o
políticas de IAM). Las políticas que se adjuntan a un recurso se denominan «Basados en recursosPolíticas
de. DynamoDB solo admite políticas basadas en identidad (políticas de IAM).
Temas
Puede asociar políticas a identidades de IAM. Por ejemplo, puede hacer lo siguiente:
• Asociar una política de permisos a un usuario o grupo de su cuentaPara conceder a un usuario permisos
para crear un recurso de Amazon DynamoDB, como una tabla, puede asociar una política de permisos a
un usuario o a un grupo al que pertenezca el usuario.
• Asociar una política de permisos a un rol (conceder permisos entre cuentas): puede asociar una política
de permisos basada en identidad a un rol de IAM para conceder permisos entre cuentas. Por ejemplo, el
administrador de la cuenta A puede crear un rol para conceder permisos entre cuentas a otra cuenta de
AWS (por ejemplo, a la cuenta B) o a un servicio de AWS, tal y como se indica a continuación:
1. El administrador de la cuenta A crea un rol de IAM y asocia una política de permisos a dicho rol, que
concede permisos sobre los recursos de la cuenta A.
2. El administrador de la cuenta A asocia una política de confianza al rol que identifica la cuenta B como
la entidad principal que puede asumir el rol.
3. A continuación, el administrador de la cuenta B puede delegar permisos para asumir el rol a cualquier
usuario de la cuenta B. De este modo, los usuarios de la cuenta B podrán crear recursos y obtener
acceso a ellos en la cuenta A. La entidad principal de la política de confianza también puede ser la
entidad principal de un servicio de AWS si desea conceder permisos para asumir el rol a un servicio
de AWS.
Para obtener más información acerca del uso de IAM para delegar permisos, consulteAdministración de
accesosen laGuía del usuario de IAM.
A continuación, se muestra un ejemplo de política que concede permisos para una acción de DynamoDB
(dynamodb:ListTables). El carácter comodín (*) del campoResourceEl valor de indica que puede
utilizar esta acción para obtener los nombres de todas las tablas que son propiedad deAWSen la cuenta
actualAWSRegión .
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ListTables",
"Effect": "Allow",
"Action": [
"dynamodb:ListTables"
],
"Resource": "*"
}
]
}
Para obtener más información acerca del uso de políticas basadas en identidad con DynamoDB,
consulteUso de políticas basadas en identidad (políticas de IAM) con Amazon DynamoDB (p. 898). Para
obtener más información sobre usuarios, grupos, roles y permisos, consulte Identidades (usuarios, grupos
y roles) en la Guía del usuario de IAM.
Otros servicios, como Amazon S3, también admiten políticas de permisos basadas en recursos. Por
ejemplo, puede asociar una política a un bucket de S3 para administrar los permisos de acceso a dicho
bucket. DynamoDB no admite políticas basadas en recursos.
• Recurso: use un Nombre de recurso de Amazon (ARN) para identificar el recurso al que se aplica la
política. Para obtener más información, consulte Recursos y operaciones de DynamoDB (p. 896).
• Acción: utilice palabras clave de acción para identificar las operaciones del recurso que desea permitir
o denegar. Por ejemplo,dynamodb:Querypermite al usuario realizar los permisos para realizar
DynamoDBQuery.
• Efecto: especifique el efecto (permitir o denegar) cuando el usuario solicite la acción específica. Si no
concede acceso de forma explícita (permitir) a un recurso, el acceso se deniega implícitamente. También
puede denegar explícitamente el acceso a un recurso para asegurarse de que un usuario no pueda
obtener acceso a él, aunque otra política le conceda acceso.
• Entidad principal: en las políticas basadas en identidades (políticas de IAM), el usuario al que se asocia
esta política es la entidad principal implícita. Para las políticas basadas en recursos, debe especificar el
usuario, la cuenta, el servicio u otra entidad que desee que reciba permisos (se aplica solo a las políticas
basadas en recursos). DynamoDB no admite políticas basadas en recursos.
Para obtener más información acerca de la sintaxis y descripciones de las políticas de IAM,
consulteAWSReferencia de la política de IAMen laGuía del usuario de IAM.
Para un listEn la que se muestran todas las operaciones de la API de Amazon DynamoDB y los recursos
a los que se aplican, consulte: permisos de la API DynamoDB Referencia de acciones, recursos y
condiciones (p. 908).
Le recomendamos que consulte primero los temas de introducción en los que se explican los
conceptos básicos y las opciones disponibles para administrar el acceso a sus recursos de
DynamoDB. Para obtener más información, consulte Información general sobre la administración
de permisos de acceso a sus recursos de Amazon DynamoDB (p. 895).
• Permisos de IAM necesarios para utilizar la consola de Amazon DynamoDB (p. 899)
• AWSPolíticas de IAM administradas (predefinidas) por Amazon DynamoDB (p. 900)
• Ejemplos de políticas administradas por el cliente (p. 900)
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DescribeQueryScanBooksTable",
"Effect": "Allow",
"Action": [
"dynamodb:DescribeTable",
"dynamodb:Query",
"dynamodb:Scan"
],
"Resource": "arn:aws:dynamodb:us-west-2:account-id:table/Books"
}
]
}
La política de anterior tiene una instrucción que concede permisos para tres acciones de DynamoDB
(dynamodb:DescribeTable,dynamodb:Query, ydynamodb:Scan) en una tabla en elus-west-2
AWS, que es propiedad de laAWSla cuenta especificada poraccount-id. Lanombre de recurso de
Amazon (ARN)en laResourcevalor especifica la tablathatse aplican los permisosDe a.
Si crea una política de IAM que sea más restrictiva que el mínimo de permisos necesarios,
la consola no funcionará del modo esperado para los usuarios con esa política de IAM. Para
asegurarse de que esos usuarios puedan seguir utilizando la consola de DynamoDB, asocie también
laAmazonDynamoDBReadOnlyAccess AWSpara el usuario, como se describe enAWSPolíticas de IAM
administradas (predefinidas) por Amazon DynamoDB (p. 900).
No es necesario que conceda permisos mínimos para la consola a los usuarios que solo realizan llamadas
a laAWS CLIo la API de Amazon DynamoDB.
LaFLEGAWSLas políticas administradas de, que puede asociar a los usuarios de su cuenta, son
específicas de DynamoDB y se agrupan según los escenarios de caso de uso:
Puede revisar estosAWSInicie sesión en la consola de IAM y busque las políticas específicas.
Important
En los siguientes ejemplos de políticas se utiliza uno de losAWS RRegiones y tienen ID de cuenta
y nombres de tabla ficticios.
Ejemplos:
• Política de IAM para conceder permisos a todas las acciones de DynamoDB en una tabla (p. 901)
• Política de IAM para conceder permisos de solo lectura a los elementos de una tabla de
DynamoDB (p. 901)
• Política de IAM para conceder acceso a una tabla de DynamoDB específica y sus índices (p. 901)
• Directiva de IAM para leer, escribir, actualizar y eliminar el acceso en una tabla de DynamoDB (p. 902)
• Política de IAM para separar entornos de DynamoDB en el mismoAWSCuenta (p. 903)
• Política de IAM para evitar la compra de capacidad reservada de DynamoDB (p. 905)
• Política de IAM para conceder acceso de lectura para una secuencia de DynamoDB solamente (no para
la tabla) (p. 906)
• Directiva de IAM para permitir unaAWS LambdaFunción para acceder a registros de flujo de
DynamoDB (p. 907)
• Directiva de IAM para el acceso de lectura y escritura a un clúster de DynamoDB Accelerator
(DAX) (p. 908)
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllAPIActionsOnBooks",
"Effect": "Allow",
"Action": "dynamodb:*",
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/Books"
}
]
}
Note
A continuación, se muestra un ejemplo de cómo se utiliza un comodín (*) para
permitirTodoacciones, incluida la administración, las operaciones de datos, la supervisión y la
compra de capacidad reservada de DynamoDB. En su lugar, es una práctica recomendada
especificar explícitamente cada acción que se va a conceder y solo lo que necesita ese usuario,
rol o grupo.
Política de IAM para conceder permisos de solo lectura a los elementos de una
tabla de DynamoDB
La política de permisos siguiente concede permisos para laGetItem,BatchGetItem,Scan,Query,
yConditionCheckItemSólo acciones de DynamoDB y, como resultado, establece el acceso de sólo
lectura en elBooksUna tabla de
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ReadOnlyAPIActionsOnBooks",
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:BatchGetItem",
"dynamodb:Scan",
"dynamodb:Query",
"dynamodb:ConditionCheckItem"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/Books"
}
]
}
Política de IAM para conceder acceso a una tabla de DynamoDB específica y sus
índices
La política de siguiente concede permisos para acciones de modificación de datos en una tabla de
DynamoDB denominadaBooksy todos los índices de esa tabla. Para obtener más información sobre cómo
funcionan los índices, consulte Uso de índices secundarios para mejorar el acceso a los datos (p. 567).
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AccessTableAllIndexesOnBooks",
"Effect": "Allow",
"Action": [
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:BatchWriteItem",
"dynamodb:GetItem",
"dynamodb:BatchGetItem",
"dynamodb:Scan",
"dynamodb:Query",
"dynamodb:ConditionCheckItem"
],
"Resource": [
"arn:aws:dynamodb:us-west-2:123456789012:table/Books",
"arn:aws:dynamodb:us-west-2:123456789012:table/Books/index/*"
]
}
]
}
Directiva de IAM para leer, escribir, actualizar y eliminar el acceso en una tabla de
DynamoDB
Utilice esta política si necesita permitir que su aplicación cree, lea, actualice y elimine datos en tablas,
índices y secuencias de Amazon DynamoDB. Sustituya laAWSNombre de la región, el ID de su cuenta
yelNombre de tabla o carácter comodín (*), si procede.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DynamoDBIndexAndStreamAccess",
"Effect": "Allow",
"Action": [
"dynamodb:GetShardIterator",
"dynamodb:Scan",
"dynamodb:Query",
"dynamodb:DescribeStream",
"dynamodb:GetRecords",
"dynamodb:ListStreams"
],
"Resource": [
"arn:aws:dynamodb:us-west-2:123456789012:table/Books/index/*",
"arn:aws:dynamodb:us-west-2:123456789012:table/Books/stream/*"
]
},
{
"Sid": "DynamoDBTableAccess",
"Effect": "Allow",
"Action": [
"dynamodb:BatchGetItem",
"dynamodb:BatchWriteItem",
"dynamodb:ConditionCheckItem",
"dynamodb:PutItem",
"dynamodb:DescribeTable",
"dynamodb:DeleteItem",
"dynamodb:GetItem",
"dynamodb:Scan",
"dynamodb:Query",
"dynamodb:UpdateItem"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/Books"
},
{
"Sid": "DynamoDBDescribeLimitsAccess",
"Effect": "Allow",
"Action": "dynamodb:DescribeLimits",
"Resource": [
"arn:aws:dynamodb:us-west-2:123456789012:table/Books",
"arn:aws:dynamodb:us-west-2:123456789012:table/Books/index/*"
]
}
]
}
Para expandir esta directiva para que abarque todas las tablas de DynamoDB en todos losAWSEn las
regiones de esta cuenta, utilice un comodín (*) para la región y el nombre de la tabla. Por ejemplo:
"Resource":[
"arn:aws:dynamodb:*:123456789012:table/*/",
"arn:aws:dynamodb:*:123456789012:table/*/index/*"
]
Por este motivo, cada acción que se realiza en un entorno reduce el número de operaciones disponibles
en el otro entorno. Además, existe el riesgo de que el código del entorno obtenga por error acceso del otro
entorno.
Note
Si desea separar las cargas de trabajo de producción y de prueba para ayudar a controlar el
potencial «radio de explosión» de un evento, la mejor práctica es crearAWSpara las cargas de
trabajo de pruebas y producción. Para obtener más información, consulteAWSAdministración y
separación de cuentas.
Supongamos además que tiene dos desarrolladores, Amit y Alice, que están realizando las pruebas
deProductCatalogUna tabla de En lugar de cada desarrollador que requiera unAWSSus desarrolladores
pueden compartir la misma pruebaAWSaccount. En esta cuenta, puede crear una copia de la misma tabla
para cada desarrollador; por ejemplo, Alice_ProductCatalog y Amit_ProductCatalog. En este
caso, puede crear a los usuarios de IAM Alice y Amit en laAWSque creó para el entorno de prueba. A
continuación, puede conceder permisos a estos usuarios para que lleven a cabo acciones de DynamoDB
en las tablas de su propiedad.
Para conceder permisos a estos usuarios de IAM, puede realizar uno de los siguientes procedimientos:
• Cree una política independiente para cada usuario y, a continuación, adjunte cada política a su usuario
por separado. Por ejemplo, puede adjuntar la siguiente política al usuario Alice para concederle acceso a
acciones de DynamoDB en laAlice_ProductCatalogTabla de
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllAPIActionsOnAliceTable",
"Effect": "Allow",
"Action": [
"dynamodb:DeleteItem",
"dynamodb:DescribeContributorInsights",
"dynamodb:RestoreTableToPointInTime",
"dynamodb:ListTagsOfResource",
"dynamodb:CreateTableReplica",
"dynamodb:UpdateContributorInsights",
"dynamodb:CreateBackup",
"dynamodb:DeleteTable",
"dynamodb:UpdateTableReplicaAutoScaling",
"dynamodb:UpdateContinuousBackups",
"dynamodb:TagResource",
"dynamodb:DescribeTable",
"dynamodb:GetItem",
"dynamodb:DescribeContinuousBackups",
"dynamodb:BatchGetItem",
"dynamodb:UpdateTimeToLive",
"dynamodb:BatchWriteItem",
"dynamodb:ConditionCheckItem",
"dynamodb:UntagResource",
"dynamodb:PutItem",
"dynamodb:Scan",
"dynamodb:Query",
"dynamodb:UpdateItem",
"dynamodb:DeleteTableReplica",
"dynamodb:DescribeTimeToLive",
"dynamodb:RestoreTableFromBackup",
"dynamodb:UpdateTable",
"dynamodb:DescribeTableReplicaAutoScaling",
"dynamodb:GetShardIterator",
"dynamodb:DescribeStream",
"dynamodb:GetRecords",
"dynamodb:DescribeLimits",
"dynamodb:ListStreams"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/
Alice_ProductCatalog/*"
}
]
}
A continuación, puede crear una política distinta con un recurso diferente (la
políticaAmit_ProductCatalog) para el usuario Amit.
• En vez de adjuntar políticas a cada usuario, puede usar variables de políticas de IAM para escribir una
sola política y adjuntársela a un grupo. Debe crear un grupo y, en el caso de este ejemplo, agregar a ese
grupo a los dos usuarios, Alice y Amit. En el siguiente ejemplo se conceden permisos para llevar a cabo
todas las acciones de DynamoDB en la${aws:username}_ProductCatalogUna tabla de Al evaluar
la política, la variable ${aws:username} se reemplaza por el nombre de usuario del solicitante. Por
ejemplo, si Alice envía una solicitud para que se agregue un elemento, la acción solamente se permite si
Alice está agregando elementos a la tabla Alice_ProductCatalog.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ActionsOnUserSpecificTable",
"Effect": "Allow",
"Action": [
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:BatchWriteItem",
"dynamodb:GetItem",
"dynamodb:BatchGetItem",
"dynamodb:Scan",
"dynamodb:Query",
"dynamodb:ConditionCheckItem"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/
${aws:username}_ProductCatalog"
},
{
"Sid": "AdditionalPrivileges",
"Effect": "Allow",
"Action": [
"dynamodb:ListTables",
"dynamodb:DescribeTable",
"dynamodb:DescribeContributorInsights"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/*"
}
]
}
Note
En lugar de identificar una tabla específica como un recurso de como lo haría normalmente, podría utilizar
un carácter comodín (*) para conceder permisos en todas las tablas cuyo nombre lleve antepuesto el
usuario de IAM que realiza la solicitud, tal y como se muestra en el siguiente ejemplo.
"Resource":"arn:aws:dynamodb:us-west-2:123456789012:table/${aws:username}_*"
DynamoDB ofrece las siguientes operaciones de API para controlar el acceso a la administración de la
capacidad reservada:
LaAWS Management Consoleutiliza estas acciones de API para mostrar información sobre la capacidad
reservada y realizar adquisiciones. No puede llamar a estas operaciones desde un programa de aplicación
porque solo son accesibles desde la consola. Sin embargo, sí puede permitir o denegar el acceso a estas
operaciones en una política de permisos de IAM.
La siguiente política permite a los usuarios consultar las adquisiciones y las ofertas de capacidad
reservada mediante laAWS Management Console—pero las nuevas compras se deniegan.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowReservedCapacityDescriptions",
"Effect": "Allow",
"Action": [
"dynamodb:DescribeReservedCapacity",
"dynamodb:DescribeReservedCapacityOfferings"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:*"
},
{
"Sid": "DenyReservedCapacityPurchases",
"Effect": "Deny",
"Action": "dynamodb:PurchaseReservedCapacityOfferings",
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:*"
}
]
}
Tenga en cuenta que esta directiva utiliza el carácter comodín (*) para permitir la descripción de permisos
para todos los,yDe adenegarelcompra de capacidad reservada de DynamoDB para todos.
En algunos casos, es posible que desee impedir que una aplicación lea datos desde una tabla de
DynamoDB, pero al mismo tiempo desee permitir que se pueda obtener acceso a las secuencias de esa
tabla. Por ejemplo, puede configurarAWS LambdaPara que sondee una secuencia e invoque una función
Lambda cuando se detecten actualizaciones de elementos y, a continuación, realice un procesamiento
adicional.
Existen las siguientes acciones disponibles para controlar el acceso aStreams de DynamoDB:
• dynamodb:DescribeStream
• dynamodb:GetRecords
• dynamodb:GetShardIterator
• dynamodb:ListStreams
En el ejemplo siguiente, la política concede a los usuarios permisos para obtener acceso a las secuencias
de una tabla denominadaGameScores. El carácter de comodín (*) en el ARN coincide con cualquier
secuencia asociada a esa tabla.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AccessGameScoresStreamOnly",
"Effect": "Allow",
"Action": [
"dynamodb:DescribeStream",
"dynamodb:GetRecords",
"dynamodb:GetShardIterator",
"dynamodb:ListStreams"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores/stream/*"
}
]
}
Observe que esta política concede acceso a laGameScores, pero no a la tabla en sí.
Para conceder permisos a Lambda, utilice la directiva de permisos asociada con el rol de IAM de la función
Lambda (también conocencomo rol de ejecución). Especifique esta política al crear la función de Lambda.
Por ejemplo, puede asociar la siguiente política de permisos a un rol de ejecución con el fin de conceder
permisos a Lambda para realizar las acciones de DynamoDB Streams indicadas.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowLambdaFunctionInvocation",
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": [
"*"
]
},
{
"Sid": "APIAccessForDynamoDBStreams",
"Effect": "Allow",
"Action": [
"dynamodb:GetRecords",
"dynamodb:GetShardIterator",
"dynamodb:DescribeStream",
"dynamodb:ListStreams"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores/streams/
*"
}
]
}
Para obtener más información, consulteAWS LambdaPermisos deen laAWS LambdaGuía para
desarrolladores.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AmazonDynamoDBDAXDataOperations",
"Effect": "Allow",
"Action": [
"dax:GetItem",
"dax:PutItem",
"dax:ConditionCheckItem",
"dax:BatchGetItem",
"dax:BatchWriteItem",
"dax:DeleteItem",
"dax:Query",
"dax:UpdateItem",
"dax:Scan"
],
"Resource": "arn:aws:dax:eu-west-1:123456789012:cache/MyDAXCluster"
}
]
}
Para ampliar esta directiva a fin de abarcarDAXPara todos losAWSRegiones de una cuenta, utilice un
carácter comodín (*) para el nombre de la región.
"Resource": "arn:aws:dax:*:123456789012:cache/MyDAXCluster"
Puede usarAWSLas claves de condición generales de en sus políticas de DynamoDB para expresar
condiciones. Para obtener una lista completa deAWSteclas anchas, consulte laReferencia de elementos de
la política de IAM JSONen laGuía del usuario de IAM.
Además de la.AWSLas claves de condición que afectan a todo, DynamoDB tiene sus propias claves que
puede utilizar en las condiciones. Para obtener más información, consulte Uso de condiciones de políticas
de IAM para control de acceso preciso (p. 909).
Temas relacionados
• Control de acceso (p. 895)
• Uso de condiciones de políticas de IAM para control de acceso preciso (p. 909)
Overview
En DynamoDB, existe la opción de especificar condiciones al conceder permisos mediante una política de
IAM (consulteControl de acceso (p. 895)). Por ejemplo, puede hacer lo siguiente:
• Conceder permisos para que los usuarios puedan obtener acceso de solo lectura a determinados
elementos y atributos de una tabla o un índice secundario.
• Conceder permisos para que los usuarios puedan obtener acceso de solo escritura a determinados
atributos de una tabla, según la identidad del usuario en cuestión.
En DynamoDB, puede utilizar las claves de condición para especificar las condiciones en una política de
IAM, tal y como se muestra en el caso de uso en la siguiente sección.
Note
• Conceder permisos en una tabla, pero restringir el acceso a elementos específicos de esa tabla según
los valores de determinadas claves principales. Un ejemplo de ello sería una aplicación de una red social
de juegos en la cual los datos de juegos guardados de todos los usuarios se almacenan en una única
tabla, pero ningún usuario puede obtener acceso a los elementos de datos que no son de su propiedad,
como se muestra en la siguiente ilustración:
• Ocultar la información de tal forma que únicamente un subconjunto de atributos se encuentre visible
para el usuario. Un ejemplo de ello sería una aplicación que muestra datos de vuelos en los aeropuertos
cercanos a la ubicación donde se encuentra el usuario. Se muestran los nombres de las compañías
aéreas, los horarios de llegada y salida y los números de los vuelos. Sin embargo, se ocultan otros
atributos como el nombre de los pilotos o el número de pasajeros, como se muestra en la siguiente
ilustración:
Para implementar este tipo de control de acceso preciso, hay que escribir una política de permisos de
IAM que especifique las condiciones para obtener acceso a las credenciales de seguridad y los permisos
asociados. A continuación, se aplica la política de a los usuarios, los grupos o los roles de IAM creados
mediante la consola de IAM. La política de IAM puede restringir el acceso a elementos individuales de una
tabla, a los atributos de estos elementos o a ambas cosas al mismo tiempo.
Si lo desea, puede usar las identidades web federadas para controlar el acceso de los usuarios cuya
autenticación se lleva a cabo mediante Login with Amazon, Facebook o Google. Para obtener más
información, consulte Uso de identidades web federadas (p. 919).
El componente Condition de IAM se utiliza para implementar una política de control de acceso precisa.
Al agregar unaConditionEn una política de permisos, puede permitir o denegar el acceso a los
elementos y atributos de las tablas e índices de DynamoDB en función de sus requisitos empresariales
concretos.
Por ejemplo, tomemos una aplicación de juegos para móviles que permite a los usuarios seleccionar
un juego entre diversas opciones y jugar a él. La aplicación utiliza una tabla de DynamoDB
denominadaGameScoresPara llevar la cuenta de las puntuaciones altas y otros datos de los usuarios.
Cada elemento de la tabla se identifica de forma exclusiva con un identificador de usuario y el nombre
del juego que ha utilizado el usuario. La tabla GameScores tiene una clave principal compuesta de una
clave de partición (UserId) y de una clave de ordenación (GameTitle). Cada usuario solo tiene acceso
a los datos de juego asociados a su propio identificador de usuario. Para poder jugar, el usuario debe
pertenecer a un rol de IAM denominadoGameRoleCon una política de seguridad asociada.
Para administrar los permisos de los usuarios en esta aplicación, podría escribir una política de permisos
como la siguiente:
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowAccessToOnlyItemsMatchingUserID",
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:BatchGetItem",
"dynamodb:Query",
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:BatchWriteItem"
],
"Resource": [
"arn:aws:dynamodb:us-west-2:123456789012:table/GameScores"
],
"Condition": {
"ForAllValues:StringEquals": {
"dynamodb:LeadingKeys": [
"${www.amazon.com:user_id}"
],
"dynamodb:Attributes": [
"UserId",
"GameTitle",
"Wins",
"Losses",
"TopScore",
"TopScoreDateTime"
]
},
"StringEqualsIfExists": {
"dynamodb:Select": "SPECIFIC_ATTRIBUTES"
}
}
}
]
}
• dynamodb:LeadingKeys: esta clave de condición permite a los usuarios obtener acceso solo a los
elementos cuyo valor de clave de partición coincide con su identificador de usuario. Este identificador,
${www.amazon.com:user_id}, es una variable de sustitución. Para obtener más información sobre
las variables de sustitución, consulte Uso de identidades web federadas (p. 919).
• dynamodb:Attributes: esta clave de condición limita el acceso a los atributos concretos, de tal
forma que solamente las acciones enumeradas en la política de permisos pueden devolver valores para
estos atributos. Además, la cláusula StringEqualsIfExists garantiza que la aplicación proporcione
siempre una lista de atributos específicos que admiten acciones e impide que aplicación pueda solicitar
todos los atributos.
Al evaluar una política de IAM, el resultado siempre es true (verdadero, se permite el acceso) o false (falso,
se deniega el acceso). Si cualquier parte del componente Condition es false, la política completa se
evalúa en false y se deniega el acceso.
Important
Si utiliza dynamodb:Attributes, debe especificar los nombres de todos los atributos de clave
principal y clave de índice de la tabla y también de todos los índices secundarios enumerados en
la política. De lo contrario, DynamoDB no podrá utilizar estos atributos de clave para realizar la
acción solicitada.
Los documentos de políticas de IAM solamente pueden contener los siguientes caracteres Unicode:
tabulador horizontal (U+0009), salto de línea (U+000A), retorno de carro (U+000D) y caracteres
comprendidos entre U+0020 y U+00FF.
En la siguiente tabla se muestran las claves de condición específicas del servicio DynamoDB que se
aplican a DynamoDB.
• ALL_ATTRIBUTES
• ALL_PROJECTED_ATTRIBUTES
• SPECIFIC_ATTRIBUTES
• COUNT
dynamodb:Attributes Representa una lista de nombres los atributos de una solicitud o de los
atributos que se devuelven a partir de una solicitud.AttributesLos valores
de reciben el mismo nombre y tienen el mismo significado que los parámetros
de algunas acciones del API de DynamoDB, tal y como se muestra a
continuación:
• AttributesToGet
• ALL_OLD
• UPDATED_OLD
• ALL_NEW
• UPDATED_NEW
• TOTAL
• NONE
Muchas políticas de permisos de IAM permiten a los usuarios obtener acceso únicamente
los elementos de una tabla cuyo valor de clave de partición coincide con el identificador
de usuario. Por ejemplo, la aplicación de juegos que hemos mencionado antes limita el
acceso de este modo, de tal forma que cada usuario solo pueda obtener acceso a los
datos de juego que están asociados a su propio identificador de usuario. Las variables
de sustitución de IAM${www.amazon.com:user_id},${graph.facebook.com:id},
y${accounts.google.com:sub}contienen identificadores de usuario de Login with Amazon, Facebook
y Google. Para saber cómo una aplicación inicia sesión en uno de estos proveedores de identidad y
obtiene estos identificadores, consulte Uso de identidades web federadas (p. 919).
Note
Cada uno de los ejemplos de la sección siguiente establece en la cláusula Effect el valor Allow
y especifica solamente las acciones, los recursos y los parámetros que se permiten. Únicamente
se permite el acceso a aquello que se indica explícitamente en la política de IAM.
En algunos casos, se pueden modificar estas políticas de tal forma que se basen en la
denegación (en cuyo caso, se establecería la cláusula Effect en Deny y se invertiría toda
la lógica de la política). Sin embargo, recomendamos evitar el uso de políticas basadas en la
denegación con DynamoDB, ya que son difíciles de escribir correctamente en comparación
con las políticas basadas el permiso. Además, cualquier cambio futuro de la API de DynamoDB
(o de las entradas a la API existente) podrían dejar sin efectividad una política basada en la
denegación.
En esta sección se muestran varias políticas que permiten implementar el control de acceso preciso en las
tablas y los índices de DynamoDB.
Note
Todos los ejemplos utilizan la región us-west-2 y contienen identificadores de cuenta ficticios.
: 1 Concesión de permisos que limitan el acceso a los elementos con un valor de clave de
partición específico
La siguiente política concede permisos que permiten realizar un conjunto de acciones de DynamoDB
en laGamesScoreUna tabla de En ella, se utiliza la clave de condición dynamodb:LeadingKeys para
que los usuarios únicamente puedan realizar acciones en los elementos cuyo valor de clave de partición
UserID coincida con el identificador de usuario exclusivo de Login with Amazon correspondiente a la
aplicación.
Important
La lista de acciones no incluye permisos para Scan, porque Scan devuelve todos los elementos,
sean cuales sean sus claves principales.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "FullAccessToUserItems",
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:BatchGetItem",
"dynamodb:Query",
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:BatchWriteItem"
],
"Resource": [
"arn:aws:dynamodb:us-west-2:123456789012:table/GameScores"
],
"Condition": {
"ForAllValues:StringEquals": {
"dynamodb:LeadingKeys": [
"${www.amazon.com:user_id}"
]
}
}
}
]
}
Note
Cuando utiliza variables de políticas, debe especificar de forma explícita la versión 2012-10-17
en la política. La versión predeterminada del lenguaje de la política de acceso, 2008-10-17, no
admite variables de políticas.
Para implementar el acceso de solo lectura, puede eliminar todas las acciones que permitan modificar los
datos. En la siguiente política, solo se incluyen en la condición las acciones que proporcionan acceso de
solo lectura.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ReadOnlyAccessToUserItems",
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:BatchGetItem",
"dynamodb:Query"
],
"Resource": [
"arn:aws:dynamodb:us-west-2:123456789012:table/GameScores"
],
"Condition": {
"ForAllValues:StringEquals": {
"dynamodb:LeadingKeys": [
"${www.amazon.com:user_id}"
]
}
}
}
]
}
Important
La siguiente política de permisos únicamente permite obtener acceso a dos atributos concretos de una
tabla; para ello, se agrega la clave de condición dynamodb:Attributes. Estos atributos se pueden leer,
escribir o evaluar en una escritura condicional o un filtro de examen.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "LimitAccessToSpecificAttributes",
"Effect": "Allow",
"Action": [
"dynamodb:UpdateItem",
"dynamodb:GetItem",
"dynamodb:Query",
"dynamodb:BatchGetItem",
"dynamodb:Scan"
],
"Resource": [
"arn:aws:dynamodb:us-west-2:123456789012:table/GameScores"
],
"Condition": {
"ForAllValues:StringEquals": {
"dynamodb:Attributes": [
"UserId",
"TopScore"
]
},
"StringEqualsIfExists": {
"dynamodb:Select": "SPECIFIC_ATTRIBUTES",
"dynamodb:ReturnValues": [
"NONE",
"UPDATED_OLD",
"UPDATED_NEW"
]
}
}
}
]
}
Note
La política toma unLista de permitidas, que permite obtener acceso a los atributos que se
nombran explícitamente. Puede escribir una política equivalente que deniegue el acceso a
los demás atributos. No le recomendamos esteLista de denegaciónEnfoque. Los usuarios
pueden determinar los nombres de estos atributos denegados siguiendo elPrincipio de privilegios
mínimos, como se explica en Wikipedia enhttp://en.wikipedia.org/wiki/Principle_of_least_privilege,
y use unLista de permitidasPara enumerar todos los valores permitidos, en lugar de especificar los
atributos denegados.
Esta política no permite PutItem, DeleteItem ni BatchWriteItem. Estas acciones siempre sustituyen
el elemento anterior en su totalidad y esto permitiría a los usuarios eliminar valores de atributos anteriores
a los que no se les permite obtener acceso.
La siguiente política de permisos limita el acceso del usuario de forma que únicamente pueda actualizar
los atributos concretos que se identifican mediante la clave de condición dynamodb:Attributes. La
condición StringNotLike impide que una aplicación actualice los atributos especificados con la clave de
condición dynamodb:Attributes.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "PreventUpdatesOnCertainAttributes",
"Effect": "Allow",
"Action": [
"dynamodb:UpdateItem"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores",
"Condition": {
"ForAllValues:StringNotLike": {
"dynamodb:Attributes": [
"FreeGamesAvailable",
"BossLevelUnlocked"
]
},
"StringEquals": {
"dynamodb:ReturnValues": [
"NONE",
"UPDATED_OLD",
"UPDATED_NEW"
]
}
}
}
]
}
• La acción UpdateItem, al igual que otras acciones de escritura, requiere acceso de lectura a los
elementos para que pueda devolver valores antes y después de la actualización. En la política, se
limita la acción para obtener acceso exclusivamente a los atributos que está permitido actualizar
especificando la clave de condición dynamodb:ReturnValues. La clave de condición restringe el valor
de ReturnValues en la solicitud porque solo permite especificar NONE, UPDATED_OLD o UPDATED_NEW
y no incluye ALL_OLD ni ALL_NEW.
• Las acciones PutItem y DeleteItem sustituyen un elemento completo y, por consiguiente, permiten
que las aplicaciones modifiquen cualquier atributo. Así pues, para limitar una aplicación de modo que
únicamente pueda actualizar determinados atributos, no debe conceder permisos para estos API.
Para exigir a la aplicación que especifique una lista de atributos en la consulta, la política especifica
tambiéndynamodb:Selectpara requerir que elSelectParámetro del DynamoDBQueryLa acción
esSPECIFIC_ATTRIBUTES. La lista de atributos se limita a unos elementos concretos que se obtienen
utilizando la clave de condición dynamodb:Attributes.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "QueryOnlyProjectedIndexAttributes",
"Effect": "Allow",
"Action": [
"dynamodb:Query"
],
"Resource": [
"arn:aws:dynamodb:us-west-2:123456789012:table/GameScores/index/
TopScoreDateTimeIndex"
],
"Condition": {
"ForAllValues:StringEquals": {
"dynamodb:Attributes": [
"TopScoreDateTime",
"GameTitle",
"Wins",
"Losses",
"Attempts"
]
},
"StringEquals": {
"dynamodb:Select": "SPECIFIC_ATTRIBUTES"
}
}
}
]
La siguiente política de permisos es similar, pero la consulta debe solicitar todos los atributos que se han
proyectado en el índice.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "QueryAllIndexAttributes",
"Effect": "Allow",
"Action": [
"dynamodb:Query"
],
"Resource": [
"arn:aws:dynamodb:us-west-2:123456789012:table/GameScores/index/
TopScoreDateTimeIndex"
],
"Condition": {
"StringEquals": {
"dynamodb:Select": "ALL_PROJECTED_ATTRIBUTES"
}
}
}
]
}
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "LimitAccessToCertainAttributesAndKeyValues",
"Effect": "Allow",
"Action": [
"dynamodb:UpdateItem",
"dynamodb:GetItem",
"dynamodb:Query",
"dynamodb:BatchGetItem"
],
"Resource": [
"arn:aws:dynamodb:us-west-2:123456789012:table/GameScores",
"arn:aws:dynamodb:us-west-2:123456789012:table/GameScores/index/
TopScoreDateTimeIndex"
],
"Condition": {
"ForAllValues:StringEquals": {
"dynamodb:LeadingKeys": [
"${graph.facebook.com:id}"
],
"dynamodb:Attributes": [
"attribute-A",
"attribute-B"
]
},
"StringEqualsIfExists": {
"dynamodb:Select": "SPECIFIC_ATTRIBUTES",
"dynamodb:ReturnValues": [
"NONE",
"UPDATED_OLD",
"UPDATED_NEW"
]
}
}
}
]
}
• Las acciones de escritura permitidas por la política (UpdateItem) solo pueden modificar attribute-A
o attribute-B.
• Dado que la política permite UpdateItem, una aplicación puede insertar nuevos elementos
y los atributos ocultos serán null en los nuevos elementos. Si estos atributos se proyectan en
TopScoreDateTimeIndex, la política incluirá la ventaja agregada de impedir las consultas que
generen operaciones de recuperación (fetch) en la tabla.
• Las aplicaciones no pueden leer ningún atributo que no figure en dynamodb:Attributes.
Con esta política en vigor, una aplicación debe establecer la propiedadSelectParámetro
paraSPECIFIC_ATTRIBUTESen las solicitudes de lectura, y solo se pueden solicitar los atributos de la
lista de permisos. En las solicitudes de escritura, la aplicación no puede establecer ReturnValues en
ALL_OLD ni ALL_NEW ni puede llevar a cabo operaciones de escritura condicionales basadas en otros
atributos que no sean estos.
Temas relacionados
• Control de acceso (p. 895)
• : permisos de la API DynamoDB Referencia de acciones, recursos y condiciones (p. 908)
• El postUso de identidades web federadasAWS SDK for .NETen elAWSEl blog de desarrolladores
explica cómo utilizar las identidades web federadas con Facebook. Incluye fragmentos de código en
C# que muestran cómo asumir un rol de IAM con identidad web y cómo usar credenciales de seguridad
temporales para obtener acceso a unAWSRecurso.
• LaAWS Mobile SDK for iOSy laAWS Mobile SDK for Androidcontienen aplicaciones de ejemplo. Incluyen
código que muestra cómo invocar a los proveedores de identidad y, a continuación, cómo utilizar la
información de estos proveedores para recibir y utilizar credenciales de seguridad temporales.
• En el artículo Web Identity Federation with Mobile Applications se explican las identidades web
federadas y se muestra un ejemplo de cómo utilizarlas para obtener acceso a un recurso de AWS.
Nombre de la tabla Tipo de clave principal Nombre y tipo de clave Nombre y tipo de clave
de partición de ordenación
Ahora, supongamos que una aplicación de juegos para móviles utiliza la aplicación, con lo cual esta tiene
que aceptar miles o incluso millones de usuarios. A esta escala, resulta muy complicado administrar
individualmente a los usuarios de la aplicación y garantizar que cada uno de ellos únicamente pueda
obtener acceso a sus propios datos en la tabla GameScores. Afortunadamente, muchos usuarios ya tiene
cuentas de un proveedor de identidades tercero, como Facebook, Google o Login with Amazon. Por este
motivo, es lógico utilizar alguno de ellos para llevar a cabo las tareas de autenticación.
Para hacer esto mediante las identidades web federadas, el desarrollador de la aplicación debe registrar
esta última en un proveedor de identidades (como Login with Amazon) y obtener un identificador de
aplicación exclusivo. A continuación, el desarrollador debe crear un rol de IAM. (En este ejemplo, este rol
se llama GameRole). El rol debe tener adjunto un documento de política de IAM en el que se especifiquen
las condiciones en virtud de las cuales la aplicación podrá obtener acceso aGameScoresUna tabla de
Cuando un usuario desee jugar, iniciará sesión en esta cuenta de Login with Amazon desde la propia
aplicación de juegos. A continuación, la aplicación llamará a AWS Security Token Service ( AWS STS ),
proporcionará el identificador de aplicación de Login with Amazon y solicitará formar parte de GameRole.
AWS STS devolverá credenciales temporales de AWS a la aplicación y permitirá que esta última obtenga
acceso a la tabla GameScores, de acuerdo con lo establecido en el documento de política GameRole.
Una vez más, esta es la política de seguridad de GameRole que se mostró en Uso de condiciones de
políticas de IAM para control de acceso preciso (p. 909):
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowAccessToOnlyItemsMatchingUserID",
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:BatchGetItem",
"dynamodb:Query",
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:BatchWriteItem"
],
"Resource": [
"arn:aws:dynamodb:us-west-2:123456789012:table/GameScores"
],
"Condition": {
"ForAllValues:StringEquals": {
"dynamodb:LeadingKeys": [
"${www.amazon.com:user_id}"
],
"dynamodb:Attributes": [
"UserId",
"GameTitle",
"Wins",
"Losses",
"TopScore",
"TopScoreDateTime"
]
},
"StringEqualsIfExists": {
"dynamodb:Select": "SPECIFIC_ATTRIBUTES"
}
}
}
]
}
La cláusula Condition determina qué elementos de GameScores están visibles para la aplicación. Para
ello, compara el identificador de Login with Amazon con los valores de las claves de partición UserId de
GameScores. Solamente los elementos que pertenecen al usuario actual se pueden procesar utilizando
una de las acciones de DynamoDB enumeradas en esta política. No se puede obtener acceso a los demás
elementos de la tabla. Además, solo se puede obtener acceso a los atributos específicos enumerados en
la política.
1. Inicie sesión como desarrollador con un proveedor de identidades tercero. Los siguientes enlaces
externos proporcionan información sobre cómo inscribirse en los proveedores de identidad admitidos:
• Login with Amazon Developer Center
• Registration en el sitio web de Facebook
• Using OAuth 2.0 to Access Google APIs en el sitio de Google
2. Registre su aplicación en el proveedor de identidades. Cuando lo haga, el proveedor le proporcionará un
identificador exclusivo de la aplicación. Si desea que la aplicación funcione con varios proveedores de
identidades, tendrá que obtener un ID de aplicación de cada proveedor.
3. Cree uno o varios roles de IAM. Se requiere un rol para cada proveedor de identidades de cada
aplicación. Por ejemplo, puede crear un rol que una aplicación asuma cuando el usuario inicie sesión
mediante Login with Amazon, un segundo rol que la misma aplicación use cuando el usuario inicie
sesión mediante Facebook y un tercer rol que dicha aplicación utilice cuando el usuario inicie sesión
mediante Google.
Durante el proceso de creación de roles, deberá adjuntar una política de IAM al rol. El documento de
política debe definir los recursos de DynamoDB que la aplicación requiere y los permisos para obtener
acceso a ellos.
Para obtener más información, consulteAcerca de identidades web federadasinGuía del usuario de IAM.
Note
Como alternativa aAWS Security Token Service, puede utilizar Amazon Cognito. Amazon Cognito
es el servicio preferido para administrar credenciales temporales de aplicaciones para móviles.
Para obtener más información, consulte las páginas siguientes:
Cuando esté conforme con los ajustes, haga clic en Create policy (Crear política). Aparecerá la política
generada.
6. Haga clic enAsociación de instrucciones de políticay siga los pasos necesarios para adjuntar la política
generada a un rol de IAM.
En tiempo de ejecución, si la aplicación utiliza identidades web federadas, deberá seguir estos pasos:
Una vez que el proveedor de identidades ha autenticado al usuario, devuelve un token de identidad web
a la aplicación. El formato de este token depende del proveedor, pero suele ser una cadena muy larga
de caracteres.
2. Obtenga información temporalAWSCredenciales de seguridad. Para ello, la aplicación envía una
solicitud AssumeRoleWithWebIdentity a AWS Security Token Service ( AWS STS ). Esta solicitud
contiene los siguientes componentes:
• El token de identidad web del paso anterior
• El identificador de la aplicación del proveedor de identidades
• El nombre de recurso de Amazon (ARN) del rol de IAM que se ha creado para este proveedor de
identidades y esta aplicación
AWS STS devuelve un conjunto deAWSLas credenciales de seguridad que vencen transcurrido un
periodo determinado (el valor predeterminado son 3.600 segundos).
GET / HTTP/1.1
Host: sts.amazonaws.com
Content-Type: application/json; charset=utf-8
URL: https://sts.amazonaws.com/?ProviderId=www.amazon.com
&DurationSeconds=900&Action=AssumeRoleWithWebIdentity
&Version=2011-06-15&RoleSessionName=web-identity-federation
&RoleArn=arn:aws:iam::123456789012:role/GameRole
&WebIdentityToken=Atza|IQEBLjAsAhQluyKqyBiYZ8-kclvGTYM81e...(remaining characters
omitted)
<AssumeRoleWithWebIdentityResponse
xmlns="https://sts.amazonaws.com/doc/2011-06-15/">
<AssumeRoleWithWebIdentityResult>
<SubjectFromWebIdentityToken>amzn1.account.AGJZDKHJKAUUSW6C44CHPEXAMPLE</
SubjectFromWebIdentityToken>
<Credentials>
<SessionToken>AQoDYXdzEMf//////////wEa8AP6nNDwcSLnf+cHupC...(remaining characters
omitted)</SessionToken>
<SecretAccessKey>8Jhi60+EWUUbbUShTEsjTxqQtM8UKvsM6XAjdA==</SecretAccessKey>
<Expiration>2013-10-01T22:14:35Z</Expiration>
<AccessKeyId>06198791C436IEXAMPLE</AccessKeyId>
</Credentials>
<AssumedRoleUser>
<Arn>arn:aws:sts::123456789012:assumed-role/GameRole/web-identity-federation</Arn>
<AssumedRoleId>AROAJU4SA2VW5SZRF2YMG:web-identity-federation</AssumedRoleId>
</AssumedRoleUser>
</AssumeRoleWithWebIdentityResult>
<ResponseMetadata>
<RequestId>c265ac8e-2ae4-11e3-8775-6969323a932d</RequestId>
</ResponseMetadata>
</AssumeRoleWithWebIdentityResponse>
3. Acceso aAWSde AWS. La respuesta de AWS STS contiene información que la aplicación precisa para
poder obtener acceso a los recursos de DynamoDB:
• Los campos AccessKeyID, SecretAccessKey y SessionToken contienen credenciales de
seguridad que son válidas para este usuario y esta aplicación exclusivamente.
• El campo Expiration indica el límite de tiempo tras el cual estas credenciales ya no serán válidas.
• LaAssumedRoleIdEl campo contiene el nombre de un rol de IAM específico de la sesión que
la aplicación ha asumido y es específico de. La aplicación respeta los controles de acceso del
documento de política de IAM mientras dure esta sesión.
• LaSubjectFromWebIdentityTokenEl campo contiene el identificador exclusivo que aparece
en una variable de política de IAM para este proveedor de identidades concreto. A continuación se
muestran las variables de política de IAM correspondientes a los proveedores admitidos y algunos
ejemplos de valores que pueden adoptar:
${www.amazon.com:user_id} amzn1.account.AGJZDKHJKAUUSW6C44CHPEXAMPLE
${graph.facebook.com:id} 123456789
${accounts.google.com:sub} 123456789012345678901
Por ejemplo, políticas de IAM en las que se utilizan estas variables de política, consulteEjemplos de
políticas: Uso de condiciones para control de acceso detallado (p. 913).
Para obtener más información sobre cómoAWS STSgenera credenciales de acceso temporales,
consulteSolicitud de credenciales de seguridad temporalesinGuía del usuario de IAM.
Para obtener más información acerca de Identity and Access Management en DAX, consulteControl de
acceso DAX (p. 814).
AWS proporciona una lista actualizada frecuentemente de los servicios de AWS adscritos al ámbito de los
programas de conformidad en Servicios de AWS en el ámbito del programa de conformidad.
Los informes de auditoría de terceros están disponibles para su descarga utilizando AWS Artifact. Para
obtener más información, consulte Descarga de informes en AWS Artifact.
Para obtener más información acerca de los programas de conformidad de AWS, consulte Programas de
conformidad de AWS.
• AWS Config: un servicio que evalúa en qué medida las configuraciones de los recursos cumplen las
prácticas internas, las directrices del sector y las normativas.
• AWSCentro de seguridad de— Una visión completa de su estado de seguridad dentro deAWSDe este
modo, podrá contrariar el grado de conformidad con las prácticas recomendadas y los estándares
sectoriales.
Para obtener más información sobre zonas de disponibilidad y las regiones de AWS, consulte
Infraestructura global de AWS.
Además de laAWS, Amazon DynamoDB ofrece varias características que le ayudan con sus necesidades
de resiliencia y copia de seguridad de los datos.
DynamoDB proporciona una funcionalidad de backup bajo demanda. Le permite crear copias de
seguridad completas de las tablas para una retención y archivado a largo plazo. Para obtener más
información, consulteBackup y restauración bajo demanda para DynamoDB.
Recuperación a un momento dado
UtilizaAWSpara obtener acceso a DynamoDB a través de la red. Los clientes deben ser compatibles con
TLS (Transport Layer Security 1.0. RecomendamosTLS 1.2o posterior. Los clientes también deben admitir
conjuntos de cifrado con confidencialidad directa total (PFS) tales como Ephemeral Diffie-Hellman (DHE)
o Elliptic Curve Diffie-Hellman Ephemeral (ECDHE). La mayoría de los sistemas modernos como Java 7 y
posteriores son compatibles con estos modos. Además, las solicitudes deben estar firmadas mediante un
ID de clave de acceso y una clave de acceso secreta que esté asociada a una entidad principal de IAM.
También puede utilizar AWS Security Token Service (AWS STS) para generar credenciales de seguridad
temporales para firmar solicitudes.
También puede utilizar un punto de conexión de la nube privada virtual (VPC) para DynamoDB para
que las instancias de Amazon EC2 de la VPC utilicen sus direcciones IP privadas para tener acceso a
DynamoDB sin exponerse en la Internet pública. Para obtener más información, consulte Uso de puntos de
enlace de Amazon VPC para obtener acceso a DynamoDB (p. 927).
Para obtener acceso a la red pública de Internet, la VPC debe tener un puerto de enlace a Internet, es
decir, un router virtual que conecta su VPC a Internet. Esto permite a las aplicaciones que se ejecutan en
Amazon EC2 de su VPC obtener acceso a los recursos de Internet, como Amazon DynamoDB.
A muchos clientes les preocupa con razón la privacidad y la seguridad en el envío y recepción de datos a
través de la red pública de Internet. Estas preocupaciones se pueden atajar con el uso de una red privada
virtual (VPN) para dirigir todo el tráfico de la red de DynamoDB a través de su propia infraestructura de red
corporativa. Sin embargo, este enfoque puede conllevar problemas de ancho de banda y disponibilidad.
Estos problemas se pueden solapar con puntos de conexión de la VPC para DynamoDB. APunto de
conexión VPCPara DynamoDB, permite que las instancias de Amazon EC2 de su VPC utilicen sus
direcciones IP privadas para tener acceso a DynamoDB sin exponerse en la Internet pública. Sus
instancias EC2 no tienen que ser direcciones IP públicas ni en su VPC es necesaria una gateway de
Internet, un dispositivo NAT o una gateway privada virtual. Puede utilizar políticas de punto de enlace para
controlar el acceso a DynamoDB. El tráfico entre la VPC yAWSEl servicio no sale de la red de Amazon.
Cuando crea un punto de enlace de la VPC para DynamoDB, todas las solicitudes a un punto de enlace
de DynamoDB dentro de la región (por ejemplo,dynamodb.us-west-west-2.amazonaws.com) se enrutan a
un extremo privado de DynamoDB dentro de la red de Amazon. No es necesario modificar las aplicaciones
que se ejecutan en instancias EC2 de su VPC. El nombre del punto de enlace sigue siendo el mismo,
pero la ruta a DynamoDB permanece por completo dentro de la red de Amazon y no tiene acceso a la red
pública de Internet.
En el siguiente diagrama se muestra cómo una instancia EC2 de una VPC, puede utilizar un punto de
conexión de la VPC para tener acceso a DynamoDB.
Para obtener más información, consulte the section called “Tutorial: Uso de un punto de conexión de la
VPC para DynamoDB” (p. 928).
Temas
• Paso 1: Lanzamiento de una instancia de Amazon EC2 (p. 929)
• Paso 2: Configuración de la instancia de Amazon EC2 (p. 930)
• Paso 3: Creación de un punto de conexión de la VPC para DynamoDB (p. 931)
• Paso 4: (Opcional) Limpieza (p. 932)
• En la parte superior de la lista de AMI, vaya a Amazon Linux AMI (AMI de Amazon Linux) y elija
Select (Seleccionar).
• Elija para omitir este paso.Siguiente: Página Tag Instance (Instancia de etiqueta).
• Elija para omitir este paso.Siguiente: Página Configure Security Group (Configurar grupo de
seguridad).
• Elija Launch.
3. En la ventana Select an existing key pair or create a new key pair, proceda del modo siguiente:
• Si no dispone de un key pair de Amazon EC2, elijaCreación de un nuevo key pairSiga las
instrucciones. Se le pedirá que descargue un archivo de clave privada (.pemNecesitará este archivo
más tarde cuando inicie sesión en su instancia de Amazon EC2.
• Si ya dispone de un key pair de Amazon EC2, vaya aSeleccionar un par de clavesElija su key pair
de la lista. Debe disponer del archivo de clave privada (.pemPara poder iniciar sesión en la instancia
de Amazon EC2.
4. Cuando haya configurado el par de claves, elija Launch Instances.
5. Vuelva a la página de inicio de la consola de Amazon EC2 y elija la instancia que ha lanzado. En
el panel inferior, en laDescripción, busque la pestañaDNS públicoPara su instancia. Por ejemplo:
ec2-00-00-00-00.us-east-1.compute.amazonaws.com.
Anote el nombre de DNS público, pues lo necesitará en el paso siguiente de este tutorial (Paso 2:
Configuración de la instancia de Amazon EC2 (p. 930)).
Note
La instancia de Amazon EC2 tardará unos minutos en estar disponible. Antes de continuar con
el siguiente paso, asegúrese de que Instance State tenga el valor running y de que se hayan
superado todas las comprobaciones de estado (Status Checks).
En los pasos siguientes se presupone que se va a conectar a la instancia de Amazon EC2 desde
un equipo que ejecuta Linux. Para conocer otras formas de conexión, consulteConexión con la
instancia de Linuxen la Guía del usuario de Amazon EC2 para instancias de Linux.
1. Tendrá que autorizar el tráfico SSH entrante en su instancia de Amazon EC2. Para ello, creará un
nuevo grupo de seguridad de EC2 y, a continuación, asignará el grupo de seguridad a la instancia
EC2.
• Nombre del grupo de seguridad: escriba un nombre para su grupo de seguridad. Por ejemplo:
my-ssh-access
• Description: escriba una breve descripción del grupo de seguridad.
• VPC: seleccione la VPC predeterminada.
• En la sección Security group rules, elija Add Rule y proceda del modo siguiente:
• Type: elija SSH.
• Source: elija My IP.
Deberá especificar el archivo de clave privada (.pem) y el nombre DNS público de la instancia.
(Consulte Paso 1: Lanzamiento de una instancia de Amazon EC2 (p. 929)).
aws configure
Ahora está listo para crear un punto de conexión de la VPC para DynamoDB.
1. Antes de empezar, compruebe que puede comunicarse con DynamoDB mediante su punto de enlace
público.
La salida mostrará una lista de las tablas de DynamoDB de que tiene actualmente. (Si no tiene tablas,
la lista estará vacía).
2. Compruebe que DynamoDB es un servicio disponible para la creación de puntos de conexión de la
VPC en laAWSRegión . (El comando se muestra en negrita, seguido del resultado de ejemplo).
{
"ServiceNames": [
"com.amazonaws.us-east-1.s3",
"com.amazonaws.us-east-1.dynamodb"
]
}
En el resultado de ejemplo, DynamoDB es uno de los servicios disponibles, por lo que puede a
empezar crear un punto de conexión de la VPC para este servicio.
3. Determine el identificador de su VPC.
{
"Vpcs": [
{
"VpcId": "vpc-0bbc736e",
"InstanceTenancy": "default",
"State": "available",
"DhcpOptionsId": "dopt-8454b7e1",
"CidrBlock": "172.31.0.0/16",
"IsDefault": true
}
]
}
{
"VpcEndpoint": {
"PolicyDocument": "{\"Version\":\"2008-10-17\",\"Statement\":[{\"Effect\":
\"Allow\",\"Principal\":\"*\",\"Action\":\"*\",\"Resource\":\"*\"}]}",
"VpcId": "vpc-0bbc736e",
"State": "available",
"ServiceName": "com.amazonaws.us-east-1.dynamodb",
"RouteTableIds": [
"rtb-11aa22bb"
],
"VpcEndpointId": "vpce-9b15e2f2",
"CreationTimestamp": "2017-07-26T22:00:14Z"
}
}
5. Compruebe que puede tener acceso a DynamoDB a través del punto de conexión de la VPC.
Si lo desea, puede probar otrosAWS CLIpara DynamoDB. Para obtener más información, consulte la
Referencia de comandos de la AWS CLI.
{
"VpcEndpoint": {
"PolicyDocument": "{\"Version\":\"2008-10-17\",\"Statement\":[{\"Effect\":
\"Allow\",\"Principal\":\"*\",\"Action\":\"*\",\"Resource\":\"*\"}]}",
"VpcId": "vpc-0bbc736e",
"State": "available",
"ServiceName": "com.amazonaws.us-east-1.dynamodb",
"RouteTableIds": [],
"VpcEndpointId": "vpce-9b15e2f2",
"CreationTimestamp": "2017-07-26T22:00:14Z"
}
}
{
"Unsuccessful": []
}
La matriz vacía [] indica que la operación se ha realizado correctamente (no hay solicitudes con
error).
Las siguientes prácticas recomendadas sobre seguridad también evaluan la configuración y los análisis de
vulnerabilidades en Amazon DynamoDB:
Temas
Cifrado en reposo
DynamoDB cifra en reposo todos los datos de usuario almacenados en tablas, índices, flujos y copias
de seguridad mediante claves de cifrado almacenadas enAWS Key Management Service(AWS KMS).
Esto proporciona una capa adicional de protección de datos al proteger los datos del acceso no
autorizado al almacenamiento subyacente.
Al conceder permisos, decide quién debe obtenerlos, para qué API de DynamoDB se obtienen y qué
acciones específicas desea permitir en esos recursos. La implementación del privilegio mínimo es
clave a la hora de reducir los riesgos de seguridad y el impacto que pueden causar los errores o los
intentos malintencionados.
Adjuntar políticas de permisos a identidades de IAM (es decir, usuarios, grupos y roles) y, de ese
modo, conceder permisos para realizar operaciones en recursos de DynamoDB.
Al conceder permisos en DynamoDB, puede especificar condiciones que determinan cómo se aplica
una política de permisos. La implementación del privilegio mínimo es clave a la hora de reducir los
riesgos de seguridad y el impacto que pueden causar los errores o los intentos malintencionados.
Puede especificar condiciones cuando se conceden permisos mediante una política de IAM. Por
ejemplo, puede hacer lo siguiente:
• Conceder permisos para que los usuarios puedan obtener acceso de solo lectura a determinados
elementos y atributos de una tabla o un índice secundario.
• Conceder permisos para que los usuarios puedan obtener acceso de solo escritura a determinados
atributos de una tabla, según la identidad del usuario en cuestión.
Para obtener más información, consulte Uso de condiciones de políticas de IAM para control de
acceso preciso.
Utilizar un extremo de VPC y directivas para acceder a DynamoDB
Si solo necesita acceso a DynamoDB desde una nube privada virtual (VPC), debe usar un extremo de
VPC para limitar el acceso solo desde la VPC requerida. Al hacer esto, se impide que el tráfico pueda
recorrer una red de Internet de acceso público y estar sujeto a esa red.
El uso de un extremo de VPC para DynamoDB le permite controlar y limitar el acceso mediante lo
siguiente:
• Directivas de punto final de VPC: estas directivas se aplican en el extremo de DynamoDB VPC. Le
permiten controlar y limitar el acceso a la API de la tabla DynamoDB.
• Directivas de IAM: mediante el uso deaws:sourceVpceen las directivas asociadas a usuarios,
grupos o roles de IAM, puede exigir que todo el acceso a la tabla de DynamoDB se realice a través
del extremo de VPC especificado.
Si almacena datos confidenciales o confidenciales en DynamoDB, es posible que desee cifrar esos
datos lo más cerca posible de su origen para que los datos estén protegidos durante todo su ciclo de
vida. El cifrado de su información confidencial en tránsito y en reposo ayuda a garantizar que los datos
de texto no cifrado no estén disponibles para ningún tercero.
LaAmazon DynamoDB cifradoEs una biblioteca de software que le ayuda a proteger los datos de la
tabla antes de enviarlos a DynamoDB.
En el centro del cliente de cifrado de DynamoDB se encuentra un encriptador de elementos que cifra,
firma, verifica y descifra elementos de tabla. Recibe información acerca de los elementos de tabla
e instrucciones acerca de qué elementos hay que cifrar y firmar. Obtiene los materiales de cifrado y
las instrucciones sobre su uso de un proveedor de materiales criptográficos que usted selecciona y
configura.
Si utilizaAWSclave maestra del cliente administradapara el cifrado en reposo, el uso de esta clave
se inicia sesión enAWS CloudTrail. CloudTrail proporciona visibilidad de la actividad del usuario
mediante la grabación de las acciones realizadas en su cuenta. CloudTrail registra información
importante acerca de cada acción, incluido quién hizo la solicitud, los servicios utilizados, las acciones
realizadas, los parámetros de las acciones y los elementos de respuesta devueltos por elAWS service.
Esta información le ayuda a realizar un seguimiento de los cambios realizados en suAWSrecursos
y solucionar problemas operativos. CloudTrail facilita el cumplimiento de las políticas internas y las
normas reglamentarias.
Puede utilizar CloudTrail para auditar el uso de las claves. CloudTrail crea archivos de registro que
contienen un historial deAWSLas llamadas a la API de y los eventos relacionados de su cuenta Estos
archivos de registro incluyen todos losAWS KMSLas solicitudes de API realizadas medianteAWS
Management Console,AWSSDK y herramientas de línea de comandos, además de las creadas
a través deAWSServicios de . Puede utilizar estos archivos de registro para obtener información
sobre cuándo se usó la CMK, la operación que se solicitó, la identidad del solicitante, la dirección
CloudTrail puede supervisar tanto los eventos del plano de control como los eventos del plano de
datos. Las operaciones del plano de control permiten crear y administrar tablas de DynamoDB.
También permiten usar índices, secuencias y otros objetos que dependen de las tablas. Las
operaciones del plano de datos permiten llevar a cabo actividades de creación, lectura, actualización
y eliminación (tambiénCRUD) sobre los datos de una tabla. Algunas operaciones del plano de datos
permiten también leer datos de un índice secundario. Para habilitar el registro de eventos de plano
de datos en CloudTrail, deberá habilitar el registro de la actividad de la API del plano de datos en
CloudTrail. ConsulteRegistrar eventos de datos para senderosPara obtener más información, consulte.
Para obtener un registro continuo de los eventos deAWS, incluidos los eventos para DynamoDB, cree
unaRegistro de seguimiento de. Un registro de seguimiento permite a CloudTrail enviar archivos de
registro a un bucket de Amazon Simple Storage Service (Amazon S3). De forma predeterminada,
cuando se crea un registro de seguimiento en la consola, este se aplica a todas las regiones de AWS.
El registro de seguimiento registra los eventos de todas las regiones de la partición de AWS y envía
los archivos de registro al bucket de S3 especificado. También puede configurarAWSpara analizar en
profundidad y actuar en función de los datos de eventos recopilados en los registros de CloudTrail.
Utilice DynamoDB Streams para supervisar las operaciones del plano de datos
DynamoDB está integrado conAWS LambdaPara que pueda crear disparadores, a saber, fragmentos
de código que responden automáticamente a los eventos de DynamoDB Streams. Con los
disparadores, puede crear aplicaciones que reaccionan ante las modificaciones de datos en las tablas
de DynamoDB.
Si habilita DynamoDB Streams en una tabla, puede asociar el nombre de recurso de Amazon (ARN)
de la secuencia con una función Lambda que haya escrito. Inmediatamente después de modificar un
elemento de la tabla, aparece un nuevo registro en la secuencia de la tabla.AWS Lambdasondea la
secuencia y llama a la función Lambda de forma sincrónica cuando detecta nuevos registros de flujo.
La función Lambda pueden realizar cualquier acción que especifique, como, por ejemplo, enviar una
notificación o iniciar un flujo de trabajo.
Para ver un ejemplo, consulte .Tutorial: UsoAWS LambdaCon Amazon DynamoDB Streams. En este
ejemplo se recibe una entrada de evento DynamoDB, se procesan los mensajes que contiene y se
escriben algunos de los datos de eventos entrantes en los Amazon CloudWatch Logs.
Controle la configuración de DynamoDBAWS Config
Para ver un ejemplo, consulte .NotificacionesAWS ConfigEnvíos a un tema de Amazon SNSen laAWS
ConfigGuía para desarrolladores.
AWS Configrealiza un seguimiento continuo de los cambios de configuración que se producen entre
los recursos de. Comprueba si estos cambios infringen cualquiera de las condiciones de las reglas. Si
un recurso infringe una reglaAWS Configmarca el recurso y la regla como no conformes.
By using AWS ConfigPara evaluar las configuraciones de los recursos, puede evaluar la conformidad
de las configuraciones de los recursos con respecto a las prácticas internas, las directrices del sector
y las normativas.AWS ConfigproporcionaAWSReglas administradas, que son reglas predefinidas y
personalizables queAWS Configutiliza para evaluar si suAWSlos recursos cumplen con las mejores
prácticas comunes.
Etiquetar los recursos de DynamoDB para su identificación y automatización
Puede asignar metadatos aAWSrecursos de en forma de etiquetas. Cada etiqueta es una marca
simple que consta de una clave definida por el cliente y un valor opcional que puede hacer que sea
más fácil administrar, buscar y filtrar recursos.
El etiquetado permite implementar controles agrupados. Aunque no hay tipos inherentes de etiquetas,
le permiten clasificar recursos según su finalidad, propietario, entorno u otro criterio. A continuación se
muestran algunos ejemplos:
• Seguridad: se utiliza para determinar requisitos como el cifrado.
• Confidencialidad: un identificador para el nivel concreto de confidencialidad de los datos que admite
un recurso.
• Entorno: se utiliza para distinguir entre infraestructura de desarrollo, pruebas y producción.
Monitoreo y registro
La monitorización es una parte importante del mantenimiento de la fiabilidad, la disponibilidad y el
rendimiento de DynamoDB y susAWSSoluciones de. Debe recopilar datos de monitorización de todas las
partes de suAWSSolución para que le resulte más sencillo depurar un error que se produce en distintas
partes del código, en caso de que ocurra.AWSPara monitorizar sus recursos de DynamoDB y responder a
posibles incidentes:
Temas
• Registro y monitorización en DynamoDB (p. 938)
• Registro y monitorización en DynamoDB Accelerator (p. 980)
• Análisis del acceso a datos con CloudWatch Contributor Insights for DynamoDB (p. 980)
El siguiente paso consiste en establecer un punto de referencia del desempeño de DynamoDB normal
en su entorno. Para ello se mide el desempeño en distintos momentos y bajo distintas condiciones de
carga. Cuando monitoree DynamoDB, debe tener en cuenta el almacenamiento de los datos históricos de
monitorización. Estos datos almacenados le darán un punto de referencia con el que comparar los datos
de desempeño actuales, identificar los patrones de desempeño normales y las anomalías de desempeño,
así como desarrollar métodos de resolución de problemas.
Para establecer un punto de referencia debe, como mínimo, monitorizar los elementos siguientes:
Temas
• Herramientas de monitorización (p. 939)
• Monitorización con Amazon CloudWatch (p. 940)
• Registro de operaciones de DynamoDB utilizandoAWS CloudTrail (p. 964)
Herramientas de monitorización
AWSproporciona herramientas que puede utilizar para monitorear DynamoDB. Puede configurar algunas
de estas herramientas para que realicen la labor de monitorización automáticamente; sin embargo, otras
requieren intervención manual. Le recomendamos que automatice las tareas de monitorización en la
medida de lo posible.
• Alarmas de Amazon CloudWatch: vigile una métrica durante un periodo de tiempo especificado y realice
una o varias acciones según el valor que tenga la métrica en comparación con un determinado umbral
durante una serie de periodos de tiempo. La acción es una notificación que se envía a un tema de
Amazon Simple Notification Service (Amazon SNS) o a una política de Amazon EC2 Auto Scaling. Las
alarmas de CloudWatch no invocan acciones tan solo por tener un estado determinado; es necesario
que el estado haya cambiado y se mantenga durante un número específico de periodos. Para obtener
más información, consulte Monitorización con Amazon CloudWatch (p. 940) .
• Amazon CloudWatch Logs: monitoree, almacene y obtenga acceso a los archivos de registro de AWS
CloudTrail u otras fuentes. Para obtener más información, consulte Monitoreo de archivos de registro en
la guía del usuario de Amazon CloudWatch.
• Amazon CloudWatch Events: seleccione los eventos y diríjalos hacia uno o varios flujos o funciones
de destino para realizar cambios, capturar información de estado y aplicar medidas correctivas. Para
obtener más información, consulte ¿Qué es Amazon CloudWatch Events? en la guía del usuario de
Amazon CloudWatch.
• Monitorización de registros de AWS CloudTrail: comparta archivos de registro entre cuentas, monitorice
archivos de registro de CloudTrail en tiempo real enviándolos a CloudWatch Logs, escriba aplicaciones
de procesamiento de registros en Java y compruebe que sus archivos de registro no hayan cambiado
después de que CloudTrail los entregue. Para obtener más información, consulte Trabajar con archivos
de registro de CloudTrail en la Guía del usuarioAWS CloudTrail.
• El panel de DynamoDB
• Alertas recientes
• Capacidad total
• Estado de los servicios
• La página de inicio de CloudWatch muestra:
• Alarmas y estado actual
• Gráficos de alarmas y recursos
• Estado de los servicios
Temas
• Dimensiones y métricas de DynamoDB (p. 940)
• ¿Cómo utilizo las métricas de de DynamoDB? (p. 962)
• Creación de alarmas de CloudWatch para monitorear DynamoDB (p. 962)
Las métricas se agrupan en primer lugar por el espacio de nombres de servicio y, a continuación, por las
diversas combinaciones de dimensiones dentro de cada espacio de nombres.
Métricas de DynamoDB
Note
• ConditionalCheckFailedRequests
• ConsumedReadCapacityUnits
• ConsumedWriteCapacityUnits
• ReadThrottleEvents
• ReturnedBytes
• ReturnedItemCount
• ReturnedRecordsCount
• SuccessfulRequestLatency
• SystemErrors
• TimeToLiveDeletedItemCount
• ThrottledRequests
• TransactionConflict
• UserErrors
• WriteThrottleEvents
No todas las estadísticas, comoAverage (Media)orSum (Suma), son aplicables para todas las métricas
de. Sin embargo, todos estos valores están disponibles a través de la consola de Amazon DynamoDB
o mediante la consola de CloudWatch,AWS CLI, o bienAWSSDK para todas las métricas En la tabla
siguiente, cada métrica tiene una lista de estadísticas válidas aplicables a esa métrica.
Métrica Descripción
Unidades:Count
Estadísticas válidas:
Unidades:Count
Estadísticas válidas:
Unidades:Count
Estadísticas válidas:
Métrica Descripción
• Maximum— El número máximo de unidades de capacidad
de escritura que puede utilizar una tabla o un índice
secundario global de la cuenta.
Unidades:Count
Estadísticas válidas:
Unidades:Percent
Estadísticas válidas:
Unidades:Percent
Estadísticas válidas:
Métrica Descripción
Unidades:Milliseconds
Estadísticas válidas:
• Maximum.
• Minimum.
• Average.
Unidades:Count
Dimensiones: TableName
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Métrica Descripción
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
Métrica Descripción
Unidades:Count
Estadísticas válidas:
Métrica Descripción
Note
Métrica Descripción
Unidades:Count
Estadísticas válidas:
Métrica Descripción
Note
Unidades:Percent
Estadísticas válidas:
Unidades:Percent
Estadísticas válidas:
Métrica Descripción
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Métrica Descripción
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Count
Estadísticas válidas:
• Average
• Sample Count
• Sum
Métrica Descripción
Unidades:Count
Estadísticas válidas:
Métrica Descripción
Unidades:Count
Estadísticas válidas:
Métrica Descripción
Unidades:Count
Estadísticas válidas:
• SampleCount
• Sum
Unidades:Milliseconds
Estadísticas válidas:
• Average
• Minimum
• Maximum
Métrica Descripción
Unidades:Bytes
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Métrica Descripción
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
• Sum
Unidades:Milliseconds
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
Unidades:Count
Estadísticas válidas:
• Sum
• SampleCount
Métrica Descripción
Unidades:Count
Dimensiones: TableName
Estadísticas válidas:
• Sum
Unidades:Count
Estadísticas válidas:
• Minimum
• Maximum
• Average
• SampleCount
Métrica Descripción
• ReadThrottleEvents— Para
unGetItemevento deBatchGetItem.
• WriteThrottleEvents— Para
unPutItemorDeleteItemevento
deBatchWriteItem.
Unidades:Count
Estadísticas válidas:
• Sum
• SampleCount
Métrica Descripción
Unidades:Count
Dimensiones: TableName
Estadísticas válidas:
Métrica Descripción
• ProvisionedThroughputExceededException— Consulte
la.ThrottledRequestsmétrica en esta sección.
• ConditionalCheckFailedException— Consulte
la.ConditionalCheckFailedRequestsmétrica en esta
sección.
Unidades:Count
Estadísticas válidas:
• Sum
• SampleCount
Métrica Descripción
Unidades:Count
Estadísticas válidas:
• Sum
• SampleCount
Las métricas de DynamoDB se identifican por los valores de la cuenta, el nombre de la tabla, el nombre del
índice secundario global o la operación. Puede usar la consola de CloudWatch para recuperar los datos de
DynamoDB a lo largo de cualquier dimensión de la tabla siguiente.
Dimensión Descripción
DelegatedOperation Esta dimensión limita los datos a las operaciones que DynamoDB
realiza en su nombre. Se capturan las siguientes operaciones:
GlobalSecondaryIndexName Esta dimensión limita los datos a un índice secundario global de una
tabla. Si especifica GlobalSecondaryIndexName, también debe
especificar TableName.
Operation Esta dimensión limita los datos a una de las siguientes operaciones
de DynamoDB:
• PutItem
• DeleteItem
• UpdateItem
Dimensión Descripción
• GetItem
• BatchGetItem
• Scan
• Query
• BatchWriteItem
• TransactWriteItems
• TransactGetItems
• ExecuteTransaction
• BatchExecuteStatement
• ExecuteStatement
• GetRecords
OperationType Esta dimensión limita los datos a uno de los siguientes tipos de
operación:
• Read
• Write
Verb Esta dimensión limita los datos a uno de los siguientes verbos de
DynamoDB PartiQL:
• Insertar:PartiQLInsert
• Seleccionar:PartiQLSelect
• Update:PartiQLUpdate
• Para eliminar:PartiQLDelete
TableName Esta dimensión limita los datos a una tabla específica. Este
valor puede ser cualquier nombre de tabla en la región actual y
elAWSaccount.
Debe especificar todas las dimensiones necesarias al crear la alarma CloudWatch, ya que
CloudWatch no agregará métricas para una dimensión que falta. Crear una alarma de
CloudWatch con una dimensión que falta no dará lugar a un error al crear la alarma.
Para obtener una lista de las métricas admitidas y sus dimensiones requeridas en DynamoDB,
consulteDimensiones y métricas de DynamoDB (p. 940).
Para obtener más información, consulte Configuración de Amazon Simple Notification Service.
2. Cree la alarma. En este ejemplo, presuponemos que se han provisionado cinco unidades de
capacidad de lectura.
3. Pruebe la alarma.
Note
La alarma se activa cuando la capacidad de lectura consumida es de al menos 4 unidades por
segundo (el 80 % de las 5 unidades de capacidad de lectura provisionadas) durante 1 minuto
(60 segundos). Por lo tanto,thresholdes de 240 unidades de capacidad de lectura (4 unidades/
segundo * 60 segundos). Cada vez que se actualiza la capacidad de lectura, debe actualizar los
cálculos de envío de alarmas en consecuencia. Puede evitar este proceso si crea alarmas en la
consola de DynamoDB. De este modo, las alarmas se actualizan automáticamente.
¿Cómo puedo recibir una notificación cuando todas las solicitudes superen las
cuotas de rendimiento aprovisionado de una tabla?
1. Cree un tema sobre Amazon SNSarn:aws:sns:us-east-1:123456789012:requests-
exceeding-throughput.
Para obtener más información, consulte Configuración de Amazon Simple Notification Service.
2. Cree la alarma.
--metric-name ThrottledRequests \
--dimensions Name=TableName,Value=myTable Name=Operation,Value=aDynamoDBOperation \
--statistic Sum \
--threshold 0 \
--comparison-operator GreaterThanThreshold \
--period 300 \
--unit Count \
--evaluation-periods 1 \
--alarm-actions arn:aws:sns:us-east-1:123456789012:requests-exceeding-throughput
3. Pruebe la alarma.
¿Cómo puedo recibir una notificación si se produce cualquier error del sistema?
1. Cree un tema sobre Amazon SNSarn:aws:sns:us-east-1:123456789012:notify-on-
system-errors.
Para obtener más información, consulte Configuración de Amazon Simple Notification Service.
2. Cree la alarma.
3. Pruebe la alarma.
DynamoDB y las llamadas desde el código a las operaciones de la API de DynamoDB, utilizando tanto
PartiQL como la API clásica. Si crea un registro de seguimiento, puede habilitar la entrega continua de
eventos de CloudTrail a un bucket de Amazon S3, incluidos los eventos de DynamoDB. Si no configura
un registro de seguimiento, puede ver los eventos más recientes de la consola de CloudTrail en el Event
history (Historial de eventos). Mediante la información recopilada por CloudTrail, puede determinar la
solicitud que se realizó a DynamoDB, la dirección IP desde la que se realizó, quién la realizó y cuándo, etc.
Para una supervisión y alertas sólidas, también puede integrar eventos de CloudTrail conAmazon
CloudWatch Logs. Para mejorar el análisis de la actividad de servicio de DynamoDB e identificar cambios
en las actividades de unAWSPuede consultarAWS CloudTrailRegistros conAmazon Athena. Por ejemplo,
puede ejecutar consultas que identifiquen tendencias y aislar la actividad por atributos como el usuario o la
dirección IP de origen.
Para obtener más información acerca de CloudTrail, incluso cómo configurarlo y habilitarlo, consulte la
Guía del usuario de AWS CloudTrail.
Para obtener un registro continuo de los eventos enAWS, incluidos los eventos de DynamoDB, cree un
registro de seguimiento. Un registro de seguimiento permite a CloudTrail enviar archivos de registro a un
bucket de Amazon S3. De forma predeterminada, cuando se crea un registro de seguimiento en la consola,
el registro de seguimiento se aplica a todas las regiones de AWS. El registro de seguimiento consigna los
eventos de todas las regiones de la partición de AWS y envía los archivos de registro al bucket de Amazon
S3 especificado. También es posible configurar otros servicios de AWS para analizar en profundidad y
actuar en función de los datos de eventos recopilados en los registros de CloudTrail. Para obtener más
información, consulte los siguientes temas:
Amazon DynamoDB
• CreateBackup
• CreateGlobalTable
• CreateTable
• DeleteBackup
• DeleteTable
• DescribeBackup
• DescribeContinuousBackups
• DescribeGlobalTable
• DescribeLimits
• DescribeTable
• DescribeTimeToLive
• ListBackups
• ListTables
• ListTagsOfResource
• ListGlobalTables
• RestoreTableFromBackup
• RestoreTableToPointInTime
• TagResource
• UntagResource
• UpdateGlobalTable
• UpdateTable
• UpdateTimeToLive
• DescribeReservedCapacity
• DescribeReservedCapacityOfferings
• DescribeScalableTargets
• RegisterScalableTarget
• PurchaseReservedCapacityOfferings
DynamoDB Streams
• DescribeStream
• ListStreams
• CreateCluster
• CreateParameterGroup
• CreateSubnetGroup
• DecreaseReplicationFactor
• DeleteCluster
• DeleteParameterGroup
• DeleteSubnetGroup
• DescribeClusters
• DescribeDefaultParameters
• DescribeEvents
• DescribeParameterGroups
• DescribeParameters
• DescribeSubnetGroups
• IncreaseReplicationFactor
• ListTags
• RebootNode
• TagResource
• UntagResource
• UpdateCluster
• UpdateParameterGroup
• UpdateSubnetGroup
Amazon DynamoDB
• BatchExecuteStatement
• BatchGetItem
• BatchWriteItem
• DeleteItem
• ExecuteStatement
• ExecuteTransaction
• GetItem
• PutItem
• Consulta
• Examen
• TransactGetItems
• TransactWriteItems
• UpdateItem
Note
DynamoDB Streams
• GetRecords
• GetShardIterator
Cada entrada de registro o evento contiene información acerca de quién generó la solicitud. La información
de identidad del usuario le ayuda a determinar lo siguiente:
• Si la solicitud se realizó con credenciales de usuario AWS Identity and Access Management (IAM) o
credenciales de usuario raíz.
• Si la solicitud se realizó con credenciales de seguridad temporales de un rol o fue un usuario federado.
• Si la solicitud la realizó otro servicio de AWS.
Note
Los valores de atributo no clave se borrarán en los registros de acciones de CloudTrail utilizando
la API PartiQL y no aparecerán en los registros de acciones que utilicen la API clásica.
Los siguientes ejemplos demuestran los registros de CloudTrail de estos tipos de eventos:
Amazon DynamoDB
DynamoDB Streams
UpdateTable
{
"Records": [
{
"eventVersion": "1.03",
"userIdentity": {
"type": "AssumedRole",
"principalId": "AKIAIOSFODNN7EXAMPLE:bob",
"arn": "arn:aws:sts::111122223333:assumed-role/users/bob",
"accountId": "111122223333",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"sessionContext": {
"attributes": {
"mfaAuthenticated": "false",
"creationDate": "2015-05-28T18:06:01Z"
},
"sessionIssuer": {
"type": "Role",
"principalId": "AKIAI44QH8DHBEXAMPLE",
"arn": "arn:aws:iam::444455556666:role/admin-role",
"accountId": "444455556666",
"userName": "bob"
}
}
},
"eventTime": "2015-05-04T02:14:52Z",
"eventSource": "dynamodb.amazonaws.com",
"eventName": "UpdateTable",
"awsRegion": "us-west-2",
"sourceIPAddress": "192.0.2.0",
"userAgent": "console.aws.amazon.com",
"requestParameters": {
"provisionedThroughput": {
"writeCapacityUnits": 25,
"readCapacityUnits": 25
}
},
"responseElements": {
"tableDescription": {
"tableName": "Music",
"attributeDefinitions": [
{
"attributeType": "S",
"attributeName": "Artist"
},
{
"attributeType": "S",
"attributeName": "SongTitle"
}
],
"itemCount": 0,
"provisionedThroughput": {
"writeCapacityUnits": 10,
"numberOfDecreasesToday": 0,
"readCapacityUnits": 10,
"lastIncreaseDateTime": "May 3, 2015 11:34:14 PM"
},
"creationDateTime": "May 3, 2015 11:34:14 PM",
"keySchema": [
{
"attributeName": "Artist",
"keyType": "HASH"
},
{
"attributeName": "SongTitle",
"keyType": "RANGE"
}
],
"tableStatus": "UPDATING",
"tableSizeBytes": 0
}
},
"requestID": "AALNP0J2L244N5O15PKISJ1KUFVV4KQNSO5AEMVJF66Q9ASUAAJG",
"eventID": "eb834e01-f168-435f-92c0-c36278378b6e",
"eventType": "AwsApiCall",
"apiVersion": "2012-08-10",
"recipientAccountId": "111122223333"
}
]
}
DeleteTable
{
"Records": [
{
"eventVersion": "1.03",
"userIdentity": {
"type": "AssumedRole",
"principalId": "AKIAIOSFODNN7EXAMPLE:bob",
"arn": "arn:aws:sts::111122223333:assumed-role/users/bob",
"accountId": "111122223333",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"sessionContext": {
"attributes": {
"mfaAuthenticated": "false",
"creationDate": "2015-05-28T18:06:01Z"
},
"sessionIssuer": {
"type": "Role",
"principalId": "AKIAI44QH8DHBEXAMPLE",
"arn": "arn:aws:iam::444455556666:role/admin-role",
"accountId": "444455556666",
"userName": "bob"
}
}
},
"eventTime": "2015-05-04T13:38:20Z",
"eventSource": "dynamodb.amazonaws.com",
"eventName": "DeleteTable",
"awsRegion": "us-west-2",
"sourceIPAddress": "192.0.2.0",
"userAgent": "console.aws.amazon.com",
"requestParameters": {
"tableName": "Music"
},
"responseElements": {
"tableDescription": {
"tableName": "Music",
"itemCount": 0,
"provisionedThroughput": {
"writeCapacityUnits": 25,
"numberOfDecreasesToday": 0,
"readCapacityUnits": 25
},
"tableStatus": "DELETING",
"tableSizeBytes": 0
}
},
"requestID": "4KBNVRGD25RG1KEO9UT4V3FQDJVV4KQNSO5AEMVJF66Q9ASUAAJG",
"eventID": "a954451c-c2fc-4561-8aea-7a30ba1fdf52",
"eventType": "AwsApiCall",
"apiVersion": "2012-08-10",
"recipientAccountId": "111122223333"
}
]
}
CreateCluster
{
"Records": [
{
"eventVersion": "1.05",
"userIdentity": {
"type": "IAMUser",
"principalId": "AKIAIOSFODNN7EXAMPLE:bob",
"arn": "arn:aws:sts::111122223333:assumed-role/users/bob",
"accountId": "111122223333",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"userName": "bob"
},
"eventTime": "2019-12-17T23:17:34Z",
"eventSource": "dax.amazonaws.com",
"eventName": "CreateCluster",
"awsRegion": "us-west-2",
"sourceIPAddress": "192.0.2.0",
"userAgent": "aws-cli/1.16.304 Python/3.6.9
Linux/4.9.184-0.1.ac.235.83.329.metal1.x86_64 botocore/1.13.40",
"requestParameters": {
"sSESpecification": {
"enabled": true
},
"clusterName": "daxcluster",
"nodeType": "dax.r4.large",
"replicationFactor": 3,
"iamRoleArn": "arn:aws:iam::111122223333:role/
DAXServiceRoleForDynamoDBAccess"
},
"responseElements": {
"cluster": {
"securityGroups": [
{
"securityGroupIdentifier": "sg-1af6e36e",
"status": "active"
}
],
"parameterGroup": {
"nodeIdsToReboot": [],
"parameterGroupName": "default.dax1.0",
"parameterApplyStatus": "in-sync"
},
"clusterDiscoveryEndpoint": {
"port": 8111
},
"clusterArn": "arn:aws:dax:us-west-2:111122223333:cache/daxcluster",
"status": "creating",
"subnetGroup": "default",
"sSEDescription": {
"status": "ENABLED",
"kMSMasterKeyArn": "arn:aws:kms:us-
west-2:111122223333:key/764898e4-adb1-46d6-a762-e2f4225b4fc4"
},
"iamRoleArn": "arn:aws:iam::111122223333:role/
DAXServiceRoleForDynamoDBAccess",
"clusterName": "daxcluster",
"activeNodes": 0,
"totalNodes": 3,
"preferredMaintenanceWindow": "thu:13:00-thu:14:00",
"nodeType": "dax.r4.large"
}
},
"requestID": "585adc5f-ad05-4e27-8804-70ba1315f8fd",
"eventID": "29158945-28da-4e32-88e1-56d1b90c1a0c",
"eventType": "AwsApiCall",
"recipientAccountId": "111122223333"
}
]
}
PutItem(éxito)
{
"Records": [
{
"eventVersion": "1.06",
"userIdentity": {
"type": "AssumedRole",
"principalId": "AKIAIOSFODNN7EXAMPLE:bob",
"arn": "arn:aws:sts::111122223333:assumed-role/users/bob",
"accountId": "111122223333",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"sessionContext": {
"attributes": {
"mfaAuthenticated": "false",
"creationDate": "2015-05-28T18:06:01Z"
},
"sessionIssuer": {
"type": "Role",
"principalId": "AKIAI44QH8DHBEXAMPLE",
"arn": "arn:aws:iam::444455556666:role/admin-role",
"accountId": "444455556666",
"userName": "bob"
}
}
},
"eventTime": "2019-01-19T15:41:54Z",
"eventSource": "dynamodb.amazonaws.com",
"eventName": "PutItem",
"awsRegion": "us-west-2",
"sourceIPAddress": "192.0.2.0",
"userAgent": "aws-cli/1.15.64 Python/2.7.16 Darwin/17.7.0 botocore/1.10.63",
"requestParameters": {
"tableName": "Music",
"key": {
"Artist": "No One You Know",
"SongTitle": "Scared of My Shadow"
},
"item": [
"Artist",
"SongTitle",
"AlbumTitle"
],
"returnConsumedCapacity": "TOTAL"
},
"responseElements": null,
"requestID": "4KBNVRGD25RG1KEO9UT4V3FQDJVV4KQNSO5AEMVJF66Q9ASUAAJG",
"eventID": "a954451c-c2fc-4561-8aea-7a30ba1fdf52",
"readOnly": false,
"resources": [
{
"accountId": "111122223333",
"type": "AWS::DynamoDB::Table",
"ARN": "arn:aws:dynamodb:us-west-2:123456789012:table/Music"
}
],
"eventType": "AwsApiCall",
"apiVersion": "2012-08-10",
"managementEvent": false,
"recipientAccountId": "111122223333",
"eventCategory": "Data"
}
]
}
UpdateItem(sin éxito)
{
"Records": [
{
"eventVersion": "1.07",
"userIdentity": {
"type": "AssumedRole",
"principalId": "AKIAIOSFODNN7EXAMPLE:bob",
"arn": "arn:aws:sts::111122223333:assumed-role/users/bob",
"accountId": "111122223333",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"sessionContext": {
"sessionIssuer": {
"type": "Role",
"principalId": "AKIAI44QH8DHBEXAMPLE",
"arn": "arn:aws:iam::444455556666:role/admin-role",
"accountId": "444455556666",
"userName": "bob"
},
"attributes": {
"creationDate": "2020-09-03T22:14:13Z",
"mfaAuthenticated": "false"
}
}
},
"eventTime": "2020-09-03T22:27:15Z",
"eventSource": "dynamodb.amazonaws.com",
"eventName": "UpdateItem",
"awsRegion": "us-west-2",
"sourceIPAddress": "192.0.2.0",
"userAgent": "aws-cli/1.15.64 Python/2.7.16 Darwin/17.7.0 botocore/1.10.63",
"errorCode": "ConditionalCheckFailedException",
"errorMessage": "The conditional request failed",
"requestParameters": {
"tableName": "Music",
"key": {
"Artist": "No One You Know",
"SongTitle": "Call Me Today"
},
"updateExpression": "SET #Y = :y, #AT = :t",
"expressionAttributeNames": {
"#Y": "Year",
"#AT": "AlbumTitle"
},
"conditionExpression": "attribute_not_exists(#Y)",
"returnConsumedCapacity": "TOTAL"
},
"responseElements": null,
"requestID": "4KBNVRGD25RG1KEO9UT4V3FQDJVV4KQNSO5AEMVJF66Q9ASUAAJG",
"eventID": "a954451c-c2fc-4561-8aea-7a30ba1fdf52",
"readOnly": false,
"resources": [
{
"accountId": "111122223333",
"type": "AWS::DynamoDB::Table",
"ARN": "arn:aws:dynamodb:us-west-2:123456789012:table/Music"
}
],
"eventType": "AwsApiCall",
"apiVersion": "2012-08-10",
"managementEvent": false,
"recipientAccountId": "111122223333",
"eventCategory": "Data"
}
]
}
TransactWriteItems(éxito)
{
"Records": [
{
"eventVersion": "1.07",
"userIdentity": {
"type": "AssumedRole",
"principalId": "AKIAIOSFODNN7EXAMPLE:bob",
"arn": "arn:aws:sts::111122223333:assumed-role/users/bob",
"accountId": "111122223333",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"sessionContext": {
"sessionIssuer": {
"type": "Role",
"principalId": "AKIAI44QH8DHBEXAMPLE",
"arn": "arn:aws:iam::444455556666:role/admin-role",
"accountId": "444455556666",
"userName": "bob"
},
"attributes": {
"creationDate": "2020-09-03T22:14:13Z",
"mfaAuthenticated": "false"
}
}
},
"eventTime": "2020-09-03T21:48:12Z",
"eventSource": "dynamodb.amazonaws.com",
"eventName": "TransactWriteItems",
"awsRegion": "us-west-1",
"sourceIPAddress": "192.0.2.0",
"userAgent": "aws-cli/1.15.64 Python/2.7.16 Darwin/17.7.0 botocore/1.10.63",
"requestParameters": {
"requestItems": [
{
"operation": "Put",
"tableName": "Music",
"key": {
"Artist": "No One You Know",
"SongTitle": "Call Me Today"
},
"items": [
"Artist",
"SongTitle",
"AlbumTitle"
],
"conditionExpression": "#AT = :A",
"expressionAttributeNames": {
"#AT": "AlbumTitle"
},
"returnValuesOnConditionCheckFailure": "ALL_OLD"
},
{
"operation": "Update",
"tableName": "Music",
"key": {
"Artist": "No One You Know",
"SongTitle": "Call Me Tomorrow"
},
"updateExpression": "SET #AT = :newval",
"ConditionExpression": "attribute_not_exists(Rating)",
"ExpressionAttributeNames": {
"#AT": "AlbumTitle"
},
"returnValuesOnConditionCheckFailure": "ALL_OLD"
},
{
"operation": "Delete",
"TableName": "Music",
"key": {
"Artist": "No One You Know",
"SongTitle": "Call Me Yesterday"
},
"conditionExpression": "#P between :lo and :hi",
"expressionAttributeNames": {
"#P": "Price"
},
"ReturnValuesOnConditionCheckFailure": "ALL_OLD"
},
{
"operation": "ConditionCheck",
"TableName": "Music",
"Key": {
"Artist": "No One You Know",
"SongTitle": "Call Me Now"
},
"ConditionExpression": "#P between :lo and :hi",
"ExpressionAttributeNames": {
"#P": "Price"
},
"ReturnValuesOnConditionCheckFailure": "ALL_OLD"
}
],
"returnConsumedCapacity": "TOTAL",
"returnItemCollectionMetrics": "SIZE"
},
"responseElements": null,
"requestID": "45EN32OM6TQSMV2MI65O4L5TNFVV4KQNSO5AEMVJF66Q9ASUAAJG",
"eventID": "4f1cc78b-5c94-4174-a6ad-3ee78605381c",
"readOnly": false,
"resources": [
{
"accountId": "111122223333",
"type": "AWS::DynamoDB::Table",
"ARN": "arn:aws:dynamodb:us-west-2:123456789012:table/Music"
}
],
"eventType": "AwsApiCall",
"apiVersion": "2012-08-10",
"managementEvent": false,
"recipientAccountId": "111122223333",
"eventCategory": "Data"
}
]
}
TransactWriteItems(conTransactionCanceledException)
{
"Records": [
{
"eventVersion": "1.06",
"userIdentity": {
"type": "AssumedRole",
"principalId": "AKIAIOSFODNN7EXAMPLE:bob",
"arn": "arn:aws:sts::111122223333:assumed-role/users/bob",
"accountId": "111122223333",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"sessionContext": {
"sessionIssuer": {
"type": "Role",
"principalId": "AKIAI44QH8DHBEXAMPLE",
"arn": "arn:aws:iam::444455556666:role/admin-role",
"accountId": "444455556666",
"userName": "bob"
},
"attributes": {
"creationDate": "2020-09-03T22:14:13Z",
"mfaAuthenticated": "false"
}
}
},
"eventTime": "2019-02-01T00:42:34Z",
"eventSource": "dynamodb.amazonaws.com",
"eventName": "TransactWriteItems",
"awsRegion": "us-west-2",
"sourceIPAddress": "192.0.2.0",
"userAgent": "aws-cli/1.16.93 Python/3.4.7
Linux/4.9.119-0.1.ac.277.71.329.metal1.x86_64 botocore/1.12.83",
"errorCode": "TransactionCanceledException",
"errorMessage": "Transaction cancelled, please refer cancellation reasons for
specific reasons [ConditionalCheckFailed, None]",
"requestParameters": {
"requestItems": [
{
"operation": "Put",
"tableName": "Music",
"key": {
"Artist": "No One You Know",
"SongTitle": "Call Me Today"
},
"items": [
"Artist",
"SongTitle",
"AlbumTitle"
],
"conditionExpression": "#AT = :A",
"expressionAttributeNames": {
"#AT": "AlbumTitle"
},
"returnValuesOnConditionCheckFailure": "ALL_OLD"
},
{
"operation": "Update",
"tableName": "Music",
"key": {
"Artist": "No One You Know",
"SongTitle": "Call Me Tomorrow"
},
"updateExpression": "SET #AT = :newval",
"ConditionExpression": "attribute_not_exists(Rating)",
"ExpressionAttributeNames": {
"#AT": "AlbumTitle"
},
"returnValuesOnConditionCheckFailure": "ALL_OLD"
},
{
"operation": "Delete",
"TableName": "Music",
"key": {
"Artist": "No One You Know",
"SongTitle": "Call Me Yesterday"
},
"conditionExpression": "#P between :lo and :hi",
"expressionAttributeNames": {
"#P": "Price"
},
"ReturnValuesOnConditionCheckFailure": "ALL_OLD"
},
{
"operation": "ConditionCheck",
"TableName": "Music",
"Key": {
"Artist": "No One You Know",
"SongTitle": "Call Me Now"
},
"ConditionExpression": "#P between :lo and :hi",
"ExpressionAttributeNames": {
"#P": "Price"
},
"ReturnValuesOnConditionCheckFailure": "ALL_OLD"
}
],
"returnConsumedCapacity": "TOTAL",
"returnItemCollectionMetrics": "SIZE"
},
"responseElements": null,
"requestID": "A0GTQEKLBB9VD8E05REA5A3E1VVV4KQNSO5AEMVJF66Q9ASUAAJG",
"eventID": "43e437b5-908a-46af-84e6-e27fffb9c5cd",
"readOnly": false,
"resources": [
{
"accountId": "111122223333",
"type": "AWS::DynamoDB::Table",
"ARN": "arn:aws:dynamodb:us-west-2:123456789012:table/Music"
}
],
"eventType": "AwsApiCall",
"apiVersion": "2012-08-10",
"managementEvent": false,
"recipientAccountId": "111122223333",
"eventCategory": "Data"
}
]
}
ExecuteStatement
{
"Records": [
{
"eventVersion": "1.08",
"userIdentity": {
"type": "AssumedRole",
"principalId": "AKIAIOSFODNN7EXAMPLE:bob",
"arn": "arn:aws:sts::111122223333:assumed-role/users/bob",
"accountId": "111122223333",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"sessionContext": {
"sessionIssuer": {
"type": "Role",
"principalId": "AKIAI44QH8DHBEXAMPLE",
"arn": "arn:aws:iam::444455556666:role/admin-role",
"accountId": "444455556666",
"userName": "bob"
},
"attributes": {
"creationDate": "2020-09-03T22:14:13Z",
"mfaAuthenticated": "false"
}
}
},
"eventTime": "2021-03-03T23:06:45Z",
"eventSource": "dynamodb.amazonaws.com",
"eventName": "ExecuteStatement",
"awsRegion": "us-west-2",
"sourceIPAddress": "192.0.2.0",
"userAgent": "aws-cli/1.19.7 Python/3.6.13
Linux/4.9.230-0.1.ac.223.84.332.metal1.x86_64 botocore/1.20.7",
"requestParameters": {
"statement": "SELECT * FROM Music WHERE Artist = 'No One You Know' AND
SongTitle = 'Call Me Today' AND nonKeyAttr = ***(Redacted)"
},
"responseElements": null,
"requestID": "V7G2KCSFLP83ORB7MMFG6RIAD3VV4KQNSO5AEMVJF66Q9ASUAAJG",
"eventID": "0b5c4779-e169-4227-a1de-6ed01dd18ac7",
"readOnly": false,
"resources": [
{
"accountId": "111122223333",
"type": "AWS::DynamoDB::Table",
"ARN": "arn:aws:dynamodb:us-west-2:123456789012:table/Music"
}
],
"eventType": "AwsApiCall",
"apiVersion": "2012-08-10",
"managementEvent": false,
"recipientAccountId": "111122223333",
"eventCategory": "Data"
}
]
}
BatchExecuteStatement
{
"Records": [
{
"eventVersion": "1.08",
"userIdentity": {
"type": "AssumedRole",
"principalId": "AKIAIOSFODNN7EXAMPLE:bob",
"arn": "arn:aws:sts::111122223333:assumed-role/users/bob",
"accountId": "111122223333",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"sessionContext": {
"sessionIssuer": {
"type": "Role",
"principalId": "AKIAI44QH8DHBEXAMPLE",
"arn": "arn:aws:iam::444455556666:role/admin-role",
"accountId": "444455556666",
"userName": "bob"
},
"attributes": {
"creationDate": "2020-09-03T22:14:13Z",
"mfaAuthenticated": "false"
}
}
},
"eventTime": "2021-03-03T23:24:48Z",
"eventSource": "dynamodb.amazonaws.com",
"eventName": "BatchExecuteStatement",
"awsRegion": "us-west-2",
"sourceIPAddress": "192.0.2.0",
"userAgent": "aws-cli/1.19.7 Python/3.6.13
Linux/4.9.230-0.1.ac.223.84.332.metal1.x86_64 botocore/1.20.7",
"requestParameters": {
"requestItems": [
{
"statement": "UPDATE Music SET Album = ***(Redacted) WHERE Artist =
'No One You Know' AND SongTitle = 'Call Me Today'"
},
{
GetRecords
{
"Records": [
{
"eventVersion": "1.08",
"userIdentity": {
"type": "AssumedRole",
"principalId": "AKIAIOSFODNN7EXAMPLE:bob",
"arn": "arn:aws:sts::111122223333:assumed-role/users/bob",
"accountId": "111122223333",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"sessionContext": {
"sessionIssuer": {
"type": "Role",
"principalId": "AKIAI44QH8DHBEXAMPLE",
"arn": "arn:aws:iam::444455556666:role/admin-role",
"accountId": "444455556666",
"userName": "bob"
},
"attributes": {
"creationDate": "2020-09-03T22:14:13Z",
"mfaAuthenticated": "false"
}
}
},
"eventTime": "2021-04-15T04:15:02Z",
"eventSource": "dynamodb.amazonaws.com",
"eventName": "GetRecords",
"awsRegion": "us-west-2",
"sourceIPAddress": "192.0.2.0",
"userAgent": "aws-cli/1.19.50 Python/3.6.13
Linux/4.9.230-0.1.ac.224.84.332.metal1.x86_64 botocore/1.20.50",
"requestParameters": {
"shardIterator": "arn:aws:dynamodb:us-west-2:123456789012:table/
Music/stream/2021-04-15T04:02:47.428|1|AAAAAAAAAAH7HF3xwDQHBrvk2UBZ1PKh8bX3F
+JeH0rFwHCE7dz4VGV1ZoJ5bMxQwkmerA3wzCTL+zSseGLdSXNJP14EwrjLNvDNoZeRSJ/
n6xc3I4NYOptR4zR8d7VrjMAD6h5nR12NtxGIgJ/dVsUpluWsHyCW3PPbKsMlJSruVRWoitRhSd3S6slEWEPB0bDC7+
+ISH5mXrCHOnvyezQKlqNshTSPZ5jWwqRj2VNSXCMTGXv9P01/U0bpOUI2cuRTchgUpPSe3ur2sQrRj3KlbmIyCz7P
+H3CYlugafi8fQ5kipDSkESkIWS6O5ejzibWKg/3izms1eVIm/
zLFdEeihCYJ7G8fpHUSLX5JAk3ab68aUXGSFEZLONntgNIhQkcMo00/
mJlaIgkEdBUyqvZO1vtKUBH5YonIrZqSUhv8Coc+mh24vOg1YI+SPIXlr
+Lnl54BG6AjrmaScjHACVXoPDxPsXSJXC4c9HjoC3YSskCPV7uWi0f65/
n7JAT3cskcX2ISaLHwYzJPaMBSftxOgeRLm3BnisL32nT8uTj2gF/
PUrEjdyoqTX7EerQpcaekXmOgay5Kh8n4T2uPdM83f356vRpar/
DDp8pLFD0ddb6Yvz7zU2zGdAvTod3IScC1GpTqcjRxaMhlBVZy1TnI9Cs
+7fXMdUF6xYScjR2725icFBNLojSFVDmsfHabXaCEpmeuXZsLbp5CjcPAHa66R8mQ5tSoFjrzOEzeB4uconEXAMPLE=="
},
"responseElements": null,
"requestID": "1M0U1Q80P4LDPT7A7N1A758N2VVV4KQNSO5AEMVJF66Q9EXAMPLE",
"eventID": "09a634f2-da7d-4c9e-a259-54aceexample",
"readOnly": true,
"resources": [
{
"accountId": "111122223333",
"type": "AWS::DynamoDB::Table",
"ARN": "arn:aws:dynamodb:us-west-2:123456789012:table/Music"
}
],
"eventType": "AwsApiCall",
"apiVersion": "2012-08-10",
"managementEvent": false,
"recipientAccountId": "111122223333",
"eventCategory": "Data"
}
]
}
Para obtener más información acerca del registro y la monitorización en DAX, consulteMonitorización de
DAX (p. 797).
Al habilitar CloudWatch Contributor Insights for DynamoDB en una tabla o un índice secundario global,
puede ver los elementos a los que más se accede o sometidos a más restricciones controladas de esos
recursos.
Note
Se aplican cargos de CloudWatch Insights for DynamoDB. Para obtener más información sobre
los precios, consulte Precios de Amazon CloudWatch.
Temas
• Información de CloudWatch Contributor Insights for DynamoDB: Cómo funciona (p. 981)
• Introducción a CloudWatch Contributor Insights for DynamoDB (p. 985)
• Uso de IAM con CloudWatch Contributor Insights for DynamoDB (p. 989)
Para obtener más información acerca de CloudWatch Contributor Insights, consulteUso de Contributor
Insights para analizar datos de alta cardinalidaden laGuía del usuario de Amazon CloudWatch.
Temas
• Reglas de CloudWatch Contributor Insights for DynamoDB (p. 981)
• Descripción de los gráficos de CloudWatch Contributor Insights for DynamoDB (p. 982)
• Interacciones con otras características de DynamoDB (p. 984)
• Facturación de CloudWatch Contributor Insights for DynamoDB (p. 984)
• Elementos más accedidos (clave de partición)Identifica las claves de partición de los elementos a los
que más se accede de la tabla o del índice secundario global.
Si la tabla o el índice secundario global tiene una clave de ordenación, DynamoDB también crea las
siguientes reglas específicas para las claves de ordenación:
• Claves más accedidas (claves de partición y ordenación)Identifica las claves de partición y ordenación
de los elementos a los que más se accede de la tabla o del índice secundario global.
Note
• No puede utilizar la consola o las API de CloudWatch para modificar o eliminar directamente las
reglas creadas por CloudWatch Contributor Insights for DynamoDB. Al deshabilitar CloudWatch
Contributor Insights for DynamoDB en una tabla o un índice secundario global se eliminan
automáticamente las reglas creadas para esa tabla o índice secundario global.
• Cuando se utiliza elGetInsightRuleReportOperación con reglas de CloudWatch Contributor
Insights creadas por DynamoDB, soloMaxContributorValueyMaximumDevolver estadísticas
útiles. Las demás estadísticas de esta lista no devuelven valores significativos.
Puede crear alarmas de CloudWatch mediante las reglasde CloudWatch Contributor Insights para
DynamoDB. Esto le permite recibir una notificación cuando cualquier artículo supere o cumpla un umbral
específico para ConsumedThroughputUnits o ThrottleCount. Para obtener más información,
consulte Configuración de una alarma en datos de métricas de Contributor Insights.
DynamoDB mide la frecuencia de acceso a las claves mediante ConsumedThroughputUnits, que mide
el tráfico combinado de lectura y de escritura. ConsumedThroughputUnits se define como sigue:
Si aparecen varias líneas muy agrupadas sin valores atípicos evidentes, indica que la carga de trabajo
está relativamente equilibrada para todos los elementos durante ese espacio de tiempo determinado. Si
aparecen puntos aislados en el gráfico en lugar de líneas conectadas, indican un elemento al que se ha
accedido con frecuencia únicamente durante un breve periodo.
Si la tabla o el índice secundario global tiene una clave de ordenación, DynamoDB crea dos gráficos: uno
para las claves de partición a las que más se accede y otro para los pares de clave de partición y clave de
ordenación de acceso más frecuente. Puede ver el tráfico en el nivel de clave de partición en el gráfico de
sólo clave de partición. Puede ver el tráfico en el nivel de elemento en los gráficos de clave de ordenación
+ partición.
No se mide la limitación de escritura causada por una capacidad de escritura insuficiente para un índice
secundario global. Puede utilizar la.Most Accessed Items (Elementos a los que más se accede)gráfico del
índice secundario global para identificar patrones de acceso desequilibrados que pueden causar limitación
de escritura. Para obtener más información, consulteConsideraciones sobre el desempeño provisionado
para los índices secundarios globales.
En la consola de DynamoDB, cada punto de datos del gráfico representa el número de eventos de
limitación durante un periodo de un minuto.
Si no aparecen datos en este gráfico, indica que las solicitudes no se están sometido a limitaciones
controladas. Si ve puntos aislados en el gráfico en lugar de líneas conectadas, indican un elemento que se
ha sometido a limitaciones controladas durante un breve periodo.
Si la tabla o el índice secundario global tiene una clave de ordenación, DynamoDB crea dos gráficos:
uno para las claves de partición sometidas a más limitaciones controladas y otro para los pares de clave
de partición y clave de ordenación sometidos a más limitaciones controladas. Puede ver la cantidad de
limitaciones controladas en el nivel de particiones en el gráfico de solo claves y la cantidad de limitaciones
controladas en el nivel de elementos en los gráficos de partición y clave de ordenación.
Ejemplos de informes
A continuación se muestran ejemplos de informes generados para una tabla que tiene una clave de
partición y una clave de ordenación.
Tablas globales
CloudWatch Contributor Insights for DynamoDB monitorea réplicas de tablas globales como tablas
distintas. Gráficos de Contributor Insights de una réplica en unaAWSEs posible que la región no muestre
los mismos patrones que otra región. Esto se debe a que los datos de escritura se replican en todas las
réplicas de una tabla global, pero cada réplica solo atiende al tráfico de lectura de una región.
Cifrado en reposo
CloudWatch Contributor Insights for DynamoDB no afecta al modo en que funciona el cifrado en
DynamoDB. Los datos de clave principal que se publican en CloudWatch se cifran con elAWSLa clave
maestra del cliente (CMK). Sin embargo, DynamoDB también admite elAWSadministrada por CMK y una
CMK administrada por el cliente.
Si necesita que los datos de la clave principal se cifren con elAWSNo habilite CloudWatch Contributor
Insights for DynamoDB para esa tabla.
Si la clave principal de la tabla contiene datos protegidos mediante FGAC que no desea publicar en
CloudWatch, no habilite CloudWatch Contributor Insights for DynamoDB para esa tabla.
Control de acceso
Puede controlar el acceso a CloudWatch Contributor Insights for DynamoDBAWS Identity and Access
ManagementLimitar los permisos del plano de control de DynamoDB y los permisos del plano de datos
de CloudWatch. Para obtener más información, consulte el artículo sobre uso de IAM con CloudWatch
Contributor Insights for DynamoDB.
Si una tabla o índice secundario global incluye una clave de ordenación, cada elemento leído o escrito
representa dos eventos. Esto se debe a que DynamoDB identifica a los principales contribuyentes de
series temporales independientes: una para claves de particiones solamente y otra para pares de claves
de partición y ordenación.
Por ejemplo, supongamos que la aplicación realiza las siguientes operaciones de DynamoDB: unGetItem,
unPutItem, y aBatchWriteItemque pone cinco elementos
• Si la tabla o el índice secundario global solo tiene una clave de partición, esto dará como resultado
7 eventos (1 para GetItem, 1 para PutItem y 5 para BatchWriteItem).
• Si la tabla o el índice secundario global tiene una clave de partición y una clave de ordenación, esto dará
como resultado 14 eventos (2 para GetItem, 2 para PutItem y 10 para BatchWriteItem).
• Una operación Query siempre dará como resultado un evento, independientemente del número de
elementos devueltos.
Temas
• Uso de Contributor Insights (consola) (p. 985)
• Uso de Contributor Insights (AWS CLI) (p. 988)
8. Aparecerán los gráficos de Contributor Insights visibles en la pestaña Contributor Insights para la tabla
Music.
Solo Max Contributor Value y Maximum producen estadísticas útiles. Las demás
estadísticas de esta lista no devuelven valores significativos.
Para obtener más información acerca roles vinculados a servicios, consulte Uso de roles vinculados a
servicios en la Guía del usuario de IAM.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::*:role/aws-service-role/
contributorinsights.dynamodb.amazonaws.com/
AWSServiceRoleForDynamoDBCloudWatchContributorInsights",
"Condition": {"StringLike": {"iam:AWSServiceName":
"contributorinsights.dynamodb.amazonaws.com"}}
},
{
"Effect": "Allow",
"Action": [
"dynamodb:UpdateContributorInsights"
],
"Resource": "arn:aws:dynamodb:*:*:table/*"
}
]
}
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:GetInsightRuleReport"
],
"Resource": "arn:aws:cloudwatch:*:*:insight-rule/DynamoDBContributorInsights*"
}
]
}
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:ListContributorInsights",
"dynamodb:DescribeContributorInsights"
],
"Resource": "*"
},
{
"Effect": "Deny",
"Action": [
"dynamodb:UpdateContributorInsights"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/Books/index/Author-
index"
}
]
}
Un rol vinculado a un servicio simplifica la configuración de CloudWatch Contributor Insights for DynamoDB
porque ya no tendrá que añadir manualmente los permisos necesarios. CloudWatch Contributor Insights
for DynamoDB define los permisos de sus roles vinculados a servicios y, a menos que esté definido de
otra manera, solo CloudWatch Contributor Insights for DynamoDB puede asumir sus roles. Los permisos
definidos incluyen las políticas de confianza y de permisos, y que la política de permisos no se puede
asociar a ninguna otra entidad de IAM
Para obtener información sobre otros servicios que admiten roles vinculados a servicios, consulte Servicios
de AWS que funcionan con IAM y busque los servicios que muestran Yes (Sí) en la columna Service
Linked Role (Rol vinculado a servicios). Seleccione una opción Sí con un enlace para ver la documentación
acerca del rol vinculado al servicio en cuestión.
• contributorinsights.dynamodb.amazonaws.com
La política de permisos del rol permite que CloudWatch Contributor Insights for DynamoDB realice las
siguientes acciones en los recursos especificados:
Debe configurar permisos para permitir a una entidad de IAM (como un usuario, grupo o función) crear,
editar o eliminar la descripción de una función vinculada a un servicio. Para obtener más información,
consulte Permisos de roles vinculados a servicios en la Guía del usuario de IAM..
Si elimina este rol vinculado a servicio y necesita crearlo de nuevo, puede utilizar el mismo proceso para
volver a crear el rol en su cuenta. Cuando habilita Contributor Insights, CloudWatch Contributor Insights for
DynamoDB crea de nuevo el rol vinculado a servicios.
También puede utilizar la consola de IAM,AWS CLIo elAWSPara eliminar manualmente el rol vinculado al
servicio. Para ello, primero debe limpiar manualmente los recursos del rol vinculado al servicio para poder
eliminarlo después manualmente.
Note
Si el servicio CloudWatch Contributor Insights for DynamoDB está utilizando el rol cuando intenta
eliminar los recursos, es posible que no se pueda borrar. En tal caso, espere unos minutos e
intente de nuevo la operación.
Contenido
• Diseño NoSQL para DynamoDB (p. 994)
• Diferencias entre el diseño de datos relacionales y NoSQL (p. 994)
• Dos conceptos clave del diseño NoSQL (p. 995)
• Aproximación al diseño NoSQL (p. 995)
• Prácticas recomendadas para diseñar y utilizar claves de partición de forma eficaz (p. 996)
• Uso eficaz de la capacidad de ráfagas (p. 996)
• Descripción de la capacidad de adaptación de DynamoDB (p. 997)
• Aumento de la capacidad de rendimiento en particiones de tráfico intenso (p. 997)
• Aislamiento de elementos de acceso frecuente (p. 998)
• Diseñar claves de partición para distribuir la carga de trabajo uniformemente (p. 998)
• Uso de la fragmentación de escritura para distribuir cargas de trabajo
uniformemente (p. 999)
• Fragmentación con sufijos aleatorios (p. 999)
• Fragmentación con sufijos calculados (p. 1000)
• Distribuya la actividad de escritura de manera eficiente al cargar los datos (p. 1000)
• Prácticas recomendadas sobre el uso de claves de ordenación para organizar datos (p. 1001)
• Uso de claves de ordenación para el control de versiones (p. 1002)
• Prácticas recomendadas para utilizar índices secundarios en DynamoDB (p. 1003)
• Directrices generales sobre los índices secundarios de DynamoDB (p. 1003)
• Utilice los índices eficazmente (p. 1004)
• Elija con cautela las proyecciones (p. 1004)
• Optimice las consultas frecuentes para evitar las recuperaciones (p. 1004)
• Tenga en cuenta los límites de tamaño de la colección de elementos al crear índices
secundarios locales (p. 1005)
• Saque partido de los índices dispersos (p. 1005)
• Ejemplos de índices dispersos en DynamoDB (p. 1006)
• Uso de índices secundarios globales para consultas de agregación materializadas (p. 1007)
• Sobrecarga de índices secundarios globales (p. 1007)
• Uso de Sharing de Escritura de Índice Secundario Global para Consultas de Tabla
Selectiva (p. 1008)
• Uso de índices secundarios globales para crear una réplica consistente (p. 1009)
• Prácticas recomendadas para almacenar elementos y atributos grandes (p. 1010)
• Compresión de valores de atributos grandes (p. 1010)
• Almacenamiento de valores de atributos grandes en Amazon S3 (p. 1011)
• Prácticas recomendadas para administrar datos de series temporales en DynamoDB (p. 1011)
• Patrón de diseño de los datos de series temporales (p. 1011)
• Ejemplos de tablas de series temporales (p. 1012)
• Prácticas recomendadas para administrar relaciones de varios a varios (p. 1012)
• Patrón de diseño de listas de adyacencia (p. 1012)
• Patrón de gráficos materializados (p. 1014)
• Prácticas recomendadas para implementar un sistema de bases de datos híbrido (p. 1017)
• Si no quiere migrar todo a DynamoDB (p. 1017)
• Cómo puede implementarse un sistema híbrido (p. 1017)
• Prácticas recomendadas para modelar datos relacionales en DynamoDB (p. 1018)
• Primeros pasos para modelar datos relacionales en DynamoDB (p. 1021)
• Ejemplo de modelado de datos relacionales en DynamoDB (p. 1022)
• Prácticas recomendadas para consultar y examinar datos (p. 1024)
• Consideraciones sobre el desempeño de los exámenes (p. 1024)
• Evitar los picos repentinos en la actividad de lectura (p. 1024)
• Cómo sacar partido de los exámenes en paralelo (p. 1027)
• Elección de TotalSegments (p. 1028)
Temas
• Diferencias entre el diseño de datos relacionales y NoSQL (p. 994)
• Dos conceptos clave del diseño NoSQL (p. 995)
• Aproximación al diseño NoSQL (p. 995)
• En RDBMS, los datos se pueden consultar de manera flexible, pero las consultas son relativamente
costosas y no escalan bien cuando hay mucho tráfico (consulte Primeros pasos para modelar datos
relacionales en DynamoDB (p. 1021)).
• En una base de datos NoSQL como DynamoDB, existe un número limitado de métodos para consultar
los datos; si se utiliza cualquier otro método diferente a estos, resultará más costoso y lento realizar las
consultas.
Estas diferencias hacen que el diseño de las bases de datos sea muy distinto entre los dos sistemas:
• En RDBMS, el diseño busca la flexibilidad sin preocuparse por los detalles o el rendimiento de la
implementación. Por lo general, la optimización de consultas no afecta al diseño del esquema, pero la
normalización es importante.
• En DynamoDB, el esquema se diseña específicamente para que las consultas más habituales y más
importantes resulten lo más rápidas y económicas posible. Las estructuras de datos se ajustan a los
requisitos específicos de los casos de uso de la organización.
• Por el contrario, no debe empezar a diseñar su esquema para DynamoDB hasta que sepa las preguntas
a las que tiene que responder. Es esencial conocer de antemano los problemas del negocio y los casos
de uso de la aplicación.
• Debe mantener el menor número de tablas posible en una aplicación de DynamoDB.
En particular, antes de empezar, es importante entender tres propiedades fundamentales de los patrones
de acceso de la aplicación:
• Tamaño de los datos: Conocer cuántos datos se almacenarán y solicitarán a la vez ayudará a determinar
el método más eficaz para particionarlos.
• Forma de los datos: En lugar de dar forma a los datos al procesar las consultas (como ocurre en los
sistemas RDBMS), las bases de datos NoSQL organizan los datos de modo que la forma que tienen en
la base de datos se corresponde con la que se va a consultar. Este es un factor crucial para aumentar la
velocidad y la escalabilidad.
• Velocidad de los datos: DynamoDB escala aumentando el número de particiones físicas disponibles
para procesar las consultas y distribuyendo eficazmente los datos entre esas particiones. Conocer de
antemano cuáles serán las cargas de consulta máximas ayuda a determinar cómo deben particionarse
los datos para hacer un uso óptimo de la capacidad de E/S.
Después de identificar los requisitos de consulta específicos, puede organizar los datos con arreglo a los
principios generales que rigen el rendimiento:
• Agrupar los datos relacionales. Cuando hace 20 años se investigaba cómo optimizar las tablas
de direccionamiento, se descubrió que la "cercanía de referencias" era el factor más importante
para acelerar el tiempo de respuesta y consistía en mantener los datos relacionados reunidos en el
mismo lugar. Esto sigue siendo aplicable a los sistemas NoSQL actuales, donde mantener los datos
relacionales cerca unos de otros tiene un impacto determinante en los costos y el rendimiento. En lugar
de distribuir los elementos de datos relacionados entre diferentes tablas, en los sistemas NoSQL deben
mantenerse lo más juntos posible.
Por lo general, en una aplicación de DynamoDB, es necesario mantener el menor número de tablas
posible.
Las excepciones son aquellos casos en los que hay implicados datos de serie temporal de gran volumen
o conjuntos de datos que tienen patrones de acceso muy diferentes. Normalmente, basta una sola
tabla con índices invertidos para permitir que, a través de consultas simples, se creen y recuperen las
estructuras de datos jerárquicas y complejas que necesita la aplicación.
• Utilizar un orden de clasificación. Los elementos relacionados pueden agruparse y consultarse de
forma eficaz si su diseño de claves hace que se ordenen juntos. Esta es una estrategia importante en el
diseño NoSQL.
• Distribuir consultas. También es importante que no haya una gran cantidad de consultas concentradas
en la misma parte de la base de datos, donde podría sobrepasarse la capacidad de E/S. En su
lugar, debe diseñar claves de datos que distribuyan el tráfico lo más uniformemente posible entre las
particiones y eviten la creación de "puntos calientes".
• Utilizar índices secundarios globales. Si crea índices secundarios globales específicos, puede
permitir el uso de diferentes consultas en la tabla principal, lo que sigue siendo rápido y relativamente
económico.
Estos principios generales se traducen en unos patrones de diseño comunes que puede utilizar para
modelar los datos de forma eficaz en DynamoDB.
Por lo general, la aplicación debería diseñarse con la idea de que la actividad será uniforme en todas las
claves de las particiones lógicas de la tabla y sus índices secundarios. Puede determinar los patrones de
acceso que requiere la aplicación y estimar el total de unidades de capacidad de lectura (RCU) y unidades
de capacidad de escritura (WCU) que requiere cada una de las tablas y los índices secundarios.
DynamoDB admite los patrones de acceso utilizando el rendimiento aprovisionado, siempre y cuando el
tráfico que llega a una determinada partición no sea superior a 3.000 RCU o 1.000 WCU.
Temas
• Uso eficaz de la capacidad de ráfagas (p. 996)
• Descripción de la capacidad de adaptación de DynamoDB (p. 997)
• Diseñar claves de partición para distribuir la carga de trabajo uniformemente (p. 998)
• Uso de la fragmentación de escritura para distribuir cargas de trabajo uniformemente (p. 999)
• Distribuya la actividad de escritura de manera eficiente al cargar los datos (p. 1000)
En la actualidad, DynamoDB conserva hasta cinco minutos (300 segundos) de capacidad de lectura y
escritura sin utilizar. Durante una ráfaga de actividad de lectura o escritura ocasional, estas unidades de
capacidad adicionales pueden consumirse rápidamente, incluso a más velocidad que la capacidad de
rendimiento aprovisionada por segundo que se ha definido para la tabla.
DynamoDB también puede consumir capacidad de ráfagas para el mantenimiento en segundo plano y
otras tareas sin previo aviso.
Tenga en cuenta que estos detalles sobre la capacidad de ráfagas podrían cambiar en el futuro.
La capacidad de adaptación de se habilita de forma automática para todas las tablas de DynamoDB sin
costo adicional alguno. No es necesario habilitarla o deshabilitarla de forma explícita.
Temas
• Aumento de la capacidad de rendimiento en particiones de tráfico intenso (p. 997)
• Aislamiento de elementos de acceso frecuente (p. 998)
Para acomodar mejor los patrones de acceso desiguales, la capacidad de adaptación de DynamoDB
permite que una aplicación pueda seguir leyendo particiones calientes y escribiendo en ellas sin que
se produzca una limitación limitada, siempre que el tráfico no supere la capacidad total aprovisionada
para la tabla o la capacidad máxima de la partición. De forma automática e instantánea, la capacidad de
adaptación hace que la capacidad de rendimiento aumente en las particiones que reciben más tráfico.
Si la aplicación genera habitualmente gran intensidad de tráfico dirigido a un solo elemento, la capacidad
de adaptación puede reequilibrar los datos, de tal forma que una partición solo contenga ese elemento al
que se accede con frecuencia. En este caso, DynamoDB puede ofrecer rendimiento hasta el máximo de la
partición de 3.000 RCU o 1.000 WCU a la clave principal de ese elemento único.
Note
El uso óptimo del diseño aprovisionado de una tabla no solo depende de los patrones de carga de trabajo
de los elementos individuales, sino también del diseño de la clave de partición. Esto no significa que haya
que obtener acceso a todos los valores de la clave de partición para lograr un nivel de rendimiento eficaz
ni que el porcentaje de valores de la clave de partición a los que se obtiene acceso tenga que ser elevado.
Lo que significa es que a cuantos más valores diferentes de la clave de partición tenga acceso la carga
de trabajo, más se distribuirán estas solicitudes entre el espacio particionado. En general, el rendimiento
aprovisionado se utilizará con más eficacia cuanto mayor sea la proporción de los valores de la clave
de partición a los que se obtiene acceso en comparación con el número total de valores de la clave de
partición.
Si una tabla solo contiene un número reducido de valores de clave de partición, puede ser conveniente
distribuir las operaciones de escritura entre más valores de clave de partición distintos. En otras palabras,
conviene estructurar los elementos de clave principal de tal forma que se evite un valor de clave de
partición "caliente" (muy solicitado) que ralentice el desempeño general.
Por ejemplo, tomemos una tabla con una clave principal compuesta. La clave de partición representa
la fecha de creación del elemento, redondeada al día más próximo. La clave de ordenación es un
identificador de elemento. En un día determinado (por ejemplo, 2014-07-09), todos los elementos nuevos
se escriben en ese mismo valor de clave de partición (y en la partición física correspondiente).
Si la tabla completa cabe en una sola partición (teniendo en cuenta el crecimiento que registrarán los datos
con el paso del tiempo) y los requisitos de rendimiento de lectura y escritura de la aplicación no rebasan
la capacidad de lectura y escritura de una sola partición, la aplicación no debería verse afectada por una
limitación controlada inesperada como resultado de este particionamiento.
Sin embargo, si prevé que al escalar la tabla se va a utilizar más de una partición, debe diseñar la
aplicación de forma que pueda utilizar una cantidad mayor del rendimiento aprovisionado total de la tabla.
Por ejemplo, para una clave de partición que representara la fecha de hoy, podría elegir un número
aleatorio comprendido entre 1 y 200 y concatenarlo a la fecha como sufijo. De este modo, se generarían
valores de clave de partición, como 2014-07-09.1, 2014-07-09.2 y así sucesivamente hasta
2014-07-09.200. Al aplicar un número aleatorio a la clave de partición, las escrituras que se producen
en la tabla de cada día se distribuyen uniformemente por varias particiones. Como resultado, se mejora el
paralelismo y el rendimiento general.
Sin embargo, si quisiera leer todos los elementos de un día determinado, tendría que hacer una consulta
de todos los sufijos y fusionar después los resultados. Por ejemplo, primero debería emitir una solicitud
Query para el valor de la clave de partición 2014-07-09.1. A continuación, emita otra Query para
2014-07-09.2 y, así sucesivamente, hasta 2014-07-09.200. Por último, la aplicación tendría que
fusionar los resultados de todas estas solicitudes Query.
Consideremos el ejemplo anterior, en el que una tabla utiliza la fecha de hoy en la clave de partición.
Ahora, supongamos que cada elemento tiene un atributo OrderId (ID de pedido) accesible y que lo que
suele necesitar con más frecuencia es buscar elementos por el ID de pedido además de por la fecha.
Antes de que la aplicación escriba el elemento en la tabla, se podría calcular un sufijo hash basado
en el ID de pedido y anexarlo a la fecha de la clave de partición. El cálculo podría generar un número
comprendido entre 1 y 200 que esté bastante bien distribuido, igual que el que se genera con la estrategia
aleatoria.
Probablemente, bastaría con realizar un sencillo cálculo, como el producto de los valores de punto de
código UTF-8 de los caracteres del ID de pedido, módulo 200, +1. El valor de la clave de partición sería la
fecha junto con el resultado del cálculo.
Con esta estrategia, las escrituras se distribuyen de manera uniforme entre los valores de clave de
partición y, por lo tanto, entre las particiones físicas. Es fácil realizar una operación GetItem en un
elemento y una fecha determinados, ya que se puede calcular el valor de clave de partición de un valor de
OrderId concreto.
Para leer todos los elementos de un determinado día, debeQueryCada una de las2014-07-09.Nteclas
(dondeNes de 1—200), y su aplicación tiene que fusionar todos los resultados. El beneficio es que evitaría
que un único valor de clave de partición "caliente" acaparase toda la carga de trabajo.
Note
Para obtener información sobre una estrategia más eficaz diseñada específicamente
para administrar datos de serie temporal de gran volumen, consulte Datos de series
temporales (p. 1011).
Por ejemplo, supongamos que desea cargar mensajes de usuarios en una tabla de DynamoDB que
utiliza una clave principal compuesta conUserIDComo clave de partición yMessageIDComo clave de
clasificación.
Al cargar los datos, un enfoque que puede tomar es cargar todos los elementos de mensaje para cada
usuario, un usuario tras otro:
UserID MessageID
U1 1
U1 2
U1 ...
UserID MessageID
U2 1
U2 2
U2 ...
El problema en este caso es que las solicitudes de escritura a DynamoDB no se distribuyen entre los
valores de clave de partición. Se toma un valor de clave de partición a la vez y se cargan todos sus
elementos antes de pasar al siguiente valor de clave de partición y hacer lo mismo.
En segundo plano, DynamoDB particiona los datos de la tabla entre varios servidores. Para utilizar toda la
capacidad de rendimiento aprovisionada para la tabla, debe distribuir la carga de trabajo entre los valores
de clave de partición. Al dirigir una cantidad desigual de carga a elementos que tienen el mismo valor de
clave de partición, no se utilizan plenamente los recursos que DynamoDB ha provisionado para la tabla.
Puede distribuir el trabajo de carga utilizando la clave de ordenación para cargar un elemento de cada
valor de clave de partición, luego otro elemento de cada valor de clave de partición, etc.:
UserID MessageID
U1 1
U2 1
U3 1
... ...
U1 2
U2 2
U3 2
... ...
Cada carga que se lleva a cabo en esta secuencia se utiliza un valor de clave de partición distinto, con lo
que se mantienen ocupados más servidores de DynamoDB simultáneamente y se mejora el desempeño.
Si las claves de ordenación están bien diseñadas, tienen dos beneficios principales:
• Recopilan información relacionada en un único lugar en el que los datos se pueden consultar de forma
eficaz. Si se diseñan meticulosamente, permiten recuperar grupos de elementos relacionados que
suelen ser necesarios utilizando consultas de rango con operadores, como begins_with, between, >,
<, etc.
• Las claves de ordenación compuestas permiten definir en los datos relaciones jerárquicas (de uno a
varios) que pueden consultarse en cualquier nivel de la jerarquía.
Por ejemplo, en una tabla con ubicaciones geográficas, la clave de ordenación podría estructurarse del
modo siguiente:
[country]#[region]#[state]#[county]#[city]#[neighborhood]
Esto le permitiría crear consultas de rango eficaces para una lista de ubicaciones en cualquiera de
estos niveles de agregación, desde country hasta neighborhood, pasando por cualquier elemento
intermedio.
• Para cada nuevo elemento, cree dos copias del elemento: Una copia debe tener un prefijo de número
de versión de cero (comov0_) al principio de la clave de ordenación mientras que la otra debe tener el
prefijo de número de versión 1 (por ejemplo,v1_).
• Cada vez que el elemento se actualice, utilice el siguiente prefijo de versión en la clave de ordenación de
la versión actualizada y copie el contenido actualizado en el elemento cuyo prefijo de versión es 0. Esto
significa que la última versión de cada elemento puede localizarse fácilmente a través del prefijo 0.
Por ejemplo, un fabricante de piezas podría utilizar un esquema como el de la siguiente ilustración.
Varios auditores realizan una serie de auditorías en el elemento Equipment_1. Los resultados de cada
nueva auditoría se capturan en un nuevo elemento de la tabla, comenzando por el número de versión 1 e
incrementando el número con cada revisión.
Cuando se agrega una nueva revisión, la capa de la aplicación sustituye el contenido del elemento que
tiene la versión 0 (donde la clave de ordenación es igual a v0_Audit) por el contenido de la nueva
versión.
Siempre que la aplicación tenga que recuperar el estado de auditoría más reciente, podrá consultar el
prefijo v0_ de la clave de ordenación.
Si la aplicación tiene que recuperar todo el historial de revisiones, podrá consultar todos los elementos
situados bajo la clave de partición del elemento y filtrar el elemento v0_.
Este diseño también podría funcionar para realizar auditorías de varias piezas de un componente del
equipo si se incluyera el ID de cada pieza en la clave de ordenación, detrás del prefijo.
Contenido
• Directrices generales sobre los índices secundarios de DynamoDB (p. 1003)
• Utilice los índices eficazmente (p. 1004)
• Elija con cautela las proyecciones (p. 1004)
• Optimice las consultas frecuentes para evitar las recuperaciones (p. 1004)
• Tenga en cuenta los límites de tamaño de la colección de elementos al crear índices
secundarios locales (p. 1005)
• Saque partido de los índices dispersos (p. 1005)
• Ejemplos de índices dispersos en DynamoDB (p. 1006)
• Uso de índices secundarios globales para consultas de agregación materializadas (p. 1007)
• Sobrecarga de índices secundarios globales (p. 1007)
• Uso de Sharing de Escritura de Índice Secundario Global para Consultas de Tabla Selectiva (p. 1008)
• Uso de índices secundarios globales para crear una réplica consistente (p. 1009)
• Índice secundario globalÍndice con una clave de partición y una clave de ordenación que pueden diferir
de las claves de la tabla base. Un índice secundario global se considera "global" porque las consultas
que se realizan en el índice pueden abarcar todos los datos de la tabla base y todas las particiones. Los
índices secundarios globales no tienen limitaciones de tamaño y cuentan con su propia configuración de
rendimiento aprovisionada para la actividad de lectura y escritura, que es diferente de la configuración de
la tabla base.
• índices secundario localÍndice que tiene la misma clave de partición que la tabla base, pero una clave
de ordenación distinta. Un índice secundario local se considera "local" en el sentido de que el ámbito
de todas sus particiones se corresponde con una partición de la tabla base que tiene el mismo valor
de clave de partición. Por tanto, el tamaño total de los elementos indexados de cualquier valor de
clave de partición no puede superar los 10 GB. Además, los índices secundarios locales comparten la
configuración de rendimiento aprovisionado para la actividad de lectura y lectura con la tabla que están
indexando.
Cada tabla de DynamoDB puede tener hasta 20 índices secundarios globales (cuota predeterminada) y 5
índices secundarios locales.
Para obtener más información sobre las diferencias entre los índices secundarios globales y los índices
secundarios locales, consulte Uso de índices secundarios para mejorar el acceso a los datos (p. 567).
Por lo general, es mejor utilizar índices secundarios globales que índices secundarios locales. La
excepción es cuando se necesita una fuerte consistencia en los resultados de la consulta, algo que se
puede conseguir con un índice secundario local puede pero no con un índice secundario global (las
consultas de índices secundarios globales solo admiten la consistencia final).
A continuación, se muestran algunos principios generales y patrones de diseño que deben tenerse en
cuenta al crear índices en DynamoDB:
Temas
• Utilice los índices eficazmente (p. 1004)
• Elija con cautela las proyecciones (p. 1004)
• Optimice las consultas frecuentes para evitar las recuperaciones (p. 1004)
• Tenga en cuenta los límites de tamaño de la colección de elementos al crear índices secundarios
locales (p. 1005)
Si prevé que la actividad de escritura de una tabla va a ser muy superior a la de lectura, siga estas
prácticas recomendadas:
• Considere la posibilidad de proyectar menos atributos para minimizar el tamaño de los elementos que
se escriben en el índice. Sin embargo, esto solo es aplicable si el tamaño de los atributos proyectados
fuera mayor que una unidad de capacidad de escritura (1 KB). Por ejemplo, si el tamaño de una entrada
de índice es de tan solo 200 bytes, DynamoDB la redondeará a 1 KB. Es decir, siempre y cuando los
elementos del índice son pequeños, puede proyectar más atributos sin costo adicional.
• Evite proyectar atributos si sabe que apenas los va a necesitar en las consultas. Cada vez que se
actualiza un atributo que está proyectado en un índice, también se actualiza el índice, lo que tiene un
costo adicional. Los atributos no proyectados se pueden recuperar en un solicitud Query, aunque con
un costo superior en lo que se refiere al rendimiento aprovisionado. Sin embargo, el costo de la consulta
puede ser mucho más bajo que el de actualizar el índice con frecuencia.
• Especifique ALL solamente si desea que las consultas devuelvan el elemento de la tabla completo
ordenado mediante una clave de ordenación distinta. Al proyectar todos los atributos, ya no será
necesario recuperar la tabla. Sin embargo, en la mayoría de los casos, duplicará los costos de
almacenamiento y de actividad de escritura.
Sopese la necesidad de mantener los índices con el menor tamaño posible frente a la necesidad de
minimizar las actualizaciones lo máximo posible, tal y como se explica en la sección siguiente.
atributos que no están proyectados, DynamoDB recuperará automáticamente estos atributos de la tabla, lo
que requiere que se lea todo el elemento de la tabla. Esto genera una latencia y unas operaciones de E/S
adicionales que podrían evitarse.
Tenga en cuenta que, a menudo, las consultas "ocasionales" pueden convertirse en consultas
"esenciales". Si hay atributos que no quiere proyectar porque prevé que solo los consultará
ocasionalmente, piense en qué circunstancias esto podría cambiar y podría arrepentirse de no haberlos
proyectado.
Para obtener más información sobre recuperaciones de tablas, consulte Consideraciones sobre el
desempeño provisionado para los índices secundarios locales (p. 619).
Al agregar o actualizar un elemento de una tabla, DynamoDB actualiza todos los índices secundarios
locales afectados. Si los atributos indexados se han definido en la tabla, los índices secundarios locales
también aumentarán.
Cuando cree un índice secundario local, piense cuántos datos se van a escribir en él y cuántos de estos
elementos de datos tendrán el mismo valor de clave de partición. Si prevé que la suma de elementos de la
tabla y del índice correspondientes a un valor de clave de partición determinado superen los 10 GB, piense
si debe evitar crear el índice.
Si no puede evitar crear el índice secundario local, tendrá que prever el límite de tamaño de la colección
de elementos y adoptar medidas antes de superarlo. Para obtener estrategias sobre cómo mantenerse
dentro de los límites y adoptar medidas correctivas, consulte Límite de tamaño de una colección de
elementos (p. 623).
Los índices dispersos resultan útiles para las consultas que se realizan en una pequeña subsección de una
tabla. Por ejemplo, supongamos que tiene una tabla en la que almacena todos los pedidos de los clientes
con los siguientes atributos de clave:
Para hacer un seguimiento de las órdenes abiertas, puede incluir un atributo llamadoisOpenEn los
artículos de pedido que aún no se han enviado. Posteriormente, cuando estos pedidos se envíen, podrá
borrar el atributo. Si crea un índice de CustomerId (clave de partición) e isOpen (clave de ordenación),
en este índice solo aparecerán los pedidos en los que isOpen está definido. Cuando tiene miles de
pedidos de los cuales solo hay abiertos un pequeño número, resulta más rápido y económico consultar los
pedidos abiertos de ese índice que examinar toda la tabla.
En lugar de usar un tipo de atributo comoisOpen, podría utilizar un atributo con un valor que diera
como resultado un criterio de ordenación útil en el índice. Por ejemplo, podría utilizar un atributo
Si diseña un índice secundario global para que sea disperso, puede aprovisionarlo con un menor
rendimiento de escritura que el de la tabla base y seguir disfrutando de un nivel de rendimiento excelente.
Por ejemplo, es posible que una aplicación de juego hiciera un seguimiento de todas las puntuaciones
de cada usuario, pero lo normal es que solo deban consultarse unas cuentas puntuaciones. El diseño
siguiente se adapta eficazmente a este escenario:
Aquí, Rick ha jugado tres partidas y ha conseguido el estado Champ en una de ellas. Padma ha jugado
cuatro partidas y ha conseguido el estado Champ en dos de ellas. Observe que el atributo Award
solamente está presente en los elementos en los que el usuario consiguió una recompensa. El índice
secundario global asociado sería similar al siguiente:
El índice secundario global únicamente contiene las puntuaciones máximas que se consultan con
frecuencia, lo que conforma un pequeño subconjunto de los elementos de la tabla base.
La tabla de este ejemplo almacena canciones con la clave de partición songID. Puede habilitar Amazon
DynamoDB Streams en esta tabla y asociar una función Lambda a las secuencias para que cada vez
que se descargue una canción se agregue una entrada a la tabla conPartition-Key=SongIDySort-
Key=DownloadID. A medida que se realizan estas actualizaciones, se desencadena una función Lambda
en DynamoDB Streams. La función Lambda puede agregar y agrupar las descargas por songID y
actualizar el elemento de nivel superior: Partition-Key=songID y Sort-Key=Month. Tenga en cuenta
que, si una ejecución lambda falla justo después de escribir el nuevo valor agregado, esta ejecución podría
volver a intentarse y el valor podría agregarse varias veces, lo que dejaría un valor aproximado.
Para leer las actualizaciones prácticamente en tiempo real con una latencia en milisegundos de un
solo dígito, utilice el índice secundario global con las condiciones de consulta Month=2018-01,
ScanIndexForward=False, Limit=1.
Otra importante optimización que se utiliza aquí es que el índice secundario global es un índice disperso
y solo está disponible en los elementos que deben consultarse para recuperar los datos en tiempo real. El
índice secundario global puede proporcionar flujos de trabajo adicionales que necesiten información sobre
las 10 canciones más populares o cualquier canción descargada ese mes.
Tenga en cuenta el siguiente ejemplo, en el que se ha diseñado una tabla de DynamoDB que guarda una
gran variedad de tipos de datos.
El atributo Data, que es común a todos los elementos, tiene un contenido que varía en función de su
elemento principal. Si crea un índice secundario global para la tabla que utilice la clave de ordenación de
la tabla como clave de partición y el atributo Data como clave de ordenación, puede realizar diferentes
consultas utilizando el mismo índice secundario global. Estas consultas podrían ser las siguientes:
Para habilitar consultas selectivas en todo el espacio de claves, puede utilizar la creación de escritura
agregando un atributo que contenga un(0-N)a cada elemento que va a utilizar para la clave de partición
de índice secundario global.
A continuación se muestra un ejemplo de un esquema que utiliza esto en un flujo de trabajo de evento
crítico:
Usando este diseño de esquema, los elementos de evento se distribuyen entre0-Nen el GSI, permitiendo
una lectura de dispersión utilizando una condición de ordenación en la clave compuesta para recuperar
todos los elementos con un estado dado durante un período de tiempo especificado.
Este patrón de esquema proporciona un conjunto de resultados altamente selectivo a un costo mínimo, sin
necesidad de un escaneo de tabla.
• Establezca una capacidad de lectura aprovisionada diferente para diferentes lectores. Por ejemplo,
suponga que tiene dos aplicaciones: Una aplicación maneja consultas de alta prioridad y necesita los
niveles más altos de rendimiento de lectura, mientras que la otra maneja consultas de baja prioridad que
pueden tolerar la limitación de la actividad de lectura.
Si ambas aplicaciones leen desde la misma tabla, una carga de lectura pesada de la aplicación de
baja prioridad podría consumir toda la capacidad de lectura disponible para la tabla. Esto aceleraría la
actividad de lectura de la aplicación de alta prioridad.
En su lugar, puede crear una réplica a través de un índice secundario global cuya capacidad de lectura
puede establecer separada de la de la tabla en sí. A continuación, puede hacer que su aplicación de
prioridad baja consulte la réplica en lugar de la tabla.
• Elimine las lecturas de una tabla por completo. Por ejemplo, es posible que disponga de una aplicación
que capture un gran volumen de actividad de clics de un sitio web y no quiera correr el riesgo de que
las lecturas interfieran con ello. Puede aislar esta tabla e impedir las lecturas de otras aplicaciones
(consulteUso de condiciones de políticas de IAM para control de acceso preciso (p. 909)), mientras que
permite que otras aplicaciones lean una réplica creada usando un índice secundario global.
Para crear una réplica, configure un índice secundario global que tenga el mismo esquema de claves que
la tabla principal y proyectar en ella algunos o todos los atributos sin clave. En las aplicaciones, se pueden
dirigir parte o la totalidad de la actividad de lectura a este índice secundario global en lugar de a la tabla
principal. A continuación, puede ajustar la capacidad de lectura aprovisionada del índice secundario global
para manejar esas lecturas sin cambiar la capacidad de lectura aprovisionada de la tabla principal.
Siempre se produce un pequeño retraso de propagación entre el momento en que se escribe en la tabla
principal y el momento en que los datos escritos aparece en el índice. En otras palabras, sus aplicaciones
deben tener en cuenta que la réplica de índice secundario global solo esconsistencia finalcon la tabla
principal.
Puede crear varias réplicas globales de índice secundario para admitir diferentes patrones de lectura.
Cuando cree las réplicas, proyecte sólo los atributos que cada patrón de lectura realmente requiere. Una
aplicación puede consumir menos capacidad de lectura aprovisionada para obtener solo los datos que
necesita en lugar de tener que leer el elemento de la tabla principal. Esta optimización puede suponer un
importante ahorro en costos a largo plazo.
Por ejemplo, en la tabla Reply de la sección Creación de tablas y carga de datos para ejemplos de código
en DynamoDB (p. 333) se almacenan los mensajes que escriben los usuarios del foro. Estas respuestas
de los usuarios pueden ser cadenas de texto largas, lo que las convierte en excelentes candidatos para la
compresión.
Para ver un código de muestra en el que se ilustra cómo comprimir este tipo de mensajes en DynamoDB,
consulte lo siguiente:
• Ejemplo: Control de atributos de tipo Binary mediante elAWS SDK for JavaDocumentación de la
API (p. 471)
• Ejemplo: Control de atributos de tipo Binary mediante elAWS SDK for .NETAPI de bajo nivel (p. 495)
También puede aprovechar la compatibilidad con los metadatos de objetos de Amazon S3 para
proporcionar un enlace de regreso al elemento principal de DynamoDB. Guarde el valor de clave principal
del elemento como un metadato de Amazon S3 del objeto en Amazon S3. Normalmente, esto contribuye
positivamente al mantenimiento de los objetos de Amazon S3.
Por ejemplo, tomemos la tabla ProductCatalog de la sección Creación de tablas y carga de datos para
ejemplos de código en DynamoDB (p. 333). En los elementos de esta tabla, se almacena información
sobre el precio del elemento, su descripción, los autores (en el caso de los libros) y las dimensiones (en
el caso de otros productos). Si quisiera almacenar una imagen de cada producto que fuera demasiado
grande como para que cupiera en un elemento, podría almacenar las imágenes en Amazon S3 en lugar de
en DynamoDB.
• DynamoDB no admite transacciones que atraviesen Amazon S3 y DynamoDB. Por tanto, la aplicación
debe solventar cualquier error, que podría estar relacionado con la limpieza de objetos de Amazon S3
huérfanos.
• Amazon S3 limita la longitud de los identificadores de objetos. Por tanto, debe organizar los datos de
forma que no generen identificadores de objetos excesivamente largos ni infrinjan otras restricciones de
Amazon S3.
Para obtener más información acerca de cómo utilizar Amazon S3, consulte laAmazon Simple Storage
Service Developer Guide.
Normalmente, el siguiente patrón de diseño sirve para administrar este tipo de escenarios eficazmente:
• Cree una tabla por periodo, aprovisionada con la capacidad requerida de lectura y escritura y con los
índices que se necesitan.
• Antes de que termine cada periodo, precompile la tabla para el siguiente periodo. Justo cuando termine
el período actual, dirija el tráfico de los eventos a la nueva tabla. Puede asignar nombres a estas tablas
que indiquen los períodos que contienen.
• Tan pronto como la tabla deje de estar disponible para escribir en ella, reduzca su capacidad de
escritura aprovisionada a un valor menor (por ejemplo, 1 WCU) y aprovisione la capacidad de lectura
apropiada, según proceda. Reduzca la capacidad de lectura aprovisionada de las tablas anteriores
a medida que vayan venciendo. Puede optar por archivar o eliminar las tablas cuyo contenido va a
necesitar en pocas ocasiones o no va a necesitar nunca.
Se trata de asignar, para el periodo actual, los recursos requeridos que vayan a experimentar el máximo
volumen de tráfico y de reducir el aprovisionamiento de las tablas más antiguas que no se utilizan
activamente, con lo que se ahorra en costos. En función de sus necesidades de negocio, podría plantearse
fragmentar la escritura con el fin de distribuir el tráfico de manera uniforme en la clave de partición lógica.
Para obtener más información, consulte Uso de la fragmentación de escritura para distribuir cargas de
trabajo uniformemente (p. 999).
Algunas de las ventajas de este patrón son la escasa duplicación de los datos y la simplificación de los
patrones de consulta para buscar todas las entidades (nodos) relacionadas con una entidad de destino
(que tiene un límite con un nodo de destino).
Un ejemplo real en el que este patrón resulta útil son los sistemas de facturación en los que las facturas
(invoices) contienen varias cuentas (bills). Una cuenta puede ir en varias facturas. La clave de partición en
este ejemplo es InvoiceID o bien BillID. Las particiones BillID tienen todos los atributos específicos
de las facturas. Las particiones InvoiceID tienen un elemento que almacena atributos específicos de las
facturas y un elemento para cada BillID que aparece en la factura.
En el esquema anterior, puede ver que las cuentas de una factura pueden consultarse utilizando la clave
principal de la tabla. Para buscar todas las facturas que contienen parte de una cuenta, cree un índice
secundario global de la clave de ordenación de la tabla.
Las proyecciones del índice secundario global serían similares a las siguientes.
En el esquema anterior, se muestra una estructura de datos gráficos definida por un conjunto de
particiones de datos que contienen los elementos que definen los límites y los nodos del gráfico. Los
elementos de límite contienen un atributo Target y Type. Estos atributos se utilizan como parte de una
clave compuesta llamada "TypeTarget" para identificar el elemento de una partición de la tabla principal o
de un índice secundario global.
El primer índice secundario global se basa en el atributo Data. Este atributo utiliza la sobrecarga de
índices secundarios globales que se describió anteriormente para indexar varios tipos de atributos
diferentes; en este caso, Dates, Names, Places y Skills. Aquí, un índice secundario global es capaz de
indexar eficazmente cuatro atributos diferentes.
A medida que inserta elementos en la tabla, puede utilizar una estrategia de fragmentación inteligente
para distribuir conjuntos de elementos con grandes agregaciones (Birthdate, Skill) entre tantas particiones
lógicas de los índices secundarios globales como sean necesarias y evitar así el problema de que se creen
puntos de lectura o escritura "calientes".
El resultado de esta combinación de patrones de diseño es un almacén de datos sólido para flujos de
trabajo gráficos en tiempo real de gran eficacia. Estos flujos de trabajo pueden proporcionar consultas
de agregación de estado y límite de entidades adyacentes de gran rendimiento para motores de
recomendaciones, aplicaciones de redes sociales, clasificaciones de nodos, agregaciones de subárboles y
otros casos de uso gráficos habituales.
Si en el caso de uso no es importante la coherencia de datos en tiempo real, puede utilizar un proceso de
Amazon EMR programado para rellenar los límites con agregaciones de resumen de gráficos que sean
relevantes para los flujos de trabajo. Si la aplicación no necesita saber inmediatamente cuándo se agrega
un límite al gráfico, pude utilizar un proceso programado para agregar resultados.
Para mantener cierto nivel de consistencia, el diseño podría incluir Amazon DynamoDB Streams yAWS
Lambdapara procesar las actualizaciones de borde. También podría usar un trabajo de Amazon EMR
para validar los resultados a intervalos periódicos. Ente enfoque se ilustra en el siguiente diagrama.
Normalmente, se emplea en aplicaciones de redes sociales, donde el costo de una consulta en tiempo real
es elevado y la necesidad de conocer inmediatamente las actualizaciones de cada usuario es baja.
Por lo general, las aplicaciones de seguridad y administración de servicios de TI (ITSM) tienen que
responder en tiempo real a los cambios de estado de las entidades que se componen de agregaciones de
límites complejas. Este tipo de aplicaciones necesitan un sistema que pueda admitir varias agregaciones
en tiempo real de relaciones de segundo y tercer nivel en nodos o recorridos de límites complejos.
Si el caso de uso requiere estos tipos de flujos de trabajo de consultas de gráficos en tiempo real, le
recomendamos que considere la posibilidad de utilizar Amazon Neptune para administrarlos.
Además, algunas organizaciones conservan una variedad de sistemas relacionales existentes que han
adquirido o heredado a lo largo de décadas. Migrar los datos de estos sistemas podría resultar demasiado
arriesgado y caro como para justificar el esfuerzo.
Sin embargo, es posible que estas organizaciones se estén encontrando ahora con el hecho de que
sus operaciones dependen de sitios web orientados a los clientes que tienen un tráfico elevado y donde
la respuesta en milisegundos resulta esencial. Los sistemas relacionales solo pueden escalarse para
satisfacer esta necesidad a un precio exorbitado (y, a menudo, inaceptable).
En estas situaciones, la solución podría consistir en establecer un sistema híbrido en el que DynamoDB
cree una vista materializada de los datos almacenados en uno o varios sistemas relacionales y administrar
las solicitudes con mucho tráfico en esta vista. Este tipo de sistema podría reducir los costos, ya que se
eliminaría el hardware de los servidores, las tareas de mantenimiento y las licencias de RDBMS que se
necesitaban anteriormente para administrar el tráfico orientado al cliente.
Un sistema que integra DynamoDB Streams yAWS Lambdapuede proporcionar varias ventajas:
Para que este tipo de integración se implemente, deben darse principalmente tres tipos de
interoperaciones:
Una solución híbrida también podría resultar útil si quisiera utilizar principalmente DynamoDB, pero
también quisiera mantener un pequeño sistema relacional para las consultas puntuales o las operaciones
que necesitan una seguridad especial o en las que el tiempo no resulta un factor esencial.
Las plataformas de RDBMS utilizan un lenguaje de consulta ad hoc (por lo general, relacionado con SQL)
para generar o materializar vistas de datos normalizados compatibles con los patrones de acceso de la
capa de aplicación.
Por ejemplo, para generar una lista de pedidos de compra ordenados por la cantidad de existencias en
todos los almacenes que puede enviar cada elemento, podría emitir la siguiente consulta en el esquema
anterior:
Las consultas puntuales de este tipo proporcionan una API flexible para obtener acceso a los datos, pero
requieren una gran cantidad de procesamiento. Con frecuencia, es necesario consultar los datos de varias
ubicaciones y los resultados deben fusionarse para su posterior presentación. La consulta anterior inicia
consultas complejas en una serie de tablas para después ordenar e integrar los datos resultantes.
Otro factor que puede ralentizar los sistemas RDBMS es la necesidad de admitir un marco de
transacciones compatible con ACID. Las estructuras de datos jerárquicas que se utilizan en la mayoría
de aplicaciones de procesamiento de transacciones online (OLTP) deben dividirse y distribuirse por
varias tablas lógicas cuando se almacenan en un sistema RDBMS. Por tanto, se necesita un marco
de transacciones compatible con ACID que evite las condiciones de carrera que podrían darse si una
aplicación intentara leer un objeto que se estuviera escribiendo en ese momento. Este tipo de marco de
transacciones agrega necesariamente una sobrecarga considerable al proceso de escritura.
Estos dos factores son las principales barreras que dificultan el escalado en las plataformas RDBMS
tradicionales. Queda por ver si la comunidad de NewSQL puede proporcionar con éxito una solución
RDBMS distribuida. Con todo, es poco probable que pueda resolver las dos limitaciones indicadas.
No importa cómo se proporcione la solución, los costos de procesamiento de normalización y de las
transacciones de ACID seguirían siendo considerables.
Por este motivo, cuando la actividad requiere una respuesta de baja latencia ante consultas con mucho
tráfico, suele resultarse más ventajoso utilizar un sistema NoSQL tanto desde un punto de vista técnico
como económico. Amazon DynamoDB ayuda a resolver los problemas que limitan la escalabilidad del
sistema relacional evitándolos.
Los sistemas de bases de datos relacionales no escalan bien por las siguientes razones:
• Normalizan los datos y los guardan en varias tablas que requieren muchas consultas para escribir en el
disco.
• Normalmente, hay que sumar los costos de desempeño de un sistema de transacciones compatible con
ACID.
• Utiliza uniones caras para generar las vistas necesarias con los resultados de la consulta.
• La flexibilidad de esquemas permite que DynamoDB pueda almacenar datos jerárquicos complejos en
un solo elemento.
• El diseño de la clave compuesta permite almacenar elementos relacionados próximos entre sí en la
misma tabla.
Las consultas que se realizan en el almacén de datos son mucho más sencillas y suelen tener la forma
siguiente:
DynamoDB trabaja mucho menos para devolver los datos solicitados que el sistema RDBMS del ejemplo
anterior.
Si desea empezar a diseñar una tabla de DynamoDB que escale correctamente, debe realizar primero
algunas operaciones para identificar los patrones de acceso requeridos por los sistemas de ayuda de
operaciones y de la actividad (OSS/BSS) que deben admitirse:
• En el caso de las nuevas aplicaciones, revise los casos de usuario para determinar las actividades y los
objetivos. Documente los diferentes casos de uso que ha identificado y analice los patrones de acceso
que requieren.
• En las aplicaciones existentes, analice los registros de consultas para saber cuántas personas utilizan
actualmente el sistema y cuáles son los patrones de acceso de claves.
Tras completar este proceso, debería tener una lista similar a la siguiente:
En una aplicación real, la lista podría ser mucho más larga. Sin embargo, esta colección representa el
rango de complejidad de los patrones de consulta que podría encontrar en un entorno de producción.
Un enfoque que suele utilizarse habitualmente para diseñar esquemas de DynamoDB es identificar las
entidades de la capa de la aplicación y utilizar la desnormalización y la agregación de claves complejas
para reducir la complejidad de las consultas.
En DynamoDB, esto implica el uso de claves de ordenación complejas, índices secundarios globales
sobrecargados, tablas o índices particionados y otros patrones de diseño. Puede utilizar estos elementos
para estructurar los datos de forma que una aplicación pueda recuperar todo aquello que necesite para un
determinado patrón de acceso realizando una sola consulta en una tabla o índice. El principal patrón que
puede utilizar para modelar el esquema normalizado que se muestra en Modelos relacionales (p. 1018)
es el patrón de lista de adyacencia. Otros de los patrones que se pueden utilizar en este diseño son
la fragmentación de escrituras en índices secundarios globales, la sobrecarga de índices secundarios
globales, las claves complejas y las agregaciones materializadas.
Important
Por lo general, en una aplicación de DynamoDB, debe mantenerse el menor número de tablas
posible. Puede haber excepciones, como los casos en los que hay implicados datos de serie
temporal de gran volumen o conjuntos de datos que tienen diferentes patrones de acceso.
Normalmente, basta una sola tabla con índices invertidos para permitir que, a través de consultas
simples, se creen y recuperen las estructuras de datos jerárquicas y complejas que necesita la
aplicación.
En este patrón de diseño, tiene que definir un conjunto de tipos de entidades, que normalmente tendrán
correlación con las diferentes tablas del esquema relacional. Los elementos de entidad se agregan
después a la tabla utilizando una clave principal compuesta (partición y ordenación). La clave de partición
de estos elementos de entidad es el atributo que identifica el elemento de manera inequívoca y al que se
hace referencia genéricamente en todos los elementos como PK. El atributo de la clave de ordenación
contiene un valor que se puede usar como índice invertido o índice secundario global. Se identifica de
forma genérica como SK.
Tiene que definir las siguientes entidades, que admiten el esquema relacional de registro de pedidos:
Después de agregar estos elementos de entidad a la tabla, puede definir sus relaciones agregando
elementos de límite a las particiones de los elementos de entidad. En la tabla siguiente, se muestra este
paso.
En este ejemplo, las particiones Employee, Order y Product Entity de la tabla tienen elementos
de límite adicionales que contienen marcadores que apuntan a otros elementos de entidad de la tabla.
A continuación, debe definir algunos índices secundarios globales (GSI) que admitan todos los patrones
de acceso definidos previamente. No todos los elementos de entidad usan el mismo tipo de valor para el
atributo de la clave de ordenación o la clave principal. Todo lo que se necesita es que los atributos de la
clave de ordenación y la clave principal estén presentes para insertarlos en la tabla.
El hecho de que algunas de estas entidades tengan nombres propios mientras que otras tienen
identificadores de identidad como valores de la clave de ordenación permite que el mismo índice
secundario global pueda admitir varios tipos de consultas. Esta técnica se denomina sobrecarga de GSI.
Elimina de forma eficaz el límite predeterminado de 20 índices secundarios globales de las tablas que
contienen varios tipos de elementos. Esto puede verse en el siguiente diagrama como GSI 1.
GSI 2 está diseñado para admitir un patrón de acceso de aplicaciones bastante común cuyo objetivo
es obtener todos los elementos de la tabla que tienen un determinado estado. En el caso de las tablas
grandes que tienen una distribución desigual de los elementos entre los estados disponibles, este patrón
de acceso puede constituir un atajo, a menos que los elementos estén distribuidos entre varias particiones
lógicas que puedan consultarse en paralelo. Este patrón de diseño se denomina write sharding.
Para realizar esta operación en GSI 2, la aplicación agrega el atributo de clave principal de GSI 2 a cada
elemento Order. Rellena eso con un número aleatorio en un rango de 0 a N, donde N puede calcularse
genéricamente utilizando la siguiente fórmula, a menos que haya una razón específica para hacer lo
contrario.
PartitionMaxReadRate = 3K * ItemsPerRCU
N = MaxRequiredIO / PartitionMaxReadRate
• Habrá hasta 2 millones de pedidos en el sistema, una cifra que aumentará hasta los 3 millones en 5
años.
• Hasta un 20 por ciento de estos pedidos tendrán el estado OPEN en un momento dado.
• El registro de pedido medio rondará los 100 bytes y habrá tres registros OrderItem en la partición
de pedidos que tendrán 50 bytes cada uno, lo que hace un tamaño medio por entidad de pedido de
250 bytes.
PartitionMaxReadRate = 3K * 16 = 48K
En este caso, tendrá que distribuir todos los pedidos entre al menos 13 particiones lógicas de GSI 2 para
garantizar que la lectura de todos los elementos Order con el estado OPEN no genera una partición
"caliente" en la capa de almacenamiento físico. Es conveniente dejar margen suficiente en este número
para permitir anomalías en el conjunto de datos. Por tanto, es muy probable que un modelo con N = 15
resulte adecuado. Como se mencionó anteriormente, se hace esto agregando el valor aleatorio 0—N al
atributo GSI 2 PK de cadaOrderyOrderItemque se inserta en la tabla.
En este desglose, se presupone que el patrón de acceso que tiene que recopilar todas las facturas
OPEN tiene lugar con escasa frecuencia, de modo que puede utilizarse la capacidad de ráfagas para
cumplimentar la solicitud. Puede consultar el siguiente índice secundario global utilizando una condición de
clave de ordenación State y Date Range para generar un subconjunto o todos los elementos Orders
que tienen un determinado estado, según sea necesario.
En este ejemplo, los elementos se distribuyen aleatoriamente entre las 15 particiones lógicas. Esta
estructura funciona porque el patrón de acceso requiere que se recuperen un gran número de elementos.
Por tanto, es improbable que alguno de los 15 subprocesos devuelva conjuntos de resultados vacíos, lo
que podría significar que hay capacidad que se está desaprovechando. Una consulta siempre utiliza una
unidad de capacidad de lectura (RCU) o una unidad de capacidad de escritura (WCU), incluso si no se
devuelve nada o no se escribe ningún dato.
Si el patrón de acceso necesita hacer una consulta de alta velocidad en este índice secundario global
que devuelve un conjunto con escasos resultados, probablemente sea mejor usar un algoritmo hash para
distribuir los elementos que un patrón aleatorio. En este caso, puede seleccionar un atributo que se conoce
cuando la consulta se ejecuta en tiempo de ejecución y hash ese atributo en un espacio de claves 0—14
cuando se insertan los elementos. De ese modo, podría leerse de forma eficaz en el índice secundario
global.
Por último, puede volver a consultar los patrones de acceso que se definieron anteriormente. A
continuación, se muestra la lista con los patrones de acceso y las condiciones de consulta que utilizará con
la nueva versión de DynamoDB de la aplicación para acomodarlos.
Si es posible, debe evitar utilizar unScanOperación en una tabla o índice grandes con un filtro que elimina
muchos resultados. Además, a medida que la tabla o el índice aumentan de tamaño, elScanla operación
se ralentiza. LaScanLa operación examina cada elemento en busca de los valores solicitados y puede
utilizar el desempeño provisionado para una tabla o índice grandes en una sola operación. Para lograr
tiempos de respuesta más breves, diseñe las tablas y los índices de tal forma que las aplicaciones
puedan utilizarQueryINSTEADScan. Para las tablas, puede estudiar también la posibilidad de usar
elGetItemyBatchGetItemAPI.
De forma alternativa, diseñe la aplicación para usar operaciones Scan de tal forma que minimicen el
impacto en la tasa de solicitudes.
de elemento de 4 KB) /2 (lecturas consistentes finales) = 128 operaciones de lectura. Si solicita lecturas
muy coherentes en su lugar, elScanLa operación consumiría el doble de desempeño provisionado: 256
operaciones de lectura.
Esto representa un pico repentino de uso en comparación con la capacidad de lectura configurada para
la tabla. Este uso de unidades de capacidad en un examen impide que otras solicitudes más importantes
para la misma tabla utilicen las unidades de capacidad disponibles. Como resultado, es probable que
obtenga unProvisionedThroughputExceededexcepción para esas solicitudes.
En el siguiente diagrama se ilustra el impacto de un pico repentino del uso de unidades de capacidad que
provocan las operaciones Query y Scan, así como su impacto en las demás solicitudes para la misma
tabla.
Como se ilustra aquí, el pico de uso puede afectar el rendimiento aprovisionado de la tabla de varias
maneras:
En lugar de utilizar una gran operación Scan, puede utilizar las técnicas siguientes para minimizar el
impacto de un examen en el desempeño provisionado de una tabla.
Dado que una operación de examen lee una página completa (de forma predeterminada, 1 MB),
puede reducir el impacto de la operación de examen estableciendo un tamaño de página menor.
LaScanproporciona unLimitque se puede utilizar para establecer el tamaño de página de la solicitud.
EACHQueryo bienScanque tiene un tamaño de página menor utiliza menos operaciones de lectura y
crea una «pausa» entre cada solicitud. Por ejemplo, supongamos que cada elemento es de 4 KB y que
establece el tamaño de página en 40 elementos. AQueryconsumiría solo 20 operaciones de lectura
eventualmente consistentes o 40 operaciones de lectura fuertemente consistentes. Un mayor número de
operaciones Query o Scan permitiría que las demás solicitudes esenciales se realizasen correctamente
sin que se aplicara la limitación controlada.
• Aislar las operaciones de examen
DynamoDB se ha diseñado para facilitar la escalabilidad. En consecuencia, una aplicación puede crear
tablas para fines distintos e, incluso, duplicar contenido entre varias de ellas. Si desea realizar exámenes
en una tabla que no recibe tráfico "esencial". Algunas aplicaciones controlan esta carga rotando el
tráfico cada hora entre dos tablas: una para el tráfico esencial y otra para la contabilidad. Las demás
aplicaciones pueden efectuar este control realizando cada escritura en dos tablas: una tabla "esencial" y
otra tabla "duplicada".
Configure la aplicación para volver a intentar cualquier solicitud que reciba un código de respuesta que
indique que se ha superado el desempeño provisionado. O bien, aumente el rendimiento aprovisionado
para su tabla mediante elUpdateTable. Si la carga de trabajo presenta picos temporales que pueden
provocar que el desempeño supere ocasionalmente el nivel provisionado, repita la solicitud con retardo
exponencial. Para obtener más información sobre cómo implementar el retardo exponencial, consulte
Reintentos de error y retardo exponencial (p. 229).
Aunque los exámenes en paralelo pueden ser beneficiosos, pueden suponer una demanda excesiva
del desempeño provisionado. Con un análisis paralelo, la aplicación tiene varios trabajadores que están
ejecutandoScanOperaciones simultáneas. Esto puede consumir rápidamente toda la capacidad de lectura
aprovisionada de la tabla. En ese caso, las demás aplicaciones que necesiten obtener acceso a la tabla
podrían sufrir una limitación controlada que se lo impida.
Un examen en paralelo puede ser la elección adecuada si se cumplen las siguientes condiciones:
Elección de TotalSegments
El mejor escenario paraTotalSegmentsdepende de los datos específicos, de la configuración de
desempeño provisionado de la tabla y de los requisitos de desempeño. Es posible que deba experimentar
para lograr los resultados deseados. Recomendamos comenzar por una proporción sencilla; por
ejemplo, un segmento por cada 2 GB de datos. Por ejemplo, en el caso de una tabla de 30 GB, podría
establecerTotalSegmentsA 15 (30 GB/2 GB). Después, la aplicación utilizaría 15 trabajadores, cada uno
de los cuales examinaría un segmento diferente.
También puede elegir un valor paraTotalSegmentsque se base en los recursos del cliente. Es posible
establecerTotalSegmentsA cualquier número comprendido entre 1 y 1 000 000. DynamoDB permite
examinar esa cantidad de segmentos. Por ejemplo, si el cliente limita el número de subprocesos que se
pueden ejecutar de forma simultánea, puede aumentar gradualmenteTotalSegmentsHasta obtener el
mejorScanrendimiento con su aplicación.
Controle los exámenes en paralelo para optimizar el uso del desempeño provisionado, además de
asegurarse de que no privar de recursos a las demás aplicaciones. Aumente el valor deTotalSegmentsSi
no consume todo el desempeño provisionado, pero sigue experimentando una limitación en
elScansolicitudes. Reduzca el valor de TotalSegments si las solicitudes Scan consumen más
desempeño provisionado del que desea utilizar.
DynamoDB de con
otrosAWSServicios
Amazon DynamoDB está integrado con otrosAWS, lo que permite automatizar las tareas repetitivas o crear
aplicaciones que abarcan varios servicios. Por ejemplo:
Temas
• ConfiguraciónAWSCredenciales en sus archivos mediante Amazon Cognito (p. 1029)
• Carga de datos desde DynamoDB en Amazon Redshift (p. 1031)
• Procesamiento de datos de DynamoDB con Apache Hive en Amazon EMR (p. 1032)
• Exportación de datos de tablas de DynamoDB a Amazon S3 (p. 1057)
Por ejemplo, si desea configurar los archivos de JavaScript de modo que utilicen un rol sin autenticar de
Amazon Cognito para obtener acceso al servicio web de Amazon DynamoDB, haga lo siguiente:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "cognito-identity.amazonaws.com"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringEquals": {
"cognito-identity.amazonaws.com:aud": "us-west-2:12345678-1ab2-123a-1234-
a12345ab12"
},
"ForAnyValue:StringLike": {
"cognito-identity.amazonaws.com:amr": "unauthenticated"
}
}
}
]
}
3. Crear un rol de IAM que asume la política anterior. De este modo, Amazon Cognito se convierte en
una entidad de confianza que puede asumir laCognito_DynamoPoolUnauthRol de .
Note
Si lo prefiere, puede conceder acceso preciso a DynamoDB. Para obtener más información,
consulte Uso de condiciones de políticas de IAM para control de acceso preciso.
5. Obtenga y copie el nombre de recurso de Amazon (ARN) del rol de IAM.
7. Especifique las credenciales de Amazon Cognito en sus archivos. Modifique los valores de
IdentityPoolId y RoleArn en consecuencia.
Ahora, puede ejecutar sus programas de JavaScript en el servicio web de DynamoDB utilizando las
credenciales de Amazon Cognito. Para obtener más información, consulteConfiguración de credenciales
en un navegador weben laAWS SDK for JavaScriptGuía de introducción.
Versión de API 2012-08-10
1030
Amazon DynamoDB Guía para desarrolladores
Integración con Amazon Redshift
En lo que respecta al desempeño provisionado, una operación de copia desde una tabla de DynamoDB
cuenta con capacidad de lectura de esa tabla. Después de copiar los datos, las consultas SQL que
se llevan a cabo en Amazon Redshift no afectan a DynamoDB de ningún modo. El motivo es que las
consultas se ejecutan en una copia de los datos de DynamoDB y no en DynamoDB propiamente dicho.
Para poder cargar datos desde una tabla de DynamoDB, antes debe crear una tabla de Amazon Redshift
que actuará como destino de los datos. Tenga en cuenta que, al hacerlo, estará copiando datos de un
entorno NoSQL en un entorno SQL y que hay reglas que no se aplican por igual en ambos. A continuación
se muestran algunas de las diferencias que deben tenerse en cuenta:
• Los nombres de tablas de DynamoDB pueden contener un máximo de 255 caracteres, incluidos el
punto («.») y el guion ("-"). Además, distinguen entre mayúsculas y minúsculas. Los nombres de las
tablas de Amazon Redshift están limitados a 127 caracteres, no pueden contener puntos ni guiones y
no distinguen entre mayúsculas y minúsculas. Los nombres de las tablas tampoco pueden entrar en
conflicto con ninguna palabra reservada de Amazon Redshift.
• DynamoDB no admite el concepto NULL de SQL. Debe especificar cómo debe interpretar Amazon
Redshift los valores de atributos vacíos o en blanco de DynamoDB, para que los trate como NULL o
como campos vacíos.
• Los tipos de datos de DynamoDB no se corresponden directamente con los de Amazon Redshift. Debe
asegurarse de que cada columna de la tabla de Amazon Redshift sea del tipo y el tamaño de datos
correctos para adaptarse a los datos de DynamoDB.
Para obtener instrucciones detalladas sobre cómo cargar datos desde DynamoDB en Amazon Redshift,
consulte las secciones siguientes delGuía para desarrolladores de bases de datos Amazon Redshift:
Temas
• Overview (p. 1032)
• Tutorial: Uso de Amazon DynamoDB y Apache Hive (p. 1033)
• Crear una tabla externa en Hive (p. 1039)
• Procesamiento de instrucciones de HiveQL (p. 1041)
• Consulta de datos en DynamoDB (p. 1042)
• Copia de datos en y desde Amazon DynamoDB (p. 1044)
• Ajuste del desempeño (p. 1053)
Overview
Amazon EMR es un servicio que facilita el procesamiento rápido y rentable de enormes volúmenes
de datos. Para utilizar Amazon EMR, se lanza un clúster administrado de instancias Amazon EC2
que ejecutan el marco de trabajo de código abierto Hadoop. Hadoopes una aplicación distribuida que
implementa el algoritmo de MapReduce, en virtud del cual se mapea una tarea a varios nodos del clúster
de. En paralelo con los demás nodos, cada nodo procesa el trabajo que se ha designado para él. Por
último, las salidas se reducen a un solo nodo, que produce el resultado final.
Puede lanzar el clúster de Amazon EMR de modo que sea persistente o transitorio:
• APersistenteEl clúster se ejecuta hasta que se cierra. Los clústeres persistentes son idóneos para el
análisis de datos, el almacenamiento de datos o cualquier otro uso interactivo.
• AtransitorioSe ejecuta el tiempo suficiente para procesar un flujo de trabajo y, a continuación, se cierra
automáticamente. Los clústeres transitorios son idóneos para las tareas de procesamiento periódicas,
tales como la ejecución de scripts.
Para obtener más información sobre la arquitectura y administración de Amazon EMR, consulte laGuía de
administración de Amazon EMR.
Cuando se lanza un clúster de Amazon EMR, se especifica el número inicial y el tipo de instancias Amazon
EC2. También se especifican otras aplicaciones distribuidas (además de Hadoop) que se desea ejecutar
en el clúster. Estas aplicaciones son, entre otras, Hue, Mahout, Pig o Spark.
Para obtener información sobre las aplicaciones de Amazon EMR, consulte laGuía de publicación de
Amazon EMR.
Según la configuración del clúster, puede que disponga de uno o varios de los tipos de nodos siguientes:
• Nodo directivo: administra el clúster coordinando la distribución del ejecutable de MapReduce y de los
subconjuntos de datos sin procesar, hasta los grupos de instancias principal y de tareas. También hace
un seguimiento del estado de cada tarea realizada y monitoriza la salud de los grupos de instancias.
Solo hay un nodo de directriz en un clúster.
• Nodos principales: ejecutan tareas de MapReduce y almacenan datos utilizando el Hadoop Distributed
File System (HDFS).
• Nodos de tareas (opcionales): ejecutan las tareas de MapReduce.
Hivees una aplicación de data warehouse para Hadoop que permite procesar y analizar datos de
varios orígenes. Hive proporciona un lenguaje parecido a SQL,HiveQL, que permite trabajar con datos
almacenados localmente en el clúster de Amazon EMR o en un origen de datos externo (como Amazon
DynamoDB).
Temas
• Antes de empezar (p. 1033)
• Paso 1: Creación de un par de claves de Amazon EC2 (p. 1033)
• Paso 2: Iniciar un clúster de Amazon EMR (p. 1034)
• Paso 3: Connect con el nodo directriz (p. 1035)
• Paso 4: Carga de datos en HDFS (p. 1035)
• Paso 5: Copiar datos en DynamoDB (p. 1037)
• Paso 6: Consultar los datos de la tabla de DynamoDB (p. 1038)
• Paso 7: (Opcional) Limpieza (p. 1038)
Antes de empezar
Para este tutorial, necesitará lo siguiente:
• Una cuenta de AWS. Si no dispone de una, consulte Inscripción en AWS (p. 58).
• Un cliente SSH (Secure Shell). El cliente SSH se utiliza para conectarse al nodo de directriz del clúster
de Amazon EMR y ejecutar comandos interactivos. Los clientes SSH están disponibles de forma
predeterminada en la mayoría de las instalaciones de Linux, Unix y Mac OS X. Los usuarios de Windows
pueden descartar e instalar el cliente PuTTY, que es compatible con SSH.
Paso siguiente
Si lo pierde, key pair podrá obtener conectarse al nodo de líder del clúster de Amazon EMR.
Para obtener más información sobre pares de claves, consulte Pares de claves de Amazon EC2 en la
Guía del usuario de Amazon EC2 para instancias de Linux.
Paso siguiente
a. En Cluster name, escriba el nombre del clúster (por ejemplo, My EMR cluster).
b. En EC2 key pair, elija el par de claves que creó anteriormente.
Se tardan unos minutos en lanzar el clúster. Puede utilizar laDetalles de clústerEn la consola de Amazon
EMR para monitorizar el progreso.
Si no hay unaAWS Management ConsoleCrea un bucket de Amazon S3. El nombre del bucket deaws-
logs-account-id-region, donde account-idEs suAWSNúmero de cuenta yregionEs la región en
la que lanzó el clúster (por ejemplo,aws-logs-123456789012-us-west-2).
Note
Puede utilizar la consola de Amazon S3 para ver los archivos log. Para obtener más información,
consulteVer archivos de registroen laGuía de administración de Amazon EMR.
Puede usar este bucket para otros fines, además de generar logs. Por ejemplo, puede utilizar el bucket
como ubicación donde almacenar un script de Hive o como destino al exportar datos de Amazon
DynamoDB a Amazon S3.
Paso siguiente
1. En la consola de Amazon EMR, elija el nombre del clúster para ver su estado.
2. En la páginaDetalles de clústerBusque la páginaLíder de DNS públicofield. Se trata del nombre de
DNS público del nodo de líder del clúster de Amazon EMR.
3. A la derecha del nombre de DNS, elija el enlace SSH.
4. Siga las instrucciones enConnect al nodo de directriz mediante SSH.
En función del sistema operativo, elija laWindowsTabulador oMac/Linuxy siga las instrucciones para
conectarse al nodo de directriz.
Después de conectarse al nodo de directriz mediante SSH o PuTTY, debe aparecer un símbolo del
sistema parecido al siguiente:
[hadoop@ip-192-0-2-0 ~]$
Paso siguiente
wget https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/samples/
features.zip
unzip features.zip
head features.txt
1535908|Big Run|Stream|WV|38.6370428|-80.8595469|794
875609|Constable Hook|Cape|NJ|40.657881|-74.0990309|7
1217998|Gooseberry Island|Island|RI|41.4534361|-71.3253284|10
26603|Boone Moore Spring|Spring|AZ|34.0895692|-111.410065|3681
1506738|Missouri Flat|Flat|WA|46.7634987|-117.0346113|2605
1181348|Minnow Run|Stream|PA|40.0820178|-79.3800349|1558
1288759|Hunting Creek|Stream|TN|36.343969|-83.8029682|1024
533060|Big Charles Bayou|Bay|LA|29.6046517|-91.9828654|0
829689|Greenwood Creek|Stream|NE|41.596086|-103.0499296|3671
541692|Button Willow Island|Island|LA|31.9579389|-93.0648847|98
hive
LOAD DATA
LOCAL
INPATH './features.txt'
OVERWRITE
INTO TABLE hive_features;
7. Ahora, tiene una tabla de Hive nativa llena de datos defeatures.txtfile. Para comprobarlo, escriba
la siguiente instrucción de HiveQL:
El resultado debería ser una lista de estados y el número de accidentes geográficos de cada uno de
ellos.
Paso siguiente
a. EnTabla, escribaFeatures.
b. ParaClave principal, en elClave de particiónfield, escribaId. Establezca el tipo de datos en
Number (Número).
"dynamodb.column.mapping"="feature_id:Id,feature_name:Name,feature_class:Class,state_alpha:State,p
);
Hive enviará un trabajo de MapReduce, que se procesará en el clúster de Amazon EMR. El trabajo
puede tardará varios minutos en completarse.
6. Compruebe que los datos se han cargado en DynamoDB:
Paso siguiente
3. Los estados que tienen al menos tres accidentes geográficos con más de una milla de altitud
(5280 pies/1609,34 metros):
Paso siguiente
Sin embargo, cuando ya no necesite el clúster, conviene terminarlo y eliminar todos los recursos
asociados. De este modo, evitará que se le cobre por los recursos que no necesita.
Podemos considerar que una tabla externa es un puntero que señala a un origen de datos administrado
y almacenado en otro lugar. En este caso, el origen de datos subyacente es una tabla de DynamoDB. La
tabla debe existir previamente. No se puede crear, actualizar ni eliminar una tabla de DynamoDB desde
Hive. Utiliza laCREATE EXTERNAL TABLEPara crear la tabla externa. A partir de ese momento, podrá usar
HiveQL para trabajar con los datos de DynamoDB, como si se encontrasen almacenado localmente en
Hive.
Note
Puede utilizarINSERTPara insertar datos en una tabla externa ySELECTpara seleccionar datos de
él. Sin embargo, no se pueden usar instrucciones UPDATE ni DELETE para manipular los datos de
la tabla.
Temas
• Sintaxis de CREATE EXTERNAL TABLE (p. 1039)
• Mapeos de tipos de datos (p. 1040)
En la línea 2 se especifican las columnas y los tipos de datos dehive_table. Debe definir columnas y tipos
de datos que se correspondan con los atributos de la tabla de DynamoDB.
La línea 3 es laSTORED BY, en la que se especifica una clase que controla la administración
de los datos entre Hive y la tabla de DynamoDB. En DynamoDB,STORED BYDebe definirse
en'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'.
• El nombre de la tabla de Hive no tiene que ser igual que el de la tabla de DynamoDB.
• Los nombres de las columnas de la tabla de Hive no tienen que ser iguales que los de la tabla de
DynamoDB.
• La tabla especificada endynamodb.table.namedebe existir en DynamoDB.
• En dynamodb.column.mapping:
• Debe mapear los atributos del esquema de claves de la tabla de DynamoDB. Esto incluye la clave de
partición y la clave de ordenación (si la hay).
• No tiene que mapear los atributos que no son de clave de la tabla de DynamoDB. Sin embargo, no
aparecerá ningún dato de esos atributos cuando consulte la tabla de Hive.
• Si los tipos de datos de una columna de la tabla de Hive y de un atributo de DynamoDB son
incompatibles, apareceráNULLEn estas columnas cuando consulte la tabla de Hive.
Note
Cadena STRING
Binario BINARY
Note
• Map
• List
• Booleano
• Null
Si desea mapear un atributo de DynamoDB del tipo Number, debe elegir un tipo de Hive apropiado:
• La ColmenaBIGINTEl tipo es para enteros de 8 bytes con signo. Es igual que el tipo de datos long de
Java.
• La ColmenaDOUBLEEl tipo es para números de 8 bits con coma flotante de doble precisión. Es igual que
el tipo double de Java.
Si tiene datos numéricos almacenados en DynamoDB cuya precisión es superior a la del tipo de datos de
Hive que ha elegido, al obtener acceso a los datos de DynamoDB, podría perderse precisión.
Si exporta datos del tipo Binary de DynamoDB a (Amazon S3) o HDFS, los datos se almacenarán como
una cadena codificada en Base64. Si importa datos de Amazon S3 o HDFS al tipo Binary de DynamoDB,
debe asegurarse de que estén codificados como una cadena Base64.
Hive no devuelve los resultados de forma inmediata. En lugar de ello, envía un trabajo de MapReduce,
que se procesa en el marco Hadoop. Hive espera hasta que se ha completado el trabajo para mostrar los
resultados de la consulta:
AK 2
AL 2
AR 2
AZ 3
CA 7
CO 2
CT 2
ID 1
KS 1
ME 2
MI 1
MT 3
NC 1
NE 1
NM 1
NY 2
OR 5
PA 1
TN 1
TX 1
UT 4
VA 1
VT 2
WA 2
WY 3
Time taken: 8.753 seconds, Fetched: 25 row(s)
Si necesita cancelar el trabajo antes de que finalice, puede escribirCtrl+CEn cualquier momento.
Estos ejemplos se refieren a laddb_featuresen el tutorial (Paso 5: Copiar datos en DynamoDB (p. 1037)).
Temas
• Uso de funciones de agregación (p. 1042)
• Uso de las cláusulas GROUP BY y HAVING (p. 1042)
• Unión de dos tablas de DynamoDB (p. 1043)
• Unión de tablas de orígenes diferentes (p. 1043)
SELECT MAX(elev_in_ft)
FROM ddb_features
WHERE state_alpha = 'CO';
En el siguiente ejemplo se devuelve una lista con las cinco mayores altitudes de aquellos estados que
tienen más de cinco accidentes geográficos contenidos en la tabla ddb_features.
Tomemos una tabla de DynamoDB denominada EastCoastStates que contiene los datos siguientes:
StateName StateAbbrev
Maine ME
New Hampshire NH
Massachusetts MA
Rhode Island RI
Connecticut CT
New York NY
New Jersey NJ
Delaware DE
Maryland MD
Virginia VA
North Carolina NC
South Carolina SC
Georgia GA
Florida FL
Supongamos que la tabla está disponible como una tabla de Hive externa denominada east_coast_states:
La unión siguiente devuelve los estados de la costa oriental de Estados Unidos que tienen al menos tres
accidentes geográficos:
Hive es una solución excelente para copiar datos entre tablas de DynamoDB, buckets de Amazon S3,
tablas de Hive nativas y Hadoop Distributed File System (HDFS). En esta sección se proporcionan
ejemplos de estas operaciones.
Temas
• Copia de datos entre DynamoDB y una tabla de Hive nativa (p. 1044)
• Copia de datos entre DynamoDB y Amazon S3 (p. 1045)
• Copia de datos entre DynamoDB y HDFS (p. 1049)
• Uso de la compresión de datos (p. 1052)
• Lectura de datos de caracteres UTF-8 no imprimibles (p. 1053)
Puede ser algo conveniente si tiene que realizar muchas consultas de HiveQL, pero no desea consumir
capacidad de desempeño provisionada de DynamoDB. Dado que los datos de la tabla de Hive nativa son
una copia de los datos de DynamoDB, y no son datos «en tiempo real», en las consultas no cabe esperar
que los datos estén actualizados.
Note
Los ejemplos de esta sección se han escrito partiendo del supuesto de que ya ha llevado a cabo
los pasos delTutorial: Uso de Amazon DynamoDB y Apache Hive (p. 1033)y tener una tabla
externa en DynamoDB llamadaddb_features.
En el siguiente ejemplo se crea una tabla de Hive nativa que únicamente contiene algunos de atributos de
lagos y cumbres:
La instrucción de HiveQL siguiente permite copiar los datos de la tabla de Hive nativa a ddb_features:
Puede ser interesante hacerlo si desea crear un archivo comprimido de datos en la tabla de DynamoDB.
Por ejemplo, supongamos que tiene un entorno de pruebas en el cual necesita trabajar con un conjunto
de datos de prueba de referencia en DynamoDB. Puede copiar los datos de referencia en un bucket
de Amazon S3 y, a continuación, ejecutar las pruebas. A continuación, puede restablecer el entorno de
pruebas restaurando los datos de referencia del bucket de Amazon S3 en DynamoDB.
Si trabajaste a través deTutorial: Uso de Amazon DynamoDB y Apache Hive (p. 1033), ya dispone de un
bucket de Amazon S3 que contiene los logs de Amazon EMR. Puede utilizar este bucket para los ejemplos
de esta sección, si conoce su ruta raíz:
s3://aws-logs-accountID-region
Note
En estos ejemplos, utilizaremos una subruta contenida en el bucket, como en este ejemplo:
s3://aws-logs-123456789012-us-west-2/hive-test
Los procedimientos siguientes se han escrito partiendo del supuesto de que ya ha llevado a cabo los
pasos del tutorial y de que ya dispone de una tabla externa en DynamoDB denominadaddb_features.
Temas
• Copia de datos mediante el formato predeterminado de Hive (p. 1045)
• Copia de datos con un formato especificado por el usuario (p. 1046)
• Copia de datos sin mapeo de columnas (p. 1047)
• Visualización de los datos en Amazon S3 (p. 1048)
Cada campo se separa por un carácter SOH (inicio del encabezado, 0x01). En el archivo, SOH aparece
como^A.
1. Cree una tabla externa que apunte a los datos sin formato de Amazon S3.
1. Cree una tabla de Hive externa mapeada a Amazon S3. Al hacerlo, asegúrese de que los tipos de
datos sean coherentes con los de la tabla de DynamoDB externa.
Con una sola instrucción de HiveQL, puede rellenar la tabla de DynamoDB usando los datos de Amazon
S3:
Note
Si la tabla de DynamoDB contiene atributos de tipo Map, List, Boolean o Null, entonces este es el
único modo de usar Hive para copiar datos de DynamoDB a Amazon S3.
1. Cree una tabla externa asociada con la tabla de DynamoDB. Esta instrucción de HiveQL no contiene
ningún mapeo dynamodb.column.mapping.
Name^C{"s":"Soldiers Farewell
Hill"}^BState^C{"s":"NM"}^BClass^C{"s":"Summit"}^BElevation^C{"n":"6135"}^BLatitude^C{"n":"32.3564729"
Name^C{"s":"Jones
Run"}^BState^C{"s":"PA"}^BClass^C{"s":"Stream"}^BElevation^C{"n":"1260"}^BLatitude^C{"n":"41.2120086"}
Name^C{"s":"Sentinel
Dome"}^BState^C{"s":"CA"}^BClass^C{"s":"Summit"}^BElevation^C{"n":"8133"}^BLatitude^C{"n":"37.7229821"
Name^C{"s":"Neversweet
Gulch"}^BState^C{"s":"CA"}^BClass^C{"s":"Valley"}^BElevation^C{"n":"2900"}^BLatitude^C{"n":"41.6565269
Name^C{"s":"Chacaloochee
Bay"}^BState^C{"s":"AL"}^BClass^C{"s":"Bay"}^BElevation^C{"n":"0"}^BLatitude^C{"n":"30.6979676"}^BId^C
Cada campo comienza por un carácter STX (inicio del texto, 0x02) y termina con un carácter ETX (final del
texto, 0x03). En el archivo, STX aparece como^By ETX aparece como^C.
Los pasos siguientes se han escrito partiendo del supuesto de que ha copiado los datos de DynamoDB a
Amazon S3 por medio de uno de los procedimientos de esta sección.
1. Si tiene abierto el símbolo del sistema de Hive, salga y cambie al símbolo del sistema de Linux.
hive> exit;
2. Muestre el contenido del directorio hive-test en el bucket de Amazon S3. Aquí es donde Hive ha
copiado los datos de DynamoDB.
aws s3 ls s3://aws-logs-123456789012-us-west-2/hive-test/
aws s3 cp s3://aws-logs-123456789012-us-west-2/hive-test/000000_0 .
download: s3://aws-logs-123456789012-us-west-2/hive-test/000000_0
to ./000000_0
Note
El sistema de archivos local del nodo de directriz tiene una capacidad limitada. No utilice
este comando con archivos más grandes que el espacio disponible en el sistema de archivos
local.
Puede ser interesante hacerlo si va a ejecutar un trabajo de MapReduce que requiere datos de
DynamoDB. Si copia los datos de DynamoDB a HDFS, Hadoop puede procesarlos utilizando en paralelo
todos los nodos disponibles en el clúster de Amazon EMR. Una vez que se haya completado el trabajo de
MapReduce, puede escribir los resultados de HDFS a DDB.
En los ejemplos siguientes, Hive leerá y escribirá en el siguiente directorio de HDFS: /user/hadoop/
hive-test
Note
Los ejemplos de esta sección se han escrito partiendo del supuesto de que ya ha llevado a cabo
los pasos delTutorial: Uso de Amazon DynamoDB y Apache Hive (p. 1033)y tiene una tabla
externa en DynamoDB llamadaddb_features.
Temas
• Copia de datos mediante el formato predeterminado de Hive (p. 1049)
• Copia de datos con un formato especificado por el usuario (p. 1050)
• Copia de datos sin mapeo de columnas (p. 1050)
• Acceso a los datos de HDFS (p. 1051)
Cada campo se separa por un carácter SOH (inicio del encabezado, 0x01). En el archivo, SOH aparece
como^A.
1. Cree una tabla externa mapeada a los datos sin formato de HDFS.
LOCATION 'hdfs:///user/hadoop/hive-test';
1. Cree una tabla de Hive externa mapeada a HDFS. Al hacerlo, asegúrese de que los tipos de datos
sean coherentes con los de la tabla de DynamoDB externa.
Con una sola instrucción de HiveQL, puede rellenar la tabla de DynamoDB usando los datos de HDFS:
Note
Si la tabla de DynamoDB contiene atributos de tipo Map, List, Boolean o Null, entonces este es el
único modo de usar Hive para copiar datos de DynamoDB a HDFS.
1. Cree una tabla externa asociada con la tabla de DynamoDB. Esta instrucción de HiveQL no contiene
ningún mapeo dynamodb.column.mapping.
Name^C{"s":"Soldiers Farewell
Hill"}^BState^C{"s":"NM"}^BClass^C{"s":"Summit"}^BElevation^C{"n":"6135"}^BLatitude^C{"n":"32.3564729"
Name^C{"s":"Jones
Run"}^BState^C{"s":"PA"}^BClass^C{"s":"Stream"}^BElevation^C{"n":"1260"}^BLatitude^C{"n":"41.2120086"}
Name^C{"s":"Sentinel
Dome"}^BState^C{"s":"CA"}^BClass^C{"s":"Summit"}^BElevation^C{"n":"8133"}^BLatitude^C{"n":"37.7229821"
Name^C{"s":"Neversweet
Gulch"}^BState^C{"s":"CA"}^BClass^C{"s":"Valley"}^BElevation^C{"n":"2900"}^BLatitude^C{"n":"41.6565269
Name^C{"s":"Chacaloochee
Bay"}^BState^C{"s":"AL"}^BClass^C{"s":"Bay"}^BElevation^C{"n":"0"}^BLatitude^C{"n":"30.6979676"}^BId^C
Cada campo comienza por un carácter STX (inicio del texto, 0x02) y termina con un carácter ETX (final del
texto, 0x03). En el archivo, STX aparece como^By ETX aparece como^C.
HDFS no es lo mismo que el sistema de archivos local del nodo de directriz. No se puede trabajar con
archivos y directorios en HDFS usando comandos Linux estándar (comocat,cp,mv, o bienrm). En lugar de
ello, estas tareas se llevan a cabo usando el comando hadoop fs.
Los pasos siguientes se han escrito partiendo del supuesto de que ha copiado los datos de DynamoDB a
HDFS por medio de uno de los procedimientos de esta sección.
1. Si tiene abierto el símbolo del sistema de Hive, salga y cambie al símbolo del sistema de Linux.
hive> exit;
2. Muestre el contenido del directorio /user/hadoop/hive-test en HDFS. Aquí es donde Hive ha copiado
los datos de DynamoDB.
Found 1 items
-rw-r--r-- 1 hadoop hadoop 29504 2016-06-08 23:40 /user/hadoop/hive-test/000000_0
Note
El sistema de archivos local del nodo de directriz tiene una capacidad limitada. No utilice
este comando con archivos más grandes que el espacio disponible en el sistema de archivos
local.
SET hive.exec.compress.output=true;
Versión de API 2012-08-10
1052
Amazon DynamoDB Guía para desarrolladores
Ajuste del desempeño
SET io.seqfile.compression.type=BLOCK;
SET mapred.output.compression.codec = com.hadoop.compression.lzo.LzopCodec;
El archivo resultante de Amazon S3 tendrá un nombre generado por el sistema con.lzoal final (por
ejemplo,8d436957-57ba-4af7-840c-96c2fc7bb6f5-000000.lzo).
• org.apache.hadoop.io.compress.GzipCodec
• org.apache.hadoop.io.compress.DefaultCodec
• com.hadoop.compression.lzo.LzoCodec
• com.hadoop.compression.lzo.LzopCodec
• org.apache.hadoop.io.compress.BZip2Codec
• org.apache.hadoop.io.compress.SnappyCodec
Apache Hive en Amazon EMR implementa su propia lógica para balancear la carga de E/S en la tabla
de DynamoDB y trata de minimizar la posibilidad de sobrepasar el desempeño provisionado de la tabla.
Al final de cada consulta de Hive, Amazon EMR devuelve métricas de tiempo de ejecución, incluido el
número de veces que se ha superado el desempeño provisionado. Puede usar esta información, junto
con las métricas de CloudWatch en la tabla de DynamoDB, para mejorar el desempeño en las solicitudes
posteriores.
La consola de Amazon EMR proporciona herramientas de monitorización básica para el clúster. Para
obtener más información, consulteVer y monitorizar un clústeren laGuía de administración de Amazon
EMR.
También puede monitorizar el clúster y los trabajos de Hadoop mediante herramientas basadas en Web,
tales como Hue, Ganglia y la interfaz web de Hadoop. Para obtener más información, consulteVer las
interfaces web alojadas en clústeres de EMRen laGuía de administración de Amazon EMR.
En esta sección se describen los pasos que puede llevar a cabo para ajustar el desempeño de las
operaciones de Hive en las tablas de DynamoDB externas.
Temas
• Desempeño aprovisionado de DynamoDB (p. 1054)
• Ajuste de los mapeadores (p. 1055)
• Temas adicionales (p. 1056)
Por ejemplo, supongamos que ha provisionado 100 unidades de capacidad de lectura para la tabla de
DynamoDB. Esto permite leer 409 600 bytes por segundo (100 × 4 KB, que es el tamaño de la unidad de
capacidad de lectura). Ahora, supongamos que la tabla contiene 20 GB de datos (a saber, 21 474 836
480 bytes) y que desea usar elSELECTpara seleccionar todos los datos usando HiveQL. A continuación se
indica cómo calcular cuánto tardará aproximadamente la consulta en ejecutarse:
En esta situación, la tabla de DynamoDB es un cuello de botella. Agregar más nodos Amazon EMR no
servirá de ayuda, porque el desempeño de Hive está limitado a tan solo 409 600 bytes por segundo. La
única forma de reducir el tiempo necesario paraSELECTLa instrucción es aumentar la capacidad de lectura
provisionada de la tabla de DynamoDB.
Puede realizar un cálculo similar para calcular aproximadamente cuánto se tardaría en cargar los datos
masivamente en una tabla de Hive externa mapeada a una tabla de DynamoDB. Determine el número total
de bytes de los datos que desea cargar y, a continuación, divida esa cifra por una unidad de capacidad de
escritura de DynamoDB (1 KB). Obtendrá el número de segundos que se tardará en cargar la tabla.
Capacidad de lectura
Amazon EMR administra la carga de solicitudes en la tabla de DynamoDB de acuerdo con los
ajustes de desempeño provisionado de la tabla. Sin embargo, si observa una gran cantidad
deProvisionedThroughputExceededEn la salida del trabajo, puede ajustar la tasa de lectura
predeterminada. Para ello, puede modificar eldynamodb.throughput.read.percentVariable de
configuración de. Puede usar el comando SET para establecer esta variable en el símbolo del sistema de
Hive:
SET dynamodb.throughput.read.percent=1.0;
Esta variable persiste únicamente durante la sesión de Hive actual. Si sale de Hive y vuelve a abrirlo más
adelante, dynamodb.throughput.read.percent recuperará su valor predeterminado.
Si observa que Hive agota con frecuencia la capacidad de lectura provisionada de la tabla, o
si las solicitudes de lectura son objeto de la limitación limitada en demasiados casos, pruebe a
reducirdynamodb.throughput.read.percentA continuación0.5. Si tiene capacidad de lectura
suficiente en la tabla y desea aumentar la agilidad de las operaciones de HiveQL, puede establecer esta
variable en un valor superior a 0.5.
Capacidad de escritura
Amazon EMR administra la carga de solicitudes en la tabla de DynamoDB de acuerdo con los
ajustes de desempeño provisionado de la tabla. Sin embargo, si observa una gran cantidad
deProvisionedThroughputExceededEn la salida del trabajo, puede ajustar la tasa de escritura
predeterminada. Para ello, puede modificar eldynamodb.throughput.write.percentVariable de
configuración de. Puede usar el comando SET para establecer esta variable en el símbolo del sistema de
Hive:
SET dynamodb.throughput.write.percent=1.0;
Esta variable persiste únicamente durante la sesión de Hive actual. Si sale de Hive y vuelve a abrirlo más
adelante, dynamodb.throughput.write.percent recuperará su valor predeterminado.
Si observa que Hive agota con frecuencia la capacidad de escritura provisionada de la tabla, o
si las solicitudes de escritura son objeto de la limitación limitada en demasiados casos, pruebe a
reducirdynamodb.throughput.write.percentA continuación0.5. Si tiene capacidad suficiente en la
tabla y desea aumentar la agilidad de las operaciones de HiveQL, puede establecer esta variable en un
valor superior a 0.5.
Al escribir datos en DynamoDB utilizando Hive, debe asegurarse de que el número de unidades de
capacidad de escritura sea mayor que el número de mapeadores en el cluster. Por ejemplo, tomemos un
clúster de EMR de que consta de 10m1.xlargeNodos. Lam1.xlargeEl tipo de nodo proporciona 8 tareas de
mapeador, de modo que el clúster tendría un total de 80 mapeadores (10 × 8). Si la tabla de DynamoDB
tiene menos de 80 unidades de capacidad de escritura, entonces una operación de escritura de Hive
podría consumir todo el desempeño de escritura de dicha tabla.
Para determinar el número de mapeadores de los tipos de nodos de Amazon EMR, consulteConfiguración
de tareasen laGuía para desarrolladores de Amazon EMR.
Para obtener más información sobre los mapeadores, consulte Ajuste de los mapeadores (p. 1055).
Note
Si la tabla de DynamoDB posee gran capacidad de desempeño para las lecturas, puede probar a
aumentar el número de mapeadores de una de las siguientes formas:
• Aumente el tamaño de los nodos del clúster. Por ejemplo, si el clúster utiliza m1.large nodos (tres
mapeadores por nodo), puede probar a actualizarlos a nodos m1.xlarge (ocho mapeadores por nodo).
• Aumente el número de nodos del clúster. Por ejemplo, si tiene un clúster de tres nodos dem1.xlargeEn
total, dispone de un total de 24 mapeadores. Si duplicara el tamaño del clúster, con el mismo tipo de
nodo, tendría 48 mapeadores.
Puede utilizar la AWS Management Console para administrar el tamaño o el número de nodos del clúster.
Puede que tenga que reiniciar el clúster para que surtan efecto estos cambios.
Puede usar el parámetro dynamodb.max.map.tasks para establecer un límite superior para las tareas
de mapeo:
SET dynamodb.max.map.tasks=1
Este valor debe ser igual o superior a 1. Cuando Hive procese la consulta, el trabajo de Hadoop resultante
no usará más dedynamodb.max.map.tasksAl leer desde la tabla de DynamoDB.
Temas adicionales
A continuación se muestran otras maneras de ajustar las aplicaciones que utilizan Hive para obtener
acceso a DynamoDB.
SET dynamodb.retry.duration=2;
El valor debe ser un número entero distinto de cero que represente el número de minutos del intervalo de
reintento. El valor predeterminado de dynamodb.retry.duration es 2 (minutos).
Tiempo de solicitud
Programar las consultas de Hive que obtienen acceso a una tabla de DynamoDB cuando la demanda de
esa tabla de DynamoDB es más baja, mejora el desempeño. Por ejemplo, si la mayoría de los usuarios de
la aplicación viven en San Francisco, podría elegir exportar los datos diarios a las 4.00 h PST, cuando la
mayoría de los usuarios duerme y no actualizan los registros de la base de datos de DynamoDB.
Puede exportar una tabla de DynamoDB utilizando la herramientaAWS Management Console, elAWS
Command Line Interfaceo la API de DynamoDB. Para obtener más información, consulte Solicitar una
exportación de tabla en DynamoDB (p. 1058).
Para obtener más información acerca deAWSDisponibilidad y precios de las regiones, consulte.Precios de
Amazon DynamoDB.
Temas
• Exportación de datos de DynamoDB a Amazon S3: cómo funciona (p. 1058)
• Solicitar una exportación de tabla en DynamoDB (p. 1058)
• Formato de salida de exportación de tabla de Dynamo (p. 1062)
• Uso de exportaciones de tablas de DynamoDB con otrosAWSservices (p. 1065)
Puede optar por exportar los datos en formato JSON de DynamoDB o en formato de texto de Amazon Ion.
Para obtener más información acerca de los formatos de exportación, consulte.Objetos de datos (p. 1063).
Puede exportar datos a un bucket de S3 que pertenezca a una cuenta diferente si tiene los permisos
correctos para escribir en esa tabla. El bucket de destino puede estar en una región diferente a la
de la tabla de origen. Para obtener más información, consulte Configuración y permisos de Amazon
S3 (p. 1059).
Se pueden exportar simultáneamente hasta 300 tareas de exportación o hasta 100 TB de tamaño de tabla.
El tiempo de solicitud y la hora de la última actualización incluida en la solicitud de exportación del lago de
datos pueden variar en un plazo de un minuto. Por ejemplo, si envía la solicitud a las 2:25 PM, se garantiza
que la salida contendrá todos los datos comprometidos con la tabla hasta 2:24, y los datos confirmados
después de 2:26 no se incluirán. La salida puede contener o no modificaciones de datos realizadas entre
2:24 y 2:26. Los datos exportados tampoco son coherentes con las transacciones.
AWS CloudTrailregistra todas las acciones de la consola y de la API relacionadas con la exportación de
tablas para permitir el mantenimiento de registros, una monitorización continua y auditorías. Para obtener
más información, consulte Registro de operaciones de DynamoDB utilizandoAWS CloudTrail (p. 964).
La exportación de tablas de DynamoDB está diseñada para ser más rápida que la exportación de una
tabla mediante un análisis de tabla. Sin embargo, el tiempo exacto que tarda la exportación en completarse
depende del tamaño de la tabla y de la uniformidad de los datos de la tabla. Si su caso de uso implica
análisis en tiempo real, puede utilizar Amazon Kinesis Data Streams. Para obtener más información,
consulte laGuía del desarrollador de Amazon Kinesis Data Streams.
Para obtener más información acerca de Amazon S3, consulte laAmazon Simple Storage Service
Developer Guide.
Note
Si quiere utilizar la AWS CLI, primero tendrá que configurarla. Para obtener más información, consulte
Acceso a DynamoDB (p. 60).
Temas
• Configuración y permisos de Amazon S3 (p. 1059)
• Solicitar una exportación mediante elAWS Management Console (p. 1060)
• Obtención de detalles sobre exportaciones pasadas en elAWS Management Console (p. 1061)
• Solicitar una exportación mediante elAWS CLI (p. 1061)
• Obtención de detalles sobre exportaciones pasadas en elAWS CLI (p. 1061)
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowDynamoDBExportAction",
"Effect": "Allow",
"Action": "dynamodb:ExportTableToPointInTime",
"Resource": "arn:aws:dynamodb:us-east-1:111122223333:table/my-table"
},
{
"Sid": "AllowWriteToDestinationBucket",
"Effect": "Allow",
"Action": [
"s3:AbortMultipartUpload",
"s3:PutObject",
"s3:PutObjectAcl"
],
"Resource": "arn:aws:s3:::your-bucket/*"
}
]
}
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ExampleStatement",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:user/Dave"
},
"Action": [
"s3:AbortMultipartUpload",
"s3:PutObject",
"s3:PutObjectAcl"
],
"Resource": "arn:aws:s3:::awsexamplebucket1/*"
}
]
}
Revocar estos permisos mientras una exportación está en curso dará como resultado archivos parciales.
Si eliges cifrar tu exportación usando una clave protegida porAWS Key Management
Service(AWS KMS), la clave debe estar en la misma región que el bucket de S3 de destino.
6. Haga clic en el botón .Exportpara comenzar la exportación.
Note
Si eliges cifrar tu exportación usando una clave protegida porAWS Key Management
Service(AWS KMS), la clave debe estar en la misma región que el bucket de S3 de destino.
En el siguiente ejemplo, utilizamos la opcióntable-arnpara enumerar sólo las exportaciones de una tabla
específica.
Para recuperar información detallada sobre una tarea de exportación específica, incluida cualquier
configuración de configuración avanzada, utilice ladescribe-exportEl comando de.
Temas
• Archivos de manifiesto (p. 1062)
• Objetos de datos (p. 1063)
Archivos de manifiesto
DynamoDB crea dos archivos de manifiesto, junto con sus archivos de suma de comprobación, en el
bucket S3 especificado para cada solicitud de exportación.
export-prefix/AWSDynamoDB/ExportId/manifest-summary.json
export-prefix/AWSDynamoDB/ExportId/manifest-summary.checksum
export-prefix/AWSDynamoDB/ExportId/manifest-files.json
export-prefix/AWSDynamoDB/ExportId/manifest-files.checksum
Usted elige unexport-prefixcuando solicite una exportación de tabla. Esto le ayuda a mantener
los archivos en el bucket de S3 de destino. LaExportIdes un token único para garantizar que varias
exportaciones al mismo bucket S3 yexport-prefixno se sobrescriban entre sí.
Note
DynamoDB también crea un archivo vacío denominado_startedEn el mismo directorio que los
archivos de manifiesto. Este archivo comprueba que el depósito de destino se puede escribir y
que la exportación ha comenzado. Se puede eliminar de forma segura.
El manifiesto de resumen
Lamanifest-summary.jsonEl archivo contiene información de resumen sobre el trabajo de exportación.
Su formato es el siguiente:
{
"version": "2020-06-30",
"exportArn": "arn:aws:dynamodb:us-east-1:123456789012:table/ProductCatalog/
export/01234567890123-a1b2c3d4",
"startTime": "2020-11-04T07:28:34.028Z",
"endTime": "2020-11-04T07:33:43.897Z",
"tableArn": "arn:aws:dynamodb:us-east-1:123456789012:table/ProductCatalog",
"tableId": "12345a12-abcd-123a-ab12-1234abc12345",
"exportTime": "2020-11-04T07:28:34.028Z",
"s3Bucket": "ddb-productcatalog-export",
"s3Prefix": "2020-Nov",
"s3SseAlgorithm": "AES256",
"s3SseKmsKeyId": null,
"manifestFilesS3Key": "AWSDynamoDB/01345678901234-abc12345/manifest-files.json",
"billedSizeBytes": 0,
"itemCount": 8,
"outputFormat": "DYNAMODB_JSON"
}
El manifiesto de archivos
Lamanifest-files.jsonEl archivo contiene información sobre los archivos que contienen los datos
de tabla exportados. El archivo está enLíneas de JSON, lo que significa que las líneas nuevas se utilizan
como delimitadores de elementos. En el ejemplo siguiente, los detalles de un archivo de datos de un
manifiesto de archivos tienen formato en varias líneas para facilitar la legibilidad.
{
"itemCount": 8,
"md5Checksum": "sQMSpEILNgoQmarvDFonGQ==",
"etag": "af83d6f217c19b8b0fff8023d8ca4716-1",
"dataFileS3Key": "AWSDynamoDB/11111111111111-22222222/data/33334444EXAMPLE.json.gz"
}
Objetos de datos
DynamoDB puede exportar los datos de la tabla en dos formatos: DynamoDB JSON y Amazon Ion.
Independientemente del formato que elija, sus datos se escribirán en varios archivos comprimidos
nombrados por las claves que se encuentran en elmanifest-files.jsonfile.
export-prefix/AWSDynamoDB/ExportId/data/bafybeiczss3yxay3o4abnabbb.json.gz
export-prefix/AWSDynamoDB/ExportId/data/gkes5o3lnrhoznhnkyax3hxvya.json.gz
DynamoDB JSON
Una exportación de tabla en formato JSON de DynamoDB consta de variosItemObjetos de. Cada objeto
individual está en el formato JSON estándar de DynamoDB.
Al crear analizadores personalizados para los datos de exportación JSON de DynamoDB, tenga en cuenta
que el formatoLíneas de JSON. Esto significa que las líneas nuevas se utilizan como delimitadores de
elementos. MuchosAWS, como Athena yAWS Glue, analizará este formato automáticamente.
En el ejemplo siguiente, se ha dado formato a un único elemento de una exportación de DynamoDB JSON
en varias líneas en aras de la legibilidad.
{
"Item":{
"Authors":{
"SS":[
"Author1",
"Author2"
]
},
"Dimensions":{
"S":"8.5 x 11.0 x 1.5"
},
"ISBN":{
"S":"333-3333333333"
},
"Id":{
"N":"103"
},
"InPublication":{
"BOOL":false
},
"PageCount":{
"N":"600"
},
"Price":{
"N":"2000"
},
"ProductCategory":{
"S":"Book"
},
"Title":{
"S":"Book 103 Title"
}
}
}
Amazon Ion
Amazon Iones un formato de serialización de datos jerárquico, autodescriptivo y altamente tipado,
diseñado para abordar los desafíos rápidos de desarrollo, desacoplamiento y eficiencia a los que
se enfrentan todos los días mientras se diseñan arquitecturas a gran escala orientadas a servicios.
DynamoDB admite la exportación de datos de tabla enFormato de texto, que es un superconjunto de
JSON.
Al exportar una tabla al formato Ion, los tipos de datos de DynamoDB utilizados en la tabla se asignan
aTipos de datos de Ion. Uso de conjuntos de DynamoDBAnotaciones de tipo IonPara desambiguar el tipo
de datos utilizado en la tabla de origen.
List Lista
Map struct
Los elementos de una exportación de iones están delimitados por nuevas líneas. Cada línea comienza con
un marcador de versión Ion, seguido de un elemento en formato Ion. En el ejemplo siguiente, se ha dado
formato a un elemento de una exportación de iones en varias líneas en aras de la legibilidad.
$ion_1_0 {
Item:{
Authors:$dynamodb_SS::["Author1","Author2"],
Dimensions:"8.5 x 11.0 x 1.5",
ISBN:"333-3333333333",
Id:103.,
InPublication:false,
PageCount:6d2,
Price:2d3,
ProductCategory:"Book",
Title:"Book 103 Title"
}
}
Crear un lago de datos con Lake Formation es tan simple como definir orígenes de datos y qué políticas
de seguridad y acceso a datos desea aplicar. Lake Formation le ayuda a recopilar y catalogar datos de
bases de datos y almacenamiento de objetos, mover los datos a su nuevo lago de datos de Amazon S3,
limpiar y clasificar sus datos mediante algoritmos de aprendizaje automático y asegurar el acceso a sus
datos confidenciales. Para obtener más información, consulte AWS Lake Formation Developer Guide.
Temas
• Modo de capacidad de lectura/escritura y rendimiento (p. 1066)
• Tables (p. 1068)
• Tablas globales (p. 1069)
• Índices secundarios (p. 1069)
• Claves de partición y claves de ordenación (p. 1070)
• Reglas de nomenclatura (p. 1070)
• Tipos de datos (p. 1071)
• Items (p. 1071)
• Attributes (p. 1072)
• Parámetros de expresión (p. 1072)
• Transacciones DynamoDB (p. 1073)
• DynamoDB Streams (p. 1073)
• DynamoDB Accelerator (DAX) (p. 1074)
• Límites específicos de API (p. 1075)
• DynamoDB ado en reposo (p. 1076)
• Exportación de tablas a Amazon S3 (p. 1076)
Una unidad de capacidad de escritura equivale a una escritura por segundo para los elementos con un
tamaño de hasta 1 KB.
Las solicitudes de lectura transaccionales requieren dos unidades de capacidad de lectura por segundo
respecto a los elementos de hasta 4 KB.
Las solicitudes de escritura transaccionales requieren dos unidades de capacidad de escritura para realizar
una escritura por segundo respecto a los elementos de hasta 1 KB.
Una unidad de solicitud de escritura equivale a una escritura para los elementos con un tamaño de hasta 1
KB.
Las solicitudes de lectura transaccionales requieren dos unidades de solicitud de lectura para realizar una
lectura respecto a los elementos de hasta 4 KB.
Las solicitudes de escritura transaccionales requieren dos unidades de solicitud de escritura para realizar
una escritura respecto a los elementos de hasta 1 KB.
Note
Todo el rendimiento disponible para la cuenta se puede aplicar a una sola tabla o a varias tablas.
En la páginaAWS Management Console, puede usar Amazon CloudWatch para consultar el rendimiento
de lectura y escritura actual en un determinadoAWSEn la región, observando laread capacityywrite
capacity graphsen elMétricasPestaña. Asegúrese de no acercarse demasiado a las cuotas.
No puede superar las cuotas por cuenta al agregar capacidad aprovisionada. DynamoDB no permite
aumentar la capacidad aprovisionada con gran rapidez. Aparte de estas restricciones, puede aumentar
la capacidad aprovisionada de las tablas tanto como lo necesite. Para obtener más información sobre las
cuotas por cuenta, consulte la sección anterior, Cuotas de rendimiento predeterminadas (p. 1067).
Los límites de reducción de tablas e índices secundarios globales no están asociados, lo que
significa que los índices secundarios globales de una determinada tabla tienen sus propios
límites de reducción. Sin embargo, si una solicitud reduce el rendimiento de una tabla y un índice
secundario global, se rechazará si se supera alguno de los límites actuales. Las solicitudes no se
procesan parcialmente.
Example
En las primeras 4 horas de un día, una tabla con un índice secundario global puede modificarse de la
siguiente manera:
Al final de ese mismo día, el rendimiento de la tabla y del índice secundario global se podría reducir un
total de 27 veces cada uno.
Tables
Tamaño de la tabla
No existe ningún límite práctico del tamaño de una tabla. Las tablas no presentan restricciones en cuanto
al número de elementos o de bytes.
Tablas globales
AWSExamine algunas cuotas predeterminadas en el rendimiento que puede aprovisionar o utilizar al usar
tablas globales.
Per table, per day 10 TB for all source 10 TB for all source
tables to which a tables to which a
replica was added replica was added
Si va a agregar una réplica para una tabla que está configurada para usar más de 40 000 unidades de
capacidad de escritura (WCU), debe solicitar un aumento de la cuota de servicio para la cuota de WCU
de réplica de adición. Para solicitar un aumento de la cuota de servicio, consultehttps://aws.amazon.com/
support.
Índices secundarios
Índices secundarios por tabla
Puede definir un máximo de 5 índices secundarios locales.
Existe una cuota inicial de 20 índices secundarios globales por tabla. Para solicitar un aumento de la cuota
de servicio, consultehttps://aws.amazon.com/support.
100. Si se proyecta el mismo nombre de atributo en dos índices diferentes, esto cuenta como dos atributos
distintos a la hora de determinar la cantidad total.
Este límite no se aplica a los índices secundarios cuyo valor de ProjectionType sea KEYS_ONLY o ALL.
Hay una excepción en las tablas que utilizan índices secundarios. Con un índice secundario local, hay
un límite en los tamaños de colección de elementos: Por cada valor de clave de partición diferente, los
tamaños totales de todos los elementos de la tabla y de los índices no puede superar los 10 GB. Esto
podría restringir el número de claves de ordenación por cada valor de clave de partición. Para obtener más
información, consulte Límite de tamaño de una colección de elementos (p. 623).
Reglas de nomenclatura
Nombres de tabla y nombres de índice secundarios
Los nombres de las tablas y de los índices secundarios deben tener 3 caracteres como mínimo y 255 como
máximo. A continuación se muestran los caracteres permitidos:
• A-Z
• a-z
• 0-9
• _ (guion bajo)
• - (guion)
• . (punto)
A continuación se muestran las excepciones. Los siguientes nombres de atributo no pueden tener más de
255 caracteres:
Estos nombres de atributos deben codificarse mediante UTF-8 y el tamaño total de cada nombre (después
de la codificación) no puede superar los 255 bytes.
Tipos de datos
String
La longitud de un valor de tipo String está limitada en función del tamaño de elemento máximo de 400 KB.
Los valores de tipo String son Unicode con codificación binaria UTF-8. Dado que UTF-8 es una
codificación de ancho variable, DynamoDB determina los bytes UTF-8 de un valor de tipo String para
determinar su longitud.
Number
Un valor de tipo Number puede tener hasta 38 dígitos de precisión y puede ser positivo, negativo o cero.
DynamoDB utiliza cadenas JSON para representar los datos de tipo Number en las solicitudes y las
respuestas. Para obtener más información, consulte API de bajo nivel de DynamoDB (p. 220).
Si la precisión del número es importante, debe pasar los números a DynamoDB utilizando cadenas que se
conviertan a partir de un tipo de número.
Binary
La longitud de un valor de tipo Binary está limitada en función del tamaño de elemento máximo de 400 KB.
Las aplicaciones que utilizan atributos de tipo Binary deben codificar los datos en formato Base64 antes de
enviárselos a DynamoDB. Al recibirlos, DynamoDB decodifica los datos y los convierte a matrices de bytes
sin signo; a continuación, utiliza ese resultado como longitud del atributo.
Items
Tamaño de elemento
El tamaño máximo de un elemento en DynamoDB es de 400 KB, que incluye tanto la longitud en formato
binario del nombre de los atributos (longitud en UTF-8) y las longitudes de los valores de los atributos
(también en formato binario). El nombre de los atributos se tiene en cuenta al calcular el límite de tamaño.
Por ejemplo, tomemos un elemento con dos atributos: un atributo denominado “shirt-color” cuyo valor es
“R” y otro denominado “shirt-size” cuyo valor es “M”. El tamaño total de ese elemento es de 23 bytes.
Attributes
Pares de nombre-valor de los atributos por elemento
El tamaño acumulado de los atributos por elemento debe ajustarse al tamaño máximo de elemento de
DynamoDB (400 KB).
Parámetros de expresión
Los parámetros de expresión incluyen ProjectionExpression, ConditionExpression,
UpdateExpression y FilterExpression.
Lengths
La longitud máxima de cualquier cadena de expresión es 4 KB. Por ejemplo, el tamaño de
ConditionExpression a=b es de 3 bytes.
La longitud máxima de todas las variables de sustitución de una expresión es de 2 MB. Este
valor representa la suma de las longitudes de todos los ExpressionAttributeNames y
ExpressionAttributeValues.
Operadores y operandos
El número máximo de operadores o funciones que se admiten en una UpdateExpression es de 300. Por
ejemplo, UpdateExpression SET a = :val1 + :val2 + :val3 contiene dos operadores “+”.
Palabras reservadas
DynamoDB no impide utilizar nombres que entran en conflicto con las palabras reservadas. Para ver una
lista completa, consulte Palabras reservadas en DynamoDB (p. 1135).)
Sin embargo, si utiliza una palabra reservada en un parámetro de expresión, también debe especificar
ExpressionAttributeNames. Para obtener más información, consulte Nombres de atributos de
expresión en DynamoDB (p. 425).
Transacciones DynamoDB
Las operaciones de la API transaccionales de DynamoDB presentan las siguientes restricciones:
DynamoDB Streams
Lectores simultáneos de un fragmento en DynamoDB
Streams
No permita que más de dos procesos lean el mismo fragmento de DynamoDB Streams al mismo tiempo. Si
excede este límite, puede producirse una limitación controlada de las solicitudes.
• Regiones de EE.UU. Este (Norte de Virginia), EE.UU. Este (Ohio), EE.UU. Oeste (Norte de California),
EE.UU. Oeste (Oregón), América del Sur (São Paulo), Europa (Frankfurt), Europa (Irlanda), Asia Pacífico
(Tokio), Asia Pacífico (Seúl), Asia Pacífico (Singapur), Asia Pacífico (Sídney), China (Beijing):
• Por tabla: 40 000 unidades de capacidad de escritura
• Todas las demás regiones:
• Por tabla: 10 000 unidades de capacidad de escritura
Note
Las cuotas de rendimiento aprovisionadas también se aplican a las tablas de DynamoDB Streams
habilitados DynamoDB Streams. Para obtener más información, consulte Cuotas de rendimiento
predeterminadas (p. 1067).
Nodes
Un clúster de DAX consta exactamente de un nodo principal y entre cero y diez nodos de réplica de
lectura.
Grupos de parámetros
Puede crear hasta 20 grupos de parámetros de DAX por región.
Grupos de subredes
Puede crear hasta 50 grupos de subredes de DAX por región.
La única excepción se admite al crear una tabla con uno o varios índices secundarios. Puede tener
hasta 25 solicitudes de este tipo ejecutándose al mismo tiempo. Sin embargo, si las especificaciones
de la tabla o el índice son complejas, DynamoDB podría reducir temporalmente el número de
operaciones simultáneas.
BatchGetItem
BatchWriteItem
DescribeTableReplicaAutoScaling
DescribeLimits
Solo se debe llamar a DescribeLimits de forma periódica. Es de esperar que se produzcan errores
de limitación controlada si se realiza la llamada más de una vez por minuto.
DescribeContributorInsights/ListContributorInsights/UpdateContributorInsights
Query
Scan
UpdateTableReplicaAutoScaling
Puede cambiar las claves de cifrado para usar unaAWSCMK propiedad de tantas veces como sea preciso,
incluso si se ha agotado la cuota anterior.
Estas son las cuotas a menos que solicite una cantidad mayor. Para solicitar un aumento de la cuota de
servicio, consultehttps://aws.amazon.com/support.
• DynamoDB.
• DynamoDB Streams .
• DynamoDB Accelerator (DAX).
Apéndice DynamoDB
Temas
• Solución de problemas de establecimiento de conexiones SSL/TLS de (p. 1078)
• Ejemplos de tablas y datos (p. 1080)
• Creación de ejemplos de tablas y carga de datos (p. 1089)
• Aplicación de ejemplo de DynamoDB que utiliza elAWS SDK for Python (Boto): Toe Tic-Tac-
Toe (p. 1105)
• Importación y exportación de datos de DynamoDB medianteAWS Data Pipeline (p. 1125)
• Amazon DynamoDB Storage Backend for Titan (p. 1135)
• Palabras reservadas en DynamoDB (p. 1135)
• Parámetros condicionales heredados (p. 1144)
• Versión anterior del API de bajo nivel (2011-12-05) (p. 1161)
Para validar el acceso a los extremos de DynamoDB, deberá desarrollar una prueba que acceda a la API
de DynamoDB o a la API de DynamoDB Streams en la región EU-WEST-3 y validar que el protocolo de
enlace TLS tenga éxito. Los puntos finales específicos a los que deberá acceder en dicha prueba son:
• DynamoDB:https://dynamodb.eu-west-3.amazonaws.com
• DynamoDB Streams:https://streams.dynamodb.eu-west-3.amazonaws.com
Si su aplicación no es compatible con la Autoridad de Certificados de Amazon Trust Services, verá uno de
los siguientes errores:
healthy: dynamodb.eu-west-3.amazonaws.com
• Amazon Root CA 1
• Starfield Services Root Certificate Authority - G2
• Starfield Class 2 Certification Authority
Si los clientes ya confían en CUALQUIER de las tres CA anteriores, estas confiarán en los certificados
utilizados por DynamoDB y no se requiere ninguna acción. Sin embargo, si sus clientes no confían en
ninguna de las CA anteriores, las conexiones HTTPS a las API de Streams de DynamoDB o DynamoDB
fallarán. Para obtener más información, consulte esta publicación del blog:https://aws.amazon.com/blogs/
security/how-to-prepare-for-aws-move-to-its-own-certificate-authority/.
• Chrome:https://support.google.com/chrome/answer/95414?hl=en
• Firefox:https://support.mozilla.org/en-US/kb/update-firefox-latest-version
• Safari:https://support.apple.com/en-us/HT204416
• Internet Explorer:https://support.microsoft.com/en-us/help/17295/windows-internet-explorer-which-
version#ie=other
Los siguientes sistemas operativos y lenguajes de programación admiten certificados de Amazon Trust
Services:
• Versiones de Microsoft Windows que tienen instaladas las actualizaciones de enero de 2005 o
posteriores, Windows Vista, Windows 7, Windows Server 2008 y versiones más recientes.
• macOS X 10.4 con Java para macOS X 10.4 versión 5, macOS X 10.5 y versiones más recientes.
• Red Hat Enterprise Linux 5 (marzo de 2007), Linux 6 y Linux 7 y CentOS 5, CentOS 6 y CentOS 7
• Ubuntu 8.10
• Debian 5.0
• Amazon Linux (todas las versiones)
• Java 1.4.2_12, Java 5 actualización 2 y todas las versiones más recientes, incluyendo Java 6, Java 7 y
Java 8
Si aún no puedes conectarte, consulta la documentación del software, el proveedor del sistema operativo o
ponte en contacto conAWSSoportehttps://aws.amazon.com/supportPara obtener ayuda adicional.
• Id (Número)
• Name (Cadena)
• ForumName (Cadena)
• Subject (Cadena)
• Id (Cadena)
• ReplyDateTime (Cadena)
• PostedBy (Cadena)
• Message (Cadena)
Para obtener más información sobre estas tablas, consulte Caso de uso 1: Catálogo de productos (p. 333)
y Caso de uso 2: Solicitud de foros (p. 334).
En las secciones siguientes se muestran los ejemplos de archivos de datos que se utilizan para cargar las
tablas ProductCatalog, Forum, Thread y Reply.
Cada archivo de datos contiene variosPutRequestCada uno de los cuales contienen un único elemento.
Estos componentes PutRequest se utilizan como datos de entrada de la operación BatchWriteItem,
mediante la AWS Command Line Interface (AWS CLI).
Para obtener más información, consulte Paso 2: Cargar los datos en las tablas (p. 336) en Creación de
tablas y carga de datos para ejemplos de código en DynamoDB (p. 333).
ProductCatalogDatos de ejemplo
{
"ProductCatalog": [
{
"PutRequest": {
"Item": {
"Id": {
"N": "101"
},
"Title": {
"S": "Book 101 Title"
},
"ISBN": {
"S": "111-1111111111"
},
"Authors": {
"L": [
{
"S": "Author1"
}
]
},
"Price": {
"N": "2"
},
"Dimensions": {
"S": "8.5 x 11.0 x 0.5"
},
"PageCount": {
"N": "500"
},
"InPublication": {
"BOOL": true
},
"ProductCategory": {
"S": "Book"
}
}
}
},
{
"PutRequest": {
"Item": {
"Id": {
"N": "102"
},
"Title": {
"S": "Book 102 Title"
},
"ISBN": {
"S": "222-2222222222"
},
"Authors": {
"L": [
{
"S": "Author1"
},
{
"S": "Author2"
}
]
},
"Price": {
"N": "20"
},
"Dimensions": {
"S": "8.5 x 11.0 x 0.8"
},
"PageCount": {
"N": "600"
},
"InPublication": {
"BOOL": true
},
"ProductCategory": {
"S": "Book"
}
}
}
},
{
"PutRequest": {
"Item": {
"Id": {
"N": "103"
},
"Title": {
"S": "Book 103 Title"
},
"ISBN": {
"S": "333-3333333333"
},
"Authors": {
"L": [
{
"S": "Author1"
},
{
"S": "Author2"
}
]
},
"Price": {
"N": "2000"
},
"Dimensions": {
"S": "8.5 x 11.0 x 1.5"
},
"PageCount": {
"N": "600"
},
"InPublication": {
"BOOL": false
},
"ProductCategory": {
"S": "Book"
}
}
}
},
{
"PutRequest": {
"Item": {
"Id": {
"N": "201"
},
"Title": {
"S": "18-Bike-201"
},
"Description": {
"S": "201 Description"
},
"BicycleType": {
"S": "Road"
},
"Brand": {
"S": "Mountain A"
},
"Price": {
"N": "100"
},
"Color": {
"L": [
{
"S": "Red"
},
{
"S": "Black"
}
]
},
"ProductCategory": {
"S": "Bicycle"
}
}
}
},
{
"PutRequest": {
"Item": {
"Id": {
"N": "202"
},
"Title": {
"S": "21-Bike-202"
},
"Description": {
"S": "202 Description"
},
"BicycleType": {
"S": "Road"
},
"Brand": {
"S": "Brand-Company A"
},
"Price": {
"N": "200"
},
"Color": {
"L": [
{
"S": "Green"
},
{
"S": "Black"
}
]
},
"ProductCategory": {
"S": "Bicycle"
}
}
}
},
{
"PutRequest": {
"Item": {
"Id": {
"N": "203"
},
"Title": {
"S": "19-Bike-203"
},
"Description": {
"S": "203 Description"
},
"BicycleType": {
"S": "Road"
},
"Brand": {
"S": "Brand-Company B"
},
"Price": {
"N": "300"
},
"Color": {
"L": [
{
"S": "Red"
},
{
"S": "Green"
},
{
"S": "Black"
}
]
},
"ProductCategory": {
"S": "Bicycle"
}
}
}
},
{
"PutRequest": {
"Item": {
"Id": {
"N": "204"
},
"Title": {
"S": "18-Bike-204"
},
"Description": {
"S": "204 Description"
},
"BicycleType": {
"S": "Mountain"
},
"Brand": {
"S": "Brand-Company B"
},
"Price": {
"N": "400"
},
"Color": {
"L": [
{
"S": "Red"
}
]
},
"ProductCategory": {
"S": "Bicycle"
}
}
}
},
{
"PutRequest": {
"Item": {
"Id": {
"N": "205"
},
"Title": {
"S": "18-Bike-204"
},
"Description": {
"S": "205 Description"
},
"BicycleType": {
"S": "Hybrid"
},
"Brand": {
"S": "Brand-Company C"
},
"Price": {
"N": "500"
},
"Color": {
"L": [
{
"S": "Red"
},
{
"S": "Black"
}
]
},
"ProductCategory": {
"S": "Bicycle"
}
}
}
}
]
}
ForumDatos de ejemplo
{
"Forum": [
{
"PutRequest": {
"Item": {
"Name": {"S":"Amazon DynamoDB"},
"Category": {"S":"Amazon Web Services"},
"Threads": {"N":"2"},
"Messages": {"N":"4"},
"Views": {"N":"1000"}
}
}
},
{
"PutRequest": {
"Item": {
"Name": {"S":"Amazon S3"},
"Category": {"S":"Amazon Web Services"}
}
}
}
]
}
ThreadDatos de ejemplo
{
"Thread": [
{
"PutRequest": {
"Item": {
"ForumName": {
"S": "Amazon DynamoDB"
},
"Subject": {
"S": "DynamoDB Thread 1"
},
"Message": {
"S": "DynamoDB thread 1 message"
},
"LastPostedBy": {
"S": "User A"
},
"LastPostedDateTime": {
"S": "2015-09-22T19:58:22.514Z"
},
"Views": {
"N": "0"
},
"Replies": {
"N": "0"
},
"Answered": {
"N": "0"
},
"Tags": {
"L": [
{
"S": "index"
},
{
"S": "primarykey"
},
{
"S": "table"
}
]
}
}
}
},
{
"PutRequest": {
"Item": {
"ForumName": {
"S": "Amazon DynamoDB"
},
"Subject": {
"S": "DynamoDB Thread 2"
},
"Message": {
"S": "DynamoDB thread 2 message"
},
"LastPostedBy": {
"S": "User A"
},
"LastPostedDateTime": {
"S": "2015-09-15T19:58:22.514Z"
},
"Views": {
"N": "3"
},
"Replies": {
"N": "0"
},
"Answered": {
"N": "0"
},
"Tags": {
"L": [
{
"S": "items"
},
{
"S": "attributes"
},
{
"S": "throughput"
}
]
}
}
}
},
{
"PutRequest": {
"Item": {
"ForumName": {
"S": "Amazon S3"
},
"Subject": {
"S": "S3 Thread 1"
},
"Message": {
"S": "S3 thread 1 message"
},
"LastPostedBy": {
"S": "User A"
},
"LastPostedDateTime": {
"S": "2015-09-29T19:58:22.514Z"
},
"Views": {
"N": "0"
},
"Replies": {
"N": "0"
},
"Answered": {
"N": "0"
},
"Tags": {
"L": [
{
"S": "largeobjects"
},
{
"S": "multipart upload"
}
]
}
}
}
}
]
}
ReplyDatos de ejemplo
{
"Reply": [
{
"PutRequest": {
"Item": {
"Id": {
"S": "Amazon DynamoDB#DynamoDB Thread 1"
},
"ReplyDateTime": {
"S": "2015-09-15T19:58:22.947Z"
},
"Message": {
"S": "DynamoDB Thread 1 Reply 1 text"
},
"PostedBy": {
"S": "User A"
}
}
}
},
{
"PutRequest": {
"Item": {
"Id": {
"S": "Amazon DynamoDB#DynamoDB Thread 1"
},
"ReplyDateTime": {
"S": "2015-09-22T19:58:22.947Z"
},
"Message": {
"S": "DynamoDB Thread 1 Reply 2 text"
},
"PostedBy": {
"S": "User B"
}
}
}
},
{
"PutRequest": {
"Item": {
"Id": {
"S": "Amazon DynamoDB#DynamoDB Thread 2"
},
"ReplyDateTime": {
"S": "2015-09-29T19:58:22.947Z"
},
"Message": {
"S": "DynamoDB Thread 2 Reply 1 text"
},
"PostedBy": {
"S": "User A"
}
}
}
},
{
"PutRequest": {
"Item": {
"Id": {
"S": "Amazon DynamoDB#DynamoDB Thread 2"
},
"ReplyDateTime": {
"S": "2015-10-05T19:58:22.947Z"
},
"Message": {
"S": "DynamoDB Thread 2 Reply 2 text"
},
"PostedBy": {
"S": "User A"
}
}
}
}
]
}
EnCreación de tablas y carga de datos para ejemplos de código en DynamoDB (p. 333)En, primero se
crean las tablas en la consola de DynamoDB y, a continuación, se utiliza laAWS CLIpara agregar datos
a las tablas. En este apéndice se proporciona código para crear las tablas y agregarles datos mediante
programación.
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package com.amazonaws.codesamples;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashSet;
import java.util.TimeZone;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.CreateTableRequest;
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.LocalSecondaryIndex;
import com.amazonaws.services.dynamodbv2.model.Projection;
import com.amazonaws.services.dynamodbv2.model.ProjectionType;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
try {
deleteTable(productCatalogTableName);
deleteTable(forumTableName);
deleteTable(threadTableName);
deleteTable(replyTableName);
loadSampleProducts(productCatalogTableName);
loadSampleForums(forumTableName);
loadSampleThreads(threadTableName);
loadSampleReplies(replyTableName);
}
catch (Exception e) {
System.err.println("Program failed:");
System.err.println(e.getMessage());
}
System.out.println("Success.");
}
}
catch (Exception e) {
System.err.println("DeleteTable request failed for " + tableName);
System.err.println(e.getMessage());
}
}
try {
keySchema.add(new
KeySchemaElement().withAttributeName(partitionKeyName).withKeyType(KeyType.HASH)); //
Partition
// key
if (sortKeyName != null) {
keySchema.add(new
KeySchemaElement().withAttributeName(sortKeyName).withKeyType(KeyType.RANGE)); // Sort
// key
attributeDefinitions
.add(new
AttributeDefinition().withAttributeName(sortKeyName).withAttributeType(sortKeyType));
}
attributeDefinitions
.add(new
AttributeDefinition().withAttributeName("PostedBy").withAttributeType("S"));
// key
new
KeySchemaElement().withAttributeName("PostedBy").withKeyType(KeyType.RANGE)) // Sort
// key
.withProjection(new
Projection().withProjectionType(ProjectionType.KEYS_ONLY)));
request.setLocalSecondaryIndexes(localSecondaryIndexes);
}
request.setAttributeDefinitions(attributeDefinitions);
}
catch (Exception e) {
System.err.println("CreateTable request failed for " + tableName);
System.err.println(e.getMessage());
}
}
try {
// Add bikes.
}
catch (Exception e) {
System.err.println("Failed to create item in " + tableName);
System.err.println(e.getMessage());
}
try {
}
catch (Exception e) {
System.err.println("Failed to create item in " + tableName);
System.err.println(e.getMessage());
}
}
dateFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));
}
catch (Exception e) {
System.err.println("Failed to create item in " + tableName);
System.err.println(e.getMessage());
}
dateFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));
// Add threads.
}
catch (Exception e) {
System.err.println("Failed to create item in " + tableName);
System.err.println(e.getMessage());
}
}
/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* This file is licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License. A copy of
* the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
using System;
using System.Collections.Generic;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DocumentModel;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;
using Amazon.SecurityToken;
namespace com.amazonaws.codesamples
{
class CreateTablesLoadData
{
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Create tables (using the AWS SDK for .NET low-level API).
CreateTableProductCatalog();
CreateTableForum();
CreateTableThread(); // ForumTitle, Subject */
CreateTableReply();
},
KeySchema = new List<KeySchemaElement>()
{
new KeySchemaElement
{
AttributeName = "Name", // forum Title
KeyType = "HASH"
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 10,
WriteCapacityUnits = 5
}
});
{
TableName = tableName,
AttributeDefinitions = new List<AttributeDefinition>()
{
new AttributeDefinition
{
AttributeName = "Id",
AttributeType = "S"
},
new AttributeDefinition
{
AttributeName = "ReplyDateTime",
AttributeType = "S"
},
new AttributeDefinition
{
AttributeName = "PostedBy",
AttributeType = "S"
}
},
KeySchema = new List<KeySchemaElement>()
{
new KeySchemaElement()
{
AttributeName = "Id",
KeyType = "HASH"
},
new KeySchemaElement()
{
AttributeName = "ReplyDateTime",
KeyType = "RANGE"
}
},
LocalSecondaryIndexes = new List<LocalSecondaryIndex>()
{
new LocalSecondaryIndex()
{
IndexName = "PostedBy_index",
{
var tableDescription = response.TableDescription;
book1["ISBN"] = "111-1111111111";
book1["Authors"] = new List<string> { "Author 1" };
book1["Price"] = -2; // *** Intentional value. Later used to illustrate scan.
book1["Dimensions"] = "8.5 x 11.0 x 0.5";
book1["PageCount"] = 500;
book1["InPublication"] = true;
book1["ProductCategory"] = "Book";
productCatalogTable.PutItem(book1);
book2["Id"] = 102;
book2["Title"] = "Book 102 Title";
book2["ISBN"] = "222-2222222222";
book2["Authors"] = new List<string> { "Author 1", "Author 2" }; ;
book2["Price"] = 20;
book2["Dimensions"] = "8.5 x 11.0 x 0.8";
book2["PageCount"] = 600;
book2["InPublication"] = true;
book2["ProductCategory"] = "Book";
productCatalogTable.PutItem(book2);
productCatalogTable.PutItem(bicycle3);
forumTable.PutItem(forum1);
forumTable.PutItem(forum2);
}
// Thread 1.
var thread1 = new Document();
thread1["ForumName"] = "Amazon DynamoDB"; // Hash attribute.
thread1["Subject"] = "DynamoDB Thread 1"; // Range attribute.
thread1["Message"] = "DynamoDB thread 1 message text";
thread1["LastPostedBy"] = "User A";
thread1["LastPostedDateTime"] = DateTime.UtcNow.Subtract(new TimeSpan(14, 0, 0,
0));
thread1["Views"] = 0;
thread1["Replies"] = 0;
thread1["Answered"] = false;
thread1["Tags"] = new List<string> { "index", "primarykey", "table" };
threadTable.PutItem(thread1);
// Thread 2.
threadTable.PutItem(thread2);
// Thread 3.
var thread3 = new Document();
thread3["ForumName"] = "Amazon S3"; // Hash attribute.
thread3["Subject"] = "S3 Thread 1"; // Range attribute.
thread3["Message"] = "S3 thread 3 message text";
thread3["LastPostedBy"] = "User A";
thread3["LastPostedDateTime"] = DateTime.UtcNow.Subtract(new TimeSpan(7, 0, 0,
0));
thread3["Views"] = 0;
thread3["Replies"] = 0;
thread3["Answered"] = false;
thread3["Tags"] = new List<string> { "largeobjects", "multipart upload" };
threadTable.PutItem(thread3);
}
// Reply 1 - thread 1.
var thread1Reply1 = new Document();
thread1Reply1["Id"] = "Amazon DynamoDB#DynamoDB Thread 1"; // Hash attribute.
thread1Reply1["ReplyDateTime"] = DateTime.UtcNow.Subtract(new TimeSpan(21, 0,
0, 0)); // Range attribute.
thread1Reply1["Message"] = "DynamoDB Thread 1 Reply 1 text";
thread1Reply1["PostedBy"] = "User A";
replyTable.PutItem(thread1Reply1);
// Reply 2 - thread 1.
var thread1reply2 = new Document();
thread1reply2["Id"] = "Amazon DynamoDB#DynamoDB Thread 1"; // Hash attribute.
thread1reply2["ReplyDateTime"] = DateTime.UtcNow.Subtract(new TimeSpan(14, 0,
0, 0)); // Range attribute.
thread1reply2["Message"] = "DynamoDB Thread 1 Reply 2 text";
thread1reply2["PostedBy"] = "User B";
replyTable.PutItem(thread1reply2);
// Reply 3 - thread 1.
var thread1Reply3 = new Document();
thread1Reply3["Id"] = "Amazon DynamoDB#DynamoDB Thread 1"; // Hash attribute.
thread1Reply3["ReplyDateTime"] = DateTime.UtcNow.Subtract(new TimeSpan(7, 0, 0,
0)); // Range attribute.
thread1Reply3["Message"] = "DynamoDB Thread 1 Reply 3 text";
thread1Reply3["PostedBy"] = "User B";
replyTable.PutItem(thread1Reply3);
// Reply 1 - thread 2.
var thread2Reply1 = new Document();
thread2Reply1["Id"] = "Amazon DynamoDB#DynamoDB Thread 2"; // Hash attribute.
replyTable.PutItem(thread2Reply1);
// Reply 2 - thread 2.
var thread2Reply2 = new Document();
thread2Reply2["Id"] = "Amazon DynamoDB#DynamoDB Thread 2"; // Hash attribute.
thread2Reply2["ReplyDateTime"] = DateTime.UtcNow.Subtract(new TimeSpan(1, 0, 0,
0)); // Range attribute.
thread2Reply2["Message"] = "DynamoDB Thread 2 Reply 2 text";
thread2Reply2["PostedBy"] = "User A";
replyTable.PutItem(thread2Reply2);
}
}
}
El juego de tres en raya es un ejemplo de aplicación web creada en Amazon DynamoDB. La aplicación de
utiliza la herramientaAWS SDK for Python (Boto)para llevar a cabo las llamadas a DynamoDB necesarias
para almacenar los datos de las partidas en una tabla de DynamoDB, y el marco web de Python, Flask,
para ilustrar el desarrollo íntegro de la aplicación en DynamoDB, lo que incluye cómo se modelan los
datos. Además, en el ejemplo se muestran las prácticas recomendadas en lo que respecta al modelado
de datos en DynamoDB, lo que incluye la tabla que se crea para la aplicación del juego, la clave principal
que se define, los índices adicionales que se necesitan según los requisitos de las consultas y el uso de
atributos de valores concatenados.
Hasta que otro usuario acepta la invitación, el estado de la partida es PENDING. Una vez que un
contrincante ha aceptado la invitación, el estado de la partida cambia a IN_PROGRESS.
3. La partida comienza una vez que su contrincante ha iniciado sesión y aceptado la invitación.
4. La aplicación almacena todas las jugadas de las partidas y la información de estado en una tabla de
DynamoDB.
5. La partida termina cuando un jugador gana o si se produce un empate, en cuyo caso se establece el
estado de la partida en FINISHED.
• Paso 1: Implementación y pruebas localmente (p. 1106): en esta sección, se descarga, implementa
y prueba la aplicación en el equipo local. Las tablas requeridas se crean en la versión descargable de
DynamoDB.
• Paso 2: Examinar el modelo de datos y los detalles de implementación (p. 1110): en esta sección se
describe primero con detalle el modelo de datos, incluidos los índices y el uso del atributo de valores
concatenados. A continuación, se explica el funcionamiento de la aplicación.
• Paso 3: Implementar en producción mediante el servicio de DynamoDB (p. 1117): esta sección se
centra en las consideraciones de implementación en un entorno de producción. En este paso, se crea
una tabla mediante el servicio de Amazon DynamoDB e implementa la aplicación conAWS Elastic
Beanstalk. Cuando la aplicación se encuentra en producción, se conceden además los permisos
adecuados para que la aplicación pueda obtener acceso a la tabla de DynamoDB. Las instrucciones de
esta sección le guiarán a lo largo de todo el proceso de implementación en producción.
• Paso 4: Eliminación de los recursos (p. 1124): en esta sección se resaltan las áreas que no se abordan
en este ejemplo. En la sección también se proporcionan los pasos necesarios para eliminar elAWSLos
recursos que ha creado en los pasos anteriores para evitar que se le cobre ningún importe.
En este paso se descarga, implementa y prueba la aplicación del juego de tres en raya en el equipo local.
En lugar de utilizar el servicio web de Amazon DynamoDB, descargue DynamoDB en su equipo y cree en
él la tabla requerida.
• Python
• Flask (un micromarco de trabajo para Python)
• AWS SDK for Python (Boto)
• DynamoDB en ejecución en su equipo
• Git
1. Instalación de Python. Para ver instrucciones paso a paso, consulte Download Python.
Para ver instrucciones, consulte Install PIP. En la página de instalación, seleccione el enlace
get-pip.py y, a continuación, guarde el archivo. Después abra un terminal de comandos como
administrador y escriba lo siguiente en el símbolo del sistema.
python.exe get-pip.py
• Utilice PIP para instalar los paquetes Flask y Boto mediante el siguiente código.
3. Descargue DynamoDB en su equipo. Para obtener instrucciones sobre cómo ejecutarlo, consulte
Configuración de DynamoDB Local (versión descargable) (p. 50).
4. Descargue la aplicación Tic-Tac-Toe:
a. Instale Git. Para ver instrucciones, consulte git Downloads.
b. Ejecute el siguiente código para descargar la aplicación.
1. Inicie DynamoDB.
2. Inicie el servidor web de la aplicación Tic-Tac-Toe.
Para ello, abra un terminal de comandos, diríjase a la carpeta en la que ha descargado la aplicación
Tic-Tac-Toe (Tres en raya) y ejecute la aplicación localmente con el código siguiente.
http://localhost:5000/
4. Escriba user1 en el cuadro Log in (Iniciar sesión) para iniciar sesión como user1.
Note
sesión con el mismo alias, la aplicación funciona como si estuviesen jugando en dos
navegadores distintos.
5. Si es la primera vez que inicia el juego, aparece una página que le pide que cree la tabla requerida
(Games) en DynamoDB. Seleccione CREATE TABLE (CREAR TABLA).
http://localhost:5000/
El navegador transmite información a través de las cookies, por lo que ha de utilizar el modo de
incógnito o la navegación privada para que las cookies no se conserven.
9. Inicie sesión como user2.
Aparecerá la página de la partida con una cuadrícula de tres en raya vacía. En la página se muestra
también información pertinente sobre la partida, como el Id. de la partida, a quién le toca jugar y el
estado de la partida.
11. Juegue la partida.
Cada vez que un usuario mueve ficha, el servicio web envía una solicitud a DynamoDB para actualizar
de forma condicional el elemento de la partida en elGamesTabla INTO. Por ejemplo, las condiciones
garantizan que el movimiento haya sido válido, que la casilla elegida por el usuario esté disponible o que le
tocaba jugar al usuario que movió la ficha. Para cada jugada válida, la operación de actualización agrega
un nuevo atributo correspondiente a la casilla seleccionada en el tablero. La operación de actualización
también establece el valor del atributo existente en el usuario que puede llevar a cabo la siguiente jugada.
En la página de la partida, la aplicación realiza llamadas asíncronas a JavaScript cada segundo durante
un máximo de 5 minutos, para comprobar si el estado de la partida en DynamoDB ha cambiado. En caso
afirmativo, la aplicación actualiza la página con la nueva información. Después de 5 minutos, la aplicación
deja de realizar las solicitudes y tendrá que actualizar la página si desea obtener información actualizada.
• TablaTabla: en DynamoDB, una tabla es una colección de elementos (es decir, de registros) y cada
elemento es una colección de pares de nombre-valor denominados atributos.
En este ejemplo del juego de tres en raya, la aplicación almacena todos los datos de las partidas en
una tabla, Games. La aplicación crea un elemento en la tabla por cada partida y almacena todos los
datos de las partidas como atributos. Una partida de tres en raya puede incluir hasta nueve jugadas
o movimientos. Dado que las tablas de DynamoDB no tienen un esquema cuando el único atributo
obligatorio es la clave principal, la aplicación puede almacenar un número variable de atributos por cada
elemento de partida.
La tabla Games cuenta con una clave principal sencilla que consta de un solo atributo, GameId, de tipo
String. La aplicación asigna identificador exclusivo a cada partida. Para obtener más información acerca
de claves principales de DynamoDB, consulte.Clave principal (p. 6).
Cuando un usuario inicia una partida de tres en raya invitando a otro usuario a jugar, la aplicación crea
un nuevo elemento en la tabla Games con atributos que almacenan los metadatos de la partida, tales
como los siguientes:
• HostId, usuario que inició la partida.
• Opponent, usuario al que se invitó a jugar.
• Usuario al que le toca jugar. El usuario que inicia la partida juega primero.
• El usuario que utiliza el símbolo O en el tablero. El usuario que inicia las partidas utiliza el símbolo O.
Además, la aplicación crea un atributo StatusDate concatenado que marca el estado inicial de la
partida como PENDING. En la siguiente captura de pantalla se muestra un ejemplo de elemento tal y
como aparece en la consola de DynamoDB:
A medida que la partida avanza, la aplicación agrega un atributo a la tabla por cada jugada. El nombre
del atributo es la posición en el tablero; por ejemplo, TopLeft o BottomRight. Por ejemplo, una
jugada puede tener el atributo TopLeft con el valor O, un atributo TopRight con el valor O y un atributo
BottomRight con el valor X. El valor del atributo puede ser O o X, según cuál sea el usuario que ha
realizado la jugada. Por ejemplo, fíjese en el tablero siguiente.
• HostId-StatusDate-index. Este índice tiene HostId como clave de partición y StatusDate como
clave de ordenación. Puede utilizar este índice para realizar una consulta sobre HostId, por ejemplo,
para encontrar las partidas organizadas por un usuario concreto.
Estos índices se denominan índices secundarios globales porque su clave de partición no es la misma
(GameId) que se usó en la clave principal de la tabla.
Tenga en cuenta que en los dos índices se especifica StatusDate como clave de ordenación. Al
hacerlo, se habilita lo siguiente:
• Puede realizar consultas utilizando el operador de comparación BEGINS_WITH. Por ejemplo, puede
buscar todas las partidas que tienen el atributo IN_PROGRESS y que ha organizado un usuario
determinado. En este caso, el operador BEGINS_WITH comprueba los valores de StatusDate que
comienzan por IN_PROGRESS.
• DynamoDB almacena los elementos en el índice de forma secuente, según el valor de la clave de
ordenación. Así pues, si todos los prefijos de estado son iguales (por ejemplo, IN_PROGRESS), el
formato ISO utilizado para la parte de la fecha hará que los elementos se ordenen por orden de
antigüedad descendente. Este enfoque permite realizar con eficacia algunas consultas, tales como las
siguientes:
• Recuperar como máximo las diez partidas IN_PROGRESS más recientes organizadas por el usuario
que ha iniciado sesión. Para esta consulta, se especifica el índice HostId-StatusDate-index.
• Recuperar como máximo las diez partidas IN_PROGRESS más recientes en las que el usuario que
ha iniciado sesión sea el contrincante. Para esta consulta, se especifica el índice OpponentId-
StatusDate-index.
Para obtener más información acerca de los índices secundarios, consulte Uso de índices secundarios
para mejorar el acceso a los datos (p. 567).
• Página de inicio: en esta página se proporciona al usuario un inicio de sesión sencillo, un botón CREATE
para crear una nueva partida de tres en raya, una lista de partidas en curso, el historial de partidas y
todas las invitaciones pendientes para jugar.
Página de inicio
Cuando el usuario inicia sesión, la aplicación muestra las tres listas de información siguientes.
• invitations: esta lista muestra como máximo las diez invitaciones más recientes de otros usuarios que
el usuario que ha iniciado sesión todavía no ha aceptado. En la captura de pantalla anterior, el usuario
user1 tiene invitaciones pendientes de los usuarios user2 y user5.
• Juegos en curso: esta lista muestra como máximo las diez partidas más recientes que están en curso.
Se trata de partidas en las que el usuario está jugando activamente y cuyo estado es IN_PROGRESS. En
la captura de pantalla, el usuario user1 está jugando activamente una partida de tres en raya contra los
usuarios user3 y user4.
• Historia reciente— Esta lista muestra como máximo las diez partidas más recientes que el usuario ha
terminado, cuyo estado esFINISHED. En el juego que aparece en la captura de pantalla, el usuario
user1 ha jugado anteriormente contra el usuario user2. En la lista se muestra el resultado de cada
partida completada.
En el código, la función index (en application.py) realiza las tres llamadas siguientes para recuperar
la información de estado de las partidas:
inviteGames = controller.getGameInvites(session["username"])
inProgressGames = controller.getGamesWithStatus(session["username"], "IN_PROGRESS")
finishedGames = controller.getGamesWithStatus(session["username"], "FINISHED")
Cada una de estas llamadas devuelve una lista de elementos de DynamoDB que están integrados en la
propiedadGameObjetos de Resulta fácil extraer datos de estos objetos en la vista. La función de índice
transmite estas listas de objetos a la vista para representar el código HTML.
return render_template("index.html",
user=session["username"],
invites=inviteGames,
inprogress=inProgressGames,
finished=finishedGames)
La aplicación Tic-Tac-Toe define laGameprincipalmente para almacenar los datos de las partidas
recuperados de DynamoDB. Estas funciones devuelven listas deGameObjetos que permiten aislar el resto
de la aplicación del código relacionado con los elementos de Amazon DynamoDB. Por lo tanto, estas
funciones le ayudan a desacoplar el código de aplicación de los detalles de la capa de almacenamiento de
datos.
El patrón de arquitectura descrito aquí también se denomina patrón de interfaz de usuario (IU) de
tipo modelo-vista-controlador (MVC). En este caso, las instancias de objetos Game (que representan
datos) son el modelo y la página HTML es la vista. El controlador se divide en dos archivos. El archivo
application.py contiene la lógica del controlador correspondiente al marco de trabajo Flask,
mientras que la lógica empresarial se aísla en el archivo gameController.py. Es decir, la aplicación
almacena todo lo que se refiere al SDK de DynamoDB en su propio archivo independiente dentro
deldynamodbfolder.
Vamos a revisar las tres funciones para entender cómo consultan la tabla Games y utilizan índices
secundarios globales para recuperar los datos pertinentes.
La función getGameInvites recupera la lista de las diez invitaciones pendientes más recientes. Hay
usuarios que han creado estas partidas, pero los contrincantes no han aceptado las invitaciones para
jugar. En estas partidas, el estado sigue siendo PENDING hasta que el contrincante acepta la invitación. Si
el contrincante rechaza la invitación, la aplicación eliminará el elemento correspondiente de la tabla.
• Especifica el índice OpponentId-StatusDate-index que se debe usar con los siguientes valores de
clave de índice y operadores de comparación:
• La clave de partición es OpponentId y acepta la clave de índice user ID.
• La clave de ordenación es StatusDate y acepta el operador de comparación y el valor de clave de
índice beginswith="PENDING_".
gameInvitesIndex = self.cm.getGamesTable().query(
Opponent__eq=user,
StatusDate__beginswith="PENDING_",
index="OpponentId-StatusDate-index",
limit=10)
En el índice, para cadaOpponentId(la clave de partición) DynamoDB mantiene los elementos ordenados
porStatusDate(la clave de clasificación). Por lo tanto, las partidas que devuelve la consulta son las diez
más recientes.
Una vez que un contrincante ha aceptado una invitación a jugar, el estado de la partida cambia a
IN_PROGRESS. Cuando la partida finaliza, el estado cambia a FINISHED.
Las consultas para buscar las partidas que se encuentran en curso o que ya han finalizado son
iguales salvo por el valor de estado, que varía. Por consiguiente, la aplicación define la función
getGamesWithStatus, que acepta el valor de estado como parámetro.
En la sección siguiente se explican las partidas en curso, pero la misma descripción es aplicable también a
las partidas finalizadas.
Una lista de partidas en curso de un usuario determinado incluye los dos tipos siguientes:
La función getGamesWithStatus ejecuta las dos consultas siguientes, utilizando en cada caso el índice
secundario apropiado.
oppGamesInProgress = self.cm.getGamesTable().query(Opponent__eq=user,
StatusDate__beginswith=status,
index="OpponentId-StatusDate-index",
limit=10)
• A continuación, la función combina ambas listas, las ordena, crea una lista de entre 0 y 10 elementos
que contiene los primeros objetos Game y se la devuelve a la función de llamada (es decir, al índice).
games = self.mergeQueries(hostGamesInProgress,
oppGamesInProgress)
return games
Página de la partida
La página de la partida es donde el usuario juega las partidas de tres en raya. Muestra la cuadrícula del
juego, además de la información pertinente sobre el juego. En la siguiente captura de pantalla se muestra
un ejemplo de partida en curso:
En este caso, la página muestra al usuario como anfitrión y el estado de la partida PENDING, mientras
espera a que el contrincante acepte.
• Cuando el usuario ha aceptado una de las invitaciones pendientes de la página de inicio.
En este caso, la página muestra al usuario como contrincante y el estado de la partida IN_PROGRESS.
Cuando el usuario selecciona una opción en el tablero, se genera una solicitud POST de formulario
a la aplicación. Es decir, Flask llama a la función selectSquare (en application.py) con los
datos del formulario HTML. Esta función, a su vez, llama a la función updateBoardAndTurn (en
gameController.py) para actualizar el elemento de partida como se indica a continuación:
La función devuelve true si el elemento se actualizó correctamente; en caso contrario, devuelve false.
Tenga en cuenta lo siguiente en relación con la función updateBoardAndTurn:
• La función llama a laupdate_itemFunción del SDK para Python con el fin de realizar un conjunto de
actualizaciones finitas en un elemento existente. La función se mapea alUpdateItemen DynamoDB.
Para obtener más información, consulte UpdateItem.
Note
La diferencia entre las operaciones UpdateItem y PutItem es que PutItem sustituye al
elemento completo. Para obtener más información, consulte PutItem.
• Nuevo atributo que se va a agregar, específico de la jugada del usuario actual, y su valor (por ejemplo,
TopLeft="X").
attributeUpdates = {
position : {
"Action" : "PUT",
"Value" : { "S" : representation }
}
}
self.cm.db.update_item("Games", key=key,
attribute_updates=attributeUpdates,
expected=expectations)
Una vez que la función devuelva el resultado, la función selectSquare llama a "redirect", tal y como se
indica en el ejemplo siguiente.
redirect("/game="+gameId)
Esta llamada hace que el navegador se actualice. Durante esta actualización, la aplicación comprueba si la
partida ha terminado con un ganador o en empate. En caso afirmativo, la aplicación actualiza el elemento
de partida en consecuencia.
• Implemente la aplicación con AWS Elastic Beanstalk, un servicio fácil de utilizar para implementar y
ampliar servicios y aplicaciones web. Para obtener más información, consulteImplementación de una
aplicación de Flask enAWS Elastic Beanstalk.
Elastic Beanstalk lanza una o varias instancias Amazon Elastic Compute Cloud (Amazon EC2), que se
configuran a través de Elastic Beanstalk, en las que se ejecutará la aplicación Tic-Tac-Toe.
• Mediante el servicio Amazon DynamoDB, cree unGamestabla que existe enAWSen lugar de localmente
en el equipo.
Además, tendrá que configurar los permisos. CualquieraAWSque cree, como los recursosGamesen
DynamoDB, son privadas de forma predeterminada. Solo el propietario del recurso, es decir, la cuenta de
AWS que ha creado la tabla Games, puede obtener acceso a esta tabla. Por lo tanto, la aplicación Tic-Tac-
Toe (Tres en raya) no puede actualizar la tabla Games de forma predeterminada.
Para conceder los permisos necesarios, cree unAWS Identity and Access Management(IAM) y concédale
permisos para obtener acceso a la funciónGamesTabla INTO. Primero, la instancia de Amazon EC2 asume
esta función. En respuesta,AWSdevuelve las credenciales de seguridad temporales que la instancia de
Amazon EC2 puede utilizar para actualizar elGamesEn nombre de la aplicación Tic-Tac-Toe. Al configurar
la aplicación de Elastic Beanstalk, debe especificar el rol de IAM que la instancia o instancias de Amazon
EC2 pueden asumir. Para obtener más información sobre los roles de IAM, consulteIAM Roles for Amazon
EC2en laGuía del usuario de Amazon EC2 para instancias de Linux.
Note
Antes de crear instancias de Amazon EC2 para la aplicación Tic-Tac-Toe, primero debe
decidirAWSRegión en la que desea que Elastic Beanstalk las cree. Después de crear la aplicación
de Elastic Beanstalk, se proporciona los mismos nombre de región y punto de enlace en un
archivo de configuración. La aplicación Tic-Tac-Toe utiliza la información de este archivo para
crear elGamesy enviar solicitudes subsiguientes en unAWSRegión . Tanto el DynamoDB como
elGamesy las instancias de Amazon EC2 que Elastic Beanstalk lanza deben estar en la misma
región. Para obtener una lista de las regiones disponibles, consulteAmazon DynamoDBen
laReferencia general de Amazon Web Services.
1. Cree un rol de IAM mediante el servicio de IAM. Debe asociar una política a este rol que conceda
permisos para realizar las acciones de DynamoDB que se requieren para obtener accesoGamesTabla
INTO.
2. Empaquete el código de la aplicación Tic-Tac-Toe y un archivo de configuración y cree un archivo
.zip. Utiliza esto.zipPara proporcionar el código de la aplicación Tic-Tac-Toe a Elastic Beanstalk
y ponerlo en sus servidores. Para obtener más información acerca de la creación de un paquete,
consulte.Creación de un paquete de código fuente de una aplicaciónen laAWS Elastic BeanstalkGuía
para desarrolladores.
4. Cree la tabla DynamoDB. Mediante el servicio Amazon DynamoDB, puede crear elGamesTabla deAWS,
en lugar de localmente en su equipo. Recuerde que esta tabla posee una clave principal simple que
consta de la clave de partición GameId, de tipo String.
5. Pruebe el juego en el entorno de producción.
{
"Version":"2012-10-17",
"Statement":[
{
"Action":[
"dynamodb:ListTables"
],
"Effect":"Allow",
"Resource":"*"
},
{
"Action":[
"dynamodb:*"
],
"Effect":"Allow",
"Resource":[
"arn:aws:dynamodb:us-west-2:922852403271:table/Games",
"arn:aws:dynamodb:us-west-2:922852403271:table/Games/index/*"
]
}
]
}
Para obtener más instrucciones, consulteCreación de un rol para unAWSServicio de (AWS Management
Console)en laGuía del usuario de IAM.
Después de extraer todos los archivos, observe que se ha creado la carpeta code. Para proporcionar esta
carpeta a Elastic Beanstalk, debe empaquetar el contenido de esta carpeta como un.zipfile. En primer
lugar, debe agregar un archivo de configuración a dicha carpeta. La aplicación utiliza la información sobre
la región y el punto de enlace para crear una tabla de DynamoDB en la región especificada y para realizar
las solicitudes de operaciones subsiguientes a la tabla utilizando el punto de enlace indicado.
[dynamodb]
region=<AWS region>
endpoint=<DynamoDB endpoint>
[dynamodb]
region=us-west-2
endpoint=dynamodb.us-west-2.amazonaws.com
Para obtener una lista de regiones disponibles, consulte Amazon DynamoDB en la Referencia general
de Amazon Web Services.
Important
Al crear la aplicación de Elastic Beanstalk, solicita que se lance un entorno cuyo tipo sea
posible elegir. Para probar la aplicación Tic-Tac-Toe del ejemplo, puede elegir el tipo de
entorno Single Instance (Instancia individual), omitir el resto e ir al paso siguiente.
No obstante, tenga en cuenta que el tipo de entorno Load balancing, autoscaling (Auto
Scaling con balanceo de carga) proporciona un entorno altamente disponible y escalable,
algo que debe tener en cuenta al crear e implementar otras aplicaciones. Si elige este tipo de
entorno, también debe generar un UUID y agregárselo al archivo de configuración, tal y como
se muestra a continuación.
[dynamodb]
region=us-west-2
endpoint=dynamodb.us-west-2.amazonaws.com
[flask]
secret_key= 284e784d-1a25-4a19-92bf-8eeb7a9example
Para obtener instrucciones acerca de cómo cargar en un bucket de Amazon S3, consulte.Crear un
bucketyAñadir un objeto a un bucketen laGuía de inicio de Amazon Simple Storage Service.
1. Escriba la siguiente URL personalizada con el fin de configurar una consola de Elastic Beanstalk para
configurar el entorno.
https://console.aws.amazon.com/elasticbeanstalk/?region=<AWS-Region>#/newApplication
?applicationName=TicTacToeyour-name
&solutionStackName=Python
&sourceBundleUrl=https://s3.amazonaws.com/<bucket-name>/TicTacToe.zip
&environmentType=SingleInstance
&instanceType=t1.micro
Para obtener más información acerca de URL personalizadas, consulte.Construcción de una URL de
lanzamiento inmediatoen laAWS Elastic BeanstalkGuía para desarrolladores de . Para la URL, tenga
en cuenta lo siguiente:
Al hacerlo, se abre la consola de Elastic Beanstalk. En algunos casos, es posible que deba iniciar
sesión.
2. En la consola de Elastic Beanstalk, elija Review and Launch y, a continuación, elija Launch.
3. Anote la URL para futuras consultas. Esta URL abre la página de inicio de la aplicación Tic-Tac-Toe.
4. Configure la aplicación Tic-Tac-Toe de modo que conozca la ubicación del archivo de configuración.
Una vez que Elastic Beanstalk haya creado la aplicación, elija Configuration.
a. Elija el icono con forma de engranaje que aparece junto a Software Configuration (Configuración
de software), tal y como se muestra en la captura de pantalla siguiente.
http://<pen-name>.elasticbeanstalk.com
6. Inicie sesión como testuser1 y elija CREATE (CREAR) para comenzar una nueva partida de tres en
raya.
7. Escriba testuser2 en el cuadro Choose an Opponent (Elegir un contrincante).
Asegúrese de borrar todas las cookies en la ventana del navegador para no iniciar sesión con el
mismo nombre de usuario.
9. Escriba la misma URL para abrir la página de inicio de la aplicación, tal y como se muestra en el
ejemplo siguiente.
http://<env-name>.elasticbeanstalk.com
Pueden jugar la partida los usuarios testuser1 y testuser2. La aplicación guardará cada jugada en el
elemento correspondiente de la tabla Games.
Si ha terminado de realizar pruebas, puede eliminar los recursos que ha creado para probar la aplicación
Tic-Tac-Toe, con el fin de evitar que se le cobre algún importe.
DynamoDB Console ahora admite su propio flujo de exportación a Amazon S3, sin embargo,
no es compatible conAWS Data Pipelineflujo de importación. Para obtener más información,
consulteExportación de datos de tablas de DynamoDB a Amazon S3 (p. 1057)y la publicación del
blogExportar datos de tabla de Amazon DynamoDB a su Data Lake en Amazon S3, sin necesidad
de escribir código.
La posibilidad de importar y exportar datos resulta útil en muchos casos. Por ejemplo, supongamos que
deseamos mantener un conjunto de referencia de los datos para realizar pruebas. Podría colocar estos
datos de referencia en una tabla de DynamoDB y exportarla a Amazon S3. A continuación, tras ejecutar
una aplicación que modificase los datos de prueba, podría «restablecer» el conjunto de datos importando
de nuevo los datos de referencia de Amazon S3 a la tabla de DynamoDB. Otro ejemplo podría ser la
eliminación accidental de los datos o incluso la ejecución por error de una operación DeleteTable.
En estos casos, podría restaurar los datos a partir de un archivo exportado previamente a Amazon S3.
Incluso puede copiar datos de una tabla de DynamoDB en unaAWSA continuación, almacene los datos en
Amazon S3 y, a continuación, importen los datos de Amazon S3 a una tabla de DynamoDB idéntica de otra
región. Así, las aplicaciones de la segunda región podría obtener acceso al punto de enlace de DynamoDB
más próximo y utilizar su propia copia de los datos, con menos latencia de red.
Important
DynamoDB Backup and Restore es una característica totalmente administrada. Puede crear
backup de las tablas que ocupen desde unos pocos megabytes a cientos de terabytes de datos,
sin impacto alguno en el rendimiento y la disponibilidad de las aplicaciones de producción. Puede
restaurar la tabla con un solo clic en el menúAWS Management Consoleo una sola llamada
de API. Le recomendamos encarecidamente que utilice la función de copia de seguridad y
restauración nativa de DynamoDB en lugar de utilizarAWS Data Pipeline. Para obtener más
información, consulte Backup bajo demanda y restauración para DynamoDB (p. 701).
Para exportar una tabla de DynamoDB, utilice laAWS Data Pipelinepara crear una nueva canalización. La
canalización lanza un clúster de Amazon EMR para realizar la exportación propiamente dicha. Amazon
EMR lee los datos de DynamoDB y los escribe en un archivo de exportación de un bucket de Amazon S3.
El proceso es similar para la importación, salvo que los datos se leen en el bucket de Amazon S3 y se
escriben en la tabla de DynamoDB.
Important
También puede controlar el acceso creando políticas de IAM y adjuntándolas a usuarios, roles o grupos de
IAM. Estas políticas permiten especificar qué usuarios están autorizados para importar y exportar los datos
de DynamoDB.
Important
El usuario de IAM que lleva a cabo las importaciones y exportaciones debe tener unactive
(activa) AWSId. de clave de acceso y clave secreta. Para obtener más información, consulte
Administering Access Keys for IAM Users en la Guía del usuario de IAM.
Si nunca había utilizado AWS Data Pipeline, deberá crear manualmente DataPipelineDefaultRole y
DataPipelineDefaultResourceRole. Una vez que haya creado estos roles, podrá usarlos en cualquier
momento para exportar o importar datos de DynamoDB.
Note
Si ya había utilizado la consola de AWS Data Pipeline para crear una canalización, entonces
DataPipelineDefaultRole y DataPipelineDefaultResourceRole se crearon automáticamente en ese
momento. No es necesario que realice ninguna acción; puede omitir esta sección y comenzar
a crear canalizaciones en la consola de DynamoDB. Para obtener más información, consulte
Exportación de datos de DynamoDB a Amazon S3 (p. 1132) y Importación de datos de Amazon
S3 a DynamoDB (p. 1133).
Ahora que ha creado estos roles, puede comenzar a crear canalizaciones desde la consola de DynamoDB.
Para obtener más información, consulte Exportación de datos de DynamoDB a Amazon S3 (p. 1132) y
Importación de datos de Amazon S3 a DynamoDB (p. 1133).
Para limitar el alcance de los permisos sugeridos, la directiva en línea anterior aplica el uso de
la etiquetadynamodbdatapipeline. Si desea utilizar esta documentación sin esta limitación,
puede eliminar laConditionde la política sugerida.
2. En el panel de la consola de IAM, haga clic enUsuarios dey seleccione el usuario que desee modificar.
3. En el navegadorPermisos, haga clic en.Agregar directiva.
4. En el navegadorAsociación de permisos, haga clic en.Asociar políticas existentes directamente.
5. Seleccione ambosAmazonDynamoDBFullAccessyAWSDataPipeline_FullAccessy haga clic
enNext:Review.
6. Haga clic enAdición de permisos.
7. Back onPermisos, haga clic en.Incorporación de política insertada.
8. En el navegadorCrear una política., haga clic en.JSONpestaña.
9. Pegue el contenido de abajo.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "EMR",
"Effect": "Allow",
"Action": [
"elasticmapreduce:DescribeStep",
"elasticmapreduce:DescribeCluster",
"elasticmapreduce:RunJobFlow",
"elasticmapreduce:TerminateJobFlows"
],
"Resource": "*",
"Condition": {
"Null": {
"elasticmapreduce:RequestTag/dynamodbdatapipeline": "false"
}
}
}
]
}
Note
Puede utilizar un procedimiento similar para adjuntar esta política administrada a un rol o grupo,
en lugar de a un usuario.
Por ejemplo, supongamos que desea permitir que un usuario de IAM exporte e importe solamente
elForum,Thread, yRespondertablas de. En este procedimiento se describe cómo crear una política
personalizada para que un usuario pueda usar estas tablas, pero no las demás.
3. En el navegadorCreación de política de, vaya aCopiar unaAWSPolítica administrada dey haga clic
enSelect.
4. En el navegadorCopiar unaAWSPolítica administrada de, vaya aAmazonDynamoDBFullAccessy
haga clic enSelect.
5. En el panel Review Policy (Revisar política) haga lo siguiente:
a. Revise los valores de Policy Name (Nombre de política) y Description (Descripción) generados
automáticamente. Si lo desea, puede modificar estos valores.
b. En el cuadro de texto Policy Document (Documento de política), edite la política para restringir el
acceso a determinadas tabla. De forma predeterminada, la política permite todas las acciones de
DynamoDB en todas las tablas:
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"cloudwatch:DeleteAlarms",
"cloudwatch:DescribeAlarmHistory",
"cloudwatch:DescribeAlarms",
"cloudwatch:DescribeAlarmsForMetric",
"cloudwatch:GetMetricStatistics",
"cloudwatch:ListMetrics",
"cloudwatch:PutMetricAlarm",
"dynamodb:*",
"sns:CreateTopic",
"sns:DeleteTopic",
"sns:ListSubscriptions",
"sns:ListSubscriptionsByTopic",
"sns:ListTopics",
"sns:Subscribe",
"sns:Unsubscribe"
],
"Effect": "Allow",
"Resource": "*",
"Sid": "DDBConsole"
},
"dynamodb:*",
A continuación, construya una nueva instrucción Action que permita obtener acceso solamente
a las tablas Forum, Thread y Reply:
{
"Action": [
"dynamodb:*"
],
"Effect": "Allow",
"Resource": [
"arn:aws:dynamodb:us-west-2:123456789012:table/Forum",
"arn:aws:dynamodb:us-west-2:123456789012:table/Thread",
"arn:aws:dynamodb:us-west-2:123456789012:table/Reply"
]
},
Note
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"dynamodb:*"
],
"Effect": "Allow",
"Resource": [
"arn:aws:dynamodb:us-west-2:123456789012:table/Forum",
"arn:aws:dynamodb:us-west-2:123456789012:table/Thread",
"arn:aws:dynamodb:us-west-2:123456789012:table/Reply"
]
},
{
"Action": [
"cloudwatch:DeleteAlarms",
"cloudwatch:DescribeAlarmHistory",
"cloudwatch:DescribeAlarms",
"cloudwatch:DescribeAlarmsForMetric",
"cloudwatch:GetMetricStatistics",
"cloudwatch:ListMetrics",
"cloudwatch:PutMetricAlarm",
"sns:CreateTopic",
"sns:DeleteTopic",
"sns:ListSubscriptions",
"sns:ListSubscriptionsByTopic",
"sns:ListTopics",
"sns:Subscribe",
"sns:Unsubscribe"
],
"Effect": "Allow",
"Resource": "*",
"Sid": "DDBConsole"
},
6. Cuando esté conforme con los ajustes de la política, haga clic en Create Policy (Crear política).
Una vez que haya creado la política, puede adjuntársela a un usuario de IAM.
1. En el panel de la consola de IAM, haga clic enUsuarios dey seleccione el usuario que desee modificar.
2. En la pestaña Permissions (Permisos), haga clic en Attach Policy (Asociar política).
3. En el panel Attach Policy (Asociar política), seleccione el nombre de la política que desee y haga clic
en Attach Policy (Asociar política).
Note
Puede utilizar un procedimiento similar para adjuntar su política a un rol o grupo, en lugar de a un
usuario.
Si nunca ha usadoAWS Data PipelineAntes de seguir este procedimiento, tendrá que configurar
dos roles de IAM. Para obtener más información, consulte Creación de roles de IAM paraAWS
Data Pipeline (p. 1127).
De lo contrario, si ya dispone de al menos una canalización, elija Create new pipeline (Crear nueva
canalización).
3. En la página Create Pipeline (Crear canalización), proceda del modo siguiente:
El formato del URI de S3 Log Folder (Carpeta de registro de S3) es el mismo que el de Output
S3 Folder (Carpeta S3 de salida). El URI debe resolverse en una carpeta; los archivos log no se
pueden escribir en el nivel superior del bucket de S3.
4. Agregar una etiqueta con la clavedynamodbdatapipeliney el Valortrue.
5. Cuando esté conforme con la configuración, haga clic en Activate (Activar).
Se creará la canalización; este proceso puede tardar varios minutos en completarse. Puede monitorizar el
progreso en la consola de AWS Data Pipeline.
Cuando la exportación haya finalizado, puede ir a laConsola de Amazon S3para ver el archivo de
exportación. El nombre del archivo de salida es un valor de identificador sin extensión, como en este
ejemplo: ae10f955-fb2f-4790-9b11-fbfea01a871e_000000. El formato interno de este archivo se
describe enVerificar archivo de exportación de datosen laAWS Data PipelineGuía para desarrolladores.
Vamos a utilizar el término tabla de origen para referirnos a la tabla original desde la que se han exportado
los datos y tabla de destino para referirnos a la tabla que recibirá los datos importados. Puede importar
datos de un archivo de exportación de Amazon S3, siempre y cuando se cumplan todas las condiciones
siguientes:
La tabla de destino no tiene que estar vacía. Sin embargo, el proceso de importación reemplazará
los elementos de datos de la tabla que tengan las mismas claves que los elementos del archivo de
exportación. Por ejemplo, supongamos que tenemos una tabla denominada Customer con la clave
CustomerId y que la tabla solo contiene tres elementos (CustomerId 1, 2 y 3). Si el archivo de exportación
contiene también elementos de datos para CustomerID 1, 2 y 3, los elementos de la tabla de destino se
sustituirán por los del archivo de exportación. Si el archivo de exportación contiene también un elemento
de datos para CustomerId 4, entonces este se agregará a la tabla.
La tabla de destino puede estar en unaAWSregion. Por ejemplo, supongamos que tiene unCustomerEn
la región EE. UU. Oeste (Oregón) y exporte sus datos a Amazon S3. Podría importar esos datos a
unCustomerEn la región UE (Irlanda). Esto se denomina exportación e importación entre regiones. Para
obtener una lista deAWSregiones de, vaya aRegiones y puntos de enlace deen laAWSReferencia general
de.
Tenga en cuenta que la AWS Management Console le permite exportar varias tablas de origen a la vez.
Sin embargo, solo se pueden importar de una en una.
El formato del URI de S3 Log Folder (Carpeta de registro de S3) es el mismo que el de Output
S3 Folder (Carpeta S3 de salida). El URI debe resolverse en una carpeta; los archivos log no se
pueden escribir en el nivel superior del bucket de S3.
f. Agregar una etiqueta con la clavedynamodbdatapipeliney el Valortrue.
5. Cuando esté conforme con la configuración, haga clic en Activate (Activar).
Se creará la canalización; este proceso puede tardar varios minutos en completarse. El trabajo de
importación comenzará inmediatamente después de que se cree la canalización.
Troubleshooting
En esta sección se explican algunos modos de error básicos y cómo solucionar problemas con las
exportaciones DynamoDB.
Si se produce un error durante una importación o exportación, en la consola de AWS Data Pipeline la
canalización aparecerá con el estado ERROR. Si esto ocurre, haga clic en el nombre de la canalización en
la que se ha producido el error para abrir su página de detalles. Aparecerá información sobre todos los
pasos de la canalización y el estado de cada uno de ellos. En particular, examine todos los seguimientos
del stack de ejecución que observe.
Por último, vaya al bucket de Amazon S3 y busque los archivos log de importación o exportación que se
hayan escrito en él.
A continuación se indican algunos problemas comunes que pueden provocar errores en una canalización,
acompañados de acciones correctivas. Para diagnosticar la canalización, compare los errores que ha
observado con los problemas que se indican a continuación.
• Si se trata de una importación, asegúrese de que la tabla de destino ya exista y de que esta última tenga
el mismo esquema de claves que la tabla de origen. Estas condiciones son imprescindibles y, si no se
cumplen, la importación no se podrá realizar.
• Asegúrese de que la tubería tenga la etiquetadynamodbdatapipelineDe lo contrario, las llamadas a
la API de Amazon EMR no prosperarán.
• Asegúrese de que el bucket de Amazon S3 especificado se haya creado y de que dispone de permisos
de lectura y escritura para él.
• La canalización podría haber superado su tiempo de ejecución. Este parámetro se establece al crear la
canalización. Por ejemplo, es posible que haya establecido el tiempo de ejecución en 1 hora pero que
el trabajo de exportación haya requerido más tiempo. Pruebe a eliminar y volver a crear la canalización,
pero esta vez con más tiempo de ejecución.
• Actualice el archivo de manifiesto si realiza la restauración desde un bucket de Amazon S3 que no es el
bucket original con el que se realizó la exportación (contiene una copia de la exportación).
• Es posible que no disponga de los permisos adecuados para realizar una importación o exportación.
Para obtener más información, consulte Requisitos previos para exportar e importar datos (p. 1127).
• Es posible que haya alcanzado una cuota de recursos en suAWS, como el número máximo de
instancias de Amazon EC2 o el número máximo deAWS Data Pipelinecanalizaciones. Para obtener más
información, incluso sobre cómo solicitar un aumento de estas cuotas, consulteAWSCuotas de servicio
deen laAWSReferencia general de.
Note
Para obtener más información sobre cómo solucionar problemas en una canalización,
visiteSolución de problemasen laAWS Data PipelineGuía para desarrolladores.
AWS Data Pipelineofrece varias plantillas para crear canalizaciones; las siguientes son pertinentes para
DynamoDB.
LaAWS Data PipelineLa consola de ofrece dos plantillas predefinidas para exportar datos entre DynamoDB
y Amazon S3. Para obtener más información sobre estas plantillas, consulte las secciones siguientes de
laAWS Data PipelineGuía para desarrolladores:
Para obtener instrucciones actualizadas sobre DynamoDB Storage Backend para JanusGraph,
consulteREADME.mdfile.
Si tiene que escribir alguna expresión que contenga un nombre de atributo que entre en conflicto con una
palabra reservada de DynamoDB, puede definir un nombre de atributo de expresión para usarlo en lugar
de la palabra reservada. Para obtener más información, consulte Nombres de atributos de expresión en
DynamoDB (p. 425).
ABORT
ABSOLUTE
ACTION
ADD
AFTER
AGENT
AGGREGATE
ALL
ALLOCATE
ALTER
ANALYZE
AND
ANY
ARCHIVE
ARE
ARRAY
AS
ASC
ASCII
ASENSITIVE
ASSERTION
ASYMMETRIC
AT
ATOMIC
ATTACH
ATTRIBUTE
AUTH
AUTHORIZATION
AUTHORIZE
AUTO
AVG
BACK
BACKUP
BASE
BATCH
BEFORE
BEGIN
BETWEEN
BIGINT
BINARY
BIT
BLOB
BLOCK
BOOLEAN
BOTH
BREADTH
BUCKET
BULK
BY
BYTE
CALL
CALLED
CALLING
CAPACITY
CASCADE
CASCADED
CASE
CAST
CATALOG
CHAR
CHARACTER
CHECK
CLASS
CLOB
CLOSE
CLUSTER
CLUSTERED
CLUSTERING
CLUSTERS
COALESCE
COLLATE
COLLATION
COLLECTION
COLUMN
COLUMNS
COMBINE
COMMENT
COMMIT
COMPACT
COMPILE
COMPRESS
CONDITION
CONFLICT
CONNECT
CONNECTION
CONSISTENCY
CONSISTENT
CONSTRAINT
CONSTRAINTS
CONSTRUCTOR
CONSUMED
CONTINUE
CONVERT
COPY
CORRESPONDING
COUNT
COUNTER
CREATE
CROSS
CUBE
CURRENT
CURSOR
CYCLE
DATA
DATABASE
DATE
DATETIME
DAY
DEALLOCATE
DEC
DECIMAL
DECLARE
DEFAULT
DEFERRABLE
DEFERRED
DEFINE
DEFINED
DEFINITION
DELETE
DELIMITED
DEPTH
DEREF
DESC
DESCRIBE
DESCRIPTOR
DETACH
DETERMINISTIC
DIAGNOSTICS
DIRECTORIES
DISABLE
DISCONNECT
DISTINCT
DISTRIBUTE
DO
DOMAIN
DOUBLE
DROP
DUMP
DURATION
DYNAMIC
EACH
ELEMENT
ELSE
ELSEIF
EMPTY
ENABLE
END
EQUAL
EQUALS
ERROR
ESCAPE
ESCAPED
EVAL
EVALUATE
EXCEEDED
EXCEPT
EXCEPTION
EXCEPTIONS
EXCLUSIVE
EXEC
EXECUTE
EXISTS
EXIT
EXPLAIN
EXPLODE
EXPORT
EXPRESSION
EXTENDED
EXTERNAL
EXTRACT
FAIL
FALSE
FAMILY
FETCH
FIELDS
FILE
FILTER
FILTERING
FINAL
FINISH
FIRST
FIXED
FLATTERN
FLOAT
FOR
FORCE
FOREIGN
FORMAT
FORWARD
FOUND
FREE
FROM
FULL
FUNCTION
FUNCTIONS
GENERAL
GENERATE
GET
GLOB
GLOBAL
GO
GOTO
GRANT
GREATER
GROUP
GROUPING
HANDLER
HASH
HAVE
HAVING
HEAP
HIDDEN
HOLD
HOUR
IDENTIFIED
IDENTITY
IF
IGNORE
IMMEDIATE
IMPORT
IN
INCLUDING
INCLUSIVE
INCREMENT
INCREMENTAL
INDEX
INDEXED
INDEXES
INDICATOR
INFINITE
INITIALLY
INLINE
INNER
INNTER
INOUT
INPUT
INSENSITIVE
INSERT
INSTEAD
INT
INTEGER
INTERSECT
INTERVAL
INTO
INVALIDATE
IS
ISOLATION
ITEM
ITEMS
ITERATE
JOIN
KEY
KEYS
LAG
LANGUAGE
LARGE
LAST
LATERAL
LEAD
LEADING
LEAVE
LEFT
LENGTH
LESS
LEVEL
LIKE
LIMIT
LIMITED
LINES
LIST
LOAD
LOCAL
LOCALTIME
LOCALTIMESTAMP
LOCATION
LOCATOR
LOCK
LOCKS
LOG
LOGED
LONG
LOOP
LOWER
MAP
MATCH
MATERIALIZED
MAX
MAXLEN
MEMBER
MERGE
METHOD
METRICS
MIN
MINUS
MINUTE
MISSING
MOD
MODE
MODIFIES
MODIFY
MODULE
MONTH
MULTI
MULTISET
NAME
NAMES
NATIONAL
NATURAL
NCHAR
NCLOB
NEW
NEXT
NO
NONE
NOT
NULL
NULLIF
NUMBER
NUMERIC
OBJECT
OF
OFFLINE
OFFSET
OLD
ON
ONLINE
ONLY
OPAQUE
OPEN
OPERATOR
OPTION
OR
ORDER
ORDINALITY
OTHER
OTHERS
OUT
OUTER
OUTPUT
OVER
OVERLAPS
OVERRIDE
OWNER
PAD
PARALLEL
PARAMETER
PARAMETERS
PARTIAL
PARTITION
PARTITIONED
PARTITIONS
PATH
PERCENT
PERCENTILE
PERMISSION
PERMISSIONS
PIPE
PIPELINED
PLAN
POOL
POSITION
PRECISION
PREPARE
PRESERVE
PRIMARY
PRIOR
PRIVATE
PRIVILEGES
PROCEDURE
PROCESSED
PROJECT
PROJECTION
PROPERTY
PROVISIONING
PUBLIC
PUT
QUERY
QUIT
QUORUM
RAISE
RANDOM
RANGE
RANK
RAW
READ
READS
REAL
REBUILD
RECORD
RECURSIVE
REDUCE
REF
REFERENCE
REFERENCES
REFERENCING
REGEXP
REGION
REINDEX
RELATIVE
RELEASE
REMAINDER
RENAME
REPEAT
REPLACE
REQUEST
RESET
RESIGNAL
RESOURCE
RESPONSE
RESTORE
RESTRICT
RESULT
RETURN
RETURNING
RETURNS
REVERSE
REVOKE
RIGHT
ROLE
ROLES
ROLLBACK
ROLLUP
ROUTINE
ROW
ROWS
RULE
RULES
SAMPLE
SATISFIES
SAVE
SAVEPOINT
SCAN
SCHEMA
SCOPE
SCROLL
SEARCH
SECOND
SECTION
SEGMENT
SEGMENTS
SELECT
SELF
SEMI
SENSITIVE
SEPARATE
SEQUENCE
SERIALIZABLE
SESSION
SET
SETS
SHARD
SHARE
SHARED
SHORT
SHOW
SIGNAL
SIMILAR
SIZE
SKEWED
SMALLINT
SNAPSHOT
SOME
SOURCE
SPACE
SPACES
SPARSE
SPECIFIC
SPECIFICTYPE
SPLIT
SQL
SQLCODE
SQLERROR
SQLEXCEPTION
SQLSTATE
SQLWARNING
START
STATE
STATIC
STATUS
STORAGE
STORE
STORED
STREAM
STRING
STRUCT
STYLE
SUB
SUBMULTISET
SUBPARTITION
SUBSTRING
SUBTYPE
SUM
SUPER
SYMMETRIC
SYNONYM
SYSTEM
TABLE
TABLESAMPLE
TEMP
TEMPORARY
TERMINATED
TEXT
THAN
THEN
THROUGHPUT
TIME
TIMESTAMP
TIMEZONE
TINYINT
TO
TOKEN
TOTAL
TOUCH
TRAILING
TRANSACTION
TRANSFORM
TRANSLATE
TRANSLATION
TREAT
TRIGGER
TRIM
TRUE
TRUNCATE
TTL
TUPLE
TYPE
UNDER
UNDO
UNION
UNIQUE
UNIT
UNKNOWN
UNLOGGED
UNNEST
UNPROCESSED
UNSIGNED
UNTIL
UPDATE
UPPER
URL
USAGE
USE
USER
USERS
USING
UUID
VACUUM
VALUE
VALUED
VALUES
VARCHAR
VARIABLE
VARIANCE
VARINT
VARYING
VIEW
VIEWS
VIRTUAL
VOID
WAIT
WHEN
WHENEVER
WHERE
WHILE
WINDOW
WITH
WITHIN
WITHOUT
WORK
WRAPPED
WRITE
YEAR
ZONE
Con la introducción de los parámetros de expresión (consulteUso de expresiones en DynamoDB (p. 421)),
varios parámetros anteriores se han quedado obsoletos. En las nuevas aplicaciones no se deben utilizar
estos parámetros heredados, sino los parámetros de expresión. (Para obtener más información, consulte
Uso de expresiones en DynamoDB (p. 421).)
Note
En la siguiente tabla se muestran los API de DynamoDB que todavía admiten estos parámetros heredados,
así como los parámetros de expresión que deben utilizarse en su lugar. Esta tabla puede resultarle útil si
va a actualizar las aplicaciones de tal forma que utilicen parámetros de expresión a partir de ahora.
KeyConditions KeyConditionExpression
QueryFilter FilterExpression
ScanFilter FilterExpression
Expected ConditionExpression
En las secciones siguientes se proporciona más información acerca de los parámetros condicionales
heredados.
Temas
• AttributesToGet (p. 1145)
• AttributeUpdates (p. 1146)
• ConditionalOperator (p. 1148)
• Expected (p. 1148)
• KeyConditions (p. 1151)
• QueryFilter (p. 1153)
• ScanFilter (p. 1155)
• Escritura de condiciones con parámetros heredados (p. 1156)
AttributesToGet
AttributesToGetes una matriz de uno o varios atributos que se recuperan de DynamoDB. Si no se
proporcionan sus nombres, se devuelven todos los atributos. Si cualquiera de los atributos solicitados no
se encuentra, no aparecerá en el resultado.
AttributesToGet permite recuperar atributos de tipo List o Map; sin embargo, no puede recuperar
entradas individuales dentro de una lista o un mapa.
UsarProjectionExpressionSin embargo,
Supongamos que desea recuperar un elemento delMúsica, pero que solo quería devolver algunos de los
atributos. Podría usar una solicitud GetItem con un parámetro AttributesToGet como en este ejemplo
de la AWS CLI:
AttributeUpdates
En unUpdateItemoperación,AttributeUpdatesrepresenta, para cada uno de los atributos que se van
a modificar, su nombre, la acción que se va a llevar a cabo y su nuevo valor. Si va a actualizar un atributo
de clave de índice de alguno de los índices de esa tabla, el tipo de atributo debe coincidir con el tipo de
clave de índice definido en el elemento deAttributesDefinitionDescripción de la tabla. Puede utilizar
UpdateItem para actualizar los atributos sin clave.
Los valores de los atributos no pueden ser null. La longitud de los atributos de tipo String y Binary debe ser
mayor que cero. Los atributos de tipo Set no pueden estar vacíos. Las solicitudes con valores vacíos se
rechazan con la excepción ValidationException.
Cada entrada AttributeUpdates consta de un nombre de atributo que se va a modificar, junto con lo
siguiente:
Si se encuentra en la tabla un elemento con la clave principal especificada, los valores siguientes llevan
a cabo estas acciones:
• PUT: agrega el atributo especificado al elemento. Si el atributo ya existe, se sustituye por el nuevo
valor.
• DELETE: elimina el atributo y su valor, si no se especifica ningún valor paraDELETE. El tipo de datos
del valor especificado debe coincidir con el tipo de datos del valor existente.
Si se especifica un conjunto de valores, entonces esos valores se restarán del conjunto anterior. Por
ejemplo, si el valor del atributo era el conjunto[a,b,c]y laDELETEacción especifica[a,c], entonces
el valor final del atributo es[b]. Especificar un conjunto vacío es un error.
• ADD: si el atributo no existe ya, agrega el valor especificado al elemento. Si el atributo existe, el
comportamiento de ADD depende del tipo de datos del atributo:
Si utiliza ADD para sumar o restar de un valor numérico de un elemento que no existía
antes de la actualización, DynamoDB utilizará 0 como valor inicial.
Del mismo modo, si usaADDSi un elemento existente aumenta o restar de un valor de un
atributo que no existía antes de la actualización, DynamoDB utilizará0como valor inicial.
Por ejemplo, supongamos que el elemento que desea actualizar no tiene un atributo
denominadorecuento de elementos, pero usted decideADDEl número3a este atributo de
todos modos. DynamoDB creará larecuento de elementos, establezca su valor inicial en0,
y, por último, agregue3. El resultado será un nuevo atributo itemcount, cuyo valor será 3.
• Si el tipo de datos existente es Set yValuetambién es un conjunto, entoncesValuese anexa
al conjunto existente. Por ejemplo, si el valor del atributo es el conjunto[1,2], y elADDAcción
especificada[3], entonces el valor final del atributo es[1,2,3]. Se produce un error si se
especifica una acción ADD para un atributo de tipo Set y el tipo de atributo especificado no coincide
con el tipo de conjunto existente.
Ambos conjuntos deben tener el mismo tipo de datos primitivo. Por ejemplo, si el tipo de datos
existente es un conjunto de cadenas, Value también debe ser un conjunto de cadenas.
Si no se encuentra en la tabla ningún elemento con la clave especificada, los valores siguientes llevan a
cabo estas acciones:
• PUT: hace que DynamoDB cree un nuevo elemento con la clave principal especificada y, a
continuación, agrega el atributo.
• DELETE: no sucede nada, porque no se pueden eliminar los atributos de un elemento que no existe.
La operación se lleva a cabo, pero DynamoDB no crea ningún elemento nuevo.
• ADD: hace que DynamoDB cree un elemento con la clave principal y el número (o el conjunto de
números) suministrados para el valor del atributo. Los únicos tipos de datos permitidos son Number y
Number Set.
Si proporciona atributos que forman parte de una clave de índice, entonces los tipos de datos de tales
atributos deberán coincidir con los del esquema de la definición de atributos de la tabla.
UsarUpdateExpressionSin embargo,
Supongamos que desea modificar un elemento en elMúsicaTabla. Podría usar una solicitud UpdateItem
con un parámetro AttributeUpdates como en este ejemplo de la AWS CLI:
--table-name Music \
--key '{
"SongTitle": {"S":"Call Me Today"},
"Artist": {"S":"No One You Know"}
}' \
--update-expression 'SET Genre = :g' \
--expression-attribute-values '{
":g": {"S":"Rock"}
}'
ConditionalOperator
Operador lógico que se aplica a las condiciones de un mapa Expected, QueryFilter o ScanFilter:
• AND: si todas las condiciones se evalúan en true, entonces todo el mapa se evalúa en true.
• OR: si al menos una de las condiciones se evalúa en true, entonces todo el mapa se evalúa en true.
Expected
Expectedes un bloque condicional para unaUpdateItem.Expectedes un mapa de pares atributo-
condición. Cada entrada del mapa consta de un nombre de atributo, un operador de comparación y uno
o varios valores. DynamoDB utiliza el operador de comparación para comparar el atributo con el o los
valores suministrados. Para cada entrada de Expected, el resultado de la evaluación es true o false.
Si especifica más de una entrada en el cuadroExpectedPor defecto todas las condiciones deben
evaluarse en true. Es decir, se utiliza AND como operador para evaluar las condiciones. Si lo desea, puede
usar laConditionalOperatorparámetro para comparar las condiciones con el operador OR. En tal caso,
deberá evaluarse en true al menos una de las condiciones, en lugar de todas ellas.
Las comparaciones de valores String de tipo mayor que, igual que o menor que se basan en Unicode
con la codificación UTF-8 binaria. Por ejemplo, a es mayor que A y a es mayor que B.
Al comparar valores de tipo Binary, DynamoDB trata cada byte de los datos binarios como sin signo.
• ComparisonOperator: comparador que permite evaluar los atributos contenidos en
elAttributeValueList. Al realizar la comparación, DynamoDB utiliza lecturas de consistencia alta.
Este operador comprueba si existe un atributo, no su tipo de datos. Si el tipo de datos del
atributo»a«es nulo, y lo evalúas usandoNOT_NULL, el resultado es un booleanotrue. Este
resultado se debe a que el atributo "a" existe; su tipo de datos no es pertinente para el
operador de comparación NOT_NULL.
• NULL: el atributo no existe.NULLse admite para todos los tipos de datos, incluidas las listas y los
mapas.
Note
CONTAINS es compatible con las listas: Al evaluar»a CONTAINS b«,»a«puede ser una lista; sin
embargo,»b«no puede ser un conjunto, un mapa o una lista.
• NOT_CONTAINS: comprueba la ausencia de una subsecuencia, o la ausencia de un valor en un
conjunto.
NOT_CONTINS es compatible con las listas: Al evaluar»a NOT CONTAINS b«,»a«puede ser una
lista; sin embargo,»b«no puede ser un conjunto, un mapa o una lista.
• BEGINS_WITH: comprueba si hay un prefijo.
UsarConditionExpressionSin embargo,
Supongamos que desea modificar un elemento en elMúsica, pero solo si se cumple una condición
determinada. Podría usar una solicitud UpdateItem con un parámetro Expected como en este ejemplo
de la AWS CLI:
KeyConditions
KeyConditionsson los criterios de selección deQuery. Para ejecutar una consulta en una tabla, solo
puede usar condiciones con los atributos de clave principal de la tabla. Debe proporcionar el nombre y
valor de la clave de partición comoEQCondición. Si lo desea, puede proporcionar una segunda condición
referida a la clave de ordenación.
Note
Si no proporciona una condición de clave de ordenación, se recuperarán todos los elementos que
coincidan con la clave de partición. Si hay una expresión FilterExpression o QueryFilter
presente, se aplicará después de recuperar los elementos.
Para ejecutar una consulta en un índice, solo puede usar condiciones con los atributos de clave del índice.
Debe proporcionar el nombre y valor de la clave de partición del índice comoEQCondición. Si lo desea,
puede proporcionar una segunda condición referida a la clave de ordenación del índice.
Cada entrada KeyConditions consta de un nombre de atributo que se va a comparar, junto con lo
siguiente:
Las comparaciones de valores String de tipo mayor que, igual que o menor que se basan en Unicode
con la codificación UTF-8 binaria. Por ejemplo, a es mayor que A y a es mayor que B.
Al comparar valores de tipo Binary, DynamoDB trata cada byte de los datos binarios como sin signo.
• ComparisonOperator: comparador para evaluar atributos; por ejemplo, igual que, mayor que, menor
que, etc.
EQ | LE | LT | GE | GT | BEGINS_WITH | BETWEEN
UsarKeyConditionExpressionSin embargo,
Supongamos que desea recuperar varios elementos con la misma clave de partición delMúsicaTabla.
Podría usar una solicitud Query con un parámetro KeyConditions como en este ejemplo de la AWS CLI:
QueryFilter
En una operación Query, QueryFilter es una condición que evalúa los resultados de la consulta
después de que se hayan leído los elementos y devuelve únicamente los valores deseados.
QueryFilter se aplica después de haber leído los elementos; el proceso de filtrado no consume
ninguna unidad de capacidad de lectura adicional.
Si proporciona más de una condición en elQueryFilterPor defecto todas las condiciones deben
evaluarse en true. Es decir, se utiliza AND como operador para evaluar las condiciones. Si lo desea, puede
usar laConditionalOperator (p. 1148)parámetro para comparar las condiciones con el operador OR. En tal
caso, deberá evaluarse en true al menos una de las condiciones, en lugar de todas ellas.
Tenga en cuenta queQueryFilterNo permite atributos de clave. No puede definir una condición de filtro
en una clave de partición ni de ordenación.
Cada entrada QueryFilter consta de un nombre de atributo que se va a comparar, junto con lo
siguiente:
Las comparaciones de valores String de tipo mayor que, igual que o menor que se basan en la
codificación UTF-8 binaria. Por ejemplo, a es mayor que A y a es mayor que B.
Al comparar valores de tipo Binary, DynamoDB trata cada byte de los datos binarios como sin signo.
Para obtener más información sobre cómo especificar los tipos de datos en JSON, consulte API de bajo
nivel de DynamoDB (p. 220).
• ComparisonOperator: comparador que permite evaluar los atributos. Por ejemplo, igual que, mayor
que, menor que, etc.
UsarFilterExpressionSin embargo,
Supongamos que desea consultar elMúsicay aplique una condición a la coincidencia de elementos. Podría
usar una solicitud Query con un parámetro QueryFilter como en este ejemplo de la AWS CLI:
ScanFilter
En una operación Scan, ScanFilter es una condición que evalúa los resultados del examen y devuelve
únicamente los valores deseados.
Note
Si especifica más de una condición en el cuadroScanFilterPor defecto todas las condiciones deben
evaluarse en true. Es decir, se utiliza AND como operador para evaluar las condiciones. Si lo desea, puede
usar laConditionalOperator (p. 1148)En su lugar, OR las condiciones. En tal caso, deberá evaluarse en
true al menos una de las condiciones, en lugar de todas ellas.
Cada entrada ScanFilter consta de un nombre de atributo que se va a comparar, junto con lo siguiente:
Las comparaciones de valores String de tipo mayor que, igual que o menor que se basan en la
codificación UTF-8 binaria. Por ejemplo, a es mayor que A y a es mayor que B.
Al comparar valores de tipo Binary, DynamoDB trata cada byte de los datos binarios como sin signo.
Para obtener más información sobre cómo especificar los tipos de datos en JSON, consulte API de bajo
nivel de DynamoDB (p. 220).
• ComparisonOperator: comparador que permite evaluar los atributos. Por ejemplo, igual que, mayor
que, menor que, etc.
UsarFilterExpressionSin embargo,
Supongamos que desea escanear elMúsicay aplique una condición a la coincidencia de elementos. Podría
usar una solicitud Scan con un parámetro ScanFilter como en este ejemplo de la AWS CLI:
En las nuevas aplicaciones deben utilizarse parámetros de expresión en su lugar. Para obtener
más información, consulte Uso de expresiones en DynamoDB (p. 421).
Condiciones simples
Con los valores de los atributos, puede escribir condiciones para realizar comparaciones con los atributos
de la tabla. Una condición siempre se evalúa en true o false y consta de:
En las siguientes secciones se describen los distintos operadores de comparación, además de ejemplos
de cómo utilizarlos en las condiciones.
Utilice estos operadores para comprobar si un atributo existe o no. Dado que no hay ningún valor que
comparar, no especifique AttributeValueList.
Ejemplo
...
"Dimensions": {
ComparisonOperator: "NOT_NULL"
}
...
AttributeValueListpuede contener un solo valor de tipo String, Number, Binary, String Set, Number
Set o Binary Set. Si un elemento contiene un valor de un tipo distinto del especificado en la solicitud, el
valor no coincide. Por ejemplo, la cadena"3"No igual a3. Tampoco el número 3 es igual que el conjunto
de números [3, 2, 1].
• NE: es true si un atributo no es igual que un valor.
AttributeValueListpuede contener un solo valor de tipo String, Number, Binary, String Set, Number
Set o Binary Set. Si un elemento contiene un valor de un tipo distinto del especificado en la solicitud, el
valor no coincide.
• LE: es true si un atributo es menor o igual que un valor.
AttributeValueListpuede contener un solo valor de tipo String, Number o Binary (no un conjunto).
Si un elemento contiene un AttributeValue de un tipo distinto del especificado en la solicitud, el valor
no coincide.
• LT: es true si un atributo es menor que un valor.
AttributeValueListpuede contener un solo valor de tipo String, Number o Binary (no un conjunto).
Si un elemento contiene un valor de un tipo distinto del especificado en la solicitud, el valor no coincide.
• GE: es true si un atributo es mayor o igual que un valor.
AttributeValueListpuede contener un solo valor de tipo String, Number o Binary (no un conjunto).
Si un elemento contiene un valor de un tipo distinto del especificado en la solicitud, el valor no coincide.
• GT: es true si un atributo es mayor que un valor.
AttributeValueListpuede contener un solo valor de tipo String, Number o Binary (no un conjunto).
Si un elemento contiene un valor de un tipo distinto del especificado en la solicitud, el valor no coincide.
• CONTAINS: es true si un valor está presente en un conjunto o si un valor contiene otro valor.
AttributeValueListpuede contener un solo valor de tipo String, Number o Binary (no un conjunto).
Si el atributo de destino de la comparación es de tipo String, entonces el operador comprueba si hay
una subcadena coincidente. Si el atributo de destino de la comparación es de tipo Binary, entonces el
operador busca una subsecuencia del destino que coincida con la entrada. Si el atributo de destino de
la comparación es un conjunto, entonces el operador se evalúa en true si encuentra una coincidencia
exacta con cualquier miembro del conjunto.
• NOT_CONTAINS: es true si un valor no está presente en un conjunto o si un valor no contiene otro valor.
AttributeValueListpuede contener un solo valor de tipo String, Number o Binary (no un conjunto).
Si el atributo de destino de la comparación es de tipo String, entonces el operador comprueba la
ausencia de una subcadena coincidente. Si el atributo de destino de la comparación es de tipo Binary,
entonces el operador busca la ausencia de una subsecuencia del destino que coincida con la entrada.
Si el atributo de destino de la comparación es un conjunto, entonces el operador se evalúa en true si no
encuentra una coincidencia exacta con cualquier miembro del conjunto.
• BEGINS_WITH: es true si los primeros caracteres de un atributo coinciden con el valor proporcionado.
No use este operador para comparar números.
AttributeValueListpuede contener un solo valor de tipo String o Binary (no de tipo Number o Set).
El atributo de destino de la comparación debe ser un valor de tipo String o Binary (no de tipo Number ni
un conjunto).
Use estos operadores para comparar un atributo con un valor. Debe especificar
unaAttributeValueListConsta de un solo valor. Para la mayoría de los operadores, este debe ser un
valor escalar; sin embargo, los operadores EQ y NE también admiten conjuntos.
Ejemplos
...
"Price": {
ComparisonOperator: "GT",
AttributeValueList: [ {"N":"100"} ]
}
...
...
"ProductCategory": {
ComparisonOperator: "BEGINS_WITH",
AttributeValueList: [ {"S":"Bo"} ]
}
...
...
"Color": {
ComparisonOperator: "EQ",
AttributeValueList: [
[ {"S":"Black"}, {"S":"Red"}, {"S":"Green"} ]
]
}
...
Note
Al comparar datos de tipo Set, el orden de las entradas carece de relevancia. DynamoDB
devolverá solo los elementos con el mismo conjunto de valores, independientemente del orden
en que los especifique en la solicitud.
AttributeValueListdebe contener dos entradas del mismo tipo, que puede ser String, Number o
Binary (pero no un conjunto). Un atributo de destino coincide si el valor de destino es mayor o igual que
el primer componente y menor o igual que el segundo componente. Si un elemento contiene un valor de
un tipo distinto del especificado en la solicitud, el valor no coincide.
Use este operador para determinar si un valor de atributo está dentro de un intervalo.
AttributeValueList debe contener dos entradas escalares del mismo tipo: String, Number o Binary.
Ejemplo
La siguiente expresión se evalúa en true si el precio de un producto está comprendido entre 100 y 200.
...
"Price": {
ComparisonOperator: "BETWEEN",
AttributeValueList: [ {"N":"100"}, {"N":"200"} ]
}
...
AttributeValueListpuede contener una o varias entradas de tipo String, Number o Binary (no un
conjunto). Estos atributos se comparan con un atributo existente que no sea de tipo Set de un elemento.
Si cualquier entrada del conjunto de entrada está presente en el atributo del elemento, la expresión se
evalúa en true.
AttributeValueListpuede contener uno o varios valores de tipo String, Number o Binary (no un
conjunto). El atributo de destino de la comparación debe ser del mismo tipo y valor exactos para que se
produzca la coincidencia. Un valor de tipo String nunca coincide con un valor de tipo String Set.
Use este operador para determinar si el valor suministrado está contenido en una lista. Puede especificar
cualquier número de valores escalares en AttributeValueList, pero todos ellos deben ser del mismo
tipo de datos.
Ejemplo
...
"Id": {
ComparisonOperator: "IN",
AttributeValueList: [ {"N":"201"}, {"N":"203"}, {"N":"205"} ]
}
...
De forma predeterminada, cuando especifica más de una condición,Tododebe evaluarse en true para que
la expresión completa se evalúe en true. Es decir, se lleva a cabo una operación AND implícita.
Ejemplo
La siguiente expresión se evalúa en true si un producto es un libro que tiene al menos 600 páginas. Deben
evaluarse en true las dos condiciones, puesto que implícitamente se les aplica el operador AND.
...
"ProductCategory": {
ComparisonOperator: "EQ",
AttributeValueList: [ {"S":"Book"} ]
},
"PageCount": {
ComparisonOperator: "GE",
AttributeValueList: [ {"N":600"} ]
}
...
Puede utilizarConditionalOperator (p. 1148)para aclarar que unYse llevará a cabo la operación. En el
siguiente ejemplo, el comportamiento es el mismo que en el caso anterior.
...
"ConditionalOperator" : "AND",
"ProductCategory": {
"ComparisonOperator": "EQ",
"AttributeValueList": [ {"N":"Book"} ]
},
"PageCount": {
"ComparisonOperator": "GE",
"AttributeValueList": [ {"N":600"} ]
}
...
También puede establecer ConditionalOperator en OR, en cuyo caso al menos una de las
condiciones deberá evaluarse en true.
Ejemplo
La siguiente expresión se evalúa en true si un producto es una bicicleta de montaña, es de una marca
concreta o su precio es mayor que 100.
...
ConditionalOperator : "OR",
"BicycleType": {
"ComparisonOperator": "EQ",
"AttributeValueList": [ {"S":"Mountain" ]
},
"Brand": {
"ComparisonOperator": "EQ",
"AttributeValueList": [ {"S":"Brand-Company A" ]
},
"Price": {
"ComparisonOperator": "GT",
"AttributeValueList": [ {"N":"100"} ]
}
...
Note
En una expresión compleja, las condiciones se procesan por orden, desde la primera hasta la
última.
No se puede utilizar AND y OR en la misma expresión.
LaValueyExistscontinúa admitiendo las opciones de DynamoDB; sin embargo, solo permiten comprobar
una condición de desigualdad o si un atributo existe. Recomendamos usar ComparisonOperator y
AttributeValueList en su lugar, porque estas opciones permiten construir un abanico de condiciones
mucho más amplio.
Example
ADeleteItempermite comprobar si un libro está descatalogado y eliminarlo únicamente si se cumple esta
condición. A continuación se muestra un ejemplo de la AWS CLI en el que se usa una condición heredada:
}'
Example
APutItempermite proteger los datos para evitar que se sobrescriba un elemento existente que tenga los
mismos atributos de clave principal. A continuación se muestra un ejemplo de la en el que se usa una
condición heredada:
Note
Para las condiciones en elExpected, no utilice el archivo heredadoValueyExistsjunto con
lasComparisonOperatoryAttributeValueList. Si lo hace, se producirá un error en la
escritura condicional.
Las nuevas aplicaciones deben utilizar la versión actual del API (2012-08-10). Para obtener más
información, consulte Referencia de API de bajo nivel (p. 1077) .
Note
Recomendamos migrar las aplicaciones existentes a la versión más reciente del API
(2012-08-10), porque las nuevas características de DynamoDB no se podrán aplicar
retroactivamente en la versión anterior del API.
Temas
• BatchGetItem (p. 1162)
• BatchWriteItem (p. 1167)
• CreateTable (p. 1172)
• DeleteItem (p. 1177)
• DeleteTable (p. 1181)
• DescribeTables (p. 1184)
• GetItem (p. 1187)
• ListTables (p. 1189)
• PutItem (p. 1192)
• Query (p. 1197)
• Scan (p. 1206)
• UpdateItem (p. 1218)
• UpdateTable (p. 1224)
BatchGetItem
Important
Description
LaBatchGetItemLa operación devuelve los atributos de varios elementos de varias tablas mediante
sus claves primarias. El número máximo de elementos que pueden recuperarse en una única operación
es de 100. Además, el número de elementos recuperados está restringido por un límite de tamaño de
1 MB. Si se supera el límite de tamaño de respuesta o se devuelve un resultado parcial por haberse
excedido el desempeño provisionado de la tabla o debido a un error de procesamiento interno, DynamoDB
devuelve un valor deUnprocessedKeyspara que pueda volver a intentar la operación comenzando con
el siguiente elemento para obtener. DynamoDB ajusta automáticamente el número de elementos que
se devuelven por página para aplicar este límite. Por ejemplo, aunque solicite que se recuperen 100
elementos con un tamaño individual de 50 KB cada uno, el sistema devolverá 20 elementos y un valor
deUnprocessedKeysPara poder obtener la siguiente página de resultados. Si lo desea, la aplicación
puede incluir su propia lógica para ensamblar las páginas de resultados en un único conjunto.
BatchGetItem recupera los elementos en paralelo para minimizar las latencias de respuesta.
Al diseñar la aplicación, tenga en cuenta que DynamoDB no garantiza cómo se ordenarán los
atributos en la respuesta devuelta. Incluya en AttributesToGet los valores de clave principal
de los elementos de la solicitud para ayudar a analizar la respuesta por elementos.
Si los elementos solicitados no existen, no se devuelve nada en la respuesta para esos
elementos. Las solicitudes de elementos inexistentes consumen las unidades de capacidad de
lectura mínimas, según el tipo de lectura. Para obtener más información, consulte Tamaños y
formatos de elementos de DynamoDB (p. 354) .
Requests
Syntax
// This header is abbreviated. For a sample of a complete header, see API de bajo nivel de
DynamoDB.
POST / HTTP/1.1
x-amz-target: DynamoDB_20111205.BatchGetItem
content-type: application/x-amz-json-1.0
{"RequestItems":
{"Table1":
{"Keys":
[{"HashKeyElement": {"S":"KeyValue1"}, "RangeKeyElement":{"N":"KeyValue2"}},
{"HashKeyElement": {"S":"KeyValue3"}, "RangeKeyElement":{"N":"KeyValue4"}},
{"HashKeyElement": {"S":"KeyValue5"}, "RangeKeyElement":{"N":"KeyValue6"}}],
"AttributesToGet":["AttributeName1", "AttributeName2", "AttributeName3"]},
"Table2":
{"Keys":
[{"HashKeyElement": {"S":"KeyValue4"}},
{"HashKeyElement": {"S":"KeyValue5"}}],
"AttributesToGet": ["AttributeName4", "AttributeName5", "AttributeName6"]
}
}
}
Type: Cadena
Type: Cadena
Type: Claves
Type: Matriz
Type: Booleano
Responses
Syntax
HTTP/1.1 200
x-amzn-RequestId: 8966d095-71e9-11e0-a498-71d736f27375
content-type: application/x-amz-json-1.0
content-length: 855
{"Responses":
{"Table1":
{"Items":
[{"AttributeName1": {"S":"AttributeValue"},
"AttributeName2": {"N":"AttributeValue"},
"AttributeName3": {"SS":["AttributeValue", "AttributeValue", "AttributeValue"]}
},
{"AttributeName1": {"S": "AttributeValue"},
"AttributeName2": {"S": "AttributeValue"},
"AttributeName3": {"NS": ["AttributeValue", "AttributeValue", "AttributeValue"]}
}],
"ConsumedCapacityUnits":1},
"Table2":
{"Items":
[{"AttributeName1": {"S":"AttributeValue"},
"AttributeName2": {"N":"AttributeValue"},
"AttributeName3": {"SS":["AttributeValue", "AttributeValue", "AttributeValue"]}
},
{"AttributeName1": {"S": "AttributeValue"},
"AttributeName2": {"S": "AttributeValue"},
"AttributeName3": {"NS": ["AttributeValue", "AttributeValue","AttributeValue"]}
}],
"ConsumedCapacityUnits":1}
},
"UnprocessedKeys":
{"Table3":
{"Keys":
[{"HashKeyElement": {"S":"KeyValue1"}, "RangeKeyElement":{"N":"KeyValue2"}},
{"HashKeyElement": {"S":"KeyValue3"}, "RangeKeyElement":{"N":"KeyValue4"}},
{"HashKeyElement": {"S":"KeyValue5"}, "RangeKeyElement":{"N":"KeyValue6"}}],
"AttributesToGet":["AttributeName1", "AttributeName2", "AttributeName3"]}
}
}
Nombre Descripción
Type: Map
Type: Cadena
Type: Número
Type: Matriz
Nombre Descripción
con los elementos. Para obtener más información
sobre claves principales, consulte Clave
principal (p. 6).
Type: Booleano.
Errores especiales
Error Descripción
Examples
En los ejemplos siguientes se muestra una solicitud HTTP POST y su respuesta utilizando la
operación BatchGetItem. Para obtener ejemplos de usando laAWSSDK, consulteUso de elementos y
atributos (p. 410).
Solicitud de muestra
En el ejemplo siguiente se solicitan atributos de dos tablas diferentes.
{"RequestItems":
{"comp1":
{"Keys":
[{"HashKeyElement":{"S":"Casey"},"RangeKeyElement":{"N":"1319509152"}},
{"HashKeyElement":{"S":"Dave"},"RangeKeyElement":{"N":"1319509155"}},
{"HashKeyElement":{"S":"Riley"},"RangeKeyElement":{"N":"1319509158"}}],
"AttributesToGet":["user","status"]},
"comp2":
{"Keys":
[{"HashKeyElement":{"S":"Julie"}},{"HashKeyElement":{"S":"Mingus"}}],
"AttributesToGet":["user","friends"]}
}
Respuesta de ejemplo
El ejemplo siguiente es la respuesta.
HTTP/1.1 200 OK
x-amzn-RequestId: GTPQVRM4VJS792J1UFJTKUBVV4KQNSO5AEMVJF66Q9ASUAAJG
content-type: application/x-amz-json-1.0
content-length: 373
Date: Fri, 02 Sep 2011 23:07:39 GMT
{"Responses":
{"comp1":
{"Items":
[{"status":{"S":"online"},"user":{"S":"Casey"}},
{"status":{"S":"working"},"user":{"S":"Riley"}},
{"status":{"S":"running"},"user":{"S":"Dave"}}],
"ConsumedCapacityUnits":1.5},
"comp2":
{"Items":
[{"friends":{"SS":["Elisabeth", "Peter"]},"user":{"S":"Mingus"}},
{"friends":{"SS":["Dave", "Peter"]},"user":{"S":"Julie"}}],
"ConsumedCapacityUnits":1}
},
"UnprocessedKeys":{}
}
BatchWriteItem
Important
Description
Esta operación permite colocar o eliminar varios elementos en una o varias tablas con una sola llamada.
Si utiliza lenguajes como Java, puede usar subprocesos para cargar los elementos en paralelo. Esto
agrega complejidad a la aplicación, porque debe encargarse de los subprocesos. Otros lenguajes no
admiten los subprocesos. Por ejemplo, si utiliza PHP, debe cargar o eliminar los elementos de uno en
uno. En ambos casos, BatchWriteItem proporciona una alternativa para procesar en paralelo las
operaciones de colocación y eliminación, por lo que aporta la potencia de un grupo de subprocesos sin
tener que aumentar la complejidad de la aplicación.
Tenga en cuenta que cada una de las operaciones individuales de colocar y eliminar que
seBatchWriteItemcuesta lo mismo en términos de unidades de capacidad consumidas. Sin embargo,
porqueBatchWriteItemlleva a cabo las operaciones especificadas en paralelo, se consigue una latencia
menor. Cada una de las operaciones de eliminación de elementos inexistentes consumen una unidad de
capacidad de escritura. Para obtener más información sobre las unidades de capacidad provisionadas,
consulte Uso de tablas y datos en DynamoDB (p. 344).
• Número máximo de operaciones en una sola solicitud: puede especificar un máximo de 25 operaciones
de colocación o eliminación en total; sin embargo, el tamaño total de la solicitud no puede ser mayor que
1 MB (la carga de HTTP).
• Puede utilizar elBatchWriteItemPara colocar y eliminar elementos. No la puede utilizar para actualizar
los existentes.
• No es una operación atómica.Operaciones individuales especificadas en unBatchWriteItemson
atómicas; sin embargoBatchWriteItemEn su conjunto es una operación basada en el principio «en
la medida en que sea posible», no es atómica. Es decir, en unBatchWriteItemPuede que algunas
operaciones se realicen correctamente y otras, no. Las operaciones que presentan algún error se
devuelven en unUnprocessedItemsEn la respuesta. Algunos de estos errores podrían deberse a
que se haya superado el desempeño provisionado configurado para la tabla, o a un error transitorio de
la red, por ejemplo. Puede investigar y, si lo desea, reenviar las solicitudes. Normalmente, se llama a
BatchWriteItem en bucle, se comprueba en cada iteración si quedan elementos sin procesar y se
envía una nueva solicitud BatchWriteItem con esos elementos que faltan.
• No devuelve ningún artículo—LaBatchWriteItemDe forma eficiente, se ha diseñado para cargar
grandes cantidades de datos. No proporciona la sofisticación que ofrecen.PutItemyDeleteItem.
Por ejemplo,DeleteItemadmiteReturnValuesEl campo del cuerpo de la solicitud para solicitar el
elemento eliminado en la respuesta. En cambio, la operación BatchWriteItem no devuelve ningún
elemento de respuesta.
• A diferencia de PutItem y DeleteItem, BatchWriteItem no permite especificar condiciones para
solicitudes de escritura individuales de la operación.
• Los valores de los atributos no pueden ser null; los atributos de tipo cadena y binario deben tener una
longitud superior a cero; y los atributos de tipo conjunto no pueden estar vacíos. Las solicitudes con
valores vacíos se rechazan con la excepción ValidationException.
DynamoDB rechaza toda la operación de escritura por lotes si se cumple cualquiera de las siguientes
condiciones:
Requests
Syntax
// This header is abbreviated. For a sample of a complete header, see API de bajo nivel de
DynamoDB.
POST / HTTP/1.1
x-amz-target: DynamoDB_20111205.BatchGetItem
content-type: application/x-amz-json-1.0
{
"RequestItems" : RequestItems
}
RequestItems
{
"TableName1" : [ Request, Request, ... ],
Request ::=
PutRequest | DeleteRequest
PutRequest ::=
{
"PutRequest" : {
"Item" : {
"Attribute-Name1" : Attribute-Value,
"Attribute-Name2" : Attribute-Value,
...
}
}
}
DeleteRequest ::=
{
"DeleteRequest" : {
"Key" : PrimaryKey-Value
}
}
HashTypePK ::=
{
"HashKeyElement" : Attribute-Value
}
HashAndRangeTypePK
{
"HashKeyElement" : Attribute-Value,
"RangeKeyElement" : Attribute-Value,
}
Numeric ::=
{
"N": "Number"
}
String ::=
{
"S": "String"
}
Binary ::=
{
"B": "Base64 encoded binary data"
}
StringSet ::=
{
"SS": [ "String1", "String2", ... ]
}
NumberSet ::=
{
"NS": [ "Number1", "Number2", ... ]
}
BinarySet ::=
{
"BS": [ "Binary1", "Binary2", ... ]
}
En el cuerpo de la solicitud, laRequestItemsEl objeto JSON describe las operaciones que se van a
realizar. Las operaciones se agrupan por tablas. Puede usarBatchWriteItemPara actualizar o eliminar
varios elementos en varias tablas. Para cada solicitud de escritura específica, debe identificar el tipo de
solicitud (PutItem o DeleteItem), seguido de información detallada sobre la operación.
• Para una solicitud PutRequest, se proporciona el elemento, es decir, una lista de atributos y sus
valores.
• Para una solicitud DeleteRequest, se proporcionan el nombre y el valor de la clave principal.
Responses
Syntax
A continuación encontrará la sintaxis del cuerpo JSON devuelto en la respuesta.
{
"Responses" : ConsumedCapacityUnitsByTable
"UnprocessedItems" : RequestItems
}
ConsumedCapacityUnitsByTable
{
"TableName1" : { "ConsumedCapacityUnits", : NumericValue },
"TableName2" : { "ConsumedCapacityUnits", : NumericValue },
...
}
RequestItems
This syntax is identical to the one described in the JSON syntax in the request.
Errores especiales
No hay errores específicos de esta operación.
Examples
En el siguiente ejemplo se muestra una solicitud HTTP POST POST y la respuesta de
unBatchWriteItem. En la solicitud se especifican las siguientes operaciones en las tablas Reply y
Thread:
Para obtener ejemplos de usando laAWSSDK, consulteUso de elementos y atributos (p. 410).
Solicitud de muestra
// This header is abbreviated. For a sample of a complete header, see API de bajo nivel de
DynamoDB.
POST / HTTP/1.1
x-amz-target: DynamoDB_20111205.BatchGetItem
content-type: application/x-amz-json-1.0
{
"RequestItems":{
"Reply":[
{
"PutRequest":{
"Item":{
"ReplyDateTime":{
"S":"2012-04-03T11:04:47.034Z"
},
"Id":{
"S":"DynamoDB#DynamoDB Thread 5"
}
}
}
},
{
"DeleteRequest":{
"Key":{
"HashKeyElement":{
"S":"DynamoDB#DynamoDB Thread 4"
},
"RangeKeyElement":{
"S":"oops - accidental row"
}
}
}
}
],
"Thread":[
{
"PutRequest":{
"Item":{
"ForumName":{
"S":"DynamoDB"
},
"Subject":{
"S":"DynamoDB Thread 5"
}
}
}
}
]
}
}
Respuesta de ejemplo
En la respuesta del siguiente ejemplo se muestra una operación de colocación que se ha realizado
correctamente en las tablas Thread y Reply, y una operación que no se ha podido realizar en la tabla
Reply (por ejemplo, porque se ha aplicado una limitación controlada por haberse superado el desempeño
provisionado de la tabla). Observe lo siguiente en la respuesta de JSON:
• El objeto Responses muestra que se ha consumido una unidad de capacidad en cada tabla, Thread y
Reply, debido a sendas operaciones de colocación llevadas a cabo en ellas.
• LaUnprocessedItemsEl objeto muestra la operación de eliminación que no se pudo realizar en
la.ReplyTabla INTO A continuación, puede emitir una nueva llamada a BatchWriteItem para repetir
estas solicitudes sin procesar.
HTTP/1.1 200 OK
x-amzn-RequestId: G8M9ANLOE5QA26AEUHJKJE0ASBVV4KQNSO5AEMVJF66Q9ASUAAJG
Content-Type: application/x-amz-json-1.0
Content-Length: 536
Date: Thu, 05 Apr 2012 18:22:09 GMT
{
"Responses":{
"Thread":{
"ConsumedCapacityUnits":1.0
},
"Reply":{
"ConsumedCapacityUnits":1.0
}
},
"UnprocessedItems":{
"Reply":[
{
"DeleteRequest":{
"Key":{
"HashKeyElement":{
"S":"DynamoDB#DynamoDB Thread 4"
},
"RangeKeyElement":{
"S":"oops - accidental row"
}
}
}
}
]
}
}
CreateTable
Important
Esta sección se refiere a la versión 2011-12-05 del API, que está
obsoleta y no debe utilizarse para nuevas aplicaciones.
Para la documentación sobre el API de bajo nivel actual, consulte la.Referencia de la API de
Amazon DynamoDB.
Description
La operación CreateTable agrega una nueva tabla a la cuenta.
Este nombre de la tabla debe ser único entre los asociados con la.AWSLa cuenta que emite la solicitud
y elAWSLa región que recibe la solicitud (por ejemplo, dynamodb.us-west-2.amazonaws.com).
Cada punto de enlace de DynamoDB es totalmente independiente. Por ejemplo, si tiene dos tablas
llamadas «MyTable», una en dynamodb.us-west-2.amazonaws.com y otra en dynamodb.us-
west-1.amazonaws.com, son completamente independientes y no comparten ningún dato.
LaCreateTableLa operación activa un flujo de trabajo asincrónico para comenzar a crear la tabla.
DynamoDB devuelve inmediatamente el estado de la tabla (CREATING) hasta que la tabla esté en
elACTIVEEstado. Una vez que la tabla tiene el estado ACTIVE, puede llevar a cabo operaciones del plano
de datos.
Requests
Syntax
{"TableName":"Table1",
"KeySchema":
{"HashKeyElement":{"AttributeName":"AttributeName1","AttributeType":"S"},
"RangeKeyElement":{"AttributeName":"AttributeName2","AttributeType":"N"}},
"ProvisionedThroughput":{"ReadCapacityUnits":5,"WriteCapacityUnits":10}
}
Type: Cadena
Type: Mapa
deHashKeyElement, o
bienHashKeyElementyRangeKeyElementPara
obtener una clave principal
compuesta.
Type: Matriz
Type: Número
Type: Número
Responses
Syntax
HTTP/1.1 200 OK
x-amzn-RequestId: CSOC7TJPLR0OOKIRLGOHVAICUFVV4KQNSO5AEMVJF66Q9ASUAAJG
content-type: application/x-amz-json-1.0
content-length: 311
Date: Tue, 12 Jul 2011 21:31:03 GMT
{"TableDescription":
{"CreationDateTime":1.310506263362E9,
"KeySchema":
{"HashKeyElement":{"AttributeName":"AttributeName1","AttributeType":"S"},
"RangeKeyElement":{"AttributeName":"AttributeName2","AttributeType":"N"}},
"ProvisionedThroughput":{"ReadCapacityUnits":5,"WriteCapacityUnits":10},
"TableName":"Table1",
"TableStatus":"CREATING"
}
}
Nombre Descripción
Type: Número
Type: Matriz
Type: Número
Type: Número
Type: Cadena
Nombre Descripción
Use el API DescribeTables (p. 1184) para
comprobar el estado de la tabla.
Type: Cadena
Errores especiales
Error Descripción
Examples
En el siguiente ejemplo se crea una tabla con una clave principal compuesta que contiene una
cadena y un número. Para obtener ejemplos de usando laAWSSDK, consulteUso de tablas y datos en
DynamoDB (p. 344).
Solicitud de muestra
{"TableName":"comp-table",
"KeySchema":
{"HashKeyElement":{"AttributeName":"user","AttributeType":"S"},
"RangeKeyElement":{"AttributeName":"time","AttributeType":"N"}},
"ProvisionedThroughput":{"ReadCapacityUnits":5,"WriteCapacityUnits":10}
}
Respuesta de ejemplo
HTTP/1.1 200 OK
x-amzn-RequestId: CSOC7TJPLR0OOKIRLGOHVAICUFVV4KQNSO5AEMVJF66Q9ASUAAJG
content-type: application/x-amz-json-1.0
content-length: 311
Date: Tue, 12 Jul 2011 21:31:03 GMT
{"TableDescription":
{"CreationDateTime":1.310506263362E9,
"KeySchema":
{"HashKeyElement":{"AttributeName":"user","AttributeType":"S"},
"RangeKeyElement":{"AttributeName":"time","AttributeType":"N"}},
"ProvisionedThroughput":{"ReadCapacityUnits":5,"WriteCapacityUnits":10},
"TableName":"comp-table",
"TableStatus":"CREATING"
}
}
Acciones relacionadas
• DescribeTables (p. 1184)
• DeleteTable (p. 1181)
DeleteItem
Important
Description
Elimina un solo elemento de una tabla por su clave principal. Puede realizar una operación de eliminación
condicional que elimina el elemento si existe o si tiene un valor de atributo esperado.
Note
Si especifica DeleteItem sin atributos ni valores, se eliminan todos los atributos del elemento.
A menos que especifique condiciones, DeleteItem es una operación idempotente; aunque se
ejecute varias veces en el mismo elemento o atributo no se obtiene una respuesta de error.
Las eliminaciones condicionales solo son útiles para eliminar elementos y atributos cuando se
cumplen determinadas condiciones. Si se cumplen las condiciones, DynamoDB lleva a cabo la
eliminación. De lo contrario, el elemento no se elimina.
Puede llevar a cabo la comprobación condicional esperada en un atributo por operación.
Requests
Syntax
{"TableName":"Table1",
"Key":
{"HashKeyElement":{"S":"AttributeValue1"},"RangeKeyElement":
{"N":"AttributeValue2"}},
"Expected":{"AttributeName3":{"Value":{"S":"AttributeValue3"}}},
"ReturnValues":"ALL_OLD"}
}
Type: Cadena
Type: Mapa
deHashKeyElementa su valor
yRangeKeyElementA su valor.
Type: Cadena
"Expected" :
{"Color":{"Exists":false}}
"Expected" :
De forma predeterminada, si
utiliza el comandoExpectedy
proporcionar un
parámetroValue, DynamoDB
da por hecho que el atributo
existe y que posee un valor
que hay que sustituir. Por
lo tanto, no es preciso
especificar{"Exists":true},
porque se considera implícito.
Puede reducir la solicitud a:
"Expected" :
{"Color":{"Value":
{"S":"Yellow"}}}
Note
Si
especifica{"Exists":true}Sin
un valor de atributo que
comprobar, DynamoDB
devuelve un error.
Type: Cadena
Responses
Syntax
HTTP/1.1 200 OK
x-amzn-RequestId: CSOC7TJPLR0OOKIRLGOHVAICUFVV4KQNSO5AEMVJF66Q9ASUAAJG
content-type: application/x-amz-json-1.0
content-length: 353
Date: Tue, 12 Jul 2011 21:31:03 GMT
{"Attributes":
{"AttributeName3":{"SS":["AttributeValue3","AttributeValue4","AttributeValue5"]},
"AttributeName2":{"S":"AttributeValue2"},
"AttributeName1":{"N":"AttributeValue1"}
},
"ConsumedCapacityUnits":1
}
Nombre Descripción
Type: Número
Errores especiales
Error Descripción
Examples
Solicitud de muestra
{"TableName":"comp-table",
"Key":
{"HashKeyElement":{"S":"Mingus"},"RangeKeyElement":{"N":"200"}},
"Expected":
{"status":{"Value":{"S":"shopping"}}},
"ReturnValues":"ALL_OLD"
}
Respuesta de ejemplo
HTTP/1.1 200 OK
x-amzn-RequestId: U9809LI6BBFJA5N2R0TB0P017JVV4KQNSO5AEMVJF66Q9ASUAAJG
content-type: application/x-amz-json-1.0
content-length: 353
Date: Tue, 12 Jul 2011 22:31:23 GMT
{"Attributes":
{"friends":{"SS":["Dooley","Ben","Daisy"]},
"status":{"S":"shopping"},
"time":{"N":"200"},
"user":{"S":"Mingus"}
},
"ConsumedCapacityUnits":1
}
Acciones relacionadas
• PutItem (p. 1192)
DeleteTable
Important
Esta sección se refiere a la versión 2011-12-05 del API, que está
obsoleta y no debe utilizarse para nuevas aplicaciones.
Para la documentación sobre el API de bajo nivel actual, consulte la.Referencia de la API de
Amazon DynamoDB.
Description
LaDeleteTableLa operación elimina una tabla y todos sus elementos. Después de unaDeleteTableLa
tabla especificada se encuentra en la listaDELETINGhasta que DynamoDB complete la eliminación. Si la
tabla está en el cuadroACTIVEPuede eliminarlo. Si una tabla está enCREATINGorUPDATING, DynamoDB
devuelve unResourceInUseExceptionERROR. Si la tabla especificada no existe, DynamoDB devuelve
una excepción.ResourceNotFoundException. Si la tabla ya se encuentra en el estado DELETING, no
se devuelve ningún error.
Note
Es posible que DynamoDB siga aceptando solicitudes de operaciones con el plano de datos, tales
comoGetItemyPutItem, en una tabla en elDELETINGhasta que se complete la eliminación de la
tabla.
Las tablas son únicas entre las asociadas con elAWSLa cuenta que emite la solicitud y elAWSLa región
que recibe la solicitud (por ejemplo, dynamodb.us-west-1.amazonaws.com). Cada punto de enlace
de DynamoDB es totalmente independiente. Por ejemplo, si tiene dos tablas llamadas «MyTable»,
una en dynamodb.us-west-2.amazonaws.com y otra en dynamodb.us-west-1.amazonaws.com, son
completamente independientes y no comparten ningún dato; al eliminar una no se elimina la otra.
Requests
Syntax
{"TableName":"Table1"}
Type: Cadena
Responses
Syntax
HTTP/1.1 200 OK
x-amzn-RequestId: 4HONCKIVH1BFUDQ1U68CTG3N27VV4KQNSO5AEMVJF66Q9ASUAAJG
content-type: application/x-amz-json-1.0
content-length: 311
Date: Sun, 14 Aug 2011 22:56:22 GMT
{"TableDescription":
{"CreationDateTime":1.313362508446E9,
"KeySchema":
{"HashKeyElement":{"AttributeName":"user","AttributeType":"S"},
"RangeKeyElement":{"AttributeName":"time","AttributeType":"N"}},
"ProvisionedThroughput":{"ReadCapacityUnits":10,"WriteCapacityUnits":10},
"TableName":"Table1",
"TableStatus":"DELETING"
}
}
Nombre Descripción
Type: Número
Nombre Descripción
paraReadCapacityUnitsyWriteCapacityUnits.
Consulte Administración de la configuración
en tablas de capacidad provisionadas de
DynamoDB (p. 350).
Type: Número
Type: Número
Type: Cadena
Type: Cadena
Errores especiales
Error Descripción
Examples
Solicitud de muestra
// This header is abbreviated. For a sample of a complete header, see API de bajo nivel de
DynamoDB.
POST / HTTP/1.1
x-amz-target: DynamoDB_20111205.DeleteTable
content-type: application/x-amz-json-1.0
content-length: 40
{"TableName":"favorite-movies-table"}
Respuesta de ejemplo
HTTP/1.1 200 OK
x-amzn-RequestId: 4HONCKIVH1BFUDQ1U68CTG3N27VV4KQNSO5AEMVJF66Q9ASUAAJG
content-type: application/x-amz-json-1.0
content-length: 160
Date: Sun, 14 Aug 2011 17:20:03 GMT
{"TableDescription":
{"CreationDateTime":1.313362508446E9,
"KeySchema":
{"HashKeyElement":{"AttributeName":"name","AttributeType":"S"}},
"TableName":"favorite-movies-table",
"TableStatus":"DELETING"
}
Acciones relacionadas
• CreateTable (p. 1172)
• DescribeTables (p. 1184)
DescribeTables
Important
Esta sección se refiere a la versión 2011-12-05 del API, que está
obsoleta y no debe utilizarse para nuevas aplicaciones.
Para la documentación sobre el API de bajo nivel actual, consulte la.Referencia de la API de
Amazon DynamoDB.
Description
Devuelve información sobre la tabla, incluido su estado actual, el esquema de clave principal y
el momento de creación. Los resultados de DescribeTable presentan consistencia final. Si utiliza
DescribeTable demasiado pronto en el proceso de creación de una tabla, DynamoDB devuelve una
excepciónResourceNotFoundException. Si utiliza DescribeTable demasiado pronto en el proceso de
actualización de una tabla, los nuevos valores podrían no estar disponibles inmediatamente.
Requests
Syntax
// This header is abbreviated.
// For a sample of a complete header, see API de bajo nivel de DynamoDB.
POST / HTTP/1.1
x-amz-target: DynamoDB_20111205.DescribeTable
content-type: application/x-amz-json-1.0
{"TableName":"Table1"}
Type: Cadena
Responses
Syntax
HTTP/1.1 200
x-amzn-RequestId: 8966d095-71e9-11e0-a498-71d736f27375
content-type: application/x-amz-json-1.0
Content-Length: 543
{"Table":
{"CreationDateTime":1.309988345372E9,
ItemCount:1,
"KeySchema":
{"HashKeyElement":{"AttributeName":"AttributeName1","AttributeType":"S"},
"RangeKeyElement":{"AttributeName":"AttributeName2","AttributeType":"N"}},
"ProvisionedThroughput":{"LastIncreaseDateTime": Date, "LastDecreaseDateTime": Date,
"ReadCapacityUnits":10,"WriteCapacityUnits":10},
"TableName":"Table1",
"TableSizeBytes":1,
"TableStatus":"ACTIVE"
}
}
Nombre Descripción
Type: Cadena
Type: Número
Nombre Descripción
ni disminuido, DynamoDB no devuelve valores
para estos elementos. Consulte Administración
de la configuración en tablas de capacidad
provisionadas de DynamoDB (p. 350).
Type: Matriz
Type: Cadena
Type: Número
Errores especiales
No hay errores específicos de esta operación.
Examples
En los siguientes ejemplos se muestran una solicitud y una respuesta HTTP POST aplicando la operación
DescribeTable a una tabla denominada "comp-table". La tabla tiene una clave principal compuesta.
Solicitud de muestra
// This header is abbreviated.
// For a sample of a complete header, see API de bajo nivel de DynamoDB.
POST / HTTP/1.1
x-amz-target: DynamoDB_20111205.DescribeTable
content-type: application/x-amz-json-1.0
{"TableName":"users"}
Respuesta de ejemplo
HTTP/1.1 200
x-amzn-RequestId: 8966d095-71e9-11e0-a498-71d736f27375
content-type: application/x-amz-json-1.0
content-length: 543
{"Table":
{"CreationDateTime":1.309988345372E9,
"ItemCount":23,
"KeySchema":
{"HashKeyElement":{"AttributeName":"user","AttributeType":"S"},
"RangeKeyElement":{"AttributeName":"time","AttributeType":"N"}},
"ProvisionedThroughput":{"LastIncreaseDateTime": 1.309988345384E9,
"ReadCapacityUnits":10,"WriteCapacityUnits":10},
"TableName":"users",
"TableSizeBytes":949,
"TableStatus":"ACTIVE"
}
}
Acciones relacionadas
• CreateTable (p. 1172)
• DeleteTable (p. 1181)
• ListTables (p. 1189)
GetItem
Important
Esta sección se refiere a la versión 2011-12-05 del API, que está
obsoleta y no debe utilizarse para nuevas aplicaciones.
Para la documentación sobre el API de bajo nivel actual, consulte la.Referencia de la API de
Amazon DynamoDB.
Description
LaGetItemLa operación devuelve un conjunto deAttributesPara un elemento que coincida con la clave
principal. Si no hay ningún elemento que coincida, GetItem no devuelve ningún dato.
LaGetItemDe forma predeterminada, proporciona una lectura consistente final. Si las lecturas
consistentes finales no son aceptables en su aplicación, useConsistentRead. Aunque esta operación
puede tardar más que una lectura normal, siempre devuelve el último valor actualizado. Para obtener más
información, consulte Consistencia de lectura (p. 17) .
Requests
Syntax
{"TableName":"Table1",
"Key":
{"HashKeyElement": {"S":"AttributeValue1"},
"RangeKeyElement": {"N":"AttributeValue2"}
},
"AttributesToGet":["AttributeName3","AttributeName4"],
"ConsistentRead":Boolean
}
Type: Cadena
Type: Mapa
deHashKeyElementa su valor
yRangeKeyElementA su valor.
Type: Matriz
Type: Booleano
Responses
Syntax
HTTP/1.1 200
x-amzn-RequestId: 8966d095-71e9-11e0-a498-71d736f27375
content-type: application/x-amz-json-1.0
content-length: 144
{"Item":{
"AttributeName3":{"S":"AttributeValue3"},
"AttributeName4":{"N":"AttributeValue4"},
"AttributeName5":{"B":"dmFsdWU="}
},
"ConsumedCapacityUnits": 0.5
}
Nombre Descripción
Nombre Descripción
de la configuración en tablas de capacidad
provisionadas de DynamoDB (p. 350).
Type: Número
Errores especiales
No hay errores específicos de esta operación.
Examples
Para obtener ejemplos de usando laAWSSDK, consulteUso de elementos y atributos (p. 410).
Solicitud de muestra
{"TableName":"comptable",
"Key":
{"HashKeyElement":{"S":"Julie"},
"RangeKeyElement":{"N":"1307654345"}},
"AttributesToGet":["status","friends"],
"ConsistentRead":true
}
Respuesta de ejemplo
Observe que el valor de ConsumedCapacityUnits es 1, ya que el parámetro
opcionalConsistentReadtoma el valortrue. Si ConsistentRead se establece en false (o no se
especifica) para la misma solicitud, la respuesta presentará consistencia final, en cuyo caso el valor de
ConsumedCapacityUnits sería 0,5.
HTTP/1.1 200
x-amzn-RequestId: 8966d095-71e9-11e0-a498-71d736f27375
content-type: application/x-amz-json-1.0
content-length: 72
{"Item":
{"friends":{"SS":["Lynda, Aaron"]},
"status":{"S":"online"}
},
"ConsumedCapacityUnits": 1
}
ListTables
Important
Para la documentación sobre el API de bajo nivel actual, consulte la.Referencia de la API de
Amazon DynamoDB.
Description
Muestra una matriz de todas las tablas asociadas con la cuenta y el punto de enlace actuales.
Cada punto de enlace de DynamoDB es totalmente independiente. Por ejemplo, si tiene dos tablas
llamadas «MyTable», una en dynamodb.us-west-2.amazonaws.com y otra en dynamodb.us-
east-1.amazonaws.com, son completamente independientes y no comparten ningún dato. La operación
ListTables devuelve todos los nombres de las tablas asociadas con la cuenta que realiza la solicitud para el
punto de enlace que recibe la solicitud.
Requests
Syntax
{"ExclusiveStartTableName":"Table1","Limit":3}
De forma predeterminada, la operación ListTables solicita todos los nombres de las tablas asociadas con la
cuenta que realiza la solicitud para el punto de enlace que recibe la solicitud.
Type: Entero
Type: Cadena
Responses
Syntax
HTTP/1.1 200 OK
x-amzn-RequestId: S1LEK2DPQP8OJNHVHL8OU2M7KRVV4KQNSO5AEMVJF66Q9ASUAAJG
content-type: application/x-amz-json-1.0
content-length: 81
Date: Fri, 21 Oct 2011 20:35:38 GMT
{"TableNames":["Table1","Table2","Table3"], "LastEvaluatedTableName":"Table3"}
Nombre Descripción
Type: Matriz
Type: Cadena
Errores especiales
No hay errores específicos de esta operación.
Examples
En los ejemplos siguientes se muestra una solicitud HTTP POST y su respuesta utilizando la operación
ListTables.
Solicitud de muestra
{"ExclusiveStartTableName":"comp2","Limit":3}
Respuesta de ejemplo
HTTP/1.1 200 OK
x-amzn-RequestId: S1LEK2DPQP8OJNHVHL8OU2M7KRVV4KQNSO5AEMVJF66Q9ASUAAJG
content-type: application/x-amz-json-1.0
content-length: 81
Date: Fri, 21 Oct 2011 20:35:38 GMT
{"LastEvaluatedTableName":"comp5","TableNames":["comp3","comp4","comp5"]}
Acciones relacionadas
• DescribeTables (p. 1184)
• CreateTable (p. 1172)
• DeleteTable (p. 1181)
PutItem
Important
Esta sección se refiere a la versión 2011-12-05 del API, que está
obsoleta y no debe utilizarse para nuevas aplicaciones.
Para la documentación sobre el API de bajo nivel actual, consulte la.Referencia de la API de
Amazon DynamoDB.
Description
Crea un elemento nuevo o sustituye uno antiguo por otro nuevo (incluidos todos los atributos). Si ya
existe un elemento con la misma clave principal en la tabla especificada, el nuevo elemento sustituye por
completo al existente. Puede realizar una colocación condicional (insertar un nuevo elemento solamente
si no existe otro con la clave principal especificada) o bien sustituir un elemento existente si sus atributos
tienen determinados valores.
Los valores de los atributos no pueden ser null; los atributos de tipo cadena y binario deben tener una
longitud superior a cero; y los atributos de tipo conjunto no pueden estar vacíos. Las solicitudes con
valores vacíos se rechazan con la excepción ValidationException.
Note
Para garantizar que un nuevo elemento no sustituya un elemento existente, utilice una operación
de colocación condicional con Exists establecido en false para el o los atributos de clave
principal.
Para obtener más información acerca del uso de PutItem, consulte Uso de elementos y atributos (p. 410).
Requests
Syntax
{"TableName":"Table1",
"Item":{
"AttributeName1":{"S":"AttributeValue1"},
"AttributeName2":{"N":"AttributeValue2"},
"AttributeName5":{"B":"dmFsdWU="}
},
"Expected":{"AttributeName3":{"Value": {"S":"AttributeValue"}, "Exists":Boolean}},
"ReturnValues":"ReturnValuesConstant"}
Type: Cadena
Type: Cadena
"Expected" :
{"Color":{"Exists":false}}
"Expected" :
{"Color":{"Exists":true,
{"Value":{"S":"Yellow"}}}
De forma predeterminada, si
utiliza el comandoExpectedy
proporcionar un
parámetroValue, DynamoDB
da por hecho que el atributo
existe y que posee un valor
que hay que sustituir. Por
lo tanto, no es preciso
especificar{"Exists":true},
porque se considera implícito.
Puede reducir la solicitud a:
"Expected" :
{"Color":{"Value":
{"S":"Yellow"}}}
Note
Si
especifica{"Exists":true}Sin
un valor de atributo que
comprobar, DynamoDB
devuelve un error.
Type: Cadena
Responses
Syntax
En el ejemplo de sintaxis siguiente se supone que la solicitud ha especificado un parámetro
ReturnValues de ALL_OLD; en caso contrario, la respuesta solo contiene la entrada
ConsumedCapacityUnits.
HTTP/1.1 200
x-amzn-RequestId: 8966d095-71e9-11e0-a498-71d736f27375
content-type: application/x-amz-json-1.0
content-length: 85
{"Attributes":
{"AttributeName3":{"S":"AttributeValue3"},
"AttributeName2":{"SS":"AttributeValue2"},
"AttributeName1":{"SS":"AttributeValue1"},
},
"ConsumedCapacityUnits":1
}
Nombre Descripción
Nombre Descripción
Type: Número
Errores especiales
Error Descripción
Examples
Para obtener ejemplos de usando laAWSSDK, consulteUso de elementos y atributos (p. 410).
Solicitud de muestra
// This header is abbreviated. For a sample of a complete header, see API de bajo nivel de
DynamoDB.
POST / HTTP/1.1
x-amz-target: DynamoDB_20111205.PutItem
content-type: application/x-amz-json-1.0
{"TableName":"comp5",
"Item":
{"time":{"N":"300"},
"feeling":{"S":"not surprised"},
"user":{"S":"Riley"}
},
"Expected":
{"feeling":{"Value":{"S":"surprised"},"Exists":true}}
"ReturnValues":"ALL_OLD"
}
Respuesta de ejemplo
HTTP/1.1 200
x-amzn-RequestId: 8952fa74-71e9-11e0-a498-71d736f27375
content-type: application/x-amz-json-1.0
content-length: 84
{"Attributes":
{"feeling":{"S":"surprised"},
"time":{"N":"300"},
"user":{"S":"Riley"}},
"ConsumedCapacityUnits":1
}
Acciones relacionadas
• UpdateItem (p. 1218)
• DeleteItem (p. 1177)
Query
Important
Description
AQueryLa operación obtiene los valores de uno o varios elementos y sus atributos mediante
su clave principal (QueryPara tablas de clave principal hash y de rango). Debe proporcionar
unaHashKeyValueAdemás, puede reducir el alcance de la consulta mediante operadores de comparación
en la pestañaRangeKeyValueDe la clave principal. Utilice el parámetro ScanIndexForward para
obtener los resultados por orden ascendente o descendente según su clave de rango.
Las consultas que no devuelven resultados consumen las unidades de capacidad de lectura mínimas,
según el tipo de lectura.
Note
Si el número total de elementos que cumplen los parámetros de la consulta supera el límite de 1
MB, la consulta se detiene y se devuelven los resultados al usuario; en este caso, se facilita un
valor deLastEvaluatedKeypara continuar la consulta en una operación posterior. A diferencia
de las operaciones Scan, las operaciones Query nunca devuelven un conjunto de resultados
vacíoyaLastEvaluatedKey. El valor de LastEvaluatedKey solamente se proporciona si los
resultados superan 1 MB o si se ha utilizado el parámetro Limit.
El resultado se puede establecer para una lectura consistente con el parámetro
ConsistentRead.
Requests
Syntax
{"TableName":"Table1",
"Limit":2,
"ConsistentRead":true,
"HashKeyValue":{"S":"AttributeValue1":},
"RangeKeyCondition": {"AttributeValueList":
[{"N":"AttributeValue2"}],"ComparisonOperator":"GT"}
"ScanIndexForward":true,
"ExclusiveStartKey":{
"HashKeyElement":{"S":"AttributeName1"},
"RangeKeyElement":{"N":"AttributeName2"}
},
"AttributesToGet":["AttributeName1", "AttributeName2", "AttributeName3"]},
}
Type: Cadena
Type: Matriz
Type: Número
Type: Booleano
Count Si se establece No
entrueDynamoDB devuelve el
número total de elementos que
coinciden con los parámetros
de la consulta, en lugar de una
lista de elementos coincidentes
y sus atributos. Puede aplicar el
No lo establezca.CountDe
atruemientras proporciona una
lista deAttributesToGetDe
lo contrario, DynamoDB
devuelve un error de
validación. Para obtener
más información, consulte
Recuento de los elementos de
los resultados (p. 502) .
Type: Booleano
Type: Map
Las comparaciones de
valores de cadenas de
tipo mayor que, igual
que o menor que se
basan en sus valores
según el código de
caracteres ASCII. Por
ejemplo, a es mayor
que A y aa es mayor
que B. Para obtener
una lista de valores de
códigos, consulte http://
en.wikipedia.org/wiki/
ASCII#ASCII_printable_characters.
En el tipo Binary,
DynamoDB trata cada
byte de los datos
binarios como sin
signo; por ejemplo, al
evaluar expresiones de
consulta.
ParaEQ,AttributeValueListSolo
puede contener
unaAttributeValueTipo
String, Number o Binary (no
un conjunto). Si un elemento
contiene un AttributeValue
de un tipo distinto del
especificado en la solicitud,
el valor no coincide. Por
ejemplo,{"S":"6"}No igual
a{"N":"6"}. {"N":"6"}
tampoco es igual que {"NS":
["6", "2", "1"]}.
ParaLE,AttributeValueListSolo
puede contener
unaAttributeValueTipo
String, Number o Binary (no
un conjunto). Si un elemento
contiene un AttributeValue
de un tipo distinto del
especificado en la solicitud,
el valor no coincide. Por
ejemplo,{"S":"6"}No igual
a{"N":"6"}. {"N":"6"}
tampoco se compara con
{"NS":["6", "2", "1"]}.
LT : Menor que.
ParaLT,AttributeValueListSolo
puede contener
unaAttributeValueTipo
String, Number o Binary (no
un conjunto). Si un elemento
contiene un AttributeValue
de un tipo distinto del
especificado en la solicitud,
el valor no coincide. Por
ejemplo,{"S":"6"}No igual
a{"N":"6"}. {"N":"6"}
tampoco se compara con
{"NS":["6", "2", "1"]}.
ParaGE,AttributeValueListSolo
puede contener
unaAttributeValueTipo
String, Number o Binary (no
un conjunto). Si un elemento
contiene un AttributeValue
de un tipo distinto del
especificado en la solicitud,
el valor no coincide. Por
ejemplo,{"S":"6"}No igual
a{"N":"6"}. {"N":"6"}
tampoco se compara con
{"NS":["6", "2", "1"]}.
GT : Mayor que.
ParaGT,AttributeValueListSolo
puede contener
unaAttributeValueTipo
String, Number o Binary (no
un conjunto). Si un elemento
contiene un AttributeValue
de un tipo distinto del
especificado en la solicitud,
el valor no coincide. Por
ejemplo,{"S":"6"}No igual
a{"N":"6"}. {"N":"6"}
tampoco se compara con
{"NS":["6", "2", "1"]}.
BEGINS_WITH: comprueba si
hay un prefijo.
ParaBEGINS_WITH,AttributeValueListSolo
puede contener
unaAttributeValueTipo String
o Binary (no de tipo Number ni
Set). El atributo de destino de la
comparación debe ser un valor
de tipo String o Binary (no de tipo
Number ni un conjunto).
ParaBETWEEN,AttributeValueListdebe
contener
dosAttributeValueElementos
del mismo tipo, que puede
ser String, Number o Binary
(pero no un conjunto). Un
atributo de destino coincide
si el valor de destino es
mayor o igual que el primer
componente y menor o igual
que el segundo componente.
Si un elemento contiene un
AttributeValue de un tipo
distinto del especificado en la
solicitud, el valor no coincide.
Por ejemplo,{"S":"6"}No
se compara con.{"N":"6"}.
{"N":"6"} tampoco se
compara con {"NS":["6",
"2", "1"]}.
Type: Booleano
Tipo: HashKeyElement, o
bien HashKeyElement y
RangeKeyElement si se
trata de una clave principal
compuesta.
Responses
Syntax
HTTP/1.1 200
x-amzn-RequestId: 8966d095-71e9-11e0-a498-71d736f27375
content-type: application/x-amz-json-1.0
content-length: 308
{"Count":2,"Items":[{
"AttributeName1":{"S":"AttributeValue1"},
"AttributeName2":{"N":"AttributeValue2"},
"AttributeName3":{"S":"AttributeValue3"}
},{
"AttributeName1":{"S":"AttributeValue3"},
"AttributeName2":{"N":"AttributeValue4"},
"AttributeName3":{"S":"AttributeValue3"},
"AttributeName5":{"B":"dmFsdWU="}
}],
"LastEvaluatedKey":{"HashKeyElement":{"AttributeValue3":"S"},
"RangeKeyElement":{"AttributeValue4":"N"}
},
"ConsumedCapacityUnits":1
}
Nombre Descripción
Type: Número
Type: Número
Errores especiales
Error Descripción
Examples
Para obtener ejemplos de usando laAWSSDK, consulteUso de consultas en DynamoDB (p. 497).
Solicitud de muestra
// This header is abbreviated. For a sample of a complete header, see API de bajo nivel de
DynamoDB.
POST / HTTP/1.1
x-amz-target: DynamoDB_20111205.Query
content-type: application/x-amz-json-1.0
{"TableName":"1-hash-rangetable",
"Limit":2,
"HashKeyValue":{"S":"John"},
"ScanIndexForward":false,
"ExclusiveStartKey":{
"HashKeyElement":{"S":"John"},
"RangeKeyElement":{"S":"The Matrix"}
}
}
Respuesta de ejemplo
HTTP/1.1 200
x-amzn-RequestId: 3647e778-71eb-11e0-a498-71d736f27375
content-type: application/x-amz-json-1.0
content-length: 308
{"Count":2,"Items":[{
"fans":{"SS":["Jody","Jake"]},
"name":{"S":"John"},
"rating":{"S":"***"},
"title":{"S":"The End"}
},{
"fans":{"SS":["Jody","Jake"]},
"name":{"S":"John"},
"rating":{"S":"***"},
"title":{"S":"The Beatles"}
}],
"LastEvaluatedKey":{"HashKeyElement":{"S":"John"},"RangeKeyElement":{"S":"The Beatles"}},
"ConsumedCapacityUnits":1
}
Solicitud de muestra
// This header is abbreviated. For a sample of a complete header, see API de bajo nivel de
DynamoDB.
POST / HTTP/1.1
x-amz-target: DynamoDB_20111205.Query
content-type: application/x-amz-json-1.0
{"TableName":"1-hash-rangetable",
"Limit":2,
"HashKeyValue":{"S":"Airplane"},
"RangeKeyCondition":{"AttributeValueList":[{"N":"1980"}],"ComparisonOperator":"EQ"},
"ScanIndexForward":false}
Respuesta de ejemplo
HTTP/1.1 200
x-amzn-RequestId: 8b9ee1ad-774c-11e0-9172-d954e38f553a
content-type: application/x-amz-json-1.0
content-length: 119
{"Count":1,"Items":[{
"fans":{"SS":["Dave","Aaron"]},
"name":{"S":"Airplane"},
"rating":{"S":"***"},
"year":{"N":"1980"}
}],
"ConsumedCapacityUnits":1
}
Acciones relacionadas
• Scan (p. 1206)
Scan
Important
Esta sección se refiere a la versión 2011-12-05 del API, que está
obsoleta y no debe utilizarse para nuevas aplicaciones.
Para la documentación sobre el API de bajo nivel actual, consulte la.Referencia de la API de
Amazon DynamoDB.
Description
LaScanLa operación devuelve uno o varios elementos y sus atributos mediante la realización de
un examen completo de una tabla. Proporcione un filtro ScanFilter para obtener resultados más
específicos.
Note
Si el número total de elementos examinados supera el límite de 1 MB, el examen se detiene y se
devuelven los resultados al usuario; en este caso, se facilita un valor deLastEvaluatedKeypara
continuar el análisis en una operación posterior. Además, los resultados incluyen el número de
elementos que superan el límite. En un examen, puede suceder que ninguno de los datos de la
tabla cumplan los criterios de filtro.
El conjunto de resultados presenta consistencia final.
Requests
Syntax
// This header is abbreviated.
// For a sample of a complete header, see API de bajo nivel de DynamoDB.
POST / HTTP/1.1
x-amz-target: DynamoDB_20111205.Scan
content-type: application/x-amz-json-1.0
{"TableName":"Table1",
"Limit": 2,
"ScanFilter":{
"AttributeName1":{"AttributeValueList":
[{"S":"AttributeValue"}],"ComparisonOperator":"EQ"}
},
"ExclusiveStartKey":{
"HashKeyElement":{"S":"AttributeName1"},
"RangeKeyElement":{"N":"AttributeName2"}
},
"AttributesToGet":["AttributeName1", "AttributeName2", "AttributeName3"]},
}
Type: Cadena
Type: Matriz
Type: Número
No lo establezca.CountDe
atruemientras proporciona una
lista deAttributesToGetDe
lo contrario, DynamoDB
devuelve un error de
validación. Para obtener
más información, consulte
Recuento de los elementos de
los resultados (p. 518) .
Type: Booleano
Las comparaciones de
valores de cadenas de
tipo mayor que, igual
que o menor que se
basan en sus valores
según el código de
caracteres ASCII. Por
ejemplo, a es mayor
que A y aa es mayor
que B. Para obtener
una lista de valores de
códigos, consulte http://
en.wikipedia.org/wiki/
ASCII#ASCII_printable_characters.
En el tipo Binary,
DynamoDB trata cada
byte de los datos
binarios como sin
signo; por ejemplo, al
evaluar expresiones de
consulta.
ParaEQ,AttributeValueListSolo
puede contener
unaAttributeValueTipo
String, Number o Binary (no
un conjunto). Si un elemento
contiene un AttributeValue
de un tipo distinto del
especificado en la solicitud,
el valor no coincide. Por
ejemplo,{"S":"6"}No igual
a{"N":"6"}. {"N":"6"}
tampoco es igual que {"NS":
["6", "2", "1"]}.
ParaNE,AttributeValueListSolo
puede contener
unaAttributeValueTipo
String, Number o Binary (no
un conjunto). Si un elemento
contiene un AttributeValue
de un tipo distinto del
especificado en la solicitud,
el valor no coincide. Por
ejemplo,{"S":"6"}No igual
a{"N":"6"}. {"N":"6"}
tampoco es igual que {"NS":
["6", "2", "1"]}.
ParaLE,AttributeValueListSolo
puede contener
unaAttributeValueTipo
String, Number o Binary (no
un conjunto). Si un elemento
contiene un AttributeValue
de un tipo distinto del
especificado en la solicitud,
el valor no coincide. Por
ejemplo,{"S":"6"}No igual
a{"N":"6"}. {"N":"6"}
tampoco se compara con
{"NS":["6", "2", "1"]}.
LT : Menor que.
ParaLT,AttributeValueListSolo
puede contener
unaAttributeValueTipo
String, Number o Binary (no
un conjunto). Si un elemento
contiene un AttributeValue
de un tipo distinto del
especificado en la solicitud,
el valor no coincide. Por
ejemplo,{"S":"6"}No igual
a{"N":"6"}. {"N":"6"}
tampoco se compara con
{"NS":["6", "2", "1"]}.
ParaGE,AttributeValueListSolo
puede contener
unaAttributeValueTipo
String, Number o Binary (no
un conjunto). Si un elemento
contiene un AttributeValue
de un tipo distinto del
especificado en la solicitud,
el valor no coincide. Por
ejemplo,{"S":"6"}No igual
a{"N":"6"}. {"N":"6"}
tampoco se compara con
{"NS":["6", "2", "1"]}.
GT : Mayor que.
ParaGT,AttributeValueListSolo
puede contener
unaAttributeValueTipo
String, Number o Binary (no
un conjunto). Si un elemento
contiene un AttributeValue
de un tipo distinto del
especificado en la solicitud,
el valor no coincide. Por
ejemplo,{"S":"6"}No igual
a{"N":"6"}. {"N":"6"}
tampoco se compara con
{"NS":["6", "2", "1"]}.
ParaCONTAINS,AttributeValueListSolo
puede contener
unaAttributeValueTipo
String, Number o Binary (no
un conjunto). Si el atributo de
destino de la comparación
es de tipo String, entonces la
operación comprueba si hay
una subcadena coincidente.
Si el atributo de destino de la
comparación es de tipo Binary,
entonces la operación busca
una subsecuencia del destino
que coincida con la entrada.
Si el atributo de destino de la
comparación es un conjunto
("SS", "NS" o "BS"), entonces la
operación busca un miembro del
conjunto (no como subcadena).
NOT_CONTAINS: comprueba la
ausencia de una subsecuencia,
o la ausencia de un valor en un
conjunto.
ParaNOT_CONTAINS,AttributeValueListSolo
puede contener
unaAttributeValueTipo
String, Number o Binary (no
un conjunto). Si el atributo de
destino de la comparación es de
tipo String, entonces la operación
comprueba la ausencia de
una subcadena coincidente.
Si el atributo de destino de la
comparación es de tipo Binary,
entonces la operación busca la
ausencia de una subsecuencia
del destino que coincida con la
entrada. Si el atributo de destino
de la comparación es un conjunto
("SS", "NS" o "BS"), entonces
la operación busca la ausencia
de un miembro del conjunto (no
como subcadena).
BEGINS_WITH: comprueba si
hay un prefijo.
ParaBEGINS_WITH,AttributeValueListSolo
puede contener
unaAttributeValueTipo String
o Binary (no de tipo Number ni
Set). El atributo de destino de la
comparación debe ser un valor
de tipo String o Binary (no de tipo
Number ni un conjunto).
ParaIN,AttributeValueListPuede
contener más de
unaAttributeValueTipo
String, Number o Binary (no un
conjunto). El atributo de destino
de la comparación debe ser del
mismo tipo y valor exactos para
que se produzca la coincidencia.
Un valor de tipo String nunca
coincide con un valor de tipo
String Set.
ParaBETWEEN,AttributeValueListdebe
contener
dosAttributeValueElementos
del mismo tipo, que puede
ser String, Number o Binary
(pero no un conjunto). Un
atributo de destino coincide
si el valor de destino es
mayor o igual que el primer
componente y menor o igual
que el segundo componente.
Si un elemento contiene un
AttributeValue de un tipo
distinto del especificado en la
solicitud, el valor no coincide.
Por ejemplo,{"S":"6"}No
se compara con.{"N":"6"}.
{"N":"6"} tampoco se
compara con {"NS":["6",
"2", "1"]}.
Tipo: HashKeyElement, o
bien HashKeyElement y
RangeKeyElement si se
trata de una clave principal
compuesta.
Responses
Syntax
HTTP/1.1 200
x-amzn-RequestId: 8966d095-71e9-11e0-a498-71d736f27375
content-type: application/x-amz-json-1.0
content-length: 229
{"Count":2,"Items":[{
"AttributeName1":{"S":"AttributeValue1"},
"AttributeName2":{"S":"AttributeValue2"},
"AttributeName3":{"S":"AttributeValue3"}
},{
"AttributeName1":{"S":"AttributeValue4"},
"AttributeName2":{"S":"AttributeValue5"},
"AttributeName3":{"S":"AttributeValue6"},
"AttributeName5":{"B":"dmFsdWU="}
}],
"LastEvaluatedKey":
{"HashKeyElement":{"S":"AttributeName1"},
"RangeKeyElement":{"N":"AttributeName2"},
"ConsumedCapacityUnits":1,
"ScannedCount":2}
}
Nombre Descripción
Nombre Descripción
Type: Número
Type: Número
Type: Número
Errores especiales
Error Descripción
Examples
Para obtener ejemplos de usando laAWSSDK, consulteUso de operaciones de examen en
DynamoDB (p. 516).
Solicitud de muestra
// This header is abbreviated. For a sample of a complete header, see API de bajo nivel de
DynamoDB.
POST / HTTP/1.1
x-amz-target: DynamoDB_20111205.Scan
content-type: application/x-amz-json-1.0
{"TableName":"1-hash-rangetable","ScanFilter":{}}
Respuesta de ejemplo
HTTP/1.1 200
x-amzn-RequestId: 4e8a5fa9-71e7-11e0-a498-71d736f27375
content-type: application/x-amz-json-1.0
content-length: 465
{"Count":4,"Items":[{
"date":{"S":"1980"},
"fans":{"SS":["Dave","Aaron"]},
"name":{"S":"Airplane"},
"rating":{"S":"***"}
},{
"date":{"S":"1999"},
"fans":{"SS":["Ziggy","Laura","Dean"]},
"name":{"S":"Matrix"},
"rating":{"S":"*****"}
},{
"date":{"S":"1976"},
"fans":{"SS":["Riley"]},"
name":{"S":"The Shaggy D.A."},
"rating":{"S":"**"}
},{
"date":{"S":"1985"},
"fans":{"SS":["Fox","Lloyd"]},
"name":{"S":"Back To The Future"},
"rating":{"S":"****"}
}],
"ConsumedCapacityUnits":0.5
"ScannedCount":4}
Solicitud de muestra
// This header is abbreviated. For a sample of a complete header, see API de bajo nivel de
DynamoDB.
POST / HTTP/1.1
x-amz-target: DynamoDB_20111205.Scan
content-type: application/x-amz-json-1.0
content-length: 125
{"TableName":"comp5",
"ScanFilter":
{"time":
{"AttributeValueList":[{"N":"400"}],
"ComparisonOperator":"GT"}
}
}
Respuesta de ejemplo
HTTP/1.1 200 OK
x-amzn-RequestId: PD1CQK9QCTERLTJP20VALJ60TRVV4KQNSO5AEMVJF66Q9ASUAAJG
content-type: application/x-amz-json-1.0
content-length: 262
Date: Mon, 15 Aug 2011 16:52:02 GMT
{"Count":2,
"Items":[
{"friends":{"SS":["Dave","Ziggy","Barrie"]},
"status":{"S":"chatting"},
"time":{"N":"2000"},
"user":{"S":"Casey"}},
{"friends":{"SS":["Dave","Ziggy","Barrie"]},
"status":{"S":"chatting"},
"time":{"N":"2000"},
"user":{"S":"Fredy"}
}],
"ConsumedCapacityUnits":0.5
"ScannedCount":4
}
Solicitud de muestra
// This header is abbreviated. For a sample of a complete header, see API de bajo nivel de
DynamoDB.
POST / HTTP/1.1
x-amz-target: DynamoDB_20111205.Scan
content-type: application/x-amz-json-1.0
{"TableName":"comp5",
"Limit":2,
"ScanFilter":
{"time":
{"AttributeValueList":[{"N":"400"}],
"ComparisonOperator":"GT"}
},
"ExclusiveStartKey":
{"HashKeyElement":{"S":"Fredy"},"RangeKeyElement":{"N":"2000"}}
}
Respuesta de ejemplo
HTTP/1.1 200 OK
x-amzn-RequestId: PD1CQK9QCTERLTJP20VALJ60TRVV4KQNSO5AEMVJF66Q9ASUAAJG
content-type: application/x-amz-json-1.0
content-length: 232
Date: Mon, 15 Aug 2011 16:52:02 GMT
{"Count":1,
"Items":[
{"friends":{"SS":["Jane","James","John"]},
"status":{"S":"exercising"},
"time":{"N":"2200"},
"user":{"S":"Roger"}}
],
"LastEvaluatedKey":{"HashKeyElement":{"S":"Riley"},"RangeKeyElement":{"N":"250"}},
"ConsumedCapacityUnits":0.5
"ScannedCount":2
}
Acciones relacionadas
• Query (p. 1197)
• BatchGetItem (p. 1162)
UpdateItem
Important
Esta sección se refiere a la versión 2011-12-05 del API, que está
obsoleta y no debe utilizarse para nuevas aplicaciones.
Para la documentación sobre el API de bajo nivel actual, consulte la.Referencia de la API de
Amazon DynamoDB.
Description
Permite editar los atributos de un elemento. Puede realizar una actualización condicional, es decir,
insertar un nuevo par nombre-valor de atributo si no existe, o bien sustituir un par de nombre-valor si tiene
determinados valores de atributo esperados.
Note
Los atributos de clave principal no se pueden actualizar mediante UpdateItem. En lugar de ello,
debe eliminar el elemento y utilizar PutItem para crear otro con los nuevos atributos.
La operación UpdateItem incluye unAction, que define cómo realizar la actualización. Puede poner,
eliminar o agregar valores de atributos.
Los valores de los atributos no pueden ser null; los atributos de tipo cadena y binario deben tener una
longitud superior a cero; y los atributos de tipo conjunto no pueden estar vacíos. Las solicitudes con
valores vacíos se rechazan con la excepción ValidationException.
Si utiliza ADD para un atributo que no existe, el atributo y sus valores se agregan al elemento.
• PUT...Crea un elemento nuevo con la clave principal. A continuación, agrega el atributo especificado.
• DELETE: no sucede nada.
• ADD...Crea un elemento con la clave principal y el número (o el conjunto de números) suministrados
para el valor del atributo. No es válido para los tipos de cadena o binario.
Note
Si usaADDPara sumar o restar de un valor numérico de un elemento que no existía antes de
la actualización, DynamoDB utilizará0como valor inicial. Además, si actualiza un elemento
Para obtener más información sobre cómo usar esta operación, consulte Uso de elementos y
atributos (p. 410).
Requests
Syntax
{"TableName":"Table1",
"Key":
{"HashKeyElement":{"S":"AttributeValue1"},
"RangeKeyElement":{"N":"AttributeValue2"}},
"AttributeUpdates":{"AttributeName3":{"Value":
{"S":"AttributeValue3_New"},"Action":"PUT"}},
"Expected":{"AttributeName3":{"Value":{"S":"AttributeValue3_Current"}}},
"ReturnValues":"ReturnValuesConstant"
}
Type: Cadena
Type: Mapa
deHashKeyElementa su valor
yRangeKeyElementA su valor.
Type: Cadena
Type: Cadena
"Expected" :
{"Color":{"Exists":false}}
"Expected" :
{"Color":{"Exists":true},
{"Value":{"S":"Yellow"}}}
De forma predeterminada, si
utiliza el comandoExpectedy
proporcionar un
parámetroValue, DynamoDB
da por hecho que el atributo
existe y que posee un valor
que hay que sustituir. Por
lo tanto, no es preciso
especificar{"Exists":true},
porque se considera implícito.
Puede reducir la solicitud a:
"Expected" :
{"Color":{"Value":
{"S":"Yellow"}}}
Note
Si
especifica{"Exists":true}Sin
un valor de atributo que
comprobar, DynamoDB
devuelve un error.
Type: Cadena
Responses
Syntax
En el ejemplo de sintaxis siguiente se supone que la solicitud ha especificado un parámetro
ReturnValues de ALL_OLD; en caso contrario, la respuesta solo contiene la entrada
ConsumedCapacityUnits.
HTTP/1.1 200
x-amzn-RequestId: 8966d095-71e9-11e0-a498-71d736f27375
content-type: application/x-amz-json-1.0
content-length: 140
{"Attributes":{
"AttributeName1":{"S":"AttributeValue1"},
"AttributeName2":{"S":"AttributeValue2"},
"AttributeName3":{"S":"AttributeValue3"},
"AttributeName5":{"B":"dmFsdWU="}
},
"ConsumedCapacityUnits":1
}
Nombre Descripción
Nombre Descripción
especificado como algo distinto de NONE en la
solicitud.
Type: Número
Errores especiales
Error Descripción
Examples
Para obtener ejemplos de usando laAWSSDK, consulteUso de elementos y atributos (p. 410).
Solicitud de muestra
// This header is abbreviated. For a sample of a complete header, see API de bajo nivel de
DynamoDB.
POST / HTTP/1.1
x-amz-target: DynamoDB_20111205.UpdateItem
content-type: application/x-amz-json-1.0
{"TableName":"comp5",
"Key":
{"HashKeyElement":{"S":"Julie"},"RangeKeyElement":{"N":"1307654350"}},
"AttributeUpdates":
{"status":{"Value":{"S":"online"},
"Action":"PUT"}},
"Expected":{"status":{"Value":{"S":"offline"}}},
"ReturnValues":"ALL_NEW"
}
Respuesta de ejemplo
HTTP/1.1 200 OK
x-amzn-RequestId: 5IMHO7F01Q9P7Q6QMKMMI3R3QRVV4KQNSO5AEMVJF66Q9ASUAAJG
content-type: application/x-amz-json-1.0
content-length: 121
Date: Fri, 26 Aug 2011 21:05:00 GMT
{"Attributes":
{"friends":{"SS":["Lynda, Aaron"]},
"status":{"S":"online"},
"time":{"N":"1307654350"},
"user":{"S":"Julie"}},
"ConsumedCapacityUnits":1
}
Acciones relacionadas
• PutItem (p. 1192)
• DeleteItem (p. 1177)
UpdateTable
Important
Description
Actualiza el desempeño provisionado de la tabla en cuestión. Establece el desempeño de una tabla para
facilitar su administración; esto forma parte de la característica de desempeño provisionado de DynamoDB.
Para obtener más información, consulte Administración de la configuración en tablas de capacidad
provisionadas de DynamoDB (p. 350) .
Los valores de desempeño provisionado se pueden aumentar o reducir según los máximos o mínimos
indicados en Cuotas de servicio, cuenta y tabla en Amazon DynamoDB (p. 1066).
La tabla debe estar en laACTIVEPara poder realizar correctamente esta operación. UpdateTable es
una operación asíncrona; al ejecutar la operación, la tabla se encuentra en el cuadroUPDATINGEstado.
Mientras que la tabla está en elUPDATING, la tabla sigue teniendo el desempeño provisionado previo a la
llamada. La nueva configuración de desempeño provisionado no entra en vigor hasta que la tabla vuelve al
estado ACTIVE después de la operación UpdateTable.
Requests
Syntax
{"TableName":"Table1",
"ProvisionedThroughput":{"ReadCapacityUnits":5,"WriteCapacityUnits":15}
}
Type: Matriz
Type: Número
Type: Número
Responses
Syntax
HTTP/1.1 200 OK
x-amzn-RequestId: CSOC7TJPLR0OOKIRLGOHVAICUFVV4KQNSO5AEMVJF66Q9ASUAAJG
Content-Type: application/json
Content-Length: 311
Date: Tue, 12 Jul 2011 21:31:03 GMT
{"TableDescription":
{"CreationDateTime":1.321657838135E9,
"KeySchema":
{"HashKeyElement":{"AttributeName":"AttributeValue1","AttributeType":"S"},
"RangeKeyElement":{"AttributeName":"AttributeValue2","AttributeType":"N"}},
"ProvisionedThroughput":
{"LastDecreaseDateTime":1.321661704489E9,
"LastIncreaseDateTime":1.321663607695E9,
"ReadCapacityUnits":5,
"WriteCapacityUnits":10},
"TableName":"Table1",
"TableStatus":"UPDATING"}}
Nombre Descripción
Type: Número
Type: Matriz
Type: Cadena
Type: Cadena
Errores especiales
Error Descripción
Examples
Solicitud de muestra
{"TableName":"comp1",
"ProvisionedThroughput":{"ReadCapacityUnits":5,"WriteCapacityUnits":15}
}
Respuesta de ejemplo
HTTP/1.1 200 OK
content-type: application/x-amz-json-1.0
content-length: 390
Date: Sat, 19 Nov 2011 00:46:47 GMT
{"TableDescription":
{"CreationDateTime":1.321657838135E9,
"KeySchema":
{"HashKeyElement":{"AttributeName":"user","AttributeType":"S"},
"RangeKeyElement":{"AttributeName":"time","AttributeType":"N"}},
"ProvisionedThroughput":
{"LastDecreaseDateTime":1.321661704489E9,
"LastIncreaseDateTime":1.321663607695E9,
"ReadCapacityUnits":5,
"WriteCapacityUnits":10},
"TableName":"comp1",
"TableStatus":"UPDATING"}
}
Acciones relacionadas
• CreateTable (p. 1172)
• DescribeTables (p. 1184)
• DeleteTable (p. 1181)
NoSQL Workbench para Amazon NoSQL Workbench para Amazon 2 de marzo de 2020
DynamoDB — GA (p. 1228) DynamoDBestá disponible con
carácter general. Utilice NoSQL
Workbench para diseñar, crear,
consultar y administrar tablas de
DynamoDB.
Use Amazon DynamoDB Local Ahora, es más sencillo utilizar 22 de agosto de 2018
más fácilmente con la nueva DynamoDB Local, la versión
imagen de Docker (p. 1228) descargable de DynamoDB, para
ayudarle a desarrollar y probar
sus aplicaciones de DynamoDB
usando la nueva imagen de
Docker de DynamoDB Local.
Para obtener más información,
consulte DynamoDB (versión
descargable) y Docker.
Actualizaciones anteriores
En la siguiente tabla se describen cambios importantes en laGuía para desarrolladores de
DynamoDBantes del 3 de julio de 2018.
• Clave de partición,
denominada también atributo
hash.
• Clave de ordenación,
denominada también atributo
de intervalo.
El DynamoDBScanDe
forma predeterminada, la
operación de usa las lecturas
consistentes finales. Si lo
prefiere, puede establecer el
parámetro ConsistentRead
en true para usar lecturas
de consistencia alta. Para
obtener más información,
consulteConsistencia de lectura
de Scan (p. 519)yScanen la
Referencia de la API de Amazon
DynamoDB.
• Java: DynamoDBMappper
• .NET: Modelo de documento
y modelo de persistencia de
objetos
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.